diff --git a/.github/workflows/sync-content-cms.yml b/.github/workflows/sync-content-cms.yml
new file mode 100644
index 000000000..aad6e3f35
--- /dev/null
+++ b/.github/workflows/sync-content-cms.yml
@@ -0,0 +1,231 @@
+# GitHub Actions Workflow: Sync Content to Strapi CMS (With Relations Support)
+# This workflow syncs content changes from specific data folders to Strapi CMS
+# Supports foreign key relations: tags, authors, related_faqs
+# Triggers: On labeled PR, on push to staging/main branches
+
+name: Sync Content to Strapi CMS
+
+on:
+  pull_request:
+    types: [labeled, synchronize, opened, reopened]
+    paths:
+      - 'data/**/*.mdx'
+      - 'data/**/*.md'
+  push:
+    branches:
+      - test/cms-with-isr  # Configurable: Change to your production branch
+      - staging  # Configurable: Change to your staging branch
+    paths:
+      - 'data/**/*.mdx'
+      - 'data/**/*.md'
+
+env:
+  # Configurable: Array of folders to sync to CMS
+  SYNC_FOLDERS: '["faqs", "case-study", "comparisons", "guides"]'
+  
+  # Strapi Configuration
+  CMS_API_URL: ${{ secrets.CMS_API_URL }}
+  CMS_API_TOKEN: ${{ secrets.CMS_API_TOKEN }}
+  
+  # Revalidation Configuration
+  NEXT_PUBLIC_BASE_URL: ${{ secrets.NEXT_PUBLIC_BASE_URL }}
+  NEXT_PUBLIC_STAGING_BASE_URL: ${{ secrets.NEXT_PUBLIC_STAGING_BASE_URL }}
+  REVALIDATE_SECRET: ${{ secrets.REVALIDATE_SECRET }}
+  
+  # Branch Configuration
+  PRODUCTION_BRANCH: 'test/cms-with-isr'
+  STAGING_BRANCH: 'test/cms-with-isr'
+
+jobs:
+  detect-changes:
+    name: Detect Changed Files
+    runs-on: ubuntu-latest
+    outputs:
+      changed_files: ${{ steps.changed-files.outputs.all_changed_files }}
+      deleted_files: ${{ steps.changed-files.outputs.deleted_files }}
+      any_changed: ${{ steps.changed-files.outputs.any_changed }}
+      any_deleted: ${{ steps.changed-files.outputs.any_deleted }}
+      deployment_status: ${{ steps.determine-status.outputs.deployment_status }}
+      should_sync: ${{ steps.check-sync.outputs.should_sync }}
+    
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get Changed Files
+        id: changed-files
+        uses: tj-actions/changed-files@v44
+        with:
+          files: |
+            data/**/*.mdx
+            data/**/*.md
+          json: true
+          escape_json: false
+
+      - name: Check if Sync is Required
+        id: check-sync
+        run: |
+          echo "Checking if sync should run..."
+          
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            if [[ "${{ contains(github.event.pull_request.labels.*.name, 'staging') }}" == "true" ]]; then
+              echo "should_sync=true" >> $GITHUB_OUTPUT
+              echo "✅ Sync enabled: PR has 'staging' label"
+            else
+              echo "should_sync=false" >> $GITHUB_OUTPUT
+              echo "⏭️ Sync skipped: PR does not have 'staging' label"
+            fi
+          else
+            echo "should_sync=true" >> $GITHUB_OUTPUT
+            echo "✅ Sync enabled: Push event to branch"
+          fi
+
+      - name: Determine Deployment Status
+        id: determine-status
+        run: |
+          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
+            if [[ "${{ contains(github.event.pull_request.labels.*.name, 'staging') }}" == "true" ]]; then
+              echo "deployment_status=staging" >> $GITHUB_OUTPUT
+              echo "📦 Deployment Status: staging"
+            else
+              echo "deployment_status=draft" >> $GITHUB_OUTPUT
+              echo "📦 Deployment Status: draft"
+            fi
+          elif [[ "${{ github.ref }}" == "refs/heads/${{ env.PRODUCTION_BRANCH }}" ]]; then
+            echo "deployment_status=live" >> $GITHUB_OUTPUT
+            echo "📦 Deployment Status: live"
+          elif [[ "${{ github.ref }}" == "refs/heads/${{ env.STAGING_BRANCH }}" ]]; then
+            echo "deployment_status=staging" >> $GITHUB_OUTPUT
+            echo "📦 Deployment Status: staging"
+          else
+            echo "deployment_status=draft" >> $GITHUB_OUTPUT
+            echo "📦 Deployment Status: draft"
+          fi
+
+      - name: Display Changed Files
+        if: steps.changed-files.outputs.any_changed == 'true'
+        run: |
+          echo "📝 Changed files detected:"
+          echo '${{ steps.changed-files.outputs.all_changed_files }}' | jq -r '.[]'
+
+      - name: Display Deleted Files
+        if: steps.changed-files.outputs.any_deleted == 'true'
+        run: |
+          echo "🗑️ Deleted files detected:"
+          echo '${{ steps.changed-files.outputs.deleted_files }}' | jq -r '.[]'
+
+  sync-to-cms:
+    name: Sync Content to CMS
+    runs-on: ubuntu-latest
+    needs: detect-changes
+    if: (needs.detect-changes.outputs.any_changed == 'true' || needs.detect-changes.outputs.any_deleted == 'true') && needs.detect-changes.outputs.should_sync == 'true'
+    
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install Dependencies
+        run: |
+          npm install --no-save \
+            gray-matter \
+            axios \
+            js-yaml
+
+      - name: Sync Content to Strapi
+        id: sync
+        env:
+          CHANGED_FILES: ${{ needs.detect-changes.outputs.changed_files }}
+          DELETED_FILES: ${{ needs.detect-changes.outputs.deleted_files }}
+          DEPLOYMENT_STATUS: ${{ needs.detect-changes.outputs.deployment_status }}
+        run: node scripts/sync-content-to-strapi.js
+
+      - name: Trigger Revalidation
+        if: success()
+        env:
+          DEPLOYMENT_STATUS: ${{ needs.detect-changes.outputs.deployment_status }}
+        run: |
+          echo "🔄 Triggering ISR revalidation..."
+          echo "Environment: $DEPLOYMENT_STATUS"
+          
+          # Determine the base URL based on deployment status
+          if [ "$DEPLOYMENT_STATUS" = "live" ]; then
+            BASE_URL="${{ env.NEXT_PUBLIC_BASE_URL }}"
+            echo "Using production URL: $BASE_URL"
+          elif [ "$DEPLOYMENT_STATUS" = "staging" ]; then
+            BASE_URL="${{ env.NEXT_PUBLIC_STAGING_BASE_URL }}"
+            echo "Using staging URL: $BASE_URL"
+          else
+            echo "⏭️ Skipping revalidation for draft deployment"
+            exit 0
+          fi
+          
+          RESPONSE=$(curl -s -w "\n%{http_code}" --location "$BASE_URL/api/revalidate" \
+            --header 'Content-Type: application/json' \
+            --data "{
+              \"revalidateAll\": true,
+              \"clearCache\": true,
+              \"secret\": \"${{ env.REVALIDATE_SECRET }}\"
+            }")
+          
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | head -n-1)
+          
+          if [ "$HTTP_CODE" -eq 200 ]; then
+            echo "✅ Revalidation successful!"
+            echo "Response: $BODY"
+          else
+            echo "❌ Revalidation failed with HTTP $HTTP_CODE"
+            echo "Response: $BODY"
+            exit 1
+          fi
+
+      - name: Update PR Comment
+        if: github.event_name == 'pull_request'
+        uses: actions/github-script@v7
+        env:
+          JOB_STATUS: ${{ job.status }}
+          DEPLOYMENT_STATUS: ${{ needs.detect-changes.outputs.deployment_status }}
+        with:
+          script: |
+            const script = require('${{ github.workspace }}/scripts/update-pr-comment.js');
+            await script({github, context, core});
+
+  report-status:
+    name: Report Status
+    runs-on: ubuntu-latest
+    needs: [detect-changes, sync-to-cms]
+    if: always()
+    
+    steps:
+      - name: Report Success
+        if: needs.sync-to-cms.result == 'success'
+        run: |
+          echo "✅ Workflow completed successfully!"
+          echo "Deployment Status: ${{ needs.detect-changes.outputs.deployment_status }}"
+
+      - name: Report Failure
+        if: needs.sync-to-cms.result == 'failure'
+        run: |
+          echo "❌ Workflow failed!"
+          echo "Please check the logs above for detailed error messages."
+          exit 1
+
+      - name: Report Skipped
+        if: needs.detect-changes.outputs.should_sync != 'true' || (needs.detect-changes.outputs.any_changed != 'true' && needs.detect-changes.outputs.any_deleted != 'true')
+        run: |
+          echo "⏭️ Sync was skipped."
+          if [[ "${{ needs.detect-changes.outputs.any_changed }}" != "true" && "${{ needs.detect-changes.outputs.any_deleted }}" != "true" ]]; then
+            echo "Reason: No content files changed or deleted"
+          else
+            echo "Reason: PR does not have 'staging' label"
+          fi
diff --git a/.gitignore b/.gitignore
index 5eb4cb024..09e2415a0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,6 @@ app/tag-data.json
 # Interlinking data files (large, not for VCS)
 interlinking.csv.bak
 scripts/data/interlinking.csv
+
+# Sync results (temporary file for CI/CD)
+sync-results.json
diff --git a/app/api/revalidate/route.ts b/app/api/revalidate/route.ts
index 9f7806d83..75b225d1a 100644
--- a/app/api/revalidate/route.ts
+++ b/app/api/revalidate/route.ts
@@ -1,35 +1,196 @@
-import { revalidateTag } from 'next/cache'
+
 import { NextRequest, NextResponse } from 'next/server'
+import { revalidatePath, revalidateTag } from 'next/cache'
+import { clearPathsCache } from '@/utils/strapi'
 
-const REVALIDATE_SECRET = process.env.REVALIDATE_SECRET
+interface RevalidationResult {
+  path?: string
+  tag?: string
+  revalidated: boolean
+  type: 'route' | 'path' | 'tag'
+  timestamp: string
+}
 
 export async function POST(request: NextRequest) {
   try {
-    const requestData = await request.json()
-    const { tag, secret } = requestData
+    const body = await request.json()
+    const { 
+      paths, 
+      path, 
+      tags, 
+      tag, 
+      secret, 
+      revalidateAll = false,
+      clearCache = false 
+    } = body
+
+    if (secret !== process.env.REVALIDATE_SECRET) {
+      return NextResponse.json(
+        { message: 'Invalid secret' },
+        { status: 401 }
+      )
+    }
+
+    const results: RevalidationResult[] = []
+
+    if (clearCache) {
+      clearPathsCache()
+      console.log('Cleared paths cache')
+    }
+
+    if (revalidateAll) {
+      revalidatePath('/', 'layout')
+      revalidateTag('mdx-content-list')
+      revalidateTag('mdx-paths')
+
+      results.push({
+        path: '/',
+        revalidated: true,
+        type: 'route',
+        timestamp: new Date().toISOString(),
+      })
+    }
+
+    if (path) {
+      revalidatePath(path)
+      revalidateTag(`mdx-content-${path}`)
+
+      results.push({
+        path,
+        revalidated: true,
+        type: 'path',
+        timestamp: new Date().toISOString(),
+      })
+    }
+
+    if (paths && Array.isArray(paths)) {
+      for (const p of paths) {
+        revalidatePath(p)
+        revalidateTag(`mdx-content-${p}`)
+
+        results.push({
+          path: p,
+          revalidated: true,
+          type: 'path',
+          timestamp: new Date().toISOString(),
+        })
+      }
+    }
+
+    if (tag) {
+      revalidateTag(tag)
 
-    // Check for secret if configured
-    if (REVALIDATE_SECRET && secret !== REVALIDATE_SECRET) {
-      return NextResponse.json({ message: 'Invalid revalidation token' }, { status: 401 })
+      results.push({
+        tag,
+        revalidated: true,
+        type: 'tag',
+        timestamp: new Date().toISOString(),
+      })
     }
 
-    // Verify tag is provided
-    if (!tag) {
-      return NextResponse.json({ message: 'Missing tag parameter' }, { status: 400 })
+    if (tags && Array.isArray(tags)) {
+      for (const t of tags) {
+        revalidateTag(t)
+
+        results.push({
+          tag: t,
+          revalidated: true,
+          type: 'tag',
+          timestamp: new Date().toISOString(),
+        })
+      }
     }
 
-    // Revalidate the tag
-    revalidateTag(tag)
+    console.log('Revalidation completed:', results)
+
+    return NextResponse.json({
+      revalidated: true,
+      results,
+      timestamp: new Date().toISOString(),
+    })
+  } catch (error) {
+    console.error('Revalidation error:', error)
+    return NextResponse.json(
+      { 
+        message: 'Error revalidating paths', 
+        error: error instanceof Error ? error.message : 'Unknown error'
+      },
+      { status: 500 }
+    )
+  }
+}
+
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url)
+  const path = searchParams.get('path')
+  const tag = searchParams.get('tag')
+  const secret = searchParams.get('secret')
+  const revalidateAll = searchParams.get('revalidateAll') === 'true'
+  const clearCache = searchParams.get('clearCache') === 'true'
+
+  if (secret !== process.env.REVALIDATE_SECRET) {
+    return NextResponse.json(
+      { message: 'Invalid secret' },
+      { status: 401 }
+    )
+  }
+
+  try {
+    const results: RevalidationResult[] = []
+
+    if (clearCache) {
+      clearPathsCache()
+      console.log('Cleared paths cache')
+    }
+
+    if (revalidateAll) {
+      revalidatePath('/', 'layout')
+      revalidateTag('mdx-content-list')
+      revalidateTag('mdx-paths')
+
+      results.push({
+        path: '/',
+        revalidated: true,
+        type: 'route',
+        timestamp: new Date().toISOString(),
+      })
+    }
+
+    if (path) {
+      revalidatePath(path)
+      revalidateTag(`mdx-content-${path}`)
+
+      results.push({
+        path,
+        revalidated: true,
+        type: 'path',
+        timestamp: new Date().toISOString(),
+      })
+    }
+
+    if (tag) {
+      revalidateTag(tag)
+
+      results.push({
+        tag,
+        revalidated: true,
+        type: 'tag',
+        timestamp: new Date().toISOString(),
+      })
+    }
 
     return NextResponse.json({
       revalidated: true,
-      message: `Tag "${tag}" revalidated successfully`,
-      timestamp: Date.now(),
+      results,
+      timestamp: new Date().toISOString(),
     })
   } catch (error) {
     console.error('Revalidation error:', error)
     return NextResponse.json(
-      { message: 'Error processing revalidation request', error: String(error) },
+      { 
+        message: 'Error revalidating paths', 
+        error: error instanceof Error ? error.message : 'Unknown error'
+      },
       { status: 500 }
     )
   }
diff --git a/app/case-study/[...slug]/page.tsx b/app/case-study/[...slug]/page.tsx
index 12dfa3940..e3a8116a4 100644
--- a/app/case-study/[...slug]/page.tsx
+++ b/app/case-study/[...slug]/page.tsx
@@ -1,65 +1,230 @@
 import 'css/prism.css'
-
+import 'css/tailwind.css'
+import 'css/post.css'
+import 'css/global.css'
+import 'css/doc.css'
 import { components } from '@/components/MDXComponents'
-import { MDXLayoutRenderer } from 'pliny/mdx-components'
-import { sortPosts, coreContent, allCoreContent } from 'pliny/utils/contentlayer'
-import { allCaseStudies } from 'contentlayer/generated'
+import CaseStudyLayout from '../../../layouts/CaseStudyLayout'
 import { Metadata } from 'next'
 import siteMetadata from '@/data/siteMetadata'
 import { notFound } from 'next/navigation'
-import { CaseStudy } from '../../../.contentlayer/generated'
-import React from 'react'
-import CaseStudyLayout from '../../../layouts/CaseStudyLayout'
+import { fetchMDXContentByPath, MDXContent } from '@/utils/strapi'
+import { compileMDX } from 'next-mdx-remote/rsc'
+import readingTime from 'reading-time'
+import GithubSlugger from 'github-slugger'
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic'
+import { CoreContent } from 'pliny/utils/contentlayer'
+// import { CaseStudy } from '../../../.contentlayer/generated'
+
+// Remark and rehype plugins
+import remarkGfm from 'remark-gfm'
+import {
+  remarkExtractFrontmatter,
+  remarkCodeTitles,
+  remarkImgToJsx,
+} from 'pliny/mdx-plugins/index.js'
+import rehypeSlug from 'rehype-slug'
+import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+import rehypePrismPlus from 'rehype-prism-plus'
+import remarkMath from 'remark-math'
+
+export const revalidate = 0
+export const dynamicParams = true
+
+// Heroicon mini link for auto-linking headers
+const linkIcon = fromHtmlIsomorphic(
+  `<span class="content-header-link">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" className="w-5 h-5 linkicon">
+      <path d="M12.232 4.232a2.5 2.5 0 0 1 3.536 3.536l-1.225 1.224a.75.75 0 0 0 1.061 1.06l1.224-1.224a4 4 0 0 0-5.656-5.656l-3 3a4 4 0 0 0 .225 5.865.75.75 0 0 0 .977-1.138 2.5 2.5 0 0 1-.142-3.667l3-3Z" />
+      <path d="M11.603 7.963a.75.75 0 0 0-.977 1.138 2.5 2.5 0 0 1 .142 3.667l-3 3a2.5 2.5 0 0 1-3.536-3.536l1.225-1.224a.75.75 0 0 0-1.061-1.06l-1.224 1.224a4 4 0 1 0 5.656 5.656l3-3a4 4 0 0 0-.225-5.865Z" />
+    </svg>
+  </span>`,
+  { fragment: true }
+)
+
+// MDX processing options with all plugins
+const mdxOptions = {
+  mdxOptions: {
+    remarkPlugins: [
+      remarkExtractFrontmatter,
+      remarkGfm,
+      remarkCodeTitles,
+      remarkMath,
+      remarkImgToJsx,
+    ],
+    rehypePlugins: [
+      rehypeSlug,
+      [
+        rehypeAutolinkHeadings,
+        {
+          behavior: 'prepend',
+          headingProperties: {
+            className: ['content-header'],
+          },
+          content: linkIcon,
+        },
+      ],
+      [rehypePrismPlus, { defaultLanguage: 'tsx', ignoreMissing: true }],
+    ],
+  },
+}
+
+// Generate table of contents from MDX content
+function generateTOC(content: string) {
+  const regXHeader = /\n(?<flag>#{1,3})\s+(?<content>.+)/g
+  const slugger = new GithubSlugger()
+
+  // Remove code blocks to avoid parsing headers inside code
+  const regXCodeBlock = /```[\s\S]*?```/g
+  const contentWithoutCodeBlocks = content.replace(regXCodeBlock, '')
+
+  const headings = Array.from(contentWithoutCodeBlocks.matchAll(regXHeader))
+    .map(({ groups }) => {
+      const flag = groups?.flag
+      const content = groups?.content
+      if (!content) return null
+      return {
+        value: content,
+        url: `#${slugger.slug(content)}`,
+        depth: flag?.length == 1 ? 1 : flag?.length == 2 ? 2 : 3,
+      }
+    })
+    .filter((heading): heading is NonNullable<typeof heading> => heading !== null)
+
+  return headings
+}
 
 export async function generateMetadata({
   params,
 }: {
   params: { slug: string[] }
-}): Promise<Metadata | undefined> {
-  const slug = decodeURI(params.slug.join('/'))
-  const post = allCaseStudies.find((p) => p.slug === slug)
-
-  return {
-    title: post?.title,
-    description: post?.title,
-    openGraph: {
-      title: post?.title,
-      description: post?.title,
-      siteName: siteMetadata.title,
-      locale: 'en_US',
-      type: 'article',
-      url: './',
-    },
-    twitter: {
-      card: 'summary_large_image',
-      title: post?.title,
-      description: post?.title,
-    },
+}): Promise<Metadata> {
+  try {
+    // Handle root case
+    if (!params.slug || params.slug.length === 0) {
+      return {
+        title: 'Case Studies - SigNoz',
+        description: 'Customer case studies and success stories with SigNoz',
+        openGraph: {
+          title: 'Case Studies - SigNoz',
+          description: 'Customer case studies and success stories with SigNoz',
+          type: 'website',
+        },
+      }
+    }
+
+    // Convert slug array to path
+    const path = params.slug.join('/')
+
+    try {
+      const response = await fetchMDXContentByPath('case-studies', path, 'live')
+      const content = Array.isArray(response.data) ? response.data[0] : response.data
+
+      return {
+        title: content?.title,
+        description: content?.description || content?.title,
+        openGraph: {
+          title: content?.title,
+          description: content?.description || content?.title,
+          siteName: siteMetadata.title,
+          locale: 'en_US',
+          type: 'article',
+          url: './',
+        },
+        twitter: {
+          card: 'summary_large_image',
+          title: content?.title,
+          description: content?.description || content?.title,
+        },
+      }
+    } catch (error) {
+      // Content not found, return 404 metadata
+      return {
+        title: 'Page Not Found',
+        description: 'The requested case study could not be found.',
+        robots: {
+          index: false,
+          follow: false,
+        },
+      }
+    }
+  } catch (error) {
+    console.error('Error generating metadata:', error)
+    return {
+      title: 'Error',
+      description: 'An error occurred while loading the case study.',
+    }
   }
 }
 
-export const generateStaticParams = async () => {
-  const paths = allCaseStudies.map((p) => ({ slug: p.slug?.split('/') }))
-
-  return paths
+// Generate static params - returning empty array to generate all pages at runtime
+export async function generateStaticParams() {
+  return []
 }
 
 export default async function Page({ params }: { params: { slug: string[] } }) {
-  const slug = decodeURI(params.slug.join('/'))
-  const post = allCaseStudies.find((p) => p.slug === slug) as CaseStudy
+  const path = params.slug.join('/')
+  console.log(`Fetching case study content for path: ${path}`)
 
-  if (!post) {
+  // Fetch content from Strapi with error handling
+  let content: MDXContent
+  try {
+    if (!process.env.NEXT_PUBLIC_SIGNOZ_CMS_API_URL) {
+      throw new Error('Strapi API URL is not configured')
+    }
+
+    const response = await fetchMDXContentByPath('case-studies', path, 'live')
+    if (!response || !response.data) {
+      console.error(`Invalid response for path: ${path}`)
+      notFound()
+    }
+    content = Array.isArray(response.data) ? response.data[0] : response.data
+  } catch (error) {
+    console.error('Error fetching case study content:', error)
     notFound()
   }
 
-  const mainContent = coreContent(post)
-  const Layout = CaseStudyLayout
+  if (!content) {
+    console.log(`No content returned for path: ${path}`)
+    notFound()
+  }
+
+  // Generate computed fields
+  const readingTimeData = readingTime(content?.content)
+  const toc = generateTOC(content?.content)
+
+  // Compile MDX content with all plugins
+  let compiledContent
+  try {
+    const { content: mdxContent } = await compileMDX({
+      source: content?.content,
+      components,
+      options: mdxOptions as any,
+    })
+    compiledContent = mdxContent
+  } catch (error) {
+    console.error('Error compiling MDX:', error)
+    notFound()
+  }
+
+  // Prepare content for CaseStudyLayout
+  const mainContent: CoreContent<MDXContent> = {
+    title: content?.title,
+    slug: path,
+    path: content?.path || `/case-study/${path}`,
+    type: 'CaseStudy',
+    readingTime: readingTimeData,
+    filePath: `/case-study/${path}`,
+    toc: toc,
+    image: content.image,
+    authors: content.authors?.map((author) => author?.key) || [],
+  }
 
   return (
     <>
-      <Layout content={mainContent} toc={post.toc}>
-        <MDXLayoutRenderer code={post.body.code} components={components} toc={post.toc} />
-      </Layout>
+      <CaseStudyLayout content={mainContent} toc={toc}>
+        <div className="prose prose-slate max-w-none dark:prose-invert">{compiledContent}</div>
+      </CaseStudyLayout>
     </>
   )
 }
diff --git a/app/case-study/loading.tsx b/app/case-study/loading.tsx
deleted file mode 100644
index 869139f44..000000000
--- a/app/case-study/loading.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "@/components/GlobalLoader/GlobalLoader"
\ No newline at end of file
diff --git a/app/comparisons/[...slug]/page.tsx b/app/comparisons/[...slug]/page.tsx
index 09a362987..7da8c6afb 100644
--- a/app/comparisons/[...slug]/page.tsx
+++ b/app/comparisons/[...slug]/page.tsx
@@ -1,11 +1,11 @@
 import 'css/prism.css'
+import 'css/tailwind.css'
+import 'css/post.css'
+import 'css/global.css'
+import 'css/doc.css'
 import 'katex/dist/katex.css'
 
 import { components } from '@/components/MDXComponents'
-import { MDXLayoutRenderer } from 'pliny/mdx-components'
-import { sortPosts, coreContent, allCoreContent } from 'pliny/utils/contentlayer'
-import { allAuthors, allComparisons } from 'contentlayer/generated'
-import type { Authors, Comparison } from 'contentlayer/generated'
 import OpenTelemetryLayout from '@/layouts/OpenTelemetryLayout'
 import BlogLayout from '@/layouts/BlogLayout'
 import { Metadata } from 'next'
@@ -13,6 +13,26 @@ import siteMetadata from '@/data/siteMetadata'
 import { notFound } from 'next/navigation'
 import PageFeedback from '../../../components/PageFeedback/PageFeedback'
 import React from 'react'
+import { fetchMDXContentByPath, MDXContent } from '@/utils/strapi'
+import { generateStructuredData } from '@/utils/structuredData'
+import { compileMDX } from 'next-mdx-remote/rsc'
+import readingTime from 'reading-time'
+import GithubSlugger from 'github-slugger'
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic'
+import { CoreContent } from 'pliny/utils/contentlayer'
+// import type { Authors, Comparison } from 'contentlayer/generated'
+
+// Remark and rehype plugins
+import remarkGfm from 'remark-gfm'
+import {
+  remarkExtractFrontmatter,
+  remarkCodeTitles,
+  remarkImgToJsx,
+} from 'pliny/mdx-plugins/index.js'
+import rehypeSlug from 'rehype-slug'
+import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+import rehypePrismPlus from 'rehype-prism-plus'
+import remarkMath from 'remark-math'
 
 const defaultLayout = 'BlogLayout'
 const layouts = {
@@ -20,92 +40,263 @@ const layouts = {
   BlogLayout,
 }
 
-export const dynamicParams = false
-export const dynamic = 'force-static'
+export const revalidate = 0
+export const dynamicParams = true
+
+// Heroicon mini link for auto-linking headers
+const linkIcon = fromHtmlIsomorphic(
+  `<span class="content-header-link">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" className="w-5 h-5 linkicon">
+      <path d="M12.232 4.232a2.5 2.5 0 0 1 3.536 3.536l-1.225 1.224a.75.75 0 0 0 1.061 1.06l1.224-1.224a4 4 0 0 0-5.656-5.656l-3 3a4 4 0 0 0 .225 5.865.75.75 0 0 0 .977-1.138 2.5 2.5 0 0 1-.142-3.667l3-3Z" />
+      <path d="M11.603 7.963a.75.75 0 0 0-.977 1.138 2.5 2.5 0 0 1 .142 3.667l-3 3a2.5 2.5 0 0 1-3.536-3.536l1.225-1.224a.75.75 0 0 0-1.061-1.06l-1.224 1.224a4 4 0 1 0 5.656 5.656l3-3a4 4 0 0 0-.225-5.865Z" />
+    </svg>
+  </span>`,
+  { fragment: true }
+)
+
+// MDX processing options with all plugins
+const mdxOptions = {
+  mdxOptions: {
+    remarkPlugins: [
+      remarkExtractFrontmatter,
+      remarkGfm,
+      remarkCodeTitles,
+      remarkMath,
+      remarkImgToJsx,
+    ],
+    rehypePlugins: [
+      rehypeSlug,
+      [
+        rehypeAutolinkHeadings,
+        {
+          behavior: 'prepend',
+          headingProperties: {
+            className: ['content-header'],
+          },
+          content: linkIcon,
+        },
+      ],
+      [rehypePrismPlus, { defaultLanguage: 'tsx', ignoreMissing: true }],
+    ],
+  },
+}
+
+// Generate table of contents from MDX content
+function generateTOC(content: string) {
+  const regXHeader = /\n(?<flag>#{1,3})\s+(?<content>.+)/g
+  const slugger = new GithubSlugger()
+
+  // Remove code blocks to avoid parsing headers inside code
+  const regXCodeBlock = /```[\s\S]*?```/g
+  const contentWithoutCodeBlocks = content.replace(regXCodeBlock, '')
+
+  const headings = Array.from(contentWithoutCodeBlocks.matchAll(regXHeader))
+    .map(({ groups }) => {
+      const flag = groups?.flag
+      const content = groups?.content
+      if (!content) return null
+      return {
+        value: content,
+        url: `#${slugger.slug(content)}`,
+        depth: flag?.length == 1 ? 1 : flag?.length == 2 ? 2 : 3,
+      }
+    })
+    .filter((heading): heading is NonNullable<typeof heading> => heading !== null)
+
+  return headings
+}
 
 export async function generateMetadata({
   params,
 }: {
   params: { slug: string[] }
-}): Promise<Metadata | undefined> {
-  const slug = decodeURI(params.slug.join('/'))
-  const post = allComparisons.find((p) => p.slug === slug)
+}): Promise<Metadata> {
+  try {
+    // Convert slug array to path
+    const path = params.slug.join('/')
 
+    try {
+      const isProduction = process.env.VERCEL_ENV === 'production'
+      const deployment_status = isProduction ? 'live' : 'staging'
+      const response = await fetchMDXContentByPath('comparisons', path, deployment_status)
+      const content = response.data as MDXContent
 
-  if (!post) {
-    return notFound()
-  }
+      // Extract author names from the content
+      const authorNames = content.authors?.map((author) => author?.name) || ['SigNoz Team']
 
-  const authorList = post?.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-
-  const publishedAt = new Date(post.date).toISOString()
-  const modifiedAt = new Date(post.lastmod || post.date).toISOString()
-  const authors = authorDetails.map((author) => author.name)
-  let imageList = [siteMetadata.socialBanner]
-  if (post.image) {
-    imageList = typeof post.image === 'string' ? [post.image] : post.image
-  }
-  const ogImages = imageList.map((img) => {
+      const publishedAt = new Date(content.date).toISOString()
+      const modifiedAt = new Date(content.lastmod || content.date).toISOString()
+
+      let imageList = [siteMetadata.socialBanner]
+      if (content.image) {
+        imageList = typeof content.image === 'string' ? [content.image] : content.image
+      }
+      const ogImages = imageList.map((img) => {
+        return {
+          url: img.includes('http') ? img : siteMetadata.siteUrl + img,
+        }
+      })
+
+      return {
+        title: content.title,
+        description: content?.description,
+        openGraph: {
+          title: content.title,
+          description: content?.description,
+          siteName: siteMetadata.title,
+          locale: 'en_US',
+          type: 'article',
+          publishedTime: publishedAt,
+          modifiedTime: modifiedAt,
+          url: './',
+          images: ogImages,
+          authors: authorNames.length > 0 ? authorNames : [siteMetadata.author],
+        },
+        twitter: {
+          card: 'summary_large_image',
+          title: content.title,
+          description: content?.description,
+          images: imageList,
+        },
+      }
+    } catch (error) {
+      // Content not found, return 404 metadata
+      return {
+        title: 'Page Not Found',
+        description: 'The requested comparison could not be found.',
+        robots: {
+          index: false,
+          follow: false,
+        },
+      }
+    }
+  } catch (error) {
+    console.error('Error generating metadata:', error)
     return {
-      url: img.includes('http') ? img : siteMetadata.siteUrl + img,
+      title: 'Error',
+      description: 'An error occurred while loading the comparison.',
     }
-  })
-
-  return {
-    title: post.title,
-    description: post?.description,
-    openGraph: {
-      title: post.title,
-      description: post?.description,
-      siteName: siteMetadata.title,
-      locale: 'en_US',
-      type: 'article',
-      publishedTime: publishedAt,
-      modifiedTime: modifiedAt,
-      url: './',
-      images: ogImages,
-      authors: authors.length > 0 ? authors : [siteMetadata.author],
-    },
-    twitter: {
-      card: 'summary_large_image',
-      title: post.title,
-      description: post?.description,
-      images: imageList,
-    },
   }
 }
 
-export const generateStaticParams = async () => {
-  const paths = allComparisons.map((p) => ({ slug: p.slug?.split('/') }))
-
-  return paths
+// Generate static params - returning empty array to generate all pages at runtime
+export async function generateStaticParams() {
+  return []
 }
 
 export default async function Page({ params }: { params: { slug: string[] } }) {
-  const slug = decodeURI(params.slug.join('/'))
-  // Filter out drafts in production
-  const sortedCoreContents = allCoreContent(sortPosts(allComparisons))
-  const postIndex = sortedCoreContents.findIndex((p) => p.slug === slug)
-  if (postIndex === -1) {
-    return notFound()
+  if (!params.slug || params.slug.length === 0) {
+    return <div className="min-h-screen">Redirecting to comparisons index...</div>
   }
 
-  const post = allComparisons.find((p) => p.slug === slug) as Comparison
-  const authorList = post?.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-  const mainContent = coreContent(post)
-  const jsonLd = post.structuredData
+  const path = params.slug.join('/')
+  console.log(`Fetching comparison content for path: ${path}`)
+
+  // Fetch content from Strapi with error handling
+  let content: MDXContent
+  try {
+    if (!process.env.NEXT_PUBLIC_SIGNOZ_CMS_API_URL) {
+      throw new Error('Strapi API URL is not configured')
+    }
+
+    const isProduction = process.env.VERCEL_ENV === 'production'
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = await fetchMDXContentByPath('comparisons', path, deployment_status)
+    if (!response || !response.data) {
+      console.error(`Invalid response for path: ${path}`)
+      notFound()
+    }
+    content = response.data as MDXContent
+  } catch (error) {
+    console.error('Error fetching comparison content:', error)
+    notFound()
+  }
+
+  if (!content) {
+    console.log(`No content returned for path: ${path}`)
+    notFound()
+  }
+
+  // Generate computed fields
+  const readingTimeData = readingTime(content?.content)
+  const toc = generateTOC(content?.content)
+
+  // Compile MDX content with all plugins
+  let compiledContent
+  try {
+    const { content: mdxContent } = await compileMDX({
+      source: content?.content,
+      components,
+      options: mdxOptions as any,
+    })
+    compiledContent = mdxContent
+  } catch (error) {
+    console.error('Error compiling MDX:', error)
+    notFound()
+  }
+
+  // Generate structured data
+  const structuredData = generateStructuredData('comparisons', content)
+
+  // Prepare content for Layout
+  const mainContent: CoreContent<MDXContent> = {
+    title: content.title,
+    date: content.date,
+    lastmod: content.lastmod,
+    tags: content.tags?.map((tag) => tag.value) || [],
+    draft: content.deployment_status === 'draft',
+    summary: content.summary,
+    description: content.description,
+    images: content.images || [],
+    authors: content.authors?.map((author) => author?.key) || [],
+    slug: path,
+    path: content.path || `/comparisons/${path}`,
+    type: 'Comparison',
+    readingTime: readingTimeData,
+    filePath: `/comparisons/${path}`,
+    structuredData: structuredData,
+    toc: toc,
+    relatedArticles: [],
+  }
+
+  // Prepare author details
+  const authorDetails: CoreContent<MDXContent>[] = content.authors?.map((author) => ({
+    name: author?.name || 'Unknown Author',
+    avatar: author?.image_url || '/static/images/signoz-logo.png',
+    occupation: author?.title || 'Developer Tools',
+    company: 'SigNoz',
+    email: 'team@signoz.io',
+    twitter: 'https://twitter.com/SigNozHQ',
+    linkedin: 'https://www.linkedin.com/company/signoz',
+    github: 'https://github.com/SigNoz/signoz',
+    path: `/authors/${author?.key || 'default'}`,
+    type: 'Authors',
+    slug: author?.key || 'default',
+    readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+    filePath: `/data/authors/${author?.key || 'default'}.mdx`,
+  })) || [
+    {
+      // Fallback author if no authors are found
+      name: 'SigNoz Team',
+      avatar: '/static/images/signoz-logo.png',
+      occupation: 'Developer Tools',
+      company: 'SigNoz',
+      email: 'team@signoz.io',
+      twitter: 'https://twitter.com/SigNozHQ',
+      linkedin: 'https://www.linkedin.com/company/signoz',
+      github: 'https://github.com/SigNoz/signoz',
+      path: '/authors/default',
+      type: 'Authors',
+      slug: 'default',
+      readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+      filePath: '/data/authors/default.mdx',
+    },
+  ]
 
   // Choose layout based on slug or post layout
-  let layoutName = post.layout || defaultLayout
-  if (slug.includes('opentelemetry')) {
+  let layoutName = content.layout || defaultLayout
+  if (path.includes('opentelemetry')) {
     layoutName = 'OpenTelemetryLayout'
   } else {
     layoutName = 'BlogLayout'
@@ -118,15 +309,17 @@ export default async function Page({ params }: { params: { slug: string[] } }) {
     <>
       <script
         type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(structuredData) }}
       />
       <Layout
         content={mainContent}
         authorDetails={authorDetails}
-        authors={post?.authors}
-        toc={post.toc}
+        authors={content.authors?.map((author) => author?.key) || []}
+        toc={toc}
       >
-        <MDXLayoutRenderer code={post.body.code} components={components} toc={post.toc} />
+        <div className="prose max-w-none dark:prose-invert prose-headings:scroll-mt-16">
+          {compiledContent}
+        </div>
         <PageFeedback />
       </Layout>
     </>
diff --git a/app/comparisons/loading.tsx b/app/comparisons/loading.tsx
deleted file mode 100644
index 869139f44..000000000
--- a/app/comparisons/loading.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "@/components/GlobalLoader/GlobalLoader"
\ No newline at end of file
diff --git a/app/faqs/FAQsClient.tsx b/app/faqs/FAQsClient.tsx
new file mode 100644
index 000000000..ecfaa3d62
--- /dev/null
+++ b/app/faqs/FAQsClient.tsx
@@ -0,0 +1,115 @@
+'use client'
+
+import Button from '@/components/ui/Button'
+import Link from 'next/link'
+import React, { useState } from 'react'
+
+interface FAQ {
+  title: string
+  description: string
+  path: string
+  date: string
+  tags: string[]
+  draft: boolean
+}
+
+interface FAQsClientProps {
+  faqs: FAQ[]
+}
+
+export default function FAQsClient({ faqs }: FAQsClientProps) {
+  const [selectedTags, setSelectedTags] = useState<string[]>([])
+
+  // Get unique tags from all FAQs
+  const allTags = Array.from(
+    new Set(faqs.filter((faq) => !faq.draft).flatMap((faq) => faq.tags || []))
+  ).sort()
+
+  // Filter only by tags
+  const filteredFaqs = faqs
+    .filter((faq) => !faq.draft)
+    .filter(
+      (faq) => selectedTags.length === 0 || selectedTags.some((tag) => faq.tags?.includes(tag))
+    )
+
+  const toggleTag = (tag: string) => {
+    setSelectedTags((prev) => (prev.includes(tag) ? prev.filter((t) => t !== tag) : [...prev, tag]))
+  }
+
+  console.log('filteredFaqs', filteredFaqs)
+
+  return (
+    <div className="relative min-h-screen w-full bg-signoz_ink-500">
+      <div className="bg-dot-pattern masked-dots absolute top-0 flex h-full w-full items-center justify-center" />
+      <div className="absolute left-0 right-0 top-0 mx-auto h-[300px] w-full flex-shrink-0 rounded-[956px] bg-gradient-to-b from-[rgba(190,107,241,1)] to-[rgba(69,104,220,0)] bg-[length:110%] bg-no-repeat opacity-30 blur-[300px] sm:h-[450px] sm:bg-[center_-500px] md:h-[956px]" />
+
+      <div className="relative mx-auto flex w-full max-w-7xl flex-col items-center px-4 py-8 sm:px-6 sm:py-12 md:py-24 lg:px-8">
+        <div className="w-full space-y-4 sm:space-y-6">
+          <h1 className="text-center text-2xl font-bold leading-tight tracking-tight text-signoz_vanilla-100 sm:text-3xl md:text-4xl lg:text-5xl">
+            Frequently Asked Questions
+          </h1>
+          <p className="mx-auto max-w-2xl text-center text-base leading-relaxed text-signoz_vanilla-400 sm:text-lg">
+            Find answers to common questions about SigNoz's features, capabilities, and
+            implementation
+          </p>
+          <div className="mx-auto mt-6 w-full max-w-2xl px-4 sm:mt-8">
+            <div className="flex flex-wrap items-center justify-center gap-2">
+              {allTags.map((tag) => (
+                <Button
+                  isButton
+                  key={tag}
+                  onClick={() => toggleTag(tag)}
+                  className={`rounded-full px-2 py-1 text-xs font-medium transition-colors sm:px-3 sm:text-sm ${
+                    selectedTags.includes(tag)
+                      ? 'bg-primary-500 text-signoz_vanilla-100'
+                      : 'bg-signoz_ink-400 text-signoz_vanilla-400 hover:bg-signoz_ink-300'
+                  } border border-signoz_slate-400`}
+                >
+                  {tag}
+                </Button>
+              ))}
+            </div>
+            {selectedTags.length > 0 && (
+              <Button
+                isButton
+                type="button"
+                onClick={() => setSelectedTags([])}
+                variant="link"
+                className="mt-4 w-full justify-center text-xs font-medium text-primary-400 hover:text-primary-300 sm:text-sm"
+              >
+                Clear filters
+              </Button>
+            )}
+          </div>
+        </div>
+
+        <div className="w-full py-8 sm:py-10">
+          <ul className="space-y-4 p-2 sm:space-y-6">
+            {filteredFaqs.map((faq) => (
+              <li key={faq.path}>
+                <Link
+                  href={`/faqs${faq.path}`}
+                  className="block transform rounded-lg border border-signoz_slate-400 bg-signoz_ink-400 p-4 shadow-md transition duration-500 hover:shadow-lg sm:p-6"
+                >
+                  <article>
+                    <div>
+                      <h2 className="mb-2 text-lg font-bold leading-snug tracking-tight text-signoz_vanilla-100 sm:mb-3 sm:text-xl">
+                        {faq.title}
+                      </h2>
+                      <p className="prose mb-3 line-clamp-3 max-w-none text-sm text-signoz_vanilla-400 sm:text-base">
+                        {faq.description}
+                      </p>
+                    </div>
+                    <div className="text-sm font-medium leading-6 text-primary-500 hover:text-primary-400 sm:text-base">
+                      Read more &rarr;
+                    </div>
+                  </article>
+                </Link>
+              </li>
+            ))}
+          </ul>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/app/faqs/[...slug]/page.tsx b/app/faqs/[...slug]/page.tsx
index ed3c19571..df1c85137 100644
--- a/app/faqs/[...slug]/page.tsx
+++ b/app/faqs/[...slug]/page.tsx
@@ -1,9 +1,9 @@
 import 'css/prism.css'
+import 'css/tailwind.css'
+import 'css/post.css'
+import 'css/global.css'
+import 'css/doc.css'
 import { components } from '@/components/MDXComponents'
-import { MDXLayoutRenderer } from 'pliny/mdx-components'
-import { sortPosts, coreContent, allCoreContent } from 'pliny/utils/contentlayer'
-import { allFAQs, allAuthors } from 'contentlayer/generated'
-import type { Authors } from 'contentlayer/generated'
 import FAQLayout from '@/layouts/FAQLayout'
 import { Metadata } from 'next'
 import siteMetadata from '@/data/siteMetadata'
@@ -11,84 +11,290 @@ import { notFound } from 'next/navigation'
 import Link from 'next/link'
 import { SidebarIcons } from '@/components/sidebar-icons/icons'
 import Button from '@/components/ui/Button'
+import { fetchMDXContentByPath, MDXContent } from '@/utils/strapi'
+import { generateStructuredData } from '@/utils/structuredData'
+import { CoreContent } from 'pliny/utils/contentlayer'
+import { Blog, Authors } from 'contentlayer/generated'
+import { compileMDX } from 'next-mdx-remote/rsc'
+import readingTime from 'reading-time'
+import GithubSlugger from 'github-slugger'
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic'
+
+// Remark and rehype plugins
+import remarkGfm from 'remark-gfm'
+import {
+  remarkExtractFrontmatter,
+  remarkCodeTitles,
+  remarkImgToJsx,
+} from 'pliny/mdx-plugins/index.js'
+import rehypeSlug from 'rehype-slug'
+import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+import rehypePrismPlus from 'rehype-prism-plus'
+import remarkMath from 'remark-math'
+
+export const revalidate = 0
+export const dynamicParams = true
+
+// Heroicon mini link for auto-linking headers
+const linkIcon = fromHtmlIsomorphic(
+  `<span class="content-header-link">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" className="w-5 h-5 linkicon">
+      <path d="M12.232 4.232a2.5 2.5 0 0 1 3.536 3.536l-1.225 1.224a.75.75 0 0 0 1.061 1.06l1.224-1.224a4 4 0 0 0-5.656-5.656l-3 3a4 4 0 0 0 .225 5.865.75.75 0 0 0 .977-1.138 2.5 2.5 0 0 1-.142-3.667l3-3Z" />
+      <path d="M11.603 7.963a.75.75 0 0 0-.977 1.138 2.5 2.5 0 0 1 .142 3.667l-3 3a2.5 2.5 0 0 1-3.536-3.536l1.225-1.224a.75.75 0 0 0-1.061-1.06l-1.224 1.224a4 4 0 1 0 5.656 5.656l3-3a4 4 0 0 0-.225-5.865Z" />
+    </svg>
+  </span>`,
+  { fragment: true }
+)
+
+// MDX processing options with all plugins
+const mdxOptions = {
+  mdxOptions: {
+    remarkPlugins: [
+      remarkExtractFrontmatter,
+      remarkGfm,
+      remarkCodeTitles,
+      remarkMath,
+      remarkImgToJsx,
+    ],
+    rehypePlugins: [
+      rehypeSlug,
+      [
+        rehypeAutolinkHeadings,
+        {
+          behavior: 'prepend',
+          headingProperties: {
+            className: ['content-header'],
+          },
+          content: linkIcon,
+        },
+      ],
+      [rehypePrismPlus, { defaultLanguage: 'tsx', ignoreMissing: true }],
+    ],
+  },
+}
+
+// Generate table of contents from MDX content
+function generateTOC(content: string) {
+  const regXHeader = /\n(?<flag>#{1,3})\s+(?<content>.+)/g
+  const slugger = new GithubSlugger()
+
+  // Remove code blocks to avoid parsing headers inside code
+  const regXCodeBlock = /```[\s\S]*?```/g
+  const contentWithoutCodeBlocks = content.replace(regXCodeBlock, '')
+
+  const headings = Array.from(contentWithoutCodeBlocks.matchAll(regXHeader))
+    .map(({ groups }) => {
+      const flag = groups?.flag
+      const content = groups?.content
+      if (!content) return null
+      return {
+        value: content,
+        url: `#${slugger.slug(content)}`,
+        depth: flag?.length == 1 ? 1 : flag?.length == 2 ? 2 : 3,
+      }
+    })
+    .filter((heading): heading is NonNullable<typeof heading> => heading !== null)
+
+  return headings
+}
 
 export async function generateMetadata({
   params,
 }: {
   params: { slug: string[] }
-}): Promise<Metadata | undefined> {
-  const slug = decodeURI(params.slug.join('/'))
-  const post = allFAQs.find((p) => p.slug === slug)
-  const authorList = post?.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-  if (!post) {
-    return
-  }
+}): Promise<Metadata> {
+  try {
+    // Convert slug array to path
+    const path = params.slug.join('/')
 
-  const publishedAt = new Date(post.date).toISOString()
-  const modifiedAt = new Date(post.lastmod || post.date).toISOString()
-  const authors = authorDetails.map((author) => author.name)
-
-  return {
-    title: post.title,
-    description: post.description,
-    openGraph: {
-      title: post.title,
-      description: post.description,
-      siteName: siteMetadata.title,
-      locale: 'en_US',
-      type: 'article',
-      publishedTime: publishedAt,
-      modifiedTime: modifiedAt,
-      url: './',
-      authors: authors.length > 0 ? authors : [siteMetadata.author],
-    },
-    twitter: {
-      card: 'summary_large_image',
-      title: post.title,
-      description: post.description,
-    },
+    const isProduction = process.env.VERCEL_ENV === 'production'
+
+    try {
+      const deployment_status = isProduction ? 'live' : 'staging'
+      const { data: content } = await fetchMDXContentByPath('faqs', path, deployment_status)
+
+      // Extract author names from the content
+      const authorNames = (content as MDXContent)?.authors?.map((author) => author?.name) || [
+        'SigNoz Team',
+      ]
+
+      return {
+        title: (content as MDXContent).title,
+        description:
+          (content as MDXContent)?.description || `${(content as MDXContent)?.title} - SigNoz FAQ`,
+        authors: authorNames.map((name) => ({ name })),
+        openGraph: {
+          title: (content as MDXContent)?.title,
+          description:
+            (content as MDXContent)?.description ||
+            `${(content as MDXContent)?.title} - SigNoz FAQ`,
+          siteName: siteMetadata.title,
+          locale: 'en_US',
+          type: 'article',
+          publishedTime: (content as MDXContent)?.date,
+          modifiedTime: (content as MDXContent)?.updatedAt,
+          url: (content as MDXContent)?.path || './',
+          authors: authorNames,
+        },
+        twitter: {
+          card: 'summary_large_image',
+          title: (content as MDXContent)?.title,
+          description:
+            (content as MDXContent)?.description ||
+            `${(content as MDXContent)?.title} - SigNoz FAQ`,
+        },
+      }
+    } catch (error) {
+      // Content not found, return 404 metadata
+      return {
+        title: 'Page Not Found',
+        description: 'The requested FAQ page could not be found.',
+        robots: {
+          index: false,
+          follow: false,
+        },
+      }
+    }
+  } catch (error) {
+    console.error('Error generating metadata:', error)
+    return {
+      title: 'Error',
+      description: 'An error occurred while loading the FAQ page.',
+    }
   }
 }
 
-export const generateStaticParams = async () => {
-  const paths = allFAQs.map((p) => ({ slug: p.slug?.split('/') }))
-  return paths
+// Generate static params - returning empty array to generate all pages at runtime
+export async function generateStaticParams() {
+  return []
 }
 
 export default async function Page({ params }: { params: { slug: string[] } }) {
-  const slug = decodeURI(params.slug.join('/'))
-  const sortedCoreContents = allCoreContent(sortPosts(allFAQs))
-  const postIndex = sortedCoreContents.findIndex((p) => p.slug === slug)
-  if (postIndex === -1) {
-    return notFound()
+  if (!params.slug || params.slug.length === 0) {
+    return <div className="min-h-screen">Redirecting to FAQs index...</div>
+  }
+
+  const path = params.slug.join('/')
+  console.log(`Fetching FAQ content for path: ${path}`)
+
+  const isProduction = process.env.VERCEL_ENV === 'production'
+
+  // Fetch content from Strapi with error handling
+  let content: MDXContent
+  try {
+    if (!process.env.NEXT_PUBLIC_SIGNOZ_CMS_API_URL) {
+      throw new Error('Strapi API URL is not configured')
+    }
+
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = await fetchMDXContentByPath('faqs', path, deployment_status)
+    if (!response || !response.data) {
+      console.error(`Invalid response for path: ${path}`)
+      notFound()
+    }
+    content = response.data as MDXContent
+  } catch (error) {
+    console.error('Error fetching FAQ content:', error)
+    notFound()
   }
 
-  const post = allFAQs.find((p) => p.slug === slug)
-  if (!post) {
-    return notFound()
+  if (!content) {
+    console.log(`No content returned for path: ${path}`)
+    notFound()
   }
 
-  const authorList = post.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-  const mainContent = coreContent(post as any)
-  const jsonLd = post.structuredData
+  // Generate computed fields
+  const readingTimeData = readingTime(content?.content)
+  const toc = generateTOC(content?.content)
+
+  // Compile MDX content with all plugins
+  let compiledContent
+  try {
+    const { content: mdxContent } = await compileMDX({
+      source: content?.content,
+      components,
+      options: mdxOptions as any,
+    })
+    compiledContent = mdxContent
+  } catch (error) {
+    console.error('Error compiling MDX:', error)
+    notFound()
+  }
+
+  console.log('logging content tags', content.tags)
+
+  // Generate structured data
+  const structuredData = generateStructuredData('faqs', content)
+
+  // Prepare content for FAQLayout
+  const mainContent: CoreContent<Blog> = {
+    title: content.title,
+    date: content.date,
+    lastmod: content.updatedAt,
+    tags: content.tags?.data?.map((tag) => tag.attributes?.name) || [],
+    draft: content.deployment_status === 'draft',
+    summary: content.description,
+    images: content.images || [],
+    authors: content.authors?.map((author) => author?.name) || [],
+    slug: path,
+    path: content.path || `/faqs/${path}`,
+    type: 'Blog',
+    readingTime: readingTimeData,
+    filePath: `/faqs/${path}`,
+    structuredData: structuredData,
+    toc: toc,
+    relatedArticles:
+      content.related_faqs?.data?.map((faq) => ({
+        title: faq.attributes?.title,
+        slug: faq.attributes?.path,
+        date: faq.attributes?.date,
+      })) || [],
+  }
+
+  // Prepare author details from the authors relation
+  const authorDetails: CoreContent<Authors>[] = content.authors?.data?.map((author) => ({
+    name: author.attributes?.name || 'Unknown Author',
+    avatar: author.attributes?.image_url || '/static/images/signoz-logo.png',
+    occupation: author.attributes?.title || 'Developer Tools',
+    company: 'SigNoz',
+    email: 'team@signoz.io',
+    twitter: 'https://twitter.com/SigNozHQ',
+    linkedin: 'https://www.linkedin.com/company/signoz',
+    github: 'https://github.com/SigNoz/signoz',
+    path: `/authors/${author.attributes?.key || 'default'}`,
+    type: 'Authors',
+    slug: author.attributes?.key || 'default',
+    readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+    filePath: `/data/authors/${author.attributes?.key || 'default'}.mdx`,
+  })) || [
+    {
+      // Fallback author if no authors are found
+      name: 'SigNoz Team',
+      avatar: '/static/images/signoz-logo.png',
+      occupation: 'Developer Tools',
+      company: 'SigNoz',
+      email: 'team@signoz.io',
+      twitter: 'https://twitter.com/SigNozHQ',
+      linkedin: 'https://www.linkedin.com/company/signoz',
+      github: 'https://github.com/SigNoz/signoz',
+      path: '/authors/default',
+      type: 'Authors',
+      slug: 'default',
+      readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+      filePath: '/data/authors/default.mdx',
+    },
+  ]
 
   return (
     <>
       <script
         type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(structuredData) }}
       />
 
       <div className="container mx-auto">
-        <Button variant={"ghost"} isButton={true} className="ml-3.5 mt-10 hover:bg-transparent">
+        <Button variant={'ghost'} isButton={true} className="ml-3.5 mt-10 hover:bg-transparent">
           <Link href={`/faqs/`} className="flex items-center">
             <SidebarIcons.ArrowLeft />
             <span className="pl-1.5 text-sm">Back to FAQs</span>
@@ -96,17 +302,23 @@ export default async function Page({ params }: { params: { slug: string[] } }) {
         </Button>
       </div>
 
-      <FAQLayout 
-        content={mainContent} 
-        authorDetails={authorDetails} 
-        authors={post?.authors}
-        toc={post.toc}
+      <FAQLayout
+        content={mainContent}
+        authorDetails={authorDetails}
+        authors={content.authors?.map((author) => author?.name) || []}
+        toc={toc}
+        tags={content.tags?.map((tag) => tag?.value) || []}
+        relatedArticles={
+          content.related_faqs?.map((faq) => ({
+            title: faq?.title,
+            publishedOn: faq?.date,
+            url: `/faqs/${faq?.path}`,
+          })) || []
+        }
       >
-        <MDXLayoutRenderer 
-          code={post.body.code} 
-          components={components} 
-          toc={post.toc}
-        />
+        <div className="prose max-w-none dark:prose-invert prose-headings:scroll-mt-16">
+          {compiledContent}
+        </div>
       </FAQLayout>
     </>
   )
diff --git a/app/faqs/loading.tsx b/app/faqs/loading.tsx
deleted file mode 100644
index 869139f44..000000000
--- a/app/faqs/loading.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "@/components/GlobalLoader/GlobalLoader"
\ No newline at end of file
diff --git a/app/faqs/page.tsx b/app/faqs/page.tsx
index 93c73151d..6f08a5bd3 100644
--- a/app/faqs/page.tsx
+++ b/app/faqs/page.tsx
@@ -1,109 +1,44 @@
-'use client'
-
-import Button from '@/components/ui/Button'
-import { allFAQs } from 'contentlayer/generated'
-import Link from 'next/link'
-import React, { useState } from 'react'
-
-export default function FAQsPage() {
-  const [selectedTags, setSelectedTags] = useState<string[]>([])
-
-  // Get unique tags from all FAQs
-  const allTags = Array.from(
-    new Set(
-      allFAQs
-        .filter((faq) => !faq.draft)
-        .flatMap((faq) => faq.tags || [])
-    )
-  ).sort()
-
-  // Filter only by tags
-  const faqs = allFAQs
-    .filter((faq) => !faq.draft)
-    .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
-    .filter((faq) => 
-      selectedTags.length === 0 || selectedTags.some(tag => faq.tags?.includes(tag))
-    )
-
-  const toggleTag = (tag: string) => {
-    setSelectedTags(prev =>
-      prev.includes(tag)
-        ? prev.filter(t => t !== tag)
-        : [...prev, tag]
-    )
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
+import { notFound } from 'next/navigation'
+import FAQsClient from './FAQsClient'
+
+export const revalidate = 0
+export const dynamicParams = true
+
+export default async function FAQsPage() {
+  const isProduction = process.env.VERCEL_ENV === 'production'
+  const deploymentStatus = isProduction ? 'live' : 'staging'
+
+  try {
+    // Fetch all FAQs from Strapi
+    const response = (await fetchMDXContentByPath(
+      'faqs',
+      undefined,
+      deploymentStatus,
+      true
+    )) as MDXContentApiResponse
+
+    if (!response || !response.data) {
+      console.error('Invalid response from Strapi')
+      notFound()
+    }
+
+    // Transform the data to match the client component's expected format
+    const faqs = response.data.map((faq) => ({
+      title: faq.title,
+      description: faq.description,
+      path: faq.path,
+      date: faq.date,
+      tags: faq.tags?.map((tag) => tag.value) || [],
+      draft: faq.deployment_status === 'draft',
+    }))
+
+    // Sort by date (since API sorts but we want to ensure client side too)
+    const sortedFaqs = faqs.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+
+    return <FAQsClient faqs={sortedFaqs} />
+  } catch (error) {
+    console.error('Error fetching FAQs:', error)
+    notFound()
   }
-
-  return (
-    <div className="relative min-h-screen w-full bg-signoz_ink-500">
-      <div className="bg-dot-pattern masked-dots absolute top-0 flex h-full w-full items-center justify-center" />
-      <div className="absolute left-0 right-0 top-0 mx-auto h-[300px] sm:h-[450px] w-full flex-shrink-0 rounded-[956px] bg-gradient-to-b from-[rgba(190,107,241,1)] to-[rgba(69,104,220,0)] bg-[length:110%] bg-no-repeat opacity-30 blur-[300px] sm:bg-[center_-500px] md:h-[956px]" />
-
-      <div className="relative mx-auto flex w-full max-w-7xl flex-col items-center px-4 sm:px-6 lg:px-8 py-8 sm:py-12 md:py-24">
-        <div className="w-full space-y-4 sm:space-y-6">
-          <h1 className="text-center text-2xl sm:text-3xl md:text-4xl lg:text-5xl font-bold leading-tight tracking-tight text-signoz_vanilla-100">
-            Frequently Asked Questions
-          </h1>
-          <p className="text-center text-base sm:text-lg leading-relaxed text-signoz_vanilla-400 max-w-2xl mx-auto">
-            Find answers to common questions about SigNoz's features, capabilities, and implementation
-          </p>
-          <div className="mx-auto mt-6 sm:mt-8 w-full max-w-2xl px-4">
-            <div className="flex flex-wrap items-center justify-center gap-2">
-              {allTags.map((tag) => (
-                <Button
-                  isButton
-                  key={tag}
-                  onClick={() => toggleTag(tag as string)}
-                  className={`rounded-full px-2 sm:px-3 py-1 text-xs sm:text-sm font-medium transition-colors ${
-                    selectedTags.includes(tag as string)
-                      ? 'bg-primary-500 text-signoz_vanilla-100'
-                      : 'bg-signoz_ink-400 text-signoz_vanilla-400 hover:bg-signoz_ink-300'
-                  } border border-signoz_slate-400`}
-                >
-                  {tag}
-                </Button>
-              ))}
-            </div>
-            {selectedTags.length > 0 && (
-              <Button
-                isButton
-                type="button"
-                onClick={() => setSelectedTags([])}
-                variant="link"
-                className="mt-4 w-full justify-center text-xs sm:text-sm font-medium text-primary-400 hover:text-primary-300"
-              >
-                Clear filters
-              </Button>
-            )}
-          </div>
-        </div>
-
-        <div className="w-full py-8 sm:py-10">
-          <ul className="space-y-4 p-2 sm:space-y-6">
-            {faqs.map((faq) => (
-              <li key={faq.slug}>
-                <Link
-                  href={`/faqs/${faq.slug}`}
-                  className="block transform rounded-lg border border-signoz_slate-400 bg-signoz_ink-400 p-4 sm:p-6 shadow-md transition duration-500 hover:shadow-lg"
-                >
-                  <article>
-                    <div>
-                      <h2 className="mb-2 sm:mb-3 text-lg sm:text-xl font-bold leading-snug tracking-tight text-signoz_vanilla-100">
-                        {faq.title}
-                      </h2>
-                      <p className="prose mb-3 max-w-none text-sm sm:text-base text-signoz_vanilla-400 line-clamp-3">
-                        {faq.description}
-                      </p>
-                    </div>
-                    <div className="text-sm sm:text-base font-medium leading-6 text-primary-500 hover:text-primary-400">
-                      Read more &rarr;
-                    </div>
-                  </article>
-                </Link>
-              </li>
-            ))}
-          </ul>
-        </div>
-      </div>
-    </div>
-  )
 }
diff --git a/app/guides/[...slug]/page.tsx b/app/guides/[...slug]/page.tsx
index 035aa0e7d..c5e46a2a3 100644
--- a/app/guides/[...slug]/page.tsx
+++ b/app/guides/[...slug]/page.tsx
@@ -1,9 +1,9 @@
 import 'css/prism.css'
+import 'css/tailwind.css'
+import 'css/post.css'
+import 'css/global.css'
+import 'css/doc.css'
 import { components } from '@/components/MDXComponents'
-import { MDXLayoutRenderer } from 'pliny/mdx-components'
-import { sortPosts, coreContent, allCoreContent } from 'pliny/utils/contentlayer'
-import { allGuides, allAuthors } from 'contentlayer/generated'
-import type { Authors, Guide } from 'contentlayer/generated'
 import OpenTelemetryLayout from '@/layouts/OpenTelemetryLayout'
 import GuidesLayout from '@/layouts/GuidesLayout'
 import { Metadata } from 'next'
@@ -14,6 +14,25 @@ import PageFeedback from '../../../components/PageFeedback/PageFeedback'
 import React from 'react'
 import GrafanaVsSigNozFloatingCard from '@/components/GrafanaVsSigNoz/GrafanaVsSigNozFloatingCard'
 import Button from '@/components/ui/Button'
+import { fetchMDXContentByPath, MDXContent } from '@/utils/strapi'
+import { generateStructuredData } from '@/utils/structuredData'
+import { compileMDX } from 'next-mdx-remote/rsc'
+import readingTime from 'reading-time'
+import GithubSlugger from 'github-slugger'
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic'
+import { CoreContent } from 'pliny/utils/contentlayer'
+
+// Remark and rehype plugins
+import remarkGfm from 'remark-gfm'
+import {
+  remarkExtractFrontmatter,
+  remarkCodeTitles,
+  remarkImgToJsx,
+} from 'pliny/mdx-plugins/index.js'
+import rehypeSlug from 'rehype-slug'
+import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+import rehypePrismPlus from 'rehype-prism-plus'
+import remarkMath from 'remark-math'
 
 const defaultLayout = 'GuidesLayout'
 const layouts = {
@@ -21,91 +40,263 @@ const layouts = {
   GuidesLayout,
 }
 
-export const dynamicParams = false
-export const dynamic = 'force-static'
+export const revalidate = 0
+export const dynamicParams = true
+
+// Heroicon mini link for auto-linking headers
+const linkIcon = fromHtmlIsomorphic(
+  `<span class="content-header-link">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" className="w-5 h-5 linkicon">
+      <path d="M12.232 4.232a2.5 2.5 0 0 1 3.536 3.536l-1.225 1.224a.75.75 0 0 0 1.061 1.06l1.224-1.224a4 4 0 0 0-5.656-5.656l-3 3a4 4 0 0 0 .225 5.865.75.75 0 0 0 .977-1.138 2.5 2.5 0 0 1-.142-3.667l3-3Z" />
+      <path d="M11.603 7.963a.75.75 0 0 0-.977 1.138 2.5 2.5 0 0 1 .142 3.667l-3 3a2.5 2.5 0 0 1-3.536-3.536l1.225-1.224a.75.75 0 0 0-1.061-1.06l-1.224 1.224a4 4 0 1 0 5.656 5.656l3-3a4 4 0 0 0-.225-5.865Z" />
+    </svg>
+  </span>`,
+  { fragment: true }
+)
+
+// MDX processing options with all plugins
+const mdxOptions = {
+  mdxOptions: {
+    remarkPlugins: [
+      remarkExtractFrontmatter,
+      remarkGfm,
+      remarkCodeTitles,
+      remarkMath,
+      remarkImgToJsx,
+    ],
+    rehypePlugins: [
+      rehypeSlug,
+      [
+        rehypeAutolinkHeadings,
+        {
+          behavior: 'prepend',
+          headingProperties: {
+            className: ['content-header'],
+          },
+          content: linkIcon,
+        },
+      ],
+      [rehypePrismPlus, { defaultLanguage: 'tsx', ignoreMissing: true }],
+    ],
+  },
+}
+
+// Generate table of contents from MDX content
+function generateTOC(content: string) {
+  const regXHeader = /\n(?<flag>#{1,3})\s+(?<content>.+)/g
+  const slugger = new GithubSlugger()
+
+  // Remove code blocks to avoid parsing headers inside code
+  const regXCodeBlock = /```[\s\S]*?```/g
+  const contentWithoutCodeBlocks = content.replace(regXCodeBlock, '')
+
+  const headings = Array.from(contentWithoutCodeBlocks.matchAll(regXHeader))
+    .map(({ groups }) => {
+      const flag = groups?.flag
+      const content = groups?.content
+      if (!content) return null
+      return {
+        value: content,
+        url: `#${slugger.slug(content)}`,
+        depth: flag?.length == 1 ? 1 : flag?.length == 2 ? 2 : 3,
+      }
+    })
+    .filter((heading): heading is NonNullable<typeof heading> => heading !== null)
+
+  return headings
+}
 
 export async function generateMetadata({
   params,
 }: {
   params: { slug: string[] }
-}): Promise<Metadata | undefined> {
-  const slug = decodeURI(params.slug.join('/'))
-  const post = allGuides.find((p) => p.slug === slug)
+}): Promise<Metadata> {
+  try {
+    // Convert slug array to path
+    const path = params.slug.join('/')
 
-  if (!post) {
-    return notFound()
-  }
+    try {
+      const isProduction = process.env.VERCEL_ENV === 'production'
+      const deployment_status = isProduction ? 'live' : 'staging'
+      const response = await fetchMDXContentByPath('guides', path, deployment_status)
+      const content = response.data as MDXContent
 
-  const authorList = post?.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-
-  const publishedAt = new Date(post.date).toISOString()
-  const modifiedAt = new Date(post.lastmod || post.date).toISOString()
-  const authors = authorDetails.map((author) => author.name)
-  let imageList = [siteMetadata.socialBanner]
-  if (post.image) {
-    imageList = typeof post.image === 'string' ? [post.image] : post.image
-  }
-  const ogImages = imageList.map((img) => {
+      // Extract author names from the content
+      const authorNames = content.authors?.map((author) => author?.name) || ['SigNoz Team']
+
+      const publishedAt = new Date(content.date).toISOString()
+      const modifiedAt = new Date(content.lastmod || content.date).toISOString()
+
+      let imageList = [siteMetadata.socialBanner]
+      if (content.image) {
+        imageList = typeof content.image === 'string' ? [content.image] : content.image
+      }
+      const ogImages = imageList.map((img) => {
+        return {
+          url: img.includes('http') ? img : siteMetadata.siteUrl + img,
+        }
+      })
+
+      return {
+        title: content.title,
+        description: content.description,
+        openGraph: {
+          title: content.title,
+          description: content.description,
+          siteName: siteMetadata.title,
+          locale: 'en_US',
+          type: 'article',
+          publishedTime: publishedAt,
+          modifiedTime: modifiedAt,
+          url: './',
+          images: ogImages,
+          authors: authorNames.length > 0 ? authorNames : [siteMetadata.author],
+        },
+        twitter: {
+          card: 'summary_large_image',
+          title: content.title,
+          description: content.summary,
+          images: imageList,
+        },
+      }
+    } catch (error) {
+      // Content not found, return 404 metadata
+      return {
+        title: 'Page Not Found',
+        description: 'The requested guide could not be found.',
+        robots: {
+          index: false,
+          follow: false,
+        },
+      }
+    }
+  } catch (error) {
+    console.error('Error generating metadata:', error)
     return {
-      url: img.includes('http') ? img : siteMetadata.siteUrl + img,
+      title: 'Error',
+      description: 'An error occurred while loading the guide.',
     }
-  })
-
-  return {
-    title: post.title,
-    description: post.description,
-    openGraph: {
-      title: post.title,
-      description: post.description,
-      siteName: siteMetadata.title,
-      locale: 'en_US',
-      type: 'article',
-      publishedTime: publishedAt,
-      modifiedTime: modifiedAt,
-      url: './',
-      images: ogImages,
-      authors: authors.length > 0 ? authors : [siteMetadata.author],
-    },
-    twitter: {
-      card: 'summary_large_image',
-      title: post.title,
-      description: post.summary,
-      images: imageList,
-    },
   }
 }
 
-export const generateStaticParams = async () => {
-  const paths = allGuides.map((p) => ({ slug: p.slug?.split('/') }))
-
-  return paths
+// Generate static params - returning empty array to generate all pages at runtime
+export async function generateStaticParams() {
+  return []
 }
 
 export default async function Page({ params }: { params: { slug: string[] } }) {
-  const slug = decodeURI(params.slug.join('/'))
-  // Filter out drafts in production
-  const sortedCoreContents = allCoreContent(sortPosts(allGuides))
-  const postIndex = sortedCoreContents.findIndex((p) => p.slug === slug)
-  if (postIndex === -1) {
-    return notFound()
+  if (!params.slug || params.slug.length === 0) {
+    return <div className="min-h-screen">Redirecting to guides index...</div>
   }
 
-  const post = allGuides.find((p) => p.slug === slug) as Guide
-  const authorList = post?.authors || ['default']
-  const authorDetails = authorList.map((author) => {
-    const authorResults = allAuthors.find((p) => p.slug === author)
-    return coreContent(authorResults as Authors)
-  })
-  const mainContent = coreContent(post)
-  const jsonLd = post.structuredData
+  const path = params.slug.join('/')
+  console.log(`Fetching guide content for path: ${path}`)
+
+  // Fetch content from Strapi with error handling
+  let content: MDXContent
+  try {
+    if (!process.env.NEXT_PUBLIC_SIGNOZ_CMS_API_URL) {
+      throw new Error('Strapi API URL is not configured')
+    }
+
+    const isProduction = process.env.VERCEL_ENV === 'production'
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = await fetchMDXContentByPath('guides', path, deployment_status)
+    if (!response || !response.data) {
+      console.error(`Invalid response for path: ${path}`)
+      notFound()
+    }
+    content = response.data as MDXContent
+  } catch (error) {
+    console.error('Error fetching guide content:', error)
+    notFound()
+  }
+
+  if (!content) {
+    console.log(`No content returned for path: ${path}`)
+    notFound()
+  }
+
+  // Generate computed fields
+  const readingTimeData = readingTime(content?.content)
+  const toc = generateTOC(content?.content)
+
+  // Compile MDX content with all plugins
+  let compiledContent
+  try {
+    const { content: mdxContent } = await compileMDX({
+      source: content?.content,
+      components,
+      options: mdxOptions as any,
+    })
+    compiledContent = mdxContent
+  } catch (error) {
+    console.error('Error compiling MDX:', error)
+    notFound()
+  }
+
+  // Generate structured data
+  const structuredData = generateStructuredData('guides', content)
+
+  // Prepare content for Layout
+  const mainContent: CoreContent<MDXContent> = {
+    title: content.title,
+    date: content.date,
+    lastmod: content.lastmod,
+    tags: content.tags?.map((tag) => tag.value) || [],
+    draft: content.deployment_status === 'draft',
+    summary: content.summary,
+    description: content.description,
+    images: content.images || [],
+    authors: content.authors?.map((author) => author?.key) || [],
+    slug: path,
+    path: content.path || `/guides/${path}`,
+    type: 'Guide',
+    readingTime: readingTimeData,
+    filePath: `/guides/${path}`,
+    structuredData: structuredData,
+    toc: toc,
+    relatedArticles: [],
+  }
+
+  // Prepare author details
+  const authorDetails: CoreContent<MDXContent>[] = content.authors?.map((author) => ({
+    name: author?.name || 'Unknown Author',
+    avatar: author?.image_url || '/static/images/signoz-logo.png',
+    occupation: author?.title || 'Developer Tools',
+    company: 'SigNoz',
+    email: 'team@signoz.io',
+    twitter: 'https://twitter.com/SigNozHQ',
+    linkedin: 'https://www.linkedin.com/company/signoz',
+    github: 'https://github.com/SigNoz/signoz',
+    path: `/authors/${author?.key || 'default'}`,
+    type: 'Authors',
+    slug: author?.key || 'default',
+    readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+    filePath: `/data/authors/${author?.key || 'default'}.mdx`,
+  })) || [
+    {
+      // Fallback author if no authors are found
+      name: 'SigNoz Team',
+      avatar: '/static/images/signoz-logo.png',
+      occupation: 'Developer Tools',
+      company: 'SigNoz',
+      email: 'team@signoz.io',
+      twitter: 'https://twitter.com/SigNozHQ',
+      linkedin: 'https://www.linkedin.com/company/signoz',
+      github: 'https://github.com/SigNoz/signoz',
+      path: '/authors/default',
+      type: 'Authors',
+      slug: 'default',
+      readingTime: { text: '', minutes: 0, time: 0, words: 0 },
+      filePath: '/data/authors/default.mdx',
+    },
+  ]
 
   // Choose layout based on slug or post layout
-  let layoutName = post.layout || defaultLayout
-  if (slug.includes('opentelemetry')) {
+  let layoutName = content.layout || defaultLayout
+  if (path.includes('opentelemetry')) {
     layoutName = 'OpenTelemetryLayout'
   } else {
     layoutName = 'GuidesLayout'
@@ -114,19 +305,23 @@ export default async function Page({ params }: { params: { slug: string[] } }) {
   // @ts-ignore
   const Layout = layouts[layoutName]
 
-  // Check if the slug contains Grafana or Prometheus
+  // Check if the path contains Grafana or Prometheus
   const isGrafanaOrPrometheusArticle =
-    slug.toLowerCase().includes('grafana') || slug.toLowerCase().includes('prometheus')
+    path.toLowerCase().includes('grafana') || path.toLowerCase().includes('prometheus')
 
   return (
     <>
       <script
         type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(structuredData) }}
       />
 
       <div className="container mx-auto">
-        <Button variant={"ghost"} to={`/resource-center/guides/`} className="ml-3.5 mt-10 hover:bg-transparent">
+        <Button
+          variant={'ghost'}
+          to={`/resource-center/guides/`}
+          className="ml-3.5 mt-10 hover:bg-transparent"
+        >
           <span className="flex items-center">
             <SidebarIcons.ArrowLeft />
             <span className="pl-1.5 text-sm">Back to Guides</span>
@@ -137,14 +332,16 @@ export default async function Page({ params }: { params: { slug: string[] } }) {
       <Layout
         content={mainContent}
         authorDetails={authorDetails}
-        authors={post?.authors}
-        toc={post.toc}
+        authors={content.authors?.map((author) => author?.key) || []}
+        toc={toc}
       >
-        <MDXLayoutRenderer code={post.body.code} components={components} toc={post.toc} />
+        <div className="prose max-w-none dark:prose-invert prose-headings:scroll-mt-16">
+          {compiledContent}
+        </div>
         <PageFeedback />
       </Layout>
 
-      {/* Render GrafanaVsSigNozFloatingCard if the slug contains Grafana or Prometheus */}
+      {/* Render GrafanaVsSigNozFloatingCard if the path contains Grafana or Prometheus */}
       {isGrafanaOrPrometheusArticle && <GrafanaVsSigNozFloatingCard />}
     </>
   )
diff --git a/app/guides/page/[page]/page.tsx b/app/guides/page/[page]/page.tsx
index 54648306f..8696b5403 100644
--- a/app/guides/page/[page]/page.tsx
+++ b/app/guides/page/[page]/page.tsx
@@ -1,34 +1,87 @@
 import ListLayout from '@/layouts/ListLayoutWithTags'
-import { allCoreContent, sortPosts } from 'pliny/utils/contentlayer'
-import { allGuides } from 'contentlayer/generated'
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
+import readingTime from 'reading-time'
+import { notFound } from 'next/navigation'
+import { CoreContent } from 'pliny/utils/contentlayer'
 
 const POSTS_PER_PAGE = 5
 
-export const generateStaticParams = async () => {
-  const totalPages = Math.ceil(allGuides.length / POSTS_PER_PAGE)
-  const paths = Array.from({ length: totalPages }, (_, i) => ({ page: (i + 1).toString() }))
+export const revalidate = 0
+export const dynamicParams = true
 
-  return paths
+export const generateStaticParams = async () => {
+  // Return empty array for ISR
+  return []
 }
 
-export default function Page({ params }: { params: { page: string } }) {
-  const posts = allCoreContent(sortPosts(allGuides))
-  const pageNumber = parseInt(params.page as string)
-  const initialDisplayPosts = posts.slice(
-    POSTS_PER_PAGE * (pageNumber - 1),
-    POSTS_PER_PAGE * pageNumber
-  )
-  const pagination = {
-    currentPage: pageNumber,
-    totalPages: Math.ceil(posts.length / POSTS_PER_PAGE),
-  }
+export default async function Page({ params }: { params: { page: string } }) {
+  try {
+    // Fetch all guides from Strapi
+    const isProduction = process.env.VERCEL_ENV === 'production'
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = (await fetchMDXContentByPath(
+      'guides',
+      undefined,
+      deployment_status,
+      true
+    )) as MDXContentApiResponse
+
+    if (!response || !response.data) {
+      console.error('Invalid response from Strapi for guides')
+      notFound()
+    }
+
+    // Transform the data to match the expected format
+    const guides = response.data.map((guide) => {
+      const readingTimeData = readingTime(guide.content || '')
 
-  return (
-    <ListLayout
-      posts={posts}
-      initialDisplayPosts={initialDisplayPosts}
-      pagination={pagination}
-      title="All Posts"
-    />
-  )
+      return {
+        title: guide.title,
+        description: guide.description,
+        summary: guide.summary,
+        date: guide.date,
+        lastmod: guide.lastmod,
+        tags: guide.tags?.map((tag) => tag.value) || [],
+        draft: guide.deployment_status === 'draft',
+        slug: guide.path?.replace(/^\//, '') || '',
+        path: guide.path,
+        image: guide.image,
+        images: guide.images || [],
+        authors: guide.authors?.map((author) => author?.key) || [],
+        readingTime: readingTimeData,
+        type: 'Guide',
+      }
+    })
+
+    // Sort by date (descending)
+    const sortedGuides = guides.sort(
+      (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+    )
+
+    // Filter out drafts
+    const posts = sortedGuides.filter((g) => !g.draft)
+
+    const pageNumber = parseInt(params.page as string)
+    const initialDisplayPosts = posts.slice(
+      POSTS_PER_PAGE * (pageNumber - 1),
+      POSTS_PER_PAGE * pageNumber
+    )
+    const pagination = {
+      currentPage: pageNumber,
+      totalPages: Math.ceil(posts.length / POSTS_PER_PAGE),
+    }
+
+    return (
+      <ListLayout
+        posts={posts as CoreContent<any>[]} // TODO: fix types here, adding any for build
+        initialDisplayPosts={initialDisplayPosts as CoreContent<any>[]}
+        pagination={pagination}
+        title="All Posts"
+      />
+    )
+  } catch (error) {
+    console.error('Error fetching guides:', error)
+    notFound()
+  }
 }
diff --git a/app/layout.tsx b/app/layout.tsx
index c44ee335d..068ed2d55 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -107,7 +107,7 @@ export default function RootLayout({ children }: { children: React.ReactNode })
 
         <ThemeProviders>
           <GrowthBookProvider>
-            <Suspense>
+            {/* <Suspense> */}
               <SectionContainer>
                 <div className="relative flex h-screen flex-col justify-between ">
                   <SearchProvider searchConfig={siteMetadata.search as SearchConfig}>
@@ -117,7 +117,7 @@ export default function RootLayout({ children }: { children: React.ReactNode })
                   <MainFooter />
                 </div>
               </SectionContainer>
-            </Suspense>
+            {/* </Suspense> */}
           </GrowthBookProvider>
         </ThemeProviders>
       </body>
diff --git a/app/loading.tsx b/app/loading.tsx
deleted file mode 100644
index 869139f44..000000000
--- a/app/loading.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "@/components/GlobalLoader/GlobalLoader"
\ No newline at end of file
diff --git a/app/resource-center/Shared/BlogPostCard.tsx b/app/resource-center/Shared/BlogPostCard.tsx
index 50e283b2d..da55b678b 100644
--- a/app/resource-center/Shared/BlogPostCard.tsx
+++ b/app/resource-center/Shared/BlogPostCard.tsx
@@ -1,16 +1,12 @@
 import siteMetadata from '@/data/siteMetadata'
-import { Blog, Comparison, Guide, Opentelemetry } from 'contentlayer/generated'
+import { Blog, Opentelemetry } from 'contentlayer/generated'
 import Authors from '../../../constants/authors.json'
 import { Clock4 } from 'lucide-react'
 import Link from 'next/link'
 import { CoreContent } from 'pliny/utils/contentlayer'
 import { formatDate } from 'pliny/utils/formatDate'
 
-export default function BlogPostCard({
-  blog,
-}: {
-  blog: CoreContent<Blog | Comparison | Opentelemetry | Guide>
-}) {
+export default function BlogPostCard({ blog }: { blog: CoreContent<Blog | Opentelemetry> }) {
   const { path, date, title, authors } = blog
 
   const getAuthorDetails = (authorID) => {
@@ -61,7 +57,7 @@ export default function BlogPostCard({
             </div>
             <div className="flex items-center gap-1.5 whitespace-nowrap font-mono dark:text-stone-300">
               <Clock4 size={16} />
-              <div className="text-xs font-mono dark:text-white">{blog.readingTime.text}</div>
+              <div className="font-mono text-xs dark:text-white">{blog.readingTime.text}</div>
             </div>
           </div>
         </div>
diff --git a/app/resource-center/comparisons/Comparisons.tsx b/app/resource-center/comparisons/Comparisons.tsx
index e231588df..c25a3bb50 100644
--- a/app/resource-center/comparisons/Comparisons.tsx
+++ b/app/resource-center/comparisons/Comparisons.tsx
@@ -1,75 +1,58 @@
-'use client'
-
-import { allComparisons } from 'contentlayer/generated'
-import { allCoreContent, sortPosts } from 'pliny/utils/contentlayer'
-import BlogPostCard from '../Shared/BlogPostCard'
-import SearchInput from '../Shared/Search'
-import React from 'react'
-import { filterData } from 'app/utils/common'
-import { Frown } from 'lucide-react'
-
-interface ComparisonsPageHeaderProps {
-  onSearch: (e) => void
-}
-
-const ComparisonsPageHeader: React.FC<ComparisonsPageHeaderProps> = ({ onSearch }) => {
-  return (
-    <section className="mb-[72px] flex max-w-[697px] flex-col leading-[143%]">
-      <h2 className="mb-0 self-start text-sm font-medium uppercase tracking-wider text-signoz_sakura-500 dark:text-signoz_sakura-400">
-        resources
-      </h2>
-      <h1 className="my-0 mt-3 self-start text-3xl font-semibold text-indigo-500 dark:text-indigo-200">
-        Comparisons
-      </h1>
-      <p className="my-4 w-full text-lg leading-8 tracking-normal text-gray-700 dark:text-stone-300 max-md:max-w-full">
-        Stay informed about the latest tools in the observability domain with in-depth comparisons
-        of popular options to determine the best fit for your needs.
-      </p>
-
-      <SearchInput placeholder={'Search for a blog...'} onSearch={onSearch} />
-    </section>
-  )
-}
-
-export default function ComparisonsListing() {
-  const posts = allCoreContent(sortPosts(allComparisons))
-  const primaryFeaturedBlogs = posts.slice(0, 2)
-  const secondaryFeaturedBlogs = posts.slice(0)
-
-  const [blogs, setBlogs] = React.useState(secondaryFeaturedBlogs)
-  const [searchValue, setSearchValue] = React.useState('')
-
-  const handleSearch = (e) => {
-    setSearchValue(e.target.value)
-    const filteredPosts = filterData(posts, e.target.value)
-    setBlogs(filteredPosts)
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
+import ComparisonsClient from './ComparisonsClient'
+import readingTime from 'reading-time'
+
+export default async function ComparisonsListing() {
+  try {
+    // Fetch all comparisons from Strapi
+    const isProduction = process.env.VERCEL_ENV === 'production'
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = (await fetchMDXContentByPath(
+      'comparisons',
+      undefined,
+      deployment_status,
+      true
+    )) as MDXContentApiResponse
+
+    if (!response || !response.data) {
+      console.error('Invalid response from Strapi for comparisons')
+      return <ComparisonsClient comparisons={[]} />
+    }
+
+    // Transform the data to match the expected format
+    const comparisons = response.data.map((comparison) => {
+      const readingTimeData = readingTime(comparison.content || '')
+
+      return {
+        title: comparison.title,
+        description: comparison.description,
+        summary: comparison.summary,
+        date: comparison.date,
+        lastmod: comparison.lastmod,
+        tags: comparison.tags?.map((tag) => tag.value) || [],
+        draft: comparison.deployment_status === 'draft',
+        slug: comparison.path?.replace(/^\//, '') || '', // Remove leading slash for slug
+        path: comparison.path,
+        image: comparison.image,
+        images: comparison.images || [],
+        authors: comparison.authors?.map((author) => author?.key) || [],
+        readingTime: readingTimeData,
+        type: 'Comparison',
+      }
+    })
+
+    // Sort by date (descending)
+    const sortedComparisons = comparisons.sort(
+      (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+    )
+
+    // Filter out drafts
+    const publishedComparisons = sortedComparisons.filter((c) => !c.draft)
+
+    return <ComparisonsClient comparisons={publishedComparisons} />
+  } catch (error) {
+    console.error('Error fetching comparisons:', error)
+    return <ComparisonsClient comparisons={[]} />
   }
-
-  return (
-    <div className="comparisons">
-      <ComparisonsPageHeader onSearch={handleSearch} />
-
-      {searchValue && searchValue.length == 0 && (
-        <div className="mt-5 w-full max-md:max-w-full">
-          <div className="mt-4 grid gap-4 sm:grid-cols-1 md:grid-cols-2">
-            {primaryFeaturedBlogs.map((featuredBlog, index) => {
-              return <BlogPostCard blog={featuredBlog} key={index} />
-            })}
-          </div>
-        </div>
-      )}
-
-      {blogs && Array.isArray(blogs) && blogs.length <= 0 && (
-        <div className="no-blogs my-8 flex items-center gap-4 font-mono font-bold">
-          <Frown size={16} /> No Comparisons found
-        </div>
-      )}
-
-      <div className="mt-4 grid gap-4 sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3">
-        {blogs.map((post, index) => {
-          return <BlogPostCard blog={post} key={index} />
-        })}
-      </div>
-    </div>
-  )
 }
diff --git a/app/resource-center/comparisons/ComparisonsClient.tsx b/app/resource-center/comparisons/ComparisonsClient.tsx
new file mode 100644
index 000000000..889c59300
--- /dev/null
+++ b/app/resource-center/comparisons/ComparisonsClient.tsx
@@ -0,0 +1,77 @@
+'use client'
+
+import BlogPostCard from '../Shared/BlogPostCard'
+import SearchInput from '../Shared/Search'
+import React from 'react'
+import { filterData } from 'app/utils/common'
+import { Frown } from 'lucide-react'
+
+interface ComparisonsPageHeaderProps {
+  onSearch: (e) => void
+}
+
+const ComparisonsPageHeader: React.FC<ComparisonsPageHeaderProps> = ({ onSearch }) => {
+  return (
+    <section className="mb-[72px] flex max-w-[697px] flex-col leading-[143%]">
+      <h2 className="mb-0 self-start text-sm font-medium uppercase tracking-wider text-signoz_sakura-500 dark:text-signoz_sakura-400">
+        resources
+      </h2>
+      <h1 className="my-0 mt-3 self-start text-3xl font-semibold text-indigo-500 dark:text-indigo-200">
+        Comparisons
+      </h1>
+      <p className="my-4 w-full text-lg leading-8 tracking-normal text-gray-700 dark:text-stone-300 max-md:max-w-full">
+        Stay informed about the latest tools in the observability domain with in-depth comparisons
+        of popular options to determine the best fit for your needs.
+      </p>
+
+      <SearchInput placeholder={'Search for a blog...'} onSearch={onSearch} />
+    </section>
+  )
+}
+
+interface ComparisonsClientProps {
+  comparisons: any[]
+}
+
+export default function ComparisonsClient({ comparisons }: ComparisonsClientProps) {
+  const posts = comparisons
+  const primaryFeaturedBlogs = posts.slice(0, 2)
+  const secondaryFeaturedBlogs = posts.slice(0)
+
+  const [blogs, setBlogs] = React.useState(secondaryFeaturedBlogs)
+  const [searchValue, setSearchValue] = React.useState('')
+
+  const handleSearch = (e) => {
+    setSearchValue(e.target.value)
+    const filteredPosts = filterData(posts, e.target.value)
+    setBlogs(filteredPosts)
+  }
+
+  return (
+    <div className="comparisons">
+      <ComparisonsPageHeader onSearch={handleSearch} />
+
+      {searchValue && searchValue.length == 0 && (
+        <div className="mt-5 w-full max-md:max-w-full">
+          <div className="mt-4 grid gap-4 sm:grid-cols-1 md:grid-cols-2">
+            {primaryFeaturedBlogs.map((featuredBlog, index) => {
+              return <BlogPostCard blog={featuredBlog} key={index} />
+            })}
+          </div>
+        </div>
+      )}
+
+      {blogs && Array.isArray(blogs) && blogs.length <= 0 && (
+        <div className="no-blogs my-8 flex items-center gap-4 font-mono font-bold">
+          <Frown size={16} /> No Comparisons found
+        </div>
+      )}
+
+      <div className="mt-4 grid gap-4 sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3">
+        {blogs.map((post, index) => {
+          return <BlogPostCard blog={post} key={index} />
+        })}
+      </div>
+    </div>
+  )
+}
diff --git a/app/resource-center/comparisons/page.tsx b/app/resource-center/comparisons/page.tsx
index 76bb50db5..5e8cd50f5 100644
--- a/app/resource-center/comparisons/page.tsx
+++ b/app/resource-center/comparisons/page.tsx
@@ -1,25 +1,14 @@
-'use client'
-
-import React, { useState } from 'react'
-import Blogs from '../blog/Blogs'
+import React from 'react'
 import Comparisons from './Comparisons'
-import Guides from '../guides/Guides'
-import OpenTelemetry from '../opentelemetry/OpenTelemetry'
 
-export default function ComparisonsHome() {
-  const [activeTab, setActiveTab] = useState('comparisons-tab')
+export const revalidate = 0
+export const dynamicParams = true
 
+export default async function ComparisonsHome() {
   return (
-    <div className="container mx-auto py-16 sm:py-8 !mt-[48px]">
-
+    <div className="container mx-auto !mt-[48px] py-16 sm:py-8">
       <div className="tab-content pt-6">
-        {activeTab === 'blog-tab' && <Blogs />}
-
-        {activeTab === 'comparisons-tab' && <Comparisons />}
-
-        {activeTab === 'guides-tab' && <Guides />}
-
-        {activeTab === 'openTelemetry-tab' && <OpenTelemetry />}
+        <Comparisons />
       </div>
     </div>
   )
diff --git a/app/resource-center/guides/Guides.tsx b/app/resource-center/guides/Guides.tsx
index 62dcc0b66..c155a4cc0 100644
--- a/app/resource-center/guides/Guides.tsx
+++ b/app/resource-center/guides/Guides.tsx
@@ -1,125 +1,58 @@
-'use client'
-
-import { allGuides } from 'contentlayer/generated'
-import { allCoreContent, sortPosts } from 'pliny/utils/contentlayer'
-import React, { useState, useEffect, useMemo } from 'react'
-import BlogPostCard from '../Shared/BlogPostCard'
-import { filterData } from 'app/utils/common'
-import SearchInput from '../Shared/Search'
-import { Frown } from 'lucide-react'
-import SideBar, { GUIDES_TOPICS } from '@/components/SideBar'
-
-interface HeadingProps {
-  tag: string
-  text: string
-  className?: string
-}
-
-const Heading: React.FC<HeadingProps> = ({ tag, text, className = '' }) => {
-  const Tag = tag as keyof JSX.IntrinsicElements
-  return <Tag className={className}>{text}</Tag>
-}
-
-interface GuidesHeaderProps {
-  title: string
-  description: string
-  searchPlaceholder?: string
-  onSearch: (e) => void
-}
-
-const GuidesHeader = ({ title, description, searchPlaceholder, onSearch }) => {
-  return (
-    <section className="mb-[16px] flex max-w-[697px] flex-col leading-[143%]">
-      <h2 className="mb-0 self-start text-center text-sm font-medium uppercase tracking-wider text-signoz_sakura-500 dark:text-signoz_sakura-400">
-        resources
-      </h2>
-      <h1 className="my-0 mt-3 self-start text-3xl font-semibold text-indigo-500 dark:text-indigo-200">
-        {title}
-      </h1>
-      <p className="my-4  w-full text-lg leading-8 tracking-normal text-stone-700 dark:text-stone-300 max-md:max-w-full">
-        {description}
-      </p>
-      <SearchInput placeholder={searchPlaceholder || ''} onSearch={onSearch} />
-    </section>
-  )
-}
-
-export default function Guides() {
-  const posts = allCoreContent(sortPosts(allGuides))
-  const [activeItem, setActiveItem] = useState(GUIDES_TOPICS.ALL)
-  const [searchQuery, setSearchQuery] = useState('')
-  const POST_PER_PAGE = 20
-  const pageNumber = 1
-
-  useEffect(() => {
-    if (!window) {
-      return
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
+import GuidesClient from './GuidesClient'
+import readingTime from 'reading-time'
+
+export default async function Guides() {
+  try {
+    // Fetch all guides from Strapi
+    const isProduction = process.env.VERCEL_ENV === 'production'
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = (await fetchMDXContentByPath(
+      'guides',
+      undefined,
+      deployment_status,
+      true
+    )) as MDXContentApiResponse
+
+    if (!response || !response.data) {
+      console.error('Invalid response from Strapi for guides')
+      return <GuidesClient guides={[]} />
     }
 
-    const activeItemToSet: GUIDES_TOPICS =
-      (window.location.hash as GUIDES_TOPICS) || GUIDES_TOPICS.ALL
-
-    setActiveItem(activeItemToSet)
-  }, [window])
-
-  const blogs = useMemo(() => {
-    if (searchQuery) {
-      return filterData(posts, searchQuery)
-    }
-
-    if (activeItem === GUIDES_TOPICS.ALL) {
-      return posts
-    }
-
-    const formattedActiveItem = activeItem.replace('#', '').toLowerCase().replace(/\s+/g, '')
-
-    return posts.filter((post) => {
-      const postTags = post.tags?.map((tag) => tag.toLowerCase().replace(/\s+/g, ''))
-      return postTags?.includes(formattedActiveItem)
+    // Transform the data to match the expected format
+    const guides = response.data.map((guide) => {
+      const readingTimeData = readingTime(guide.content || '')
+
+      return {
+        title: guide.title,
+        description: guide.description,
+        summary: guide.summary,
+        date: guide.date,
+        lastmod: guide.lastmod,
+        tags: guide.tags?.map((tag) => tag.value) || [],
+        draft: guide.deployment_status === 'draft',
+        slug: guide.path?.replace(/^\//, '') || '', // Remove leading slash for slug
+        path: guide.path,
+        image: guide.image,
+        images: guide.images || [],
+        authors: guide.authors?.map((author) => author?.key) || [],
+        readingTime: readingTimeData,
+        type: 'Guide',
+      }
     })
-  }, [searchQuery, activeItem])
 
-  const handleCategoryClick = (category) => {
-    setActiveItem(category)
-    window.history.pushState(null, '', category)
-  }
+    // Sort by date (descending)
+    const sortedGuides = guides.sort(
+      (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
+    )
 
-  const handleSearch = (e) => {
-    setSearchQuery(e.target.value)
-    setActiveItem(GUIDES_TOPICS.ALL)
-  }
+    // Filter out drafts
+    const publishedGuides = sortedGuides.filter((g) => !g.draft)
 
-  const pagination = {
-    currentPage: pageNumber,
-    totalPages: Math.ceil(posts.length / POST_PER_PAGE),
-    pageRoute: 'guide',
+    return <GuidesClient guides={publishedGuides} />
+  } catch (error) {
+    console.error('Error fetching guides:', error)
+    return <GuidesClient guides={[]} />
   }
-
-  return (
-    <div>
-      <GuidesHeader
-        title="SigNoz Guides"
-        description="Level up your engineering skills with great resources, tutorials, and guides on monitoring, observability, Opentelemetry, and more."
-        searchPlaceholder="Search for guides..."
-        onSearch={handleSearch}
-      />
-
-      <div className="relative mt-8 flex flex-col gap-8 xl:-mr-16 xl:pr-16">
-        <SideBar onCategoryClick={handleCategoryClick} activeItem={activeItem} />
-        <div className="flex-1">
-          {blogs && Array.isArray(blogs) && blogs.length <= 0 && (
-            <div className="no-blogs my-8 flex items-center gap-4 font-mono font-bold">
-              <Frown size={16} /> No Guides found
-            </div>
-          )}
-
-          <div className="grid gap-4 sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3">
-            {blogs.map((post) => {
-              return <BlogPostCard key={post.slug} blog={post} />
-            })}
-          </div>
-        </div>
-      </div>
-    </div>
-  )
 }
diff --git a/app/resource-center/guides/GuidesClient.tsx b/app/resource-center/guides/GuidesClient.tsx
new file mode 100644
index 000000000..51c958fb4
--- /dev/null
+++ b/app/resource-center/guides/GuidesClient.tsx
@@ -0,0 +1,116 @@
+'use client'
+
+import React, { useState, useEffect, useMemo } from 'react'
+import BlogPostCard from '../Shared/BlogPostCard'
+import { filterData } from 'app/utils/common'
+import SearchInput from '../Shared/Search'
+import { Frown } from 'lucide-react'
+import SideBar, { GUIDES_TOPICS } from '@/components/SideBar'
+
+interface GuidesHeaderProps {
+  title: string
+  description: string
+  searchPlaceholder?: string
+  onSearch: (e) => void
+}
+
+const GuidesHeader = ({ title, description, searchPlaceholder, onSearch }) => {
+  return (
+    <section className="mb-[16px] flex max-w-[697px] flex-col leading-[143%]">
+      <h2 className="mb-0 self-start text-center text-sm font-medium uppercase tracking-wider text-signoz_sakura-500 dark:text-signoz_sakura-400">
+        resources
+      </h2>
+      <h1 className="my-0 mt-3 self-start text-3xl font-semibold text-indigo-500 dark:text-indigo-200">
+        {title}
+      </h1>
+      <p className="my-4 w-full text-lg leading-8 tracking-normal text-stone-700 dark:text-stone-300 max-md:max-w-full">
+        {description}
+      </p>
+      <SearchInput placeholder={searchPlaceholder || ''} onSearch={onSearch} />
+    </section>
+  )
+}
+
+interface GuidesClientProps {
+  guides: any[]
+}
+
+export default function GuidesClient({ guides }: GuidesClientProps) {
+  const posts = guides
+  const [activeItem, setActiveItem] = useState(GUIDES_TOPICS.ALL)
+  const [searchQuery, setSearchQuery] = useState('')
+  const POST_PER_PAGE = 20
+  const pageNumber = 1
+
+  useEffect(() => {
+    if (!window) {
+      return
+    }
+
+    const activeItemToSet: GUIDES_TOPICS =
+      (window.location.hash as GUIDES_TOPICS) || GUIDES_TOPICS.ALL
+
+    setActiveItem(activeItemToSet)
+  }, [])
+
+  const blogs = useMemo(() => {
+    if (searchQuery) {
+      return filterData(posts, searchQuery)
+    }
+
+    if (activeItem === GUIDES_TOPICS.ALL) {
+      return posts
+    }
+
+    const formattedActiveItem = activeItem.replace('#', '').toLowerCase().replace(/\s+/g, '')
+
+    return posts.filter((post) => {
+      const postTags = post.tags?.map((tag) => tag.toLowerCase().replace(/\s+/g, ''))
+      return postTags?.includes(formattedActiveItem)
+    })
+  }, [searchQuery, activeItem, posts])
+
+  const handleCategoryClick = (category) => {
+    setActiveItem(category)
+    window.history.pushState(null, '', category)
+  }
+
+  const handleSearch = (e) => {
+    setSearchQuery(e.target.value)
+    setActiveItem(GUIDES_TOPICS.ALL)
+  }
+
+  const pagination = {
+    currentPage: pageNumber,
+    totalPages: Math.ceil(posts.length / POST_PER_PAGE),
+    pageRoute: 'guide',
+  }
+
+  return (
+    <div>
+      <GuidesHeader
+        title="SigNoz Guides"
+        description="Level up your engineering skills with great resources, tutorials, and guides on monitoring, observability, Opentelemetry, and more."
+        searchPlaceholder="Search for guides..."
+        onSearch={handleSearch}
+      />
+
+      <div className="relative mt-8 flex flex-col gap-8 xl:-mr-16 xl:pr-16">
+        <SideBar onCategoryClick={handleCategoryClick} activeItem={activeItem} />
+        <div className="flex-1">
+          {blogs && Array.isArray(blogs) && blogs.length <= 0 && (
+            <div className="no-blogs my-8 flex items-center gap-4 font-mono font-bold">
+              <Frown size={16} /> No Guides found
+            </div>
+          )}
+
+          <div className="grid gap-4 sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3">
+            {blogs.map((post) => {
+              return <BlogPostCard key={post.slug} blog={post} />
+            })}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/app/resource-center/guides/page.tsx b/app/resource-center/guides/page.tsx
index 0a444a1bf..00a642462 100644
--- a/app/resource-center/guides/page.tsx
+++ b/app/resource-center/guides/page.tsx
@@ -1,25 +1,14 @@
-'use client'
-
-import React, { useState } from 'react'
-import Blogs from '../blog/Blogs'
-import Comparisons from '../comparisons/Comparisons'
+import React from 'react'
 import Guides from './Guides'
-import OpenTelemetry from '../opentelemetry/OpenTelemetry'
 
-export default function GuidesHome() {
-  const [activeTab, setActiveTab] = useState('guides-tab')
+export const revalidate = 0
+export const dynamicParams = true
 
+export default async function GuidesHome() {
   return (
-    <div className="container mx-auto py-16 sm:py-8 !mt-[48px]">
-
+    <div className="container mx-auto !mt-[48px] py-16 sm:py-8">
       <div className="tab-content pt-6">
-        {activeTab === 'blog-tab' && <Blogs />}
-
-        {activeTab === 'comparisons-tab' && <Comparisons />}
-
-        {activeTab === 'guides-tab' && <Guides />}
-
-        {activeTab === 'openTelemetry-tab' && <OpenTelemetry />}
+        <Guides />
       </div>
     </div>
   )
diff --git a/app/resource-center/loading.tsx b/app/resource-center/loading.tsx
deleted file mode 100644
index 869139f44..000000000
--- a/app/resource-center/loading.tsx
+++ /dev/null
@@ -1 +0,0 @@
-export { default } from "@/components/GlobalLoader/GlobalLoader"
\ No newline at end of file
diff --git a/app/rss/route.ts b/app/rss/route.ts
new file mode 100644
index 000000000..65e51eb2b
--- /dev/null
+++ b/app/rss/route.ts
@@ -0,0 +1,45 @@
+import { NextResponse } from 'next/server'
+import { sortPosts } from 'pliny/utils/contentlayer.js'
+import siteMetadata from '@/data/siteMetadata.js'
+import { generateRss } from '@/lib/rssFeed'
+import { allBlogs, allDocs, allOpentelemetries } from 'contentlayer/generated'
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
+
+export const runtime = 'nodejs'
+export const revalidate = 60
+
+const CACHE_CONTROL_HEADER = 's-maxage=60, stale-while-revalidate=30'
+
+export async function GET() {
+  const isProduction = process.env.VERCEL_ENV === 'production'
+  const deploymentStatus = isProduction ? 'live' : 'staging'
+
+  const allFaqs = (await fetchMDXContentByPath(
+    'faqs',
+    undefined,
+    deploymentStatus,
+    true
+  )) as MDXContentApiResponse
+
+  const allPosts = [
+    ...allFaqs.data?.map((faq) => ({
+      ...faq,
+      slug: `faqs${faq.path}`,
+    })),
+    ...allBlogs,
+    ...allOpentelemetries,
+    ...allDocs,
+  ]
+
+  const publishedPosts = sortPosts((allPosts as any[]).filter((post) => post.draft !== true))
+  const rssXml = generateRss(siteMetadata, publishedPosts)
+
+  const response = new NextResponse(rssXml, {
+    headers: {
+      'Content-Type': 'text/xml; charset=utf-8',
+      'Cache-Control': CACHE_CONTROL_HEADER,
+    },
+  })
+
+  return response
+}
diff --git a/app/sitemap.ts b/app/sitemap.ts
index f431522a3..d57ccff1e 100644
--- a/app/sitemap.ts
+++ b/app/sitemap.ts
@@ -1,6 +1,7 @@
 import { MetadataRoute } from 'next'
-import { allBlogs, allAuthors, allComparisons, allGuides, allOpentelemetries, allDocs, allFAQs } from 'contentlayer/generated'
+import { allBlogs, allAuthors, allOpentelemetries, allDocs } from 'contentlayer/generated'
 import siteMetadata from '@/data/siteMetadata'
+import { fetchMDXContentByPath, MDXContentApiResponse } from '@/utils/strapi'
 
 const mapChangeFrequency = (
   frequency: string
@@ -19,7 +20,10 @@ const mapChangeFrequency = (
   }
 }
 
-export default function sitemap(): MetadataRoute.Sitemap {
+export const dynamic = 'force-dynamic'
+export const revalidate = 60
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
   const siteUrl = siteMetadata.siteUrl
 
   const blogRoutes = allBlogs
@@ -40,7 +44,16 @@ export default function sitemap(): MetadataRoute.Sitemap {
       priority: 0.5,
     }))
 
-  const comparisonRoutes = allComparisons
+  // const comparisonRoutes = allComparisons
+  //   .filter((post) => !post.draft)
+  //   .map((post) => ({
+  //     url: `${siteUrl}/${post.path}/`,
+  //     lastModified: post.lastmod || post.date,
+  //     changeFrequency: mapChangeFrequency('weekly'),
+  //     priority: 0.5,
+  //   }))
+
+  const opentelemetryRoutes = allOpentelemetries
     .filter((post) => !post.draft)
     .map((post) => ({
       url: `${siteUrl}/${post.path}/`,
@@ -49,29 +62,77 @@ export default function sitemap(): MetadataRoute.Sitemap {
       priority: 0.5,
     }))
 
-  const opentelemetryRoutes = allOpentelemetries
-    .filter((post) => !post.draft)
-    .map((post) => ({
-      url: `${siteUrl}/${post.path}/`,
-      lastModified: post.lastmod || post.date,
+  // New section for guides
+  // const guideRoutes = allGuides
+  //   .filter((guide) => !guide.draft)
+  //   .map((guide) => ({
+  //     url: `${siteUrl}/${guide.path}/`,
+  //     lastModified: guide.lastmod || guide.date,
+  //     changeFrequency: mapChangeFrequency('weekly'),
+  //     priority: 0.7,
+  //   }))
+
+  const isProduction = process.env.VERCEL_ENV === 'production'
+  const deploymentStatus = isProduction ? 'live' : 'staging'
+
+  // Fetch FAQs from Strapi CMS at runtime
+  let faqRoutes: MetadataRoute.Sitemap = []
+  try {
+    const faqsResponse = (await fetchMDXContentByPath(
+      'faqs',
+      undefined,
+      deploymentStatus,
+      true
+    )) as MDXContentApiResponse
+    console.log('FAQs response:', faqsResponse)
+    faqRoutes = faqsResponse.data.map((faq) => ({
+      url: `${siteUrl}/faqs${faq.path}/`,
+      lastModified: faq.date || faq.updatedAt || faq.publishedAt,
+    }))
+  } catch (error) {
+    console.error('Error fetching FAQs for sitemap:', error)
+    // Return empty array if fetching fails
+  }
+
+  let caseStudyRoutes: MetadataRoute.Sitemap = []
+  try {
+    const caseStudiesResponse = (await fetchMDXContentByPath(
+      'case-studies',
+      undefined,
+      deploymentStatus,
+      true
+    )) as MDXContentApiResponse
+    console.log('Case studies response:', caseStudiesResponse)
+    caseStudyRoutes = caseStudiesResponse.data.map((caseStudy) => ({
+      url: `${siteUrl}/case-study${caseStudy.path}/`,
       changeFrequency: mapChangeFrequency('weekly'),
       priority: 0.5,
+      lastModified: caseStudy.updatedAt || caseStudy.publishedAt,
     }))
+  } catch (error) {
+    console.error('Error fetching case studies for sitemap:', error)
+    // Return empty array if fetching fails
+  }
 
-  // New section for guides
-  const guideRoutes = allGuides
-    .filter((guide) => !guide.draft)
-    .map((guide) => ({
-      url: `${siteUrl}/${guide.path}/`,
-      lastModified: guide.lastmod || guide.date,
+  let guideRoutes: MetadataRoute.Sitemap = []
+  try {
+    const guidesResponse = (await fetchMDXContentByPath(
+      'guides',
+      undefined,
+      deploymentStatus,
+      true
+    )) as MDXContentApiResponse
+    console.log('Guides response:', guidesResponse)
+    guideRoutes = guidesResponse.data.map((guide) => ({
+      url: `${siteUrl}/guides${guide.path}/`,
+      lastModified: guide.updatedAt || guide.publishedAt,
       changeFrequency: mapChangeFrequency('weekly'),
       priority: 0.7,
     }))
-
-  const faqRoutes = allFAQs.map((faq) => ({
-    url: `${siteUrl}/${faq.path}/`,
-    lastModified: faq.lastmod || faq.date,
-  }))
+  } catch (error) {
+    console.error('Error fetching guides for sitemap:', error)
+    // Return empty array if fetching fails
+  }
 
   const routes = [
     '',
@@ -93,5 +154,13 @@ export default function sitemap(): MetadataRoute.Sitemap {
     changeFrequency: mapChangeFrequency('weekly'),
   }))
 
-  return [...routes, ...blogRoutes, ...comparisonRoutes, ...opentelemetryRoutes, ...docRoutes, ...guideRoutes, ...faqRoutes]
-}
\ No newline at end of file
+  return [
+    ...routes,
+    ...blogRoutes,
+    ...opentelemetryRoutes,
+    ...docRoutes,
+    ...guideRoutes,
+    ...faqRoutes,
+    ...caseStudyRoutes,
+  ]
+}
diff --git a/app/tag-data.json b/app/tag-data.json
index cc12cc47b..28414e0d0 100644
--- a/app/tag-data.json
+++ b/app/tag-data.json
@@ -1,146 +1,78 @@
 {
-  "opentelemetry": 162,
-  "signoz": 43,
+  "opentelemetry": 114,
+  "signoz": 41,
   "community": 7,
-  "prometheus": 75,
+  "prometheus": 9,
   "distributed-tracing": 19,
-  "monitoring": 75,
+  "monitoring": 7,
   "tech-tutorial": 31,
-  "javascript": 20,
+  "javascript": 18,
   "tech-resources": 10,
   "api-monitoring": 1,
   "open-source": 11,
   "product": 38,
-  "tools-comparison": 58,
-  "jaeger": 16,
+  "tools-comparison": 30,
+  "jaeger": 13,
   "node": 1,
   "events": 1,
-  "python": 11,
-  "log-management": 17,
-  "apm": 13,
-  "security": 2,
-  "claude-code": 2,
+  "python": 10,
+  "log-management": 16,
+  "apm": 5,
+  "security": 1,
+  "claude-code": 1,
   "product-updates": 38,
   "database-monitoring": 4,
-  "infrastructure": 3,
+  "infrastructure": 2,
   "cloud": 1,
-  "aws": 3,
+  "aws": 1,
   "talks": 4,
-  "datadog": 5,
-  "pricing": 4,
-  "observability": 65,
+  "datadog": 1,
+  "pricing": 2,
+  "observability": 23,
   "team": 1,
   "opentelemetry-instrumentation": 25,
   "go--golang": 4,
-  "java": 4,
-  "microservices": 2,
-  "docker": 13,
+  "java": 2,
+  "microservices": 1,
+  "docker": 6,
   "databases": 1,
   "ai": 1,
   "coding": 1,
   "launch-week": 6,
   "operations": 1,
-  "kubernetes": 12,
-  "logging": 50,
-  "langchain": 3,
+  "kubernetes": 5,
+  "logging": 4,
+  "langchain": 2,
   "llm": 1,
   "mcp": 1,
   "mysql": 1,
   "nginx": 1,
-  "nodejs": 2,
-  "metrics": 4,
+  "nodejs": 1,
+  "metrics": 1,
   "traces": 1,
   "logs": 1,
   "feature-flags": 1,
-  "devops": 11,
+  "devops": 1,
   "software-development": 1,
   "continuous-delivery": 1,
   "net": 2,
   "elixir--erlang": 1,
   "fastapi": 1,
   "golang": 1,
-  "llamaindex": 2,
+  "llamaindex": 1,
   "nextjs": 5,
   "web-vitals": 1,
   "php": 1,
   "ruby": 1,
   "rust": 1,
   "spring-boot": 1,
-  "vercel-ai-sdk": 2,
+  "vercel-ai-sdk": 1,
   "guides": 2,
   "monitoring-tools": 1,
   "redis": 1,
-  "splunk": 3,
+  "splunk": 1,
   "alternatives": 1,
   "hiring": 1,
   "jokes": 1,
-  "mcp-servers": 1,
-  "appdynamics": 1,
-  "sre": 7,
-  "tools-comparision": 6,
-  "tools-comparisions": 2,
-  "tools-comparisons": 6,
-  "observability-tools": 1,
-  "clickhouse": 1,
-  "analytics": 1,
-  "database": 1,
-  "performance": 4,
-  "tools": 1,
-  "dynatrace": 2,
-  "graylog": 2,
-  "loki": 1,
-  "faq": 101,
-  "cloud-native": 2,
-  "honeycomb": 1,
-  "incident-management": 2,
-  "network-monitoring": 1,
-  "it-monitoring": 1,
-  "grafana": 19,
-  "infra": 1,
-  "sentry": 2,
-  "comparison": 1,
-  "zabbix": 1,
-  "log-analysis": 1,
-  "artificial-intelligence": 1,
-  "machine-learning": 1,
-  "data-analytics": 1,
-  "alerts": 1,
-  "aws-lambda": 1,
-  "linux": 1,
-  "authentication": 1,
-  "iframe": 1,
-  "dashboards": 1,
-  "containerization": 1,
-  "visualization": 1,
-  "cybersecurity": 1,
-  "incident-response": 1,
-  "nist-framework": 1,
-  "threat-detection": 1,
-  "data-breach": 1,
-  "performance-monitoring": 1,
-  "kibana": 1,
-  "loggly": 1,
-  "visibility": 1,
-  "time-series-data": 1,
-  "promql": 2,
-  "react": 1,
-  "error-tracking": 1,
-  "application-monitoring": 1,
-  "ssh": 1,
-  "systemctl": 1,
-  "missing-values": 1,
-  "time-series": 1,
-  "opentelemetry-tutorials": 11,
-  "java-monitoring": 3,
-  "javascript-monitoring": 1,
-  "python-monitoring": 1,
-  "signoz-cloud": 410,
-  "self-host": 407,
-  "monitor": 1,
-  "crew-ai": 1,
-  "google-gemini": 1,
-  "langgraph": 1,
-  "openai": 1,
-  "features": 6,
-  "usecases": 1
+  "mcp-servers": 1
 }
\ No newline at end of file
diff --git a/app/test-mdx/[...slug]/page.tsx b/app/test-mdx/[...slug]/page.tsx
new file mode 100644
index 000000000..e34857c06
--- /dev/null
+++ b/app/test-mdx/[...slug]/page.tsx
@@ -0,0 +1,318 @@
+import { notFound } from 'next/navigation'
+import { fetchMDXContentByPath, MDXContent } from '@/utils/strapi'
+import { generateStructuredData } from '@/utils/structuredData'
+import { compileMDX } from 'next-mdx-remote/rsc'
+import { components } from '@/components/MDXComponents'
+import { Metadata } from 'next'
+import readingTime from 'reading-time'
+import GithubSlugger from 'github-slugger'
+import { fromHtmlIsomorphic } from 'hast-util-from-html-isomorphic'
+import 'css/prism.css'
+import 'css/tailwind.css'
+import 'css/post.css'
+import 'css/global.css'
+import 'css/doc.css'
+
+// Remark and rehype plugins
+import remarkGfm from 'remark-gfm'
+import {
+  remarkExtractFrontmatter,
+  remarkCodeTitles,
+  remarkImgToJsx,
+} from 'pliny/mdx-plugins/index.js'
+import rehypeSlug from 'rehype-slug'
+import rehypeAutolinkHeadings from 'rehype-autolink-headings'
+import rehypePrismPlus from 'rehype-prism-plus'
+import remarkMath from 'remark-math'
+
+export const revalidate = 0
+export const dynamicParams = true
+
+// Heroicon mini link for auto-linking headers
+const linkIcon = fromHtmlIsomorphic(
+  `<span class="content-header-link">
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" className="w-5 h-5 linkicon">
+      <path d="M12.232 4.232a2.5 2.5 0 0 1 3.536 3.536l-1.225 1.224a.75.75 0 0 0 1.061 1.06l1.224-1.224a4 4 0 0 0-5.656-5.656l-3 3a4 4 0 0 0 .225 5.865.75.75 0 0 0 .977-1.138 2.5 2.5 0 0 1-.142-3.667l3-3Z" />
+      <path d="M11.603 7.963a.75.75 0 0 0-.977 1.138 2.5 2.5 0 0 1 .142 3.667l-3 3a2.5 2.5 0 0 1-3.536-3.536l1.225-1.224a.75.75 0 0 0-1.061-1.06l-1.224 1.224a4 4 0 1 0 5.656 5.656l3-3a4 4 0 0 0-.225-5.865Z" />
+    </svg>
+  </span>`,
+  { fragment: true }
+)
+
+// MDX processing options with all plugins
+const mdxOptions = {
+  mdxOptions: {
+    remarkPlugins: [
+      remarkExtractFrontmatter,
+      remarkGfm,
+      remarkCodeTitles,
+      remarkMath,
+      remarkImgToJsx,
+    ],
+    rehypePlugins: [
+      rehypeSlug,
+      [
+        rehypeAutolinkHeadings,
+        {
+          behavior: 'prepend',
+          headingProperties: {
+            className: ['content-header'],
+          },
+          content: linkIcon,
+        },
+      ],
+      [rehypePrismPlus, { defaultLanguage: 'tsx', ignoreMissing: true }],
+    ],
+  },
+}
+
+// Generate table of contents from MDX content
+function generateTOC(content: string) {
+  const regXHeader = /\n(?<flag>#{1,3})\s+(?<content>.+)/g
+  const slugger = new GithubSlugger()
+
+  // Remove code blocks to avoid parsing headers inside code
+  const regXCodeBlock = /```[\s\S]*?```/g
+  const contentWithoutCodeBlocks = content.replace(regXCodeBlock, '')
+
+  const headings = Array.from(contentWithoutCodeBlocks.matchAll(regXHeader)).map(({ groups }) => {
+    const flag = groups?.flag
+    const content = groups?.content
+    return {
+      value: content,
+      url: content ? `#${slugger.slug(content)}` : undefined,
+      depth: flag?.length == 1 ? 1 : flag?.length == 2 ? 2 : 3,
+    }
+  })
+
+  return headings
+}
+
+// Generate static params - returning empty array to generate all pages at runtime
+export async function generateStaticParams() {
+  return []
+}
+
+// Generate metadata for SEO optimization
+export async function generateMetadata({
+  params,
+}: {
+  params: { slug?: string[] }
+}): Promise<Metadata> {
+  try {
+    // Handle root case
+    if (!params.slug || params.slug.length === 0) {
+      return {
+        title: 'Test MDX from Strapi',
+        description: 'Test implementation for rendering MDX content from Strapi CMS using ISR',
+        openGraph: {
+          title: 'Test MDX from Strapi',
+          description: 'Test implementation for rendering MDX content from Strapi CMS using ISR',
+          type: 'website',
+        },
+      }
+    }
+
+    // Convert slug array to path
+    const path = params.slug.join('/')
+
+    const isProduction = process.env.VERCEL_ENV === 'production'
+
+    try {
+      const deployment_status = isProduction ? 'live' : 'staging'
+      const { data: content } = await fetchMDXContentByPath('case-studies', path, deployment_status)
+
+      return {
+        title: (content as MDXContent)?.title,
+        description:
+          (content as MDXContent)?.description || `Read about ${(content as MDXContent)?.title}`,
+        // keywords: content?.keywords, // TODO: Add keyword support later
+        authors: [{ name: 'SigNoz Team' }],
+        openGraph: {
+          title: (content as MDXContent)?.title,
+          description:
+            (content as MDXContent)?.description || `Read about ${(content as MDXContent)?.title}`,
+          type: 'article',
+          publishedTime: (content as MDXContent)?.publishedAt,
+          modifiedTime: (content as MDXContent)?.updatedAt,
+          url: `/${path}`,
+        },
+        twitter: {
+          card: 'summary_large_image',
+          title: (content as MDXContent)?.title,
+          description:
+            (content as MDXContent)?.description || `Read about ${(content as MDXContent)?.title}`,
+        },
+      }
+    } catch (error) {
+      // Content not found, return 404 metadata
+      return {
+        title: 'Page Not Found',
+        description: 'The requested page could not be found.',
+        robots: {
+          index: false,
+          follow: false,
+        },
+      }
+    }
+  } catch (error) {
+    console.error('Error generating metadata:', error)
+    return {
+      title: 'Error',
+      description: 'An error occurred while loading the page.',
+    }
+  }
+}
+
+// Main page component
+export default async function TestMDXPage({ params }: { params: { slug?: string[] } }) {
+  console.log('Rendering page with params:', params)
+
+  if (!params.slug || params.slug.length === 0) {
+    return <div className="min-h-screen">something something test here blabla</div>
+  }
+
+  const path = params.slug.join('/')
+  console.log(`Fetching content for path: ${path}`)
+
+  const isProduction = process.env.VERCEL_ENV === 'production'
+
+  // Fetch content from Strapi with error handling
+  let content: MDXContent
+  try {
+    if (!process.env.NEXT_PUBLIC_SIGNOZ_CMS_API_URL) {
+      throw new Error('Strapi API URL is not configured')
+    }
+
+    const deployment_status = isProduction ? 'live' : 'staging'
+
+    const response = await fetchMDXContentByPath('case-studies', path, deployment_status)
+    if (!response || !response.data) {
+      console.error(`Invalid response for path: ${path}`)
+      notFound()
+    }
+    content = response.data as MDXContent
+  } catch (error) {
+    notFound()
+  }
+
+  if (!content) {
+    console.log(`No content returned for path: ${path}`)
+    notFound()
+  }
+
+  console.log(`Successfully fetched content: ${content?.title} for path: ${path}`)
+  console.log('Content:', content?.content)
+  console.log('Content Authors:', content?.authors)
+  console.log('Content related_faqs:', content?.related_faqs)
+  // Generate computed fields similar to contentlayer
+  const readingTimeData = readingTime(content?.content)
+  const toc = generateTOC(content?.content)
+
+  // Compile MDX content with all plugins
+  let compiledContent
+  try {
+    const { content: mdxContent, frontmatter } = await compileMDX({
+      source: content?.content,
+      components,
+      options: mdxOptions as any,
+    })
+    compiledContent = mdxContent
+
+    console.log(
+      'Compiled Content:',
+      JSON.stringify(compiledContent, null, 2),
+      compiledContent?.structuredData,
+      frontmatter
+    )
+  } catch (error) {
+    console.error('Error compiling MDX:', error)
+    notFound()
+  }
+
+  // Generate structured data based on collection type
+  const structuredData = generateStructuredData('case-studies', content)
+  console.log('logging structured data for case-studies', structuredData)
+
+  return (
+    <div className="min-h-screen">
+      {/* Add structured data script */}
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(structuredData) }}
+      />
+      <div className="container mx-auto max-w-6xl px-4 py-8">
+        <div className="grid grid-cols-1 gap-8 lg:grid-cols-4">
+          {/* Main content */}
+          <article className="lg:col-span-3">
+            <header className="mb-8 border-b border-gray-200 pb-8">
+              <h1 className="mb-4 text-4xl font-bold">{content?.title}</h1>
+
+              {content?.description && <p className="mb-6 text-xl">{content?.description}</p>}
+
+              <div className="flex items-center space-x-4 text-sm">
+                <time dateTime={content?.publishedAt}>
+                  Published:{' '}
+                  {new Date(content?.publishedAt).toLocaleDateString('en-US', {
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                  })}
+                </time>
+
+                {content?.updatedAt !== content?.publishedAt && (
+                  <span>
+                    Updated:{' '}
+                    {new Date(content?.updatedAt).toLocaleDateString('en-US', {
+                      year: 'numeric',
+                      month: 'long',
+                      day: 'numeric',
+                    })}
+                  </span>
+                )}
+
+                <span>•</span>
+                <span>{readingTimeData.text}</span>
+              </div>
+            </header>
+
+            {/* MDX Content */}
+            <div className="prose max-w-none dark:prose-invert prose-headings:scroll-mt-16">
+              {compiledContent}
+            </div>
+          </article>
+
+          {/* Sidebar with Table of Contents */}
+          {toc.length > 0 && (
+            <aside className="lg:col-span-1">
+              <div className="sticky top-8">
+                <div className="rounded-lg p-6">
+                  <h2 className="mb-4 text-lg font-semibold">Table of Contents</h2>
+                  <nav>
+                    <ul className="space-y-2 text-sm">
+                      {toc.map((heading, index) => (
+                        <li
+                          key={index}
+                          className={`${
+                            heading.depth === 2 ? 'ml-0' : heading.depth === 3 ? 'ml-4' : 'ml-8'
+                          }`}
+                        >
+                          <a
+                            href={heading.url}
+                            className="block py-1 transition-colors duration-200"
+                          >
+                            {heading.value}
+                          </a>
+                        </li>
+                      ))}
+                    </ul>
+                  </nav>
+                </div>
+              </div>
+            </aside>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/app/test-mdx/page.tsx b/app/test-mdx/page.tsx
new file mode 100644
index 000000000..6b31489f9
--- /dev/null
+++ b/app/test-mdx/page.tsx
@@ -0,0 +1,3 @@
+export default function TestMDXPage() {
+  return <div>Test MDX Page</div>
+}
\ No newline at end of file
diff --git a/components/Chatbase/ChatbaseServer.tsx b/components/Chatbase/ChatbaseServer.tsx
index f2d9c6b3d..efba3b709 100644
--- a/components/Chatbase/ChatbaseServer.tsx
+++ b/components/Chatbase/ChatbaseServer.tsx
@@ -21,7 +21,7 @@ export default async function ChatbaseServer({
   const secret = process.env.CHATBASE_SECRET_KEY
 
   if (!secret) {
-    console.warn('CHATBASE_SECRET_KEY not found in environment variables')
+    // console.warn('CHATBASE_SECRET_KEY not found in environment variables')
     return (
       <>
         <ChatbaseCookieSync />
diff --git a/contentlayer.config.ts b/contentlayer.config.ts
index 9f469b4a3..1c9b6b3bd 100644
--- a/contentlayer.config.ts
+++ b/contentlayer.config.ts
@@ -559,8 +559,8 @@ export const FAQ = defineDocumentType(() => ({
           name: doc.title,
           acceptedAnswer: {
             '@type': 'Answer',
-            text: doc.description
-          }
+            text: doc.description,
+          },
         },
         url: `${siteMetadata.siteUrl}/faqs/${doc.slug}`,
       }),
@@ -570,7 +570,7 @@ export const FAQ = defineDocumentType(() => ({
 
 export default makeSource({
   contentDirPath: 'data',
-  documentTypes: [Blog, Authors, Comparison, Guide, Opentelemetry, Doc, Newsroom, CaseStudy, FAQ],
+  documentTypes: [Blog, Authors, Opentelemetry, Doc, Newsroom],
   mdx: {
     cwd: process.cwd(),
     remarkPlugins: [
diff --git a/data/blog/o11y.mdx b/data/blog/o11y.mdx
index 02579b7d2..dfdb197c4 100644
--- a/data/blog/o11y.mdx
+++ b/data/blog/o11y.mdx
@@ -1,13 +1,23 @@
 ---
-
 title: Understanding O11y - A Beginner's Guide
 slug: o11y
 date: 2024-07-19
 tags: [opentelemetry, observability]
 authors: [yuvraj]
 description: Learn the essentials of O11y (Observability) in this beginner's guide. Discover how to implement it effectively to improve system performance and reliability.
-keywords: [observability, O11y, OpenTelemetry, system performance, logging, metrics, tracing, SigNoz, DevOps, monitoring]
-
+keywords:
+  [
+    observability,
+    O11y,
+    OpenTelemetry,
+    system performance,
+    logging,
+    metrics,
+    tracing,
+    SigNoz,
+    DevOps,
+    monitoring,
+  ]
 ---
 
 “O11y”, also known as Observability, is changing how we handle system performance.
@@ -31,16 +41,16 @@ Technically, O11y refers to the ability to understand the internal state of a sy
 Traditionally, O11y has three main parts:
 
 - Logs: What happened?
-    - Detailed records of events within your system.
+  - Detailed records of events within your system.
 - Metrics: How much and how often?
-    - Numerical representations of data measured over intervals of time.
+  - Numerical representations of data measured over intervals of time.
 - Traces: Where did it happen?
-    - A way to track a request as it travels through different parts of your system, like following a trail of breadcrumbs. Helpful in distributed systems.
+  - A way to track a request as it travels through different parts of your system, like following a trail of breadcrumbs. Helpful in distributed systems.
 
-<Figure 
-        src="/img/blog/2024/07/o11y-O11y_Beginners_Guide.webp"
-        alt="O11y Beginner's Guide diagram showing logs, metrics, and traces"
-        caption="O11y Beginner's Guide: The three pillars of observability - logs, metrics, and traces"
+<Figure
+  src="/img/blog/2024/07/o11y-O11y_Beginners_Guide.webp"
+  alt="O11y Beginner's Guide diagram showing logs, metrics, and traces"
+  caption="O11y Beginner's Guide: The three pillars of observability - logs, metrics, and traces"
 />
 
 But observability is much more than that. At its root, it’s about building more resilient applications, and when things break, it’s about surfacing issues so that they can be resolved quickly.
@@ -56,13 +66,12 @@ While logs, metrics, and traces are indeed crucial components of observability,
 - Log data can be aggregated to create meaningful metrics.
 - Trace data can be used to generate granular, attribute-based metrics.
 
-<Figure 
-        src="/img/blog/2024/07/o11y-Untitled.webp"
-        alt="A better model where all signals come together to give insights to users"
-        caption="A better model where all signals come together to give insights to users"
+<Figure
+  src="/img/blog/2024/07/o11y-Untitled.webp"
+  alt="A better model where all signals come together to give insights to users"
+  caption="A better model where all signals come together to give insights to users"
 />
 
-
 A better model where all signals come together to give insights to users
 
 At SigNoz, we envision [**observability as a mesh or network rather than a set of pillars**](https://signoz.io/blog/observability-net/). This interconnected approach allows for more powerful correlations and faster problem-solving.
@@ -75,7 +84,7 @@ When troubleshooting complex systems, the ability to correlate different signals
 2. Correlated infrastructure metrics might reveal CPU saturation on a particular VM.
 3. Logs from the affected service could indicate a mutex locking problem.
 
-By viewing all these signals in context, you can quickly pinpoint the root cause of issues. 
+By viewing all these signals in context, you can quickly pinpoint the root cause of issues.
 
 ## Why Should You Care About O11y?
 
@@ -95,26 +104,25 @@ It's not just about looking good to your boss. It's about sleeping better at nig
 Implementing O11y doesn't have to be overwhelming. Here's a step-by-step approach:
 
 1. Start with tracing
-    - Pick a tool (OpenTelemetry is solid)
-    - Instrument your code to create spans for important operations.
-    - Configure a trace exporter to send data to your chosen backend.
-    - Visualize and analyze your traces.
+   - Pick a tool (OpenTelemetry is solid)
+   - Instrument your code to create spans for important operations.
+   - Configure a trace exporter to send data to your chosen backend.
+   - Visualize and analyze your traces.
 2. Add some metrics
-    - Figure out what numbers matter to you (KPIs for your system)
-    - Implement metric collection for these KPIs (e.g., request rate, error rate, latency).
-    - Use tools like Prometheus to scrape and store metrics.
-    - Create dashboards to visualize your metrics.
+   - Figure out what numbers matter to you (KPIs for your system)
+   - Implement metric collection for these KPIs (e.g., request rate, error rate, latency).
+   - Use tools like Prometheus to scrape and store metrics.
+   - Create dashboards to visualize your metrics.
 3. Enhance your logs
-    - Structure them to make them easily parsable (no more spaghetti logs)
-    - Link them to your traces using traceID
-    - Use [log aggregation tools](https://signoz.io/comparisons/log-aggregation-tools/) to centralize and analyze your logs.
-    
-    <Figure 
-        src="/img/blog/2024/07/o11y-Napkin_selection.webp"
-        alt="Getting started with O11y"
-        caption="Getting started with O11y"
-    />
-    
+   - Structure them to make them easily parsable (no more spaghetti logs)
+   - Link them to your traces using traceID
+   - Use [log aggregation tools](https://signoz.io/comparisons/log-aggregation-tools/) to centralize and analyze your logs.
+
+   <Figure
+     src="/img/blog/2024/07/o11y-Napkin_selection.webp"
+     alt="Getting started with O11y"
+     caption="Getting started with O11y"
+   />
 
 ## O11y Tools You Should Know
 
@@ -142,21 +150,21 @@ SigNoz fully embraces OpenTelemetry, leveraging its powerful instrumentation cap
 SigNoz makes O11y easy (It's open-source, so no selling your kidney). Here's how:
 
 1. SetUp SigNoz
-    - SigNoz offers a **free trial of 30 days with full access to all features**. If you don’t already have an account, you can sign up [**here**](https://signoz.io/teams/).
-    - Want an open-source self hosted version? SetUp using Docker [here](https://signoz.io/docs/install/docker/).
+   - SigNoz offers a **free trial of 30 days with full access to all features**. If you don’t already have an account, you can sign up [**here**](https://signoz.io/teams/).
+   - Want an open-source self hosted version? SetUp using Docker [here](https://signoz.io/docs/install/docker/).
 2. Instrument your app
-    - Use OpenTelemetry [SDKs](https://signoz.io/docs/instrumentation/overview/) to instrument your app.
-    - Add a few lines of code
-    - Watch the magic happen
+   - Use OpenTelemetry [SDKs](https://signoz.io/docs/instrumentation/overview/) to instrument your app.
+   - Add a few lines of code
+   - Watch the magic happen
 3. Use the dashboard
-    - See all your traces, metrics, and logs in one place
-    - Set up alerts (so you can sleep at night)
-    - Impress your team with your newfound powers.
-
-<Figure 
-        src="/img/blog/2024/07/o11y-Signoz_Thumbnail.webp"
-        alt="SigNoz Traces Dashboard"
-        caption="SigNoz Traces Dashboard"
+   - See all your traces, metrics, and logs in one place
+   - Set up alerts (so you can sleep at night)
+   - Impress your team with your newfound powers.
+
+<Figure
+  src="/img/blog/2024/07/o11y-Signoz_Thumbnail.webp"
+  alt="SigNoz Traces Dashboard"
+  caption="SigNoz Traces Dashboard"
 />
 
 ## O11y Best Practices
@@ -195,7 +203,7 @@ Many companies have successfully implemented observability to improve their syst
 - Uber leverages observability to optimize ride dispatching and maintain service reliability.
 - GitHub employs observability to quickly detect and resolve issues in its global code hosting platform.
 
-As systems continue to grow in complexity, observability will play an increasingly crucial role in maintaining reliability and performance. 
+As systems continue to grow in complexity, observability will play an increasingly crucial role in maintaining reliability and performance.
 
 The future? More AI, more automation, and more sleep for on-call engineers.
 
@@ -231,4 +239,4 @@ Start with open-source tools and focus on the most critical metrics. Scale your
 
 O11y is your system's health tracker. Start now, thank yourself later.
 
-<GetStartedSigNoz />
\ No newline at end of file
+<GetStartedSigNoz />
diff --git a/data/case-study/blip.mdx b/data/case-study/blip.mdx
index aad641e1f..08e9ef683 100644
--- a/data/case-study/blip.mdx
+++ b/data/case-study/blip.mdx
@@ -1,23 +1,18 @@
 ---
 title: How Blip uses SigNoz to improve their issue resolution time by 14x
-slug: blipbillboards
 image: /img/case_study/BlipBillBoards.png
+description: ''
 authors: [pranay]
 # hide_table_of_contents: true
 ---
+
 <div class="avatar">
-  <a
-    class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://twitter.com/pranay01">
-    <img
-      alt="Pranay Profile"
-      src="/img/authors/pranay_profile_pic.webp" />
+  <a class="avatar__photo-link avatar__photo avatar__photo--lg" href="https://twitter.com/pranay01">
+    <img alt="Pranay Profile" src="/img/authors/pranay_profile_pic.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Pranay Prateek</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
@@ -66,9 +61,11 @@ Going through all the checklists made it a very slow endpoint. And we knew it wa
 
 But what happened behind the scenes was nebulous. For example, we knew it was taking 20 seconds to get rendered, but we had no idea of what exactly happened during those 20 seconds.
 
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/trace-filter.webp" alt="SigNoz trace filter page "/>
-    <figcaption><i>Trace filters helps you find interesting spans quickly, which you can dive deeper into </i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/trace-filter.webp" alt="SigNoz trace filter page " />
+  <figcaption>
+    <i>Trace filters helps you find interesting spans quickly, which you can dive deeper into </i>
+  </figcaption>
 </figure>
 
 ### Logs did not solve the problem.
@@ -91,9 +88,11 @@ But now we know how to avoid such things. For example, an endpoint came up just
 
 ### N+1 query issue.
 
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/Nplus1.webp" alt="N+1 query "/>
-    <figcaption><i>N+1 queries are suboptimal and can lead to significant perf impact</i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/Nplus1.webp" alt="N+1 query " />
+  <figcaption>
+    <i>N+1 queries are suboptimal and can lead to significant perf impact</i>
+  </figcaption>
 </figure>
 
 SigNoz showed me that if someone hits this particular endpoint with a particular campaign with a specific amount of data, it leads to 100 SQL queries in a single request. So if you do a `select` query on all of the rows you're looking for in the database in one go, it creates one SQL query. It takes like 5 seconds to complete, which is not great, but it's not terrible.
@@ -142,9 +141,11 @@ We use distributed tracing a lot. We use all the features of distributed tracing
 
 The second feature that we use the most is the application metrics page which shows latency like p95, p99, and response times for different endpoints. At a glance, we can review which endpoints are taking longer and investigate them.
 
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/ServiceMap.webp" alt="Service Map "/>
-    <figcaption><i>SigNoz Service Map shows a birds eye view of your architecture</i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/ServiceMap.webp" alt="Service Map " />
+  <figcaption>
+    <i>SigNoz Service Map shows a birds eye view of your architecture</i>
+  </figcaption>
 </figure>
 
 ### Any advice for teams trying to set up their observability systems?
diff --git a/data/case-study/brainfish.mdx b/data/case-study/brainfish.mdx
index 86c304327..46aa3750e 100644
--- a/data/case-study/brainfish.mdx
+++ b/data/case-study/brainfish.mdx
@@ -1,31 +1,33 @@
 ---
-
 title: How Brainfish leveraged SigNoz for effective Kubernetes monitoring & Logs management
-slug: brainfish
 image: /img/case_study/brainfish-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
-<a
-class="avatar__photo-link avatar__photo avatar__photo--lg"
-href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-<img
-alt="Ankit Profile"
-src="/img/users/ankit-anand.webp" />
-</a>
-<div class="avatar__intro">
-<div class="avatar__name">Ankit Anand</div>
-<small class="avatar__subtitle">
-Maintainer, SigNoz
-</small>
-</div>
+  <a
+    class="avatar__photo-link avatar__photo avatar__photo--lg"
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
+  </a>
+  <div class="avatar__intro">
+    <div class="avatar__name">Ankit Anand</div>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
+  </div>
 </div>
 
 ## About Brainfish
 
-<a href = "https://www.brainfi.sh/" rel="noopener noreferrer nofollow" target="_blank" >Brainfish</a> is an AI platform that enhances customer experience by providing intelligent product onboarding and support solutions. Leveraging large language and visual models, Brainfish aims to build an autopilot for SaaS products, enabling seamless user interactions without human interference. Their mission is to empower businesses to offer self-service product discovery, reducing the load on customer support teams and improving overall user satisfaction.
-
+<a href="https://www.brainfi.sh/" rel="noopener noreferrer nofollow" target="_blank">
+  Brainfish
+</a>
+is an AI platform that enhances customer experience by providing intelligent product onboarding and
+support solutions. Leveraging large language and visual models, Brainfish aims to build an autopilot
+for SaaS products, enabling seamless user interactions without human interference. Their mission is
+to empower businesses to offer self-service product discovery, reducing the load on customer support
+teams and improving overall user satisfaction.
 
 ## The Challenge: Ensuring High-Quality Software Delivery and Developer Productivity
 
@@ -44,16 +46,15 @@ Some of the critical challenges that the Brainfish team faced were:
 
 Brainfish chose SigNoz as its observability platform due to its ease of integration, open-source nature, and comprehensive feature set, which met its complex monitoring needs.
 
-*"I was tasked to evaluate the next-generation observability tools for the whole organization. To be honest, I've studied more than 10 tools in the market. We eventually landed on SigNoz, which says a lot."*
+_"I was tasked to evaluate the next-generation observability tools for the whole organization. To be honest, I've studied more than 10 tools in the market. We eventually landed on SigNoz, which says a lot."_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
-
 Brainfish conducted thorough research and evaluated over ten solutions, including Datadog, before identifying SigNoz as the most suitable option.
 
 ### Enhanced Developer Experience with SigNoz vs. Elastic Cloud for observability
 
-*"The experience of getting started with SigNoz was straightforward. Especially coming from the background of Elastic Cloud—my gosh, compared to that, it's a breeze with SigNoz. Elastic is a versatile tool and not particularly tied to observability. In SigNoz, you know exactly what you’re doing, and getting things like K8s monitoring set up was pretty easy.”*
+_"The experience of getting started with SigNoz was straightforward. Especially coming from the background of Elastic Cloud—my gosh, compared to that, it's a breeze with SigNoz. Elastic is a versatile tool and not particularly tied to observability. In SigNoz, you know exactly what you’re doing, and getting things like K8s monitoring set up was pretty easy.”_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
@@ -61,8 +62,7 @@ Before selecting SigNoz, Brainfish initially used Elastic Cloud for its observab
 
 <YouTube id="bi-5KbMXeM0" mute={false} />
 
-
-Some of the things that the Brainfish team liked about getting started with SigNoz: 
+Some of the things that the Brainfish team liked about getting started with SigNoz:
 
 - **Straightforward Onboarding:** SigNoz provided a clean and intuitive interface, making it easy for the team to get started.
 - **OpenTelemetry Support:** Leveraging OpenTelemetry allowed Brainfish to implement a vendor-agnostic approach, ensuring flexibility and future-proofing their observability stack.
@@ -72,7 +72,7 @@ Some of the things that the Brainfish team liked about getting started with SigN
 
 Brainfish leverages SigNoz to monitor critical AI-related metrics for their platform's performance. As Charlie mentioned:
 
-*"Running an AI company means you will use different large language models, and SigNoz can help to track token usage and large language model allocation. Because we allow customers to choose the model for themselves, we can see how much traffic goes to each model and adjust our priorities accordingly."*
+_"Running an AI company means you will use different large language models, and SigNoz can help to track token usage and large language model allocation. Because we allow customers to choose the model for themselves, we can see how much traffic goes to each model and adjust our priorities accordingly."_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
@@ -84,14 +84,13 @@ Brainfish relies heavily on Kubernetes to deploy its microservices. SigNoz enabl
 
 <YouTube id="Uipl4CbEvhU" mute={false} />
 
-
 With SigNoz, the team monitors:
 
 - **Pod Restart Alerts:** Set up alerts for pod restarts to catch issues like memory leaks or mishandled exceptions.
 - **Infrastructure Metrics:** Monitored CPU usage, memory allocation, and pod statuses without needing to access AWS Console frequently.
 - **Custom Dashboards:** Created dashboards using ClickHouse queries to visualize custom metrics, such as token usage for different large language models.
 
-*"We monitor Kubernetes workloads and use SigNoz to draw diagrams so that we can have something pretty and increase the engagement of engineers."*
+_"We monitor Kubernetes workloads and use SigNoz to draw diagrams so that we can have something pretty and increase the engagement of engineers."_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
@@ -114,7 +113,7 @@ Here’s a step-by-step breakdown of how the Brainfish team troubleshoots an iss
 
 ### Enhanced Logging and Correlation Features
 
-*"SigNoz helps us to decentralize logs across multiple pods. By selecting the deployment, Kubernetes deployment version, and applications, we can quickly narrow down relevant logs. This significantly reduces troubleshooting time."*
+_"SigNoz helps us to decentralize logs across multiple pods. By selecting the deployment, Kubernetes deployment version, and applications, we can quickly narrow down relevant logs. This significantly reduces troubleshooting time."_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
@@ -139,7 +138,7 @@ By implementing SigNoz, Brainfish successfully enhanced its observability, strea
 
 With SigNoz, Brainfish can focus on its mission to revolutionize customer experience through AI-driven solutions, confident that its infrastructure is robustly monitored and its engineering team is empowered.
 
-*"We are pretty happy with SigNoz. The quality of the software has increased, and it's important to me that the software we deliver to customers makes them happy."*
+_"We are pretty happy with SigNoz. The quality of the software has increased, and it's important to me that the software we deliver to customers makes them happy."_
 
 — Charlie Shen, Lead DevOps Engineer, Brainfish
 
@@ -149,4 +148,4 @@ With SigNoz, Brainfish can focus on its mission to revolutionize customer experi
 
 [![Get Started - Free CTA](/img/launch_week/try-signoz-cloud-blog-cta.png)](https://signoz.io/teams/)
 
----
\ No newline at end of file
+---
diff --git a/data/case-study/cedana.mdx b/data/case-study/cedana.mdx
index 74b094ddb..1a4fe2a97 100644
--- a/data/case-study/cedana.mdx
+++ b/data/case-study/cedana.mdx
@@ -1,28 +1,23 @@
 ---
-
-title:  How Cedana Leverages SigNoz to Ensure Uptime in Real-Time Compute Operations
-slug: cedana
+title: How Cedana Leverages SigNoz to Ensure Uptime in Real-Time Compute Operations
 image: /img/case_study/cedana-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
   <a
     class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-    <img
-      alt="Ankit Profile"
-      src="/img/users/ankit-anand.webp" />
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Ankit Anand</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
-
 ## About Cedana
 
 [Cedana](https://www.cedana.ai/), a YCombinator backed startup, offers an automated system for saving, migrating, and resuming compute workloads to ensure operational reliability during hardware failures. By enabling seamless recovery and continuity, Cedana optimizes real-time computational tasks across various environments. To ensure operational stability and continuous performance, Cedana uses SigNoz to monitor its infrastructure comprehensively.
@@ -31,16 +26,15 @@ authors: [ankit_anand]
 
 Cedana operates at a low level in the computing stack, meaning any errors or failures could have significant impacts on customer operations. Ensuring the reliability of their daemon processes across multiple nodes, as well as tracking performance metrics, became a top priority.
 
-*"We work at such a low level that anything can go wrong, and system reliability is key. Monitoring helps us track what happens when things fail, which is crucial for our platform’s success."*
+_"We work at such a low level that anything can go wrong, and system reliability is key. Monitoring helps us track what happens when things fail, which is crucial for our platform’s success."_
 
 — Niranjan Ravichandra, Co-founder & CTO, Cedana
 
 Cedana needed an observability solution that was easy to set up, could provide in-depth metrics on their daemons, and would integrate seamlessly with their existing infrastructure.
 
-
 ## Why SigNoz?
 
-*"Getting started with SigNoz was incredibly easy. We were able to set up the OpenTelemetry collector quickly and start monitoring our systems almost immediately. The platform’s ease of use and fast setup allowed us to focus more on optimizing our infrastructure without any hassle."* 
+_"Getting started with SigNoz was incredibly easy. We were able to set up the OpenTelemetry collector quickly and start monitoring our systems almost immediately. The platform’s ease of use and fast setup allowed us to focus more on optimizing our infrastructure without any hassle."_
 
 — Niranjan Ravichandra, Co-founder & CTO, Cedana
 
@@ -49,23 +43,22 @@ Cedana needed an observability solution that was easy to set up, could provide i
 When looking for an observability platform, Cedana chose SigNoz for several important reasons:
 
 1. **Easy Setup with OpenTelemetry:**
-    
-    Niranjan discovered SigNoz while transitioning from BetterStack to OpenTelemetry. The ease of setting up SigNoz with OpenTelemetry allowed Cedana to quickly instrument their system and start collecting logs, metrics, and traces with minimal overhead.
-    
+
+   Niranjan discovered SigNoz while transitioning from BetterStack to OpenTelemetry. The ease of setting up SigNoz with OpenTelemetry allowed Cedana to quickly instrument their system and start collecting logs, metrics, and traces with minimal overhead.
+
 2. **Superior Performance Monitoring:**
-    
-    SigNoz provided the deep visibility Cedana needed to monitor the behavior and performance of their daemons across customer nodes. They could track failures, monitor uptime, and analyze performance metrics effectively using SigNoz's APM.
-    
+
+   SigNoz provided the deep visibility Cedana needed to monitor the behavior and performance of their daemons across customer nodes. They could track failures, monitor uptime, and analyze performance metrics effectively using SigNoz's APM.
+
 3. **Custom Data Analysis with ClickHouse Integration:**
-    
-    SigNoz’s backend, powered by ClickHouse, allowed Cedana to export performance data to Jupyter notebooks for advanced analysis. This enabled the team to generate custom reports for customers and gain deeper insights into how their product was being used across hundreds of nodes.
-    
+
+   SigNoz’s backend, powered by ClickHouse, allowed Cedana to export performance data to Jupyter notebooks for advanced analysis. This enabled the team to generate custom reports for customers and gain deeper insights into how their product was being used across hundreds of nodes.
 
 ## Implementation: Observability Across Production and Staging Environments
 
 Cedana implemented SigNoz across both production and staging environments to ensure consistent monitoring throughout their development and deployment pipelines. This allowed them to catch potential issues early in staging and optimize their system before pushing updates to production.
 
-*"We use SigNoz in both production and staging environments to ensure that we can monitor performance and catch issues early. This helps us keep our infrastructure stable across all environments."*
+_"We use SigNoz in both production and staging environments to ensure that we can monitor performance and catch issues early. This helps us keep our infrastructure stable across all environments."_
 
 — Niranjan Ravichandra, Co-founder & CTO, Cedana
 
@@ -75,14 +68,12 @@ SigNoz’s distributed tracing and APM allowed Cedana to track the behavior of t
 
 One of the most powerful use cases for Cedana was the ability to export performance data from SigNoz and analyze it in custom environments like Jupyter notebooks. This allowed them to dig deeper into their data, identify optimization opportunities, and create detailed reports for customers.
 
-
 <YouTube id="zb1KzY3qXNw" mute={false} />
 
-*"We pull data into Jupyter notebooks from SigNoz’s ClickHouse backend to analyze performance trends across hundreds of nodes. This has been invaluable for optimizing our infrastructure and making business decisions."*
+_"We pull data into Jupyter notebooks from SigNoz’s ClickHouse backend to analyze performance trends across hundreds of nodes. This has been invaluable for optimizing our infrastructure and making business decisions."_
 
 — Niranjan Ravichandra, Co-founder & CTO, Cedana
 
-
 ## Looking Ahead - More detailed dashboards
 
 SigNoz has become an integral part of Cedana’s observability stack, providing real-time insights, performance monitoring, and deep traceability across its complex infrastructure.
@@ -91,10 +82,10 @@ Currently using SigNoz for tracing and logs, Cedana aims to set up more detailed
 
 With its easy integration, powerful data analysis features, and robust alerting capabilities, SigNoz has empowered Cedana to ensure the reliability and performance of its platform as it scales.
 
-*"SigNoz has been great for us—easy to set up, powerful, and flexible. It’s helping us optimize performance and ensure reliability as we grow."*
+_"SigNoz has been great for us—easy to set up, powerful, and flexible. It’s helping us optimize performance and ensure reliability as we grow."_
 
 — Niranjan Ravichandra, Co-founder & CTO, Cedana
 
 ---
 
-SigNoz cloud is the easiest way to run SigNoz. You can sign up [**here**](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
\ No newline at end of file
+SigNoz cloud is the easiest way to run SigNoz. You can sign up [**here**](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
diff --git a/data/case-study/instasafe.mdx b/data/case-study/instasafe.mdx
index 29fbfe673..8d6b006f9 100644
--- a/data/case-study/instasafe.mdx
+++ b/data/case-study/instasafe.mdx
@@ -1,70 +1,61 @@
 ---
-title:  How InstaSafe chose SigNoz over Grafana and Elastic APM to power their observability needs
-slug: instasafe
+title: How InstaSafe chose SigNoz over Grafana and Elastic APM to power their observability needs
 image: /img/case_study/instasafe-banner.png
+description: ''
 authors: [pranay]
-
 ---
+
 <div class="avatar">
-  <a
-    class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://twitter.com/pranay01">
-    <img
-      alt="Pranay Profile"
-      src="/img/authors/pranay_profile_pic.webp" />
+  <a class="avatar__photo-link avatar__photo avatar__photo--lg" href="https://twitter.com/pranay01">
+    <img alt="Pranay Profile" src="/img/authors/pranay_profile_pic.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Pranay Prateek</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
 <br />
 
-
-*I sat down with Bhaswanth, Software Architect at <a href = "https://instasafe.com" rel="noopener noreferrer nofollow" target="_blank" >InstaSafe</a> to understand how they use SigNoz at InstaSafe. Here’s a few snippets from our conversation (edited for legibility)*
+_I sat down with Bhaswanth, Software Architect at <a href = "https://instasafe.com" rel="noopener noreferrer nofollow" target="_blank" >InstaSafe</a> to understand how they use SigNoz at InstaSafe. Here’s a few snippets from our conversation (edited for legibility)_
 
 ![Instsafe Case Study](/img/case_study/instasafe-banner.webp)
 
-
 ![Instsafe Numbers](/img/case_study/instasafe-numbers.svg)
 
-
 ### Can you share about what does Instasafe do? What are your key products?
 
 Instasafe provides Zero Trust Application and Network access products for remote teams. With users from around 40 countries creating around 100,000 authenticated sessions per day, uptime is very important for us.
 
 With huge number of teams suddenly moving to working remotely, Instasafe experienced a surge in demand which amplified the need for a good observability setup.
 
-
-
 ### Why is high uptime important to Instasafe?
 
 Availability of InstaSafe platform is critically important as our customers ability to do business depends on InstaSafe’s connectivity. Maintaining an uptime of 99.99 or 5 nines is important to us.
 
 Bhaswanth says “For large sites, availability is very important because our customers' applications are dependent on our connectivity.”
 
-
-
 ### What are your key use cases in Observability
 
 “We observed that some of our APIs, they take a lot of time to process. We could not figure out why. Because when we test in our own environment everything seems fine. But we don't do it at scale of the customers, right”
 
 And what is the P99 latency? Such things. We didn't know how our applications did on such metrics before.”
+
 <br />
 
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/instasafe-sc-traces.webp" alt="InstaSafe Traces"/>
-    <figcaption><i> Instasafe uses traces extensively to solve performance issues</i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/instasafe-sc-traces.webp" alt="InstaSafe Traces" />
+  <figcaption>
+    <i> Instasafe uses traces extensively to solve performance issues</i>
+  </figcaption>
 </figure>
 
-<br /><br />
+<br />
+<br />
 
 ### What tools did you try before moving to SigNoz?
 
-“So we tried a lot many things like Grafana or Jaeger. Different platform for different needs - Grafana + Prometheus for Metrics, Jaeger for traces. One major challenge that we faced especially is the maintenance of these platforms” says Bhashwanth. 
+“So we tried a lot many things like Grafana or Jaeger. Different platform for different needs - Grafana + Prometheus for Metrics, Jaeger for traces. One major challenge that we faced especially is the maintenance of these platforms” says Bhashwanth.
 
 Combining different platforms for Metrics and Traces made configuring and maintaining these platforms non trivial and difficult to maintain.
 
@@ -74,36 +65,37 @@ How much ever resources we had ELK was eating up all of it and was very slow. It
 
 <br />
 
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/instasafe-trace-filter.webp" alt="InstaSafe Trace Filter"/>
-    <figcaption><i> Filter the right traces to focus on</i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/instasafe-trace-filter.webp" alt="InstaSafe Trace Filter" />
+  <figcaption>
+    <i> Filter the right traces to focus on</i>
+  </figcaption>
 </figure>
 
 <br />
 
-
-<figure data-zoomable align='center'>
-    <img src="/img/case_study/instasafe-sc-exceptions.webp" alt="InstaSafe Exceptions"/>
-    <figcaption><i> Exceptions page will all exceptions in a single view</i></figcaption>
+<figure data-zoomable align="center">
+  <img src="/img/case_study/instasafe-sc-exceptions.webp" alt="InstaSafe Exceptions" />
+  <figcaption>
+    <i> Exceptions page will all exceptions in a single view</i>
+  </figcaption>
 </figure>
 
 <br />
 
 ### What did you like about SigNoz?
 
- “I was looking for common platforms and exploring some upcoming open source tracing products. Then I found out SigNoz.I thought to give it a try. I think I spent around maybe 20-30 minutes to apply and everything was up. End to end. It's not just the server side metrics, but including the endpoint latencies, et al. 
+“I was looking for common platforms and exploring some upcoming open source tracing products. Then I found out SigNoz.I thought to give it a try. I think I spent around maybe 20-30 minutes to apply and everything was up. End to end. It's not just the server side metrics, but including the endpoint latencies, et al.
 So I was able to run a script and then configure everything.”
 
 ”This was the turning point for me to look at the SigNoz. What I liked was that you have both metrics and traces and logs in the roadmap potential one. And second, simplicity and easier to maintain for a team like ours.”
 
 ### Any advice for new teams which are thinking of setting up their Observability systems or upgrading them?
 
-“I think one mistake, which I have done in that past is - that when we look at a platform we want to use all its feature rather than thinking what problem is it solving for us. If we start collecting data for something which we don’t need now, but may be in the future - it might just add more load to the system, without giving us any benefit today - and may lead to bottlenecks.” 
+“I think one mistake, which I have done in that past is - that when we look at a platform we want to use all its feature rather than thinking what problem is it solving for us. If we start collecting data for something which we don’t need now, but may be in the future - it might just add more load to the system, without giving us any benefit today - and may lead to bottlenecks.”
 
 So, I would suggest to understand what data do you need today - and only send that data to the platform.
 
-
-
 ---
 
 Thank you for taking out the time to read this case study. If you have any feedback or want to share your story using SigNoz, please feel free to reach out to `hello@signoz.io` with `Case Study` as subject.
@@ -112,4 +104,4 @@ Sharing stories of how different teams are using SigNoz helps the community in l
 
 Feel free to join our slack community and say hi! 👋
 
-[![SigNoz Slack community](/img/blog/common/join_slack_cta.webp)](https://signoz.io/slack)
\ No newline at end of file
+[![SigNoz Slack community](/img/blog/common/join_slack_cta.webp)](https://signoz.io/slack)
diff --git a/data/case-study/kiwi.mdx b/data/case-study/kiwi.mdx
index 40c672921..7c58e06f3 100644
--- a/data/case-study/kiwi.mdx
+++ b/data/case-study/kiwi.mdx
@@ -1,25 +1,21 @@
 ---
-
 title: How Kiwi Reduced API Response Times from 20 Seconds to Milliseconds Using SigNoz
-slug: kiwi
 image: /img/case_study/kiwi-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
-<a
-class="avatar__photo-link avatar__photo avatar__photo--lg"
-href="[https://www.linkedin.com/in/ankit-anand-686a53a1/](https://www.linkedin.com/in/ankit-anand-686a53a1/)">
-<img
-alt="Ankit Profile"
-src="/img/users/ankit-anand.webp" />
-</a>
-<div class="avatar__intro">
-<div class="avatar__name">Ankit Anand</div>
-<small class="avatar__subtitle">
-Maintainer, SigNoz
-</small>
-</div>
+  <a
+    class="avatar__photo-link avatar__photo avatar__photo--lg"
+    href="[https://www.linkedin.com/in/ankit-anand-686a53a1/](https://www.linkedin.com/in/ankit-anand-686a53a1/)"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
+  </a>
+  <div class="avatar__intro">
+    <div class="avatar__name">Ankit Anand</div>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
+  </div>
 </div>
 
 ## About Kiwi
@@ -30,7 +26,7 @@ Maintainer, SigNoz
 
 Operating in the fintech space, Kiwi's systems are predominantly real-time. Any downtime or delay can result in immediate user churn, as customers might switch to competitors like Google Pay.
 
-*"All our systems are real-time. If something is down, we need to fix it quickly, or we'll just lose the customer. They'll quickly switch to Google Pay or some other reliable source."*
+_"All our systems are real-time. If something is down, we need to fix it quickly, or we'll just lose the customer. They'll quickly switch to Google Pay or some other reliable source."_
 
 — **Khushhal Reddy, Senior Backend Developer, Kiwi**
 
@@ -38,7 +34,7 @@ Operating in the fintech space, Kiwi's systems are predominantly real-time. Any
 
 Additionally, Kiwi partners with multiple banks that impose strict guidelines on monitoring, logging, and data residency to comply with the Reserve Bank of India's (RBI) regulations.
 
-*"Banks have compliance requirements that mandate a robust monitoring and logging stack. If something goes wrong, they ask us for proofs or traces of the user journey. We need to store and report user activities, errors encountered, and steps taken to resolve issues."*
+_"Banks have compliance requirements that mandate a robust monitoring and logging stack. If something goes wrong, they ask us for proofs or traces of the user journey. We need to store and report user activities, errors encountered, and steps taken to resolve issues."_
 
 — **Khushhal Reddy, Senior Backend Engineer, Kiwi**
 
@@ -57,7 +53,7 @@ One thing that we consistently hear from developers and founders is how quick an
 
 ### Seamless Integration and Customization
 
-*"When we started using SigNoz, our team was very small. We wanted quick integrations so we could start using it immediately. SigNoz was very easy to integrate and customize on our end. We could set up new alerts or dashboards in just five minutes without external assistance."*
+_"When we started using SigNoz, our team was very small. We wanted quick integrations so we could start using it immediately. SigNoz was very easy to integrate and customize on our end. We could set up new alerts or dashboards in just five minutes without external assistance."_
 
 — **Khushhal Reddy, Senior Backend Engineer, Kiwi**
 
@@ -67,9 +63,9 @@ By utilizing OpenTelemetry, Kiwi could instrument their applications easily, col
 
 ### Open Source and Cost-Effective
 
-The team at Kiwi are big fans of open-source tools. They have plans to contribute back to the open-source version of SigNoz. Open-source tools are more transparent by nature, and the team preferred SigNoz cloud over solutions like Datadog and New Relic. 
+The team at Kiwi are big fans of open-source tools. They have plans to contribute back to the open-source version of SigNoz. Open-source tools are more transparent by nature, and the team preferred SigNoz cloud over solutions like Datadog and New Relic.
 
-*"We didn't want to go with expensive tools. SigNoz being open source was a big plus for us. We're big fans of open-source tools, and it opens up an opportunity to contribute back to the project if we want something custom."*
+_"We didn't want to go with expensive tools. SigNoz being open source was a big plus for us. We're big fans of open-source tools, and it opens up an opportunity to contribute back to the project if we want something custom."_
 
 — **Khushhal Reddy**
 
@@ -83,7 +79,7 @@ Data residency was critical for Kiwi, and Kiwi chose to partner up with SigNoz a
 
 <YouTube id="3M5MGt1DrJs" mute={false} />
 
-*"There's a very strict guideline that all data you pass to any third party has to be in India. We requested SigNoz to ensure our data is hosted in the India region to comply with RBI regulations."*
+_"There's a very strict guideline that all data you pass to any third party has to be in India. We requested SigNoz to ensure our data is hosted in the India region to comply with RBI regulations."_
 
 — **Khushhal Reddy**
 
@@ -98,7 +94,7 @@ Kiwi relies heavily on SigNoz for real-time monitoring and alerting to maintain
 - **On-Call Management:** All on-call schedules are based on SigNoz alerts. Developers are immediately notified of any fatal errors or system issues.
 - **Immediate Issue Detection:** Rapid alerts enable the team to address problems before they impact users.
 
-*"Our on-call schedules are based on SigNoz alerting. As soon as there are fatal errors in our system, we get notified immediately. It's very helpful in maintaining our service reliability."*
+_"Our on-call schedules are based on SigNoz alerting. As soon as there are fatal errors in our system, we get notified immediately. It's very helpful in maintaining our service reliability."_
 
 — **Khushhal Reddy**
 
@@ -106,7 +102,7 @@ Kiwi relies heavily on SigNoz for real-time monitoring and alerting to maintain
 
 Ensuring the reliable delivery of One-Time Passwords (OTPs) is crucial for Kiwi's user authentication and transaction security. However, monitoring OTP delivery can be challenging, especially when third-party OTP services report successful API responses even if users do not receive the OTPs.
 
-*"Even if the OTP servers are up, users might not be getting the OTPs. We cannot track it because the API response gives us a success. To address this, we place specific log lines in our code. If these log lines occur too frequently within a short time frame—say, multiple times in five or ten minutes—we know there's something wrong with the OTP system."*
+_"Even if the OTP servers are up, users might not be getting the OTPs. We cannot track it because the API response gives us a success. To address this, we place specific log lines in our code. If these log lines occur too frequently within a short time frame—say, multiple times in five or ten minutes—we know there's something wrong with the OTP system."_
 
 — **Khushhal Reddy, Backend Developer, Kiwi**
 
@@ -118,7 +114,7 @@ By leveraging SigNoz's logging and alerting capabilities, Kiwi sets up alerts ba
 
 Given their extensive integration with banking APIs, monitoring third-party services is crucial for Kiwi.
 
-*"We have dashboards set up to track all calls to third-party APIs. We monitor every request and response, including success rates and error codes like 5xx or 4xx. This helps us identify issues with bank APIs in real-time."*
+_"We have dashboards set up to track all calls to third-party APIs. We monitor every request and response, including success rates and error codes like 5xx or 4xx. This helps us identify issues with bank APIs in real-time."_
 
 — **Khushhal Reddy**
 
@@ -128,7 +124,7 @@ SigNoz empowers the Kiwi team to monitor third-party APIs with:
 - **Alerting on API Failures:** Immediate alerts are set up for third-party API downtimes, allowing quick communication with banking partners.
 - **Business Impact Analysis:** By tracking API performance, the business team can assess the impact on user experience and take proactive measures.
 
-*"If a bank's API is down, we get alerted immediately and can inform our business team and the bank to resolve the issue quickly. This level of monitoring is essential for us."*
+_"If a bank's API is down, we get alerted immediately and can inform our business team and the bank to resolve the issue quickly. This level of monitoring is essential for us."_
 
 — **Khushhal Reddy**
 
@@ -136,7 +132,7 @@ SigNoz empowers the Kiwi team to monitor third-party APIs with:
 
 Interestingly, the business team at Kiwi also leverages SigNoz dashboards to make informed decisions.
 
-*"Our business team uses SigNoz to track customer retention and the user journey. They monitor specific log lines corresponding to different steps in the app. If they see a drop in users reaching a particular step, they know there's an issue to address."*
+_"Our business team uses SigNoz to track customer retention and the user journey. They monitor specific log lines corresponding to different steps in the app. If they see a drop in users reaching a particular step, they know there's an issue to address."_
 
 — **Khushhal Reddy**
 
@@ -148,7 +144,7 @@ Some of the use-cases for business teams in SigNoz:
 - **Performance Metrics:** Monitoring third-party services that affect user experience, like OTP delivery systems.
 - **Cross-Verification:** Comparing data from SigNoz with tools like Mixpanel to ensure accuracy.
 
-*"Sometimes, we notice discrepancies in Mixpanel events. SigNoz provides a backend verification, ensuring that the data we have is accurate and reliable."*
+_"Sometimes, we notice discrepancies in Mixpanel events. SigNoz provides a backend verification, ensuring that the data we have is accurate and reliable."_
 
 — **Khushhal Reddy**
 
@@ -156,7 +152,7 @@ Some of the use-cases for business teams in SigNoz:
 
 Kiwi encountered a critical issue where a simple GET API call was taking 20 seconds instead of milliseconds, impacting user experience.
 
-*"We used SigNoz traces to investigate the issue. The database query was responding in milliseconds, but the API was still slow. SigNoz helped us discover that our application threads were getting choked due to asynchronous calls. We fixed the issue at the application level, and the API response time reduced to milliseconds."*
+_"We used SigNoz traces to investigate the issue. The database query was responding in milliseconds, but the API was still slow. SigNoz helped us discover that our application threads were getting choked due to asynchronous calls. We fixed the issue at the application level, and the API response time reduced to milliseconds."_
 
 — **Khushhal Reddy**
 
@@ -169,7 +165,7 @@ Kiwi encountered a critical issue where a simple GET API call was taking 20 seco
 3. **Application-Level Fixes:** Resolved threading issues in the Java application code.
 4. **Validation:** Monitored the improved performance using SigNoz to confirm the fix.
 
-*"Initially, we thought it was a DB problem, but SigNoz helped us pinpoint the real issue in our application code. It saved us a lot of time and effort."*
+_"Initially, we thought it was a DB problem, but SigNoz helped us pinpoint the real issue in our application code. It saved us a lot of time and effort."_
 
 — **Khushhal Reddy**
 
@@ -181,10 +177,9 @@ Kiwi uses SigNoz in development, staging, and production environments to ensure
 - **Load Testing:** SigNoz is used during load and endurance tests to identify system performance under high traffic.
 - **Continuous Monitoring:** Developers monitor their services daily, using SigNoz to ensure everything is functioning as expected.
 
-
 <YouTube id="QpHzvjGZxd8" mute={false} />
 
-*"We deploy new code to our lower environments, monitor it using SigNoz, and only then move it to production. It helps us ensure everything is working as expected before it goes live."*
+_"We deploy new code to our lower environments, monitor it using SigNoz, and only then move it to production. It helps us ensure everything is working as expected before it goes live."_
 
 — **Khushhal Reddy**
 
@@ -202,7 +197,7 @@ Kiwi uses SigNoz in development, staging, and production environments to ensure
 - **Resource Utilization:** Monitored CPU, memory, and JVM metrics to optimize resource usage.
 - **Scalability:** Prepared the system to handle 10x increases in user traffic confidently.
 
-*"We continuously monitor our systems during load tests using SigNoz. It helps us identify choke points and optimize them before scaling."*
+_"We continuously monitor our systems during load tests using SigNoz. It helps us identify choke points and optimize them before scaling."_
 
 — **Khushhal Reddy**
 
@@ -210,9 +205,9 @@ Kiwi uses SigNoz in development, staging, and production environments to ensure
 
 <YouTube id="OsxXI-kRres" mute={false} />
 
-Kiwi also uses Cloudwatch for logs. But the costs are unpredictable. 
+Kiwi also uses Cloudwatch for logs. But the costs are unpredictable.
 
-*"CloudWatch charges based on the queries you run, and developers wouldn't know how much a query would cost until after running it. It was especially concerning during urgent issues when the priority is to fix the problem, not monitor costs. There were instances where our CloudWatch expenses exceeded our EC2 instance costs."*
+_"CloudWatch charges based on the queries you run, and developers wouldn't know how much a query would cost until after running it. It was especially concerning during urgent issues when the priority is to fix the problem, not monitor costs. There were instances where our CloudWatch expenses exceeded our EC2 instance costs."_
 
 — **Khushhal Reddy, Backend Developer, Kiwi**
 
@@ -222,16 +217,16 @@ That’s why the team at Kiwi is planning to move everything to SigNoz soon. We
 
 Kiwi plans to move more of their infrastructure monitoring from CloudWatch to SigNoz, including AWS logs and additional metrics.
 
-*"We're starting to send more of our AWS logs to SigNoz. Our goal is to have all our dashboards for every infra component in one place. It not only saves cost but also makes monitoring more efficient."*
+_"We're starting to send more of our AWS logs to SigNoz. Our goal is to have all our dashboards for every infra component in one place. It not only saves cost but also makes monitoring more efficient."_
 
 — **Khushhal Reddy**
 
 SigNoz has become an indispensable part of Kiwi's observability stack, enabling them to ensure real-time reliability, maintain regulatory compliance, and optimize system performance—all while being cost-effective.
 
-*"SigNoz is something we use daily. If I have ten tabs open, six of them are SigNoz. It’s essential for our operations. It helps me sleep well at night knowing that things are working, and if something goes wrong, we're able to quickly resolve it."*
+_"SigNoz is something we use daily. If I have ten tabs open, six of them are SigNoz. It’s essential for our operations. It helps me sleep well at night knowing that things are working, and if something goes wrong, we're able to quickly resolve it."_
 
 — **Khushhal Reddy**
 
 ---
 
-**SigNoz Cloud** is the easiest way to run SigNoz. You can sign up [here](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
\ No newline at end of file
+**SigNoz Cloud** is the easiest way to run SigNoz. You can sign up [here](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
diff --git a/data/case-study/linkcy.mdx b/data/case-study/linkcy.mdx
index b5d43e83e..87c110898 100644
--- a/data/case-study/linkcy.mdx
+++ b/data/case-study/linkcy.mdx
@@ -1,25 +1,21 @@
 ---
-
-title:  How Fintech Startup Linkcy Monitors Critical APIs with SigNoz Dashboards
-slug: linkcy
+title: How Fintech Startup Linkcy Monitors Critical APIs with SigNoz Dashboards
 image: /img/case_study/linkcy-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
-<a
-class="avatar__photo-link avatar__photo avatar__photo--lg"
-href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-<img
-alt="Ankit Profile"
-src="/img/users/ankit-anand.webp" />
-</a>
-<div class="avatar__intro">
-<div class="avatar__name">Ankit Anand</div>
-<small class="avatar__subtitle">
-Maintainer, SigNoz
-</small>
-</div>
+  <a
+    class="avatar__photo-link avatar__photo avatar__photo--lg"
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
+  </a>
+  <div class="avatar__intro">
+    <div class="avatar__name">Ankit Anand</div>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
+  </div>
 </div>
 
 ### About Linkcy
@@ -32,7 +28,7 @@ With a compact but efficient tech team of five engineers, Linkcy prioritizes rel
 
 ### **The Challenge - Needed a Comprehensive Observability Solution**
 
-Despite using multiple tools across different teams—**Sentry for error tracking and Grafana for infrastructure monitoring**—Linkcy lacked a **unified** observability platform. During their research, they came across SigNoz. 
+Despite using multiple tools across different teams—**Sentry for error tracking and Grafana for infrastructure monitoring**—Linkcy lacked a **unified** observability platform. During their research, they came across SigNoz.
 
 Linkcy needed a **comprehensive observability solution** to:
 
@@ -60,15 +56,15 @@ Linkcy leverages SigNoz to monitor its API traffic and user interactions. The te
 - Monitor the success rate of operations such as money transfers.
 - Identify API errors (e.g., HTTP 500 responses) and debug issues quickly.
 
-*"We now have a better understanding of how each client is using our API technically."*
+_"We now have a better understanding of how each client is using our API technically."_
 
 - Alexandre Moray, Senior Software Engineer
 
 ### **Real-Time Dashboards for Multi-Tenant API Monitoring**
 
-Linkcy uses SigNoz dashboards to monitor the performance and usage of its critical APIs. The dashboards provide real-time visibility into API traffic, transaction volumes, and failure rates. By filtering data per client or operation, the team can quickly detect anomalies, troubleshoot issues, and optimize API efficiency. 
+Linkcy uses SigNoz dashboards to monitor the performance and usage of its critical APIs. The dashboards provide real-time visibility into API traffic, transaction volumes, and failure rates. By filtering data per client or operation, the team can quickly detect anomalies, troubleshoot issues, and optimize API efficiency.
 
-*"Our product owner, despite not having a technical background, was able to create dashboards to track webhook activity with our provider."*
+_"Our product owner, despite not having a technical background, was able to create dashboards to track webhook activity with our provider."_
 
 - Alexandre Moray, Senior Software Engineer
 
@@ -78,7 +74,7 @@ These insights help both technical and non-technical stakeholders, including pro
 
 ### **4Alerting & Troubleshooting**
 
-*"We set up alerts when our API exceeded rate limits with an external provider, allowing us to take action before customers were affected."*
+_"We set up alerts when our API exceeded rate limits with an external provider, allowing us to take action before customers were affected."_
 
 - Alexandre Moray, Senior Software Engineer
 
@@ -86,9 +82,9 @@ While Linkcy primarily uses dashboards for monitoring, they have started setting
 
 ### **5. Monitoring Temporal Workflows with OpenTelemetry**
 
-*"Now, we can see a full trace of financial transactions, linking API calls with Temporal workflows, which was previously missing in our setup."*
+_"Now, we can see a full trace of financial transactions, linking API calls with Temporal workflows, which was previously missing in our setup."_
 
-- Alexandre Moray, Senior Software Engineer 
+- Alexandre Moray, Senior Software Engineer
 
 <YouTube id="vxc29SnzEKc" mute={false} />
 
@@ -104,11 +100,11 @@ With SigNoz, Linkcy has achieved:
 
 ## **Future Plans**
 
-*"The experience with SigNoz has been great. The open-source nature and OpenTelemetry support make it a perfect fit for our growing fintech infrastructure."*
+_"The experience with SigNoz has been great. The open-source nature and OpenTelemetry support make it a perfect fit for our growing fintech infrastructure."_
 
 - Alexandre Moray, Senior Software Engineer
 
-As Linkcy continues to scale, its future roadmap focuses on enhancing observability across its expanding infrastructure. The team plans to implement more advanced **alerting mechanisms** to automate anomaly detection and proactive issue resolution. They are also exploring **SigNoz’s new Infrastructure Monitoring module** to replace existing Grafana-based monitoring, ensuring deeper insights into Kubernetes performance. 
+As Linkcy continues to scale, its future roadmap focuses on enhancing observability across its expanding infrastructure. The team plans to implement more advanced **alerting mechanisms** to automate anomaly detection and proactive issue resolution. They are also exploring **SigNoz’s new Infrastructure Monitoring module** to replace existing Grafana-based monitoring, ensuring deeper insights into Kubernetes performance.
 
 Additionally, Linkcy aims to optimize its OpenTelemetry implementation further, reducing manual instrumentation efforts and streamlining observability across services. With an increasing number of clients onboard, the company is committed to continuously refining its monitoring strategy to maintain high availability, optimize costs, and ensure seamless operations for financial transactions.
 
@@ -118,11 +114,10 @@ Additionally, Linkcy aims to optimize its OpenTelemetry implementation further,
 
 For fintech startups like Linkcy, where security, compliance, and **operational visibility** are crucial, **SigNoz offers a powerful observability stack** with the flexibility of open-source and the robustness of a commercial-grade solution.
 
-
 ---
 
 **SigNoz Cloud** is the easiest way to run SigNoz. You can sign up [**here**](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
 
 [![Get Started - Free CTA](/img/launch_week/try-signoz-cloud-blog-cta.png)](https://signoz.io/teams/)
 
----
\ No newline at end of file
+---
diff --git a/data/case-study/mailmodo.mdx b/data/case-study/mailmodo.mdx
index b176e1200..dd24ab73f 100644
--- a/data/case-study/mailmodo.mdx
+++ b/data/case-study/mailmodo.mdx
@@ -1,41 +1,43 @@
 ---
-
 title: How Mailmodo streamlined monitoring of 200GB+ daily logs from 200+ microservices with SigNoz
-slug: mailmodo
 image: /img/case_study/mailmodo-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
-<a
-class="avatar__photo-link avatar__photo avatar__photo--lg"
-href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-<img
-alt="Ankit Profile"
-src="/img/users/ankit-anand.webp" />
-</a>
-<div class="avatar__intro">
-<div class="avatar__name">Ankit Anand</div>
-<small class="avatar__subtitle">
-Maintainer, SigNoz
-</small>
-</div>
+  <a
+    class="avatar__photo-link avatar__photo avatar__photo--lg"
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
+  </a>
+  <div class="avatar__intro">
+    <div class="avatar__name">Ankit Anand</div>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
+  </div>
 </div>
 
 ## About Mailmodo
 
-<a href = "https://www.mailmodo.com/" rel="noopener noreferrer nofollow" target="_blank" >Mailmodo</a> is a rapidly scaling email marketing platform backed by YCombinator that empowers businesses to create and send interactive AMP emails. By embedding forms, surveys, and widgets directly within emails, Mailmodo enhances engagement rates and streamlines the customer journey. Serving high-profile clients in critical email campaigns, Mailmodo processes billions of emails daily, necessitating robust log management and observability.
+<a href="https://www.mailmodo.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Mailmodo
+</a>
+is a rapidly scaling email marketing platform backed by YCombinator that empowers businesses to
+create and send interactive AMP emails. By embedding forms, surveys, and widgets directly within
+emails, Mailmodo enhances engagement rates and streamlines the customer journey. Serving
+high-profile clients in critical email campaigns, Mailmodo processes billions of emails daily,
+necessitating robust log management and observability.
 
 We sat down with <a href = "https://www.linkedin.com/in/avneesh-kumar-992a3a46/" rel="noopener noreferrer nofollow" target="_blank" >Avneesh Kumar</a>, VP of Engineering at Mailmodo to discuss the team’s experience with SigNoz.
 
 ![Mailmodo Case Study](/img/case_study/mailmodo-cover.webp)
 
-
 ## The Challenge: Managing High-Volume Logs and Enhancing Developer Productivity
 
 As Mailmodo transitioned from a monolithic application to a microservices architecture with over 200 services, the complexity and volume of logs increased exponentially.
 
-*"We produce on a daily basis almost 200 GB of logs, and during peak times, it can reach up to 500-600 GB. Managing such a massive volume of logs became a significant challenge for us."*
+_"We produce on a daily basis almost 200 GB of logs, and during peak times, it can reach up to 500-600 GB. Managing such a massive volume of logs became a significant challenge for us."_
 
 — **Avneesh Kumar, VP of Engineering, Mailmodo**
 
@@ -52,15 +54,15 @@ Mailmodo chose SigNoz as its centralized logging platform due to its seamless in
 
 ### Discovering SigNoz Through Open Source Solutions
 
-*"We were already using ClickHouse as our OLAP solution. We realized any company that uses ClickHouse can compress logs and enable faster search. That's when we came across SigNoz."*
+_"We were already using ClickHouse as our OLAP solution. We realized any company that uses ClickHouse can compress logs and enable faster search. That's when we came across SigNoz."_
 
 — **Avneesh Kumar**
 
 After evaluating other solutions like Loki and BetterStack, Mailmodo found SigNoz to be the most suitable for their logging needs.
 
-As an advocate for open-source solutions, Avneesh loved the fact that SigNoz is open-source and 
+As an advocate for open-source solutions, Avneesh loved the fact that SigNoz is open-source and
 
-*"The best thing about SigNoz is that it's open source. I can go into the source code and look at what's happening. That's a great confidence booster for long-term usage."*
+_"The best thing about SigNoz is that it's open source. I can go into the source code and look at what's happening. That's a great confidence booster for long-term usage."_
 
 — **Avneesh Kumar**
 
@@ -72,7 +74,7 @@ As an advocate for open-source solutions, Avneesh loved the fact that SigNoz is
 
 Once the Mailmodo team integrated SigNoz for logs monitoring, the team saw significant improvements in troubleshooting speed.
 
-*"The ingestion rates and search speeds with SigNoz have significantly improved our troubleshooting speed."*
+_"The ingestion rates and search speeds with SigNoz have significantly improved our troubleshooting speed."_
 
 — **Avneesh Kumar**
 
@@ -80,8 +82,7 @@ Once the Mailmodo team integrated SigNoz for logs monitoring, the team saw signi
 
 ### Empowering Customer Success Teams
 
-<YouTube id="PQdprlVprtU" mute={false} /> 
-
+<YouTube id="PQdprlVprtU" mute={false} />
 
 By providing controlled access to SigNoz dashboards, Mailmodo enabled their technical support team to handle customer queries independently.
 
@@ -89,7 +90,7 @@ By providing controlled access to SigNoz dashboards, Mailmodo enabled their tech
 - **Improved Response Times:** Faster resolution of customer issues enhances customer satisfaction.
 - **Regulatory Compliance:** Access controls ensure that only authorized personnel view sensitive logs.
 
-*"Our most prominent use case was to give access to logs to the customer support team. Now that dependency has completely been removed from the tech team."*
+_"Our most prominent use case was to give access to logs to the customer support team. Now that dependency has completely been removed from the tech team."_
 
 — **Avneesh Kumar**
 
@@ -97,13 +98,12 @@ By providing controlled access to SigNoz dashboards, Mailmodo enabled their tech
 
 Mailmodo leveraged SigNoz's parameterized dashboards to monitor logs across different environments and services.
 
-*"We have created parameterized dashboards using SigNoz. In a single dashboard, we can monitor all logs and plot intuitive graphs to see what's happening."*
+_"We have created parameterized dashboards using SigNoz. In a single dashboard, we can monitor all logs and plot intuitive graphs to see what's happening."_
 
 — **Avneesh Kumar**
 
 <YouTube id="0lcvwU3qp3s" mute={false} />
 
-
 Having parametrized dashboards helped the Mailmodo engineering team quickly monitor logs across environments and other resource attributes.
 
 - **Environment-Specific Views:** Dashboards display logs for debug, UAT, and production environments.
@@ -114,14 +114,13 @@ Having parametrized dashboards helped the Mailmodo engineering team quickly moni
 
 <YouTube id="LQ7INbT6ASI" mute={false} />
 
-
 Mailmodo utilizes SigNoz's alerting capabilities to monitor log patterns and receive notifications on critical issues.
 
 - **Aggregated Alerts:** Grouping similar errors reduces noise and highlights significant issues.
 - **Third-Party Integration Monitoring:** Alerts notify the team when integrations fail due to issues like expired API keys or endpoint failures.
 - **Timely Interventions:** Developers can act swiftly on alerts to resolve issues before they impact customers.
 
-*"We are setting up alerts so as soon as the number of errors spikes, we get notified. This helps us maintain service reliability."*
+_"We are setting up alerts so as soon as the number of errors spikes, we get notified. This helps us maintain service reliability."_
 
 — **Avneesh Kumar**
 
@@ -129,13 +128,12 @@ Mailmodo utilizes SigNoz's alerting capabilities to monitor log patterns and rec
 
 By shifting log access to the technical support team, the Mailmodo team was able to save 6 hours of precious developer time on an average daily.
 
-*"We have started saving almost six hours on a daily basis, which we can now invest in other tech debts and backlogs."*
+_"We have started saving almost six hours on a daily basis, which we can now invest in other tech debts and backlogs."_
 
 — **Avneesh Kumar**
 
 <YouTube id="xNVo00zvE6o" mute={false} />
 
-
 Using SigNoz for logs led to:
 
 - **Time Savings:** Approximately **6 hours saved daily** as developers no longer handle routine log inquiries.
@@ -154,7 +152,7 @@ Using SigNoz for logs led to:
 - **Enhanced Customer Satisfaction:** Faster troubleshooting leads to improved customer experiences.
 - **Developer Satisfaction:** Reduced interruptions allow developers to focus on innovation and product enhancements.
 
-*"SigNoz has been a great help. The entire experience has been very smooth, and the support we receive is prompt and effective."*
+_"SigNoz has been a great help. The entire experience has been very smooth, and the support we receive is prompt and effective."_
 
 — **Avneesh Kumar**
 
@@ -162,13 +160,13 @@ Using SigNoz for logs led to:
 
 Mailmodo plans to consider SigNoz for other observability needs, such as APM and tracing, especially as they contemplate moving to Kubernetes.
 
-*"If we move to Kubernetes, SigNoz's OpenTelemetry support would make it easy to take care of observability."*
+_"If we move to Kubernetes, SigNoz's OpenTelemetry support would make it easy to take care of observability."_
 
 — **Avneesh Kumar**
 
 By implementing SigNoz for log management, Mailmodo has significantly improved operational efficiency, reduced costs, and enhanced developer productivity. The ability to handle high log volumes and empower support teams has transformed their approach to observability.
 
-*"SigNoz has not only provided a scalable, cost-effective solution but also transformed our support operations by empowering our technical support team to handle logs independently."*
+_"SigNoz has not only provided a scalable, cost-effective solution but also transformed our support operations by empowering our technical support team to handle logs independently."_
 
 — **Avneesh Kumar**
 
@@ -180,4 +178,4 @@ With SigNoz, Mailmodo can continue to scale confidently, ensuring reliable servi
 
 [![Get Started - Free CTA](/img/launch_week/try-signoz-cloud-blog-cta.png)](https://signoz.io/teams/)
 
----
\ No newline at end of file
+---
diff --git a/data/case-study/observability-for-small-teams-and-solopreneurs.mdx b/data/case-study/observability-for-small-teams-and-solopreneurs.mdx
index 635c4a310..5d31e7565 100644
--- a/data/case-study/observability-for-small-teams-and-solopreneurs.mdx
+++ b/data/case-study/observability-for-small-teams-and-solopreneurs.mdx
@@ -1,23 +1,20 @@
 ---
-title:  Democratizing Observability - How SigNoz Empowers Solo Entrepreneurs and Small Teams
-slug: observability-for-small-teams-and-solopreneurs
+title: Democratizing Observability - How SigNoz Empowers Solo Entrepreneurs and Small Teams
 image: /img/case_study/httpscout-case-study-cover.webp
+description: ''
 authors: [vishal]
-
 ---
+
 <div class="avatar">
   <a
     class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://www.linkedin.com/in/makeavish/">
-    <img
-      alt="Vishal Profile"
-      src="/img/authors/vishal-new.jpeg" />
+    href="https://www.linkedin.com/in/makeavish/"
+  >
+    <img alt="Vishal Profile" src="/img/authors/vishal-new.jpeg" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Vishal Sharma</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
@@ -43,7 +40,6 @@ When seasoned backend developer <a href = "https://www.linkedin.com/in/sheysewan
 
 "I didn't want to leak money to Datadog or New Relic while I don't have any customers," Shey explained.
 
-
 ## The Grafana Hurdle
 
 Initially, Shey considered using Grafana, inspired by its popularity among Rails developers. However, he quickly encountered several challenges:
@@ -56,8 +52,6 @@ Initially, Shey considered using Grafana, inspired by its popularity among Rails
 Additionally, integrating all three signals—traces, logs, and metrics—into a single pane of glass was significantly easier with SigNoz. This comprehensive observability from a single platform simplified Shey’s workflow and enhanced overall productivity. Instead of juggling multiple tools or dealing with complex setups, Shey could focus on what mattered most: developing and improving HTTP Scout.
 
 > "Even if I hook up the data, I still have to import graphs into Grafana or make a graph myself, like a dashboard myself, to do all those things," Shey noted.
-> 
-
 
 ## Enter SigNoz
 
@@ -65,10 +59,8 @@ SigNoz's self-hosted, open-source solution was the perfect fit, democratizing ac
 
 Shey knew about the importance of distributed tracing in applications having seen the benefits before. He wanted to set up tracing for httpscout with Grafana, but quickly realized it wasn't a great fit.
 
-
 <YouTube id="ZWuqBBtCyQo" mute={false} />
 
-
 ### Key Benefits
 
 1. **Easy setup**: Quick configuration with Docker Compose
@@ -80,13 +72,11 @@ Shey knew about the importance of distributed tracing in applications having see
 7. **Cost-effective self-hosting**: No ongoing subscription costs
 8. **Community Support:** The active and supportive SigNoz community provided valuable insights and assistance, ensuring a smooth experience for small teams and solo developers.
 
-
 ## The Impact
 
 For Shey, SigNoz embodied the democratization of observability:
 
 > "What I want from SigNoz is for it to just work, so I can go back to my other important work. And it is working. It did exactly what I wanted. So I love it's working. I'm happy."
-> 
 
 SigNoz allowed Shey to:
 
@@ -94,8 +84,6 @@ SigNoz allowed Shey to:
 - Focus on core business development
 - Scale monitoring capabilities alongside business growth
 
-
-
 ## Why It Matters
 
 SigNoz is changing the game for small companies and side projects:
@@ -107,8 +95,6 @@ SigNoz is changing the game for small companies and side projects:
 As Vishal from SigNoz puts it:
 
 > "We want to democratize observability. We want to make sure that people in smaller teams are able to deploy full stack observability (Datadog/New Relic) like features, even in the free version."
-> 
-
 
 ## The Future
 
@@ -118,9 +104,7 @@ By making advanced observability accessible to projects of all sizes, SigNoz is:
 - Enabling the creation of more reliable, performant applications from day one
 - Leveling the playing field in application performance and reliability
 
-
-*Ready to democratize observability for your project? [Get started with SigNoz today!](https://github.com/SigNoz/signoz)*
-
+_Ready to democratize observability for your project? [Get started with SigNoz today!](https://github.com/SigNoz/signoz)_
 
 ---
 
@@ -130,4 +114,4 @@ Sharing stories of how different teams are using SigNoz helps the community in l
 
 Feel free to join our slack community and say hi! 👋
 
-[![SigNoz Slack community](/img/blog/common/join_slack_cta.webp)](https://signoz.io/slack)
\ No newline at end of file
+[![SigNoz Slack community](/img/blog/common/join_slack_cta.webp)](https://signoz.io/slack)
diff --git a/data/case-study/outplay.mdx b/data/case-study/outplay.mdx
index 238719012..21d9b7ca6 100644
--- a/data/case-study/outplay.mdx
+++ b/data/case-study/outplay.mdx
@@ -1,22 +1,17 @@
 ---
 title: How Outplay uses SigNoz to improve their backend API response time by 35%
-slug: outplay
 image: /img/case_study/outplay-banner-min.jpg
+description: ''
 authors: [pranay]
 ---
+
 <div class="avatar">
-  <a
-    class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://twitter.com/pranay01">
-    <img
-      alt="Pranay Profile"
-      src="/img/authors/pranay_profile_pic.webp" />
+  <a class="avatar__photo-link avatar__photo avatar__photo--lg" href="https://twitter.com/pranay01">
+    <img alt="Pranay Profile" src="/img/authors/pranay_profile_pic.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Pranay Prateek</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
@@ -71,6 +66,7 @@ We were also checking out another tool, Tempo from Grafana. But the number of co
 We wanted to keep the number of components as small as possible. We don't want to deploy a lot of components. That increases the complexity and managing systems with many moving parts can be messy. You would need separate people to handle the issues in maintaining such systems.
 
 We needed something which just works after deploying and doesn't need continuous maintenance.
+
 <br />
 <br />
 
diff --git a/data/case-study/shaped.mdx b/data/case-study/shaped.mdx
index b61907854..a17e2b405 100644
--- a/data/case-study/shaped.mdx
+++ b/data/case-study/shaped.mdx
@@ -1,32 +1,28 @@
 ---
-
 title: YC-backed Shaped AI Swapped a Siloed Toolset for SigNoz, achieving One-Stop Observability
-slug: shaped
 image: /img/case_study/shaped-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
-<a
-class="avatar__photo-link avatar__photo avatar__photo--lg"
-href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-<img
-alt="Ankit Profile"
-src="/img/users/ankit-anand.webp" />
-</a>
-<div class="avatar__intro">
-<div class="avatar__name">Ankit Anand</div>
-<small class="avatar__subtitle">
-Maintainer, SigNoz
-</small>
-</div>
+  <a
+    class="avatar__photo-link avatar__photo avatar__photo--lg"
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
+  </a>
+  <div class="avatar__intro">
+    <div class="avatar__name">Ankit Anand</div>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
+  </div>
 </div>
 
 ## About Shaped: Powering AI-native Recommendations & Personalization
 
 Backed by Y Combinator, [Shaped](https://www.shaped.ai/) empowers companies to build production-ready ranking and recommendation models in minutes. Customers use Shaped’s powerful APIs to create personalized feed experiences for their users. The platform runs on a modern tech stack, hosted on AWS and orchestrated with Kubernetes (EKS).
 
-For a high-growth, Series A-funded startup like Shaped, both engineering efficiency and cost management are paramount.  For observability, the team found themselves grappling with a fragmented observability stack that hindered their troubleshooting efforts.
+For a high-growth, Series A-funded startup like Shaped, both engineering efficiency and cost management are paramount. For observability, the team found themselves grappling with a fragmented observability stack that hindered their troubleshooting efforts.
 
 We sat down with [Karl Lyons](https://www.linkedin.com/in/karllyons/), a senior site reliability engineer at Shaped, to understand how the engineering team at Shaped is leveraging SigNoz for observability.
 
@@ -93,4 +89,4 @@ Features like the correlation between traces and logs have proven "super useful,
 
 -Karl Lyons, Senior SRE, Shaped AI
 
-From a fragmented, costly, and frustrating setup, Shaped has moved to a state of observability clarity. With SigNoz, the entire engineering team is now equipped with a unified, one-stop, and cost-effective observability tool that has become an indispensable part of their daily workflows.
\ No newline at end of file
+From a fragmented, costly, and frustrating setup, Shaped has moved to a state of observability clarity. With SigNoz, the entire engineering team is now equipped with a unified, one-stop, and cost-effective observability tool that has become an indispensable part of their daily workflows.
diff --git a/data/case-study/tableflow.mdx b/data/case-study/tableflow.mdx
index ec0525113..01c332630 100644
--- a/data/case-study/tableflow.mdx
+++ b/data/case-study/tableflow.mdx
@@ -1,37 +1,32 @@
 ---
-title:  How TableFlow Uses SigNoz to Improve Service Reliability and Resolve Issues Quickly
-slug: tableflow
+title: How TableFlow Uses SigNoz to Improve Service Reliability and Resolve Issues Quickly
 image: /img/case_study/tableflow-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
   <a
     class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-    <img
-      alt="Ankit Profile"
-      src="/img/users/ankit-anand.webp" />
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Ankit Anand</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
-
 ## About TableFlow
 
 [TableFlow](https://tableflow.com/) is a SaaS platform backed by YCombinator that automates the import of CSV and PDF files for customer onboarding, turning unstructured documents into structured data seamlessly. As a company focused on delivering a smooth user experience, TableFlow needed a robust observability solution to ensure the stability and reliability of its services.
 
-
 ## The Challenge - CloudWatch’s lack of user-friendly log management
 
 When TableFlow was building its infrastructure, it quickly became apparent that traditional logging tools like CloudWatch weren’t meeting their needs. CloudWatch’s lack of user-friendly log management made it difficult to diagnose and resolve issues efficiently. As Eric, Co-Founder of TableFlow, explains:
 
-*"Monitoring and observability have always been crucial for us, especially when it comes to knowing what went wrong and being able to quickly find and resolve issues. Before SigNoz, CloudWatch was difficult to use for log management, and it wasn’t giving us the insights we needed.”*
+_"Monitoring and observability have always been crucial for us, especially when it comes to knowing what went wrong and being able to quickly find and resolve issues. Before SigNoz, CloudWatch was difficult to use for log management, and it wasn’t giving us the insights we needed.”_
 
 <YouTube id="XWdBnWRnV7g" mute={false} />
 
@@ -45,70 +40,61 @@ Observability is crucial to TableFlow because it ensures platform stability, ena
 
 ## Why did you choose SigNoz?
 
-*"SigNoz checked all the boxes for us: it’s open-source, feature-rich, and comes at a price point that makes sense for us. Plus, it integrates well with our existing systems, making the transition smooth."*
+_"SigNoz checked all the boxes for us: it’s open-source, feature-rich, and comes at a price point that makes sense for us. Plus, it integrates well with our existing systems, making the transition smooth."_
 
 — **Eric Ciminelli, Co-Founder, TableFlow**
 
 When evaluating observability tools, TableFlow chose SigNoz for several key reasons:
 
 1. **Feature-Rich:**
-    
-    SigNoz offered a comprehensive set of observability features, including detailed logging and alerting capabilities, that met all of TableFlow’s requirements for maintaining platform stability.
-    
+
+   SigNoz offered a comprehensive set of observability features, including detailed logging and alerting capabilities, that met all of TableFlow’s requirements for maintaining platform stability.
+
 2. **Open-Source Alignment:**
-    
-    SigNoz’s open-source nature perfectly aligned with TableFlow’s tech stack, which relies heavily on open-source components, making it a seamless fit within their existing infrastructure.
-    
+
+   SigNoz’s open-source nature perfectly aligned with TableFlow’s tech stack, which relies heavily on open-source components, making it a seamless fit within their existing infrastructure.
+
 3. **Cost-Effectiveness:**
-    
-    Compared to other solutions, SigNoz provided all the necessary observability features at a price point that was affordable for a growing company like TableFlow, allowing them to scale without incurring prohibitive costs.
-    
+
+   Compared to other solutions, SigNoz provided all the necessary observability features at a price point that was affordable for a growing company like TableFlow, allowing them to scale without incurring prohibitive costs.
 
 ## Implemented SigNoz for logging and alerting
 
 TableFlow implemented SigNoz primarily for logging and alerting. They utilized SigNoz’s ability to set up precise alerting systems based on log severity levels, which was crucial for their engineering team.
 
-*"We set up alerts based on log severity levels, which has been crucial for our engineering team. If an error log comes through, we get notified immediately, allowing us to address the issue before it impacts our users.”*
+_"We set up alerts based on log severity levels, which has been crucial for our engineering team. If an error log comes through, we get notified immediately, allowing us to address the issue before it impacts our users.”_
 
 — **Eric**
 
 TableFlow also integrated SigNoz with their AWS infrastructure, using it alongside CloudWatch, but found SigNoz much more effective for log management.
 
-*"SigNoz has been instrumental in helping us maintain platform stability. The most significant benefit has been the ability to quickly surface the information we need from logs and alerts.”*
+_"SigNoz has been instrumental in helping us maintain platform stability. The most significant benefit has been the ability to quickly surface the information we need from logs and alerts.”_
 
 — **Eric**
 
-
 ## SigNoz improved Tableflow’s reliability with streamlined log management
 
 Since implementing SigNoz, TableFlow has seen several improvements:
 
 - **Faster Issue Resolution:**
-    
-    SigNoz’s log management tools have made it much easier to diagnose and resolve issues, ensuring minimal downtime and maintaining high levels of service reliability.
-    
+  SigNoz’s log management tools have made it much easier to diagnose and resolve issues, ensuring minimal downtime and maintaining high levels of service reliability.
 - **Streamlined Log Management:**
-    
-    SigNoz’s user-friendly interface allows TableFlow to quickly access and analyze logs, something that was cumbersome with CloudWatch.
-    
+  SigNoz’s user-friendly interface allows TableFlow to quickly access and analyze logs, something that was cumbersome with CloudWatch.
 - **Improved Sleep Quality:**
-    
-    As Eric humorously noted, SigNoz has helped him “sleep well at night” by providing peace of mind that their systems are being monitored effectively.
-    
+  As Eric humorously noted, SigNoz has helped him “sleep well at night” by providing peace of mind that their systems are being monitored effectively.
 
-*"SigNoz helps me sleep well at night knowing that things are working, and if something doesn’t happen to go wrong, we’re able to quickly resolve it.”*
+_"SigNoz helps me sleep well at night knowing that things are working, and if something doesn’t happen to go wrong, we’re able to quickly resolve it.”_
 
 — **Eric**
 
-
 ## Looking Ahead - Planning to expand usage to APM & Tracing
 
 While TableFlow currently uses SigNoz primarily for logs and alerts, they are planning to expand its use. As the company continues to grow, they are exploring additional features like detailed performance monitoring and tracing to further enhance their observability capabilities.
 
-*"As we scale, performance monitoring and detailed tracing will become more of a priority for us, and we plan to leverage SigNoz for these as well.”*
+_"As we scale, performance monitoring and detailed tracing will become more of a priority for us, and we plan to leverage SigNoz for these as well.”_
 
 — **Eric**
 
 ---
 
-SigNoz cloud is the easiest way to run SigNoz. You can sign up [here](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
\ No newline at end of file
+SigNoz cloud is the easiest way to run SigNoz. You can sign up [here](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
diff --git a/data/case-study/thehindu.mdx b/data/case-study/thehindu.mdx
index 06104c6eb..ec271502b 100644
--- a/data/case-study/thehindu.mdx
+++ b/data/case-study/thehindu.mdx
@@ -1,27 +1,23 @@
 ---
-title:  How The Hindu uses SigNoz APM to Optimize App Performance
-slug: thehindu
+title: How The Hindu uses SigNoz APM to Optimize App Performance
 image: /img/case_study/thehindu-cover.webp
+description: ''
 authors: [ankit_anand]
-
 ---
+
 <div class="avatar">
   <a
     class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://www.linkedin.com/in/ankit-anand-686a53a1/">
-    <img
-      alt="Ankit Profile"
-      src="/img/users/ankit-anand.webp" />
+    href="https://www.linkedin.com/in/ankit-anand-686a53a1/"
+  >
+    <img alt="Ankit Profile" src="/img/users/ankit-anand.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Ankit Anand</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
-
 ## About The Hindu
 
 The Hindu, one of India’s most respected newspapers, has a rich history of delivering news to millions of readers. As the publication embarked on its digital transformation journey, ensuring the reliability and performance of its online platforms became paramount. The Hindu turned to SigNoz to monitor and optimize its complex, multi-SaaS services and cloud infrastructure.
@@ -32,13 +28,13 @@ As one of the first newspapers in India to introduce a subscription service, The
 
 They also needed a robust observability platform to monitor their multi-cloud infrastructure, which included a mix of Oracle Cloud, AWS, GCP, and an on-premises data center. SigNoz was chosen to provide end-to-end observability, helping The Hindu track every user transaction and optimize performance across their subscription-based service.
 
-> *"We needed a reliable observability platform to monitor the entire user journey, especially after launching our subscription service. SigNoz gave us the visibility we needed to ensure everything worked seamlessly across our digital platforms."*
+> _"We needed a reliable observability platform to monitor the entire user journey, especially after launching our subscription service. SigNoz gave us the visibility we needed to ensure everything worked seamlessly across our digital platforms."_
 
 > — Poonkuyilan V, IT Infrastructure and Core Applications Lead, The Hindu
 
 ## Chose SigNoz for Its Superior APM Visualizations and Detailed Performance Insights
 
-*"We integrated various APM products but didn’t get the same level of insights and traceability that SigNoz provides. With SigNoz, we can identify and resolve issues faster, optimizing our applications for better performance."*
+_"We integrated various APM products but didn’t get the same level of insights and traceability that SigNoz provides. With SigNoz, we can identify and resolve issues faster, optimizing our applications for better performance."_
 
 — **Poonkuyilan V, IT Infrastructure and Core Applications Lead, The Hindu**
 
@@ -58,29 +54,26 @@ SigNoz’s open-source nature offered greater flexibility and control, aligning
 
 ## Why SigNoz APM Outshines Other APM tools
 
-
 The Hindu had previously experimented with other APM products but found it lacking in comparison to SigNoz.
 
-*"We tried out other APM products but didn’t find it as effective as SigNoz. The visibility and insights we get from SigNoz are far superior, especially in identifying unwanted calls and optimizing application performance."*
+_"We tried out other APM products but didn’t find it as effective as SigNoz. The visibility and insights we get from SigNoz are far superior, especially in identifying unwanted calls and optimizing application performance."_
 
 — **Poonkuyilan V, IT Infrastructure and Core Applications Lead, The Hindu**
 
 SigNoz provided better traceability, allowing The Hindu to detect and eliminate unnecessary API calls, thereby improving overall system performance.
 
-
 ## Quick Adoption among developers due to OpenTelemetry
 
 One of the key advantages of SigNoz is its seamless integration with OpenTelemetry, an open-source observability framework. OpenTelemetry makes it straightforward to instrument applications for monitoring, providing standardized APIs and libraries that work across various programming languages. This compatibility ensures that teams can quickly get started with SigNoz, effortlessly collecting logs, metrics, and traces from their applications without the need for complex configurations.
 
-
-*"SigNoz’s integration with OpenTelemetry made it incredibly easy for us to get started. We could quickly instrument our applications and begin collecting the necessary observability data without hassle."*
+_"SigNoz’s integration with OpenTelemetry made it incredibly easy for us to get started. We could quickly instrument our applications and begin collecting the necessary observability data without hassle."_
 — Poonkuyilan V
 
 ## Centralized Observability on Kubernetes with SigNoz
 
 The Hindu recently expanded its use of SigNoz by fully implementing it within its Kubernetes environment. They use Oracle Cloud OKE service for Kubernetes which is quite unique. Recognizing the need for a unified observability platform, they decided to utilize SigNoz as the single source for logs, metrics and traces across their Kubernetes clusters. This implementation allows The Hindu to monitor pod resources, node health, and application logs, all from a single, centralized dashboard.
 
-*"For our Kubernetes environment, we chose SigNoz as our end-to-end monitoring platform. It allows us to monitor everything from pod resources to node health and even logs and traces, all from a single dashboard."*
+_"For our Kubernetes environment, we chose SigNoz as our end-to-end monitoring platform. It allows us to monitor everything from pod resources to node health and even logs and traces, all from a single dashboard."_
 
 — **Poonkuyilan V, IT Infrastructure and Core Applications Lead, The Hindu**
 
@@ -92,7 +85,7 @@ By centralizing its observability with SigNoz, The Hindu is able to gain compreh
 
 Before deploying any new services or updates to production, The Hindu team leverages SigNoz in their staging environment to ensure everything functions optimally. By setting up logs, metrics, and traces within SigNoz, the team can thoroughly monitor new developments and detect any potential issues early in the process. This proactive approach allows them to fine-tune performance and ensure that new features or updates are fully optimized before going live.
 
-*"In our staging environment, we use SigNoz to monitor traces and metrics before any service goes into production. This helps us ensure that everything is running smoothly and gives us confidence that our updates are ready for deployment."*
+_"In our staging environment, we use SigNoz to monitor traces and metrics before any service goes into production. This helps us ensure that everything is running smoothly and gives us confidence that our updates are ready for deployment."_
 
 — **Poonkuyilan V, IT Infrastructure and Core Applications Lead, The Hindu**
 
@@ -104,7 +97,7 @@ This practice not only helps in identifying and resolving issues but also ensure
 
 SigNoz has proven invaluable in helping The Hindu address real-time issues efficiently.
 
-*"Recently, we configured alerts for pod restarts and were able to quickly identify and resolve the root cause before it escalated. Additionally, SigNoz’s tracing capabilities helped us spot unwanted calls to third-party systems, allowing us to optimize our applications."*
+_"Recently, we configured alerts for pod restarts and were able to quickly identify and resolve the root cause before it escalated. Additionally, SigNoz’s tracing capabilities helped us spot unwanted calls to third-party systems, allowing us to optimize our applications."_
 
 — **Poonkuyilan V**
 
@@ -114,6 +107,6 @@ These capabilities have not only improved the reliability of The Hindu’s platf
 
 SigNoz has become an integral part of The Hindu’s digital operations, providing the tools necessary to monitor and optimize their complex, multi-cloud environment. With its feature-rich platform, open-source nature, and cost-effectiveness, SigNoz has empowered The Hindu to deliver a seamless digital experience to its readers.
 
-*"SigNoz has been a reliable partner in our digital transformation, offering us the control and insights we need to ensure our platforms are always performing at their best."*
+_"SigNoz has been a reliable partner in our digital transformation, offering us the control and insights we need to ensure our platforms are always performing at their best."_
 
-— **Poonkuyilan V**
\ No newline at end of file
+— **Poonkuyilan V**
diff --git a/data/case-study/wombo.mdx b/data/case-study/wombo.mdx
index 13591cae8..b580a696f 100644
--- a/data/case-study/wombo.mdx
+++ b/data/case-study/wombo.mdx
@@ -1,22 +1,17 @@
 ---
 title: How Generative AI co Wombo provides great experience to its 5mn MAU using SigNoz for Observability
-slug: wombo-ai
 image: /img/case_study/wombo-banner.webp
+description: ''
 authors: [pranay]
 ---
+
 <div class="avatar">
-  <a
-    class="avatar__photo-link avatar__photo avatar__photo--lg"
-    href="https://twitter.com/pranay01">
-    <img
-      alt="Pranay Profile"
-      src="/img/authors/pranay_profile_pic.webp" />
+  <a class="avatar__photo-link avatar__photo avatar__photo--lg" href="https://twitter.com/pranay01">
+    <img alt="Pranay Profile" src="/img/authors/pranay_profile_pic.webp" />
   </a>
   <div class="avatar__intro">
     <div class="avatar__name">Pranay Prateek</div>
-    <small class="avatar__subtitle">
-      Maintainer, SigNoz
-    </small>
+    <small class="avatar__subtitle">Maintainer, SigNoz</small>
   </div>
 </div>
 
diff --git a/data/comparisons/appdynamics-competitors.mdx b/data/comparisons/appdynamics-competitors.mdx
index 1795a320a..8e5f627b2 100644
--- a/data/comparisons/appdynamics-competitors.mdx
+++ b/data/comparisons/appdynamics-competitors.mdx
@@ -1,25 +1,25 @@
 ---
 title: Top 9 Appdynamics Competitors & Alternatives [2025 Guide]
-slug: appdynamics-competitors
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [sarafadeen-ibrahim]
 description: Explore the top 9 AppDynamics competitors for monitoring solutions. Learn why enterprises seek Appdynamics alternatives for app and infrastructure monitoring efficiency...
 image: /img/blog/2024/04/appdynamics-competitors-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [appdynamics-competitors,appdynamics,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [appdynamics-competitors, appdynamics, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-AppDynamics is a popular app and infrastructure monitoring solution. It has an AIOps-driven alert system that makes it a full-stack solution for several monitoring use cases. But despite its capabilities, users usually seek alternatives. This article is a deep dive into why.
-
 
+AppDynamics is a popular app and infrastructure monitoring solution. It has an AIOps-driven alert system that makes it a full-stack solution for several monitoring use cases. But despite its capabilities, users usually seek alternatives. This article is a deep dive into why.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 ## Why look for AppDynamics alternatives?
 
 Enterprises seek alternatives to AppDynamics for five reasons: complexity, cost, agent-based monitoring, intensive sales process, and vendor lock-in and integration.
@@ -52,12 +52,17 @@ Here are the top AppDynamics competitors—some fit specific requirements, and s
 
 ### 1. SigNoz (open-source)
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/signoz_charts_application_metrics.webp" alt="SigNoz dashboard"/>
-    <figcaption><i>SigNoz dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/common/signoz_charts_application_metrics.webp"
+    alt="SigNoz dashboard"
+  />
+  <figcaption>
+    <i>SigNoz dashboard</i>
+  </figcaption>
 </figure>
 
-
 [SigNoz](https://signoz.io/) is an open-source network and [infrastructure monitoring tool](https://signoz.io/comparisons/infrastructure-monitoring-tools/) that provides a unified user interface for analyzing and visualizing metrics, traces, and logs. With its advanced tagging and filtering, log aggregation, and distributed tracing capabilities, SigNoz provides deep insights into application latency, error rates, and throughput, helping teams identify and troubleshoot issues quickly.
 
 As an agentless open-source tool, Signoz is highly customizable and adaptable to different environments. Its strong community support and easy-to-understand documentation make it a favored choice for many.
@@ -79,13 +84,24 @@ SigNoz cloud is the easiest way to run SigNoz. You can sign up [here](https://s
 
 ### 2. Splunk
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-Splunk.webp" alt="Splunk dashboard"/>
-    <figcaption><i>Splunk dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-Splunk.webp"
+    alt="Splunk dashboard"
+  />
+  <figcaption>
+    <i>Splunk dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a> is a unified security and observability tool for monitoring and analyzing data in real-time. Through a web interface, Splunk collects, indexes and analyzes data at scale from various sources. Splunk stands out for its scalability and comprehensive data analytics capabilities. It however requires some technical expertise to set up and maintain its advanced features.
+<a href="https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is a unified security and observability tool for monitoring and analyzing data in real-time. Through
+a web interface, Splunk collects, indexes and analyzes data at scale from various sources. Splunk
+stands out for its scalability and comprehensive data analytics capabilities. It however requires
+some technical expertise to set up and maintain its advanced features.
 
 #### Features
 
@@ -101,13 +117,25 @@ Splunk's pricing is categorized into workload, ingest, entity, and activity-base
 
 ### 3. Sematext
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-Sematext.webp" alt="Sematext dashboard"/>
-    <figcaption><i>Sematext dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-Sematext.webp"
+    alt="Sematext dashboard"
+  />
+  <figcaption>
+    <i>Sematext dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://sematext.com" rel="noopener noreferrer nofollow" target="_blank" >Sematext</a> offers two packages—Sematext Cloud and Sematext Enterprise. While Sematext Cloud is a fully managed SaaS platform for infrastructure, application, and log management, Sematext Enterprise is a self-managed platform that allows businesses to maintain control over their monitoring environment. Sematext provides real-time insights into system performance, application health, and log data, enabling users to proactively identify and troubleshoot issues.
+<a href="https://sematext.com" rel="noopener noreferrer nofollow" target="_blank">
+  Sematext
+</a>
+offers two packages—Sematext Cloud and Sematext Enterprise. While Sematext Cloud is a fully managed
+SaaS platform for infrastructure, application, and log management, Sematext Enterprise is a
+self-managed platform that allows businesses to maintain control over their monitoring environment.
+Sematext provides real-time insights into system performance, application health, and log data,
+enabling users to proactively identify and troubleshoot issues.
 
 #### Features
 
@@ -123,13 +151,23 @@ Sematext offers various pricing structures, including basic, pro, pay-as-you-go,
 
 ### 4. SolarWinds
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-SolarWinds.webp" alt="SolarWinds dashboard"/>
-    <figcaption><i>SolarWinds dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-SolarWinds.webp"
+    alt="SolarWinds dashboard"
+  />
+  <figcaption>
+    <i>SolarWinds dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.solarwinds.com" rel="noopener noreferrer nofollow" target="_blank" >SolarWinds</a> is a comprehensive monitoring and management tool that offers modules such as  IT infrastructure, application, real-user and network performance monitoring. It provides the visibility and insights needed to monitor and optimize the performance of IT systems.
+<a href="https://www.solarwinds.com" rel="noopener noreferrer nofollow" target="_blank">
+  SolarWinds
+</a>
+is a comprehensive monitoring and management tool that offers modules such as  IT infrastructure,
+application, real-user and network performance monitoring. It provides the visibility and insights
+needed to monitor and optimize the performance of IT systems.
 
 #### Features
 
@@ -146,13 +184,25 @@ SolarWinds offers a variety of pricing options based on the features and modules
 
 ### 5. Nagios
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-Nagios.webp" alt="Nagios dashboard"/>
-    <figcaption><i>Nagios dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-Nagios.webp"
+    alt="Nagios dashboard"
+  />
+  <figcaption>
+    <i>Nagios dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank" >Nagios</a> provides a flexible and extensible platform for monitoring system health, performance and uptime across networks, servers, and applications. Nagios has a plugin system via which it can be tailored to specific monitoring needs. Nagios has an open-source version (Nagios Core) and a paid version (Nagios XI).  Though it has fewer and less advanced features, the open-source version, with its active community support, is a popular alternative to proprietary tools like AppDynamics.
+<a href="https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank">
+  Nagios
+</a>
+provides a flexible and extensible platform for monitoring system health, performance and uptime
+across networks, servers, and applications. Nagios has a plugin system via which it can be tailored
+to specific monitoring needs. Nagios has an open-source version (Nagios Core) and a paid version
+(Nagios XI).  Though it has fewer and less advanced features, the open-source version, with its
+active community support, is a popular alternative to proprietary tools like AppDynamics.
 
 #### Features
 
@@ -168,13 +218,24 @@ Nagios Core is free to use while Nagios XI is available on a subscription basis
 
 ### 6. New Relic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-New-Relic.webp" alt="New Relic dashboard"/>
-    <figcaption><i>New Relic dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-New-Relic.webp"
+    alt="New Relic dashboard"
+  />
+  <figcaption>
+    <i>New Relic dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank" >New Relic</a> is a monitoring and analytics platform that provides insights into application performance with detailed metrics and visualizations so that you can quickly pinpoint and resolve any performance issues. Its ability to provide end-to-end monitoring across the stack makes it a strong competitor to AppDynamics.
+<a href="https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a>
+is a monitoring and analytics platform that provides insights into application performance with
+detailed metrics and visualizations so that you can quickly pinpoint and resolve any performance
+issues. Its ability to provide end-to-end monitoring across the stack makes it a strong competitor
+to AppDynamics.
 
 #### Features
 
@@ -191,13 +252,26 @@ New Relic offers a range of pricing plans based on the number of users and volum
 
 ### 7. Datadog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-Datadog.webp" alt="Datadog dashboard"/>
-    <figcaption><i>Datadog dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-Datadog.webp"
+    alt="Datadog dashboard"
+  />
+  <figcaption>
+    <i>Datadog dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank" >Datadog</a> is a comprehensive monitoring and analytics platform that allows you to collect, visualize, and analyze data from different sources in real time. It allows you to find problems by connecting traces with different data sources like logs, metrics, queries, network activity, and user interactions, all in a single view. It also lets you filter and manage traces by keeping only the most significant ones using tags and criteria. Datadog’s strength, therefore, lies in its user-friendly interface and strong community support.
+<a href="https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+is a comprehensive monitoring and analytics platform that allows you to collect, visualize, and
+analyze data from different sources in real time. It allows you to find problems by connecting
+traces with different data sources like logs, metrics, queries, network activity, and user
+interactions, all in a single view. It also lets you filter and manage traces by keeping only the
+most significant ones using tags and criteria. Datadog’s strength, therefore, lies in its
+user-friendly interface and strong community support.
 
 #### Features
 
@@ -214,13 +288,24 @@ New Relic offers a range of pricing plans based on the number of users and volum
 
 ### 8. Dynatrace
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-Dynatrace.webp" alt="Dynatrace dashboard"/>
-    <figcaption><i>Dynatrace dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-Dynatrace.webp"
+    alt="Dynatrace dashboard"
+  />
+  <figcaption>
+    <i>Dynatrace dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.dynatrace.com" rel="noopener noreferrer nofollow" target="_blank" >Dynatrace</a> is an advanced monitoring and full-stack observability platform that utilizes artificial intelligence and automation to provide real-time insights into organizations’ entire stack. Dynatrace's focus on user experience and business impact sets it apart as a comprehensive monitoring solution and top Appdynamic alternative.
+<a href="https://www.dynatrace.com" rel="noopener noreferrer nofollow" target="_blank">
+  Dynatrace
+</a>
+is an advanced monitoring and full-stack observability platform that utilizes artificial
+intelligence and automation to provide real-time insights into organizations’ entire stack.
+Dynatrace's focus on user experience and business impact sets it apart as a comprehensive monitoring
+solution and top Appdynamic alternative.
 
 #### Features
 
@@ -235,13 +320,24 @@ Dynatrace's pricing model varies by module and is based on consumption, with pri
 
 ### 9. ManageEngine Applications Manager
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/appdynamics-competitors-ManageEngine.webp" alt="ManageEngine dashboard"/>
-    <figcaption><i>ManageEngine dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/appdynamics-competitors-ManageEngine.webp"
+    alt="ManageEngine dashboard"
+  />
+  <figcaption>
+    <i>ManageEngine dashboard</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.manageengine.com" rel="noopener noreferrer nofollow" target="_blank" >ManageEngine Applications Manager</a> is a vast APM solution that offers server, database, Kubernetes, and synthetic transaction monitoring. ManageEngine Applications Manager is known for its user-friendly interface, relatively affordable pricing model, and ease of setup, which make it a competitive alternative to the more expensive AppDynamics.
+<a href="https://www.manageengine.com" rel="noopener noreferrer nofollow" target="_blank">
+  ManageEngine Applications Manager
+</a>
+is a vast APM solution that offers server, database, Kubernetes, and synthetic transaction
+monitoring. ManageEngine Applications Manager is known for its user-friendly interface, relatively
+affordable pricing model, and ease of setup, which make it a competitive alternative to the more
+expensive AppDynamics.
 
 #### Features
 
diff --git a/data/comparisons/appdynamics-vs-splunk.mdx b/data/comparisons/appdynamics-vs-splunk.mdx
index f56bdb584..d526a6809 100644
--- a/data/comparisons/appdynamics-vs-splunk.mdx
+++ b/data/comparisons/appdynamics-vs-splunk.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: AppDynamics vs Splunk in 2025 - What's Changed with Cisco's Acquisition?
-slug: appdynamics-vs-splunk
 date: 2025-03-11
 tags: [apm, observability, appdynamics, splunk]
 authors: [nilesh_sinha]
 description: Compare AppDynamics and Splunk APM tools to find the best fit for your organization's needs. Explore features, scalability, pricing, and use cases.
-keywords: [appdynamics vs splunk, application performance monitoring, APM tools, log analytics, observability platforms]
-
+keywords:
+  [
+    appdynamics vs splunk,
+    application performance monitoring,
+    APM tools,
+    log analytics,
+    observability platforms,
+  ]
 ---
 
 AppDynamics, now part of Splunk's Observability portfolio (following Cisco's acquisition), and Splunk's broader platform together form a unified observability solution. While these tools now live under the same corporate umbrella, they still retain distinct strengths and focuses that make comparing them valuable for organizations making technology decisions.
@@ -30,10 +34,16 @@ AppDynamics (acquired by Cisco, and now part of Splunk's Observability portfolio
 - Aligns IT metrics with business outcomes – showing how performance issues impact revenue or user experience
 
 <KeyPointCallout title="AppDynamics Strength">
-  AppDynamics specializes in real-time application performance monitoring, offering deep visibility into how individual components of your system interact, from cloud-native microservices to legacy on-prem applications.
+  AppDynamics specializes in real-time application performance monitoring, offering deep visibility
+  into how individual components of your system interact, from cloud-native microservices to legacy
+  on-prem applications.
 </KeyPointCallout>
 
-<Figure src="/img/comparisons/2025/03/appdynamics-vs-splunk-appddashboard.webp" alt="AppDynamics dashboard, Credits: appdynamics" caption="AppDynamics dashboard, Credits: appdynamics" />
+<Figure
+  src="/img/comparisons/2025/03/appdynamics-vs-splunk-appddashboard.webp"
+  alt="AppDynamics dashboard, Credits: appdynamics"
+  caption="AppDynamics dashboard, Credits: appdynamics"
+/>
 
 ### Splunk
 
@@ -47,10 +57,16 @@ Splunk started as a log and machine-data analytics platform and has since evolve
 - Unifies performance monitoring with log-based troubleshooting in one ecosystem
 
 <KeyPointCallout title="Splunk Strength">
-  Splunk's strength in analyzing machine data and its newer [APM tools](https://signoz.io/blog/open-source-apm-tools/) means it can unify performance monitoring with log-based troubleshooting and security monitoring in one ecosystem​.
+  Splunk's strength in analyzing machine data and its newer [APM
+  tools](https://signoz.io/blog/open-source-apm-tools/) means it can unify performance monitoring
+  with log-based troubleshooting and security monitoring in one ecosystem​.
 </KeyPointCallout>
 
-<Figure src="/img/comparisons/2025/03/appdynamics-vs-splunk-image.webp" alt="Splunk APM" caption="Splunk APM" />
+<Figure
+  src="/img/comparisons/2025/03/appdynamics-vs-splunk-image.webp"
+  alt="Splunk APM"
+  caption="Splunk APM"
+/>
 
 ### How AppDynamics Fits into the Splunk Ecosystem
 
@@ -59,11 +75,17 @@ Cisco has been actively unifying AppDynamics with Splunk to deliver a seamless f
 - **Unified Access via SSO:** Single sign-on enables users to move securely between the two platforms, streamlining workflows for daily troubleshooting.
 - **In-Context Deep Linking:** Through Log Observer Connect integration, AppDynamics issues can be linked directly to relevant logs in Splunk, preserving context and speeding up root-cause analysis.
 - **Centralized Log Collection:** AppDynamics can forward application logs into Splunk's logging platform, centralizing log data for analysis alongside metrics and traces.
-<Figure src="/img/comparisons/2025/03/appdynamics-vs-splunk-logs-observer-connect.webp" alt="AppDynamics and Splunk integration, Credits: splunk" caption="AppDynamics and Splunk integration, Credits: splunk" />
+  <Figure
+    src="/img/comparisons/2025/03/appdynamics-vs-splunk-logs-observer-connect.webp"
+    alt="AppDynamics and Splunk integration, Credits: splunk"
+    caption="AppDynamics and Splunk integration, Credits: splunk"
+  />
 - **"Better Together" Full-Stack Observability:** AppDynamics tells you what, when, and where a problem is happening in the application, while Splunk shows why through supporting log data.
 
 <KeyPointCallout title="Integration Strength">
-  The combined AppDynamics and Splunk offering delivers end-to-end visibility from user experience to application code to infrastructure and logs, with streamlined workflows that help teams resolve issues faster.
+  The combined AppDynamics and Splunk offering delivers end-to-end visibility from user experience
+  to application code to infrastructure and logs, with streamlined workflows that help teams resolve
+  issues faster.
 </KeyPointCallout>
 
 Even within the same corporate family, the tools maintain distinct areas of excellence. AppDynamics excels at application performance and root-cause analysis, while Splunk remains the leader in log aggregation and enterprise security.
@@ -77,14 +99,16 @@ Both AppDynamics and Splunk provide robust APM capabilities, but they approach i
 AppDynamics offers one of the most comprehensive APM experiences in the industry, as this is its core functionality.
 
 - **Key Features**:
-    - Automatically discovers and maps application components and their relationships
-    - Tracks business transactions end-to-end across distributed services
-    - Provides code-level diagnostics to pinpoint exact bottlenecks
-    - Uses machine learning for dynamic baselining and anomaly detection
-    - Offers intuitive visual flow maps for easy navigation of complex app topologies
+  - Automatically discovers and maps application components and their relationships
+  - Tracks business transactions end-to-end across distributed services
+  - Provides code-level diagnostics to pinpoint exact bottlenecks
+  - Uses machine learning for dynamic baselining and anomaly detection
+  - Offers intuitive visual flow maps for easy navigation of complex app topologies
 
 <KeyPointCallout title="AppDynamics APM Strength">
-  AppDynamics excels in automated transaction tracing with minimal configuration. Once agents are installed, it provides deep visibility into application performance with intuitive visual maps, making it easier to identify and resolve issues quickly.
+  AppDynamics excels in automated transaction tracing with minimal configuration. Once agents are
+  installed, it provides deep visibility into application performance with intuitive visual maps,
+  making it easier to identify and resolve issues quickly.
 </KeyPointCallout>
 
 ### Splunk APM
@@ -92,14 +116,16 @@ AppDynamics offers one of the most comprehensive APM experiences in the industry
 Splunk's APM capabilities (part of Splunk Observability Cloud) provide comprehensive monitoring across distributed systems with a focus on full-fidelity tracing.
 
 - **Key Features**:
-    - Ingests 100% of trace data with no sampling for complete visibility
-    - Natively supports [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) for instrumenting services
-    - Offers predictive analytics to forecast potential performance issues
-    - Provides customizable dashboards for real-time monitoring
-    - Seamlessly integrates with Splunk's broader ecosystem for unified observability
+  - Ingests 100% of trace data with no sampling for complete visibility
+  - Natively supports [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) for instrumenting services
+  - Offers predictive analytics to forecast potential performance issues
+  - Provides customizable dashboards for real-time monitoring
+  - Seamlessly integrates with Splunk's broader ecosystem for unified observability
 
 <KeyPointCallout title="Splunk APM Strength">
-  Splunk APM shines in high-granularity tracing for complex, cloud-native microservice ecosystems. Its ability to ingest all trace data without sampling ensures no anomaly is missed, while its predictive capabilities help teams stay ahead of potential issues.
+  Splunk APM shines in high-granularity tracing for complex, cloud-native microservice ecosystems.
+  Its ability to ingest all trace data without sampling ensures no anomaly is missed, while its
+  predictive capabilities help teams stay ahead of potential issues.
 </KeyPointCallout>
 
 ## Log Management - AppDynamics vs Splunk
@@ -111,15 +137,18 @@ Logs are an area where Splunk has a long-established reputation, while AppDynami
 Splunk is often synonymous with log management. It can ingest logs from virtually any source (servers, applications, network devices, etc.), index them, and make them searchable with its powerful Splunk Search Processing Language (SPL).
 
 - **Key Features**:
-    - Real-time log tailing and analysis
-    - Advanced querying and filtering capabilities
-    - Visualization of log data trends
-    - Alerting based on log patterns (e.g., error rates)
-    - Transaction logging (grouping related log events)
-    - Extensive ecosystem of apps for specific log types
+  - Real-time log tailing and analysis
+  - Advanced querying and filtering capabilities
+  - Visualization of log data trends
+  - Alerting based on log patterns (e.g., error rates)
+  - Transaction logging (grouping related log events)
+  - Extensive ecosystem of apps for specific log types
 
 <KeyPointCallout title="Splunk Log Management Strength">
-  Splunk offers industry-leading log analysis capabilities, allowing you to identify patterns, anomalies, and root causes from your log data with ease. It's a cornerstone tool for many DevOps and IT teams in troubleshooting incidents because you can quickly sift through huge volumes of log data to pinpoint issues.
+  Splunk offers industry-leading log analysis capabilities, allowing you to identify patterns,
+  anomalies, and root causes from your log data with ease. It's a cornerstone tool for many DevOps
+  and IT teams in troubleshooting incidents because you can quickly sift through huge volumes of log
+  data to pinpoint issues.
 </KeyPointCallout>
 
 ### AppDynamics for Log Management
@@ -127,13 +156,16 @@ Splunk is often synonymous with log management. It can ingest logs from virtuall
 AppDynamics is not primarily a log management tool, but it recognizes the value of logs in performance troubleshooting.
 
 - **Key Features**:
-    - Analytics add-on (Business iQ) for log ingestion
-    - Correlation of log events with application performance metrics
-    - Log collection via agent extensions or integrations
-    - Native integration with Splunk for enhanced capabilities
+  - Analytics add-on (Business iQ) for log ingestion
+  - Correlation of log events with application performance metrics
+  - Log collection via agent extensions or integrations
+  - Native integration with Splunk for enhanced capabilities
 
 <KeyPointCallout title="AppDynamics and Splunk Integration">
-  With the integration between AppDynamics and Splunk, teams now get the best of both worlds. AppDynamics focuses on APM data (metrics, traces, events) while leveraging Splunk for deep log analysis. The native integration allows you to send Splunk alerts into AppDynamics and query Splunk logs from the AppDynamics UI when investigating performance issues.
+  With the integration between AppDynamics and Splunk, teams now get the best of both worlds.
+  AppDynamics focuses on APM data (metrics, traces, events) while leveraging Splunk for deep log
+  analysis. The native integration allows you to send Splunk alerts into AppDynamics and query
+  Splunk logs from the AppDynamics UI when investigating performance issues.
 </KeyPointCallout>
 
 With their integration, Splunk's industry-leading log capabilities complement AppDynamics' application performance focus, creating a more comprehensive solution than either tool alone.
@@ -147,15 +179,18 @@ When it comes to security monitoring and analytics, the two platforms have diffe
 Splunk is widely used in the security domain through Splunk Enterprise Security (SIEM) and Splunk User Behavior Analytics (UBA).
 
 - **Key Features**:
-    - Ingests security-relevant data (system logs, authentication events, network traffic logs)
-    - Equipped with correlation rules and threat detection content out of the box
-    - Uses AI-driven analytics to detect anomalies that could indicate cyber threats
-    - Detects patterns of failed logins, unusual process activity, or suspicious network traffic
-    - Provides adaptive response framework for automated actions (alerts, system quarantine)
-    - Serves as a full-fledged security analytics solution alongside IT monitoring
+  - Ingests security-relevant data (system logs, authentication events, network traffic logs)
+  - Equipped with correlation rules and threat detection content out of the box
+  - Uses AI-driven analytics to detect anomalies that could indicate cyber threats
+  - Detects patterns of failed logins, unusual process activity, or suspicious network traffic
+  - Provides adaptive response framework for automated actions (alerts, system quarantine)
+  - Serves as a full-fledged security analytics solution alongside IT monitoring
 
 <KeyPointCallout title="Splunk Security Analytics Strength">
-  Splunk provides a comprehensive security analytics platform that makes it a go-to choice for organizations wanting to combine operational and security data in one place. Security teams (SecOps) often leverage Splunk as their central dashboard for incident detection and investigation.
+  Splunk provides a comprehensive security analytics platform that makes it a go-to choice for
+  organizations wanting to combine operational and security data in one place. Security teams
+  (SecOps) often leverage Splunk as their central dashboard for incident detection and
+  investigation.
 </KeyPointCallout>
 
 ### AppDynamics for Security Analytics
@@ -163,15 +198,18 @@ Splunk is widely used in the security domain through Splunk Enterprise Security
 AppDynamics is primarily oriented toward performance, but since becoming part of Cisco, it has gained security capabilities at the application level.
 
 - **Key Features**:
-    - Works with Cisco Secure Application to perform application security monitoring
-    - Detects vulnerabilities like insecure configurations or libraries
-    - Can block certain attacks in real-time within applications
-    - Provides Runtime Application Self-Protection (RASP) capabilities
-    - Helps reduce risk within the application layer without impacting performance
-    - Focuses on the security posture of monitored applications
+  - Works with Cisco Secure Application to perform application security monitoring
+  - Detects vulnerabilities like insecure configurations or libraries
+  - Can block certain attacks in real-time within applications
+  - Provides Runtime Application Self-Protection (RASP) capabilities
+  - Helps reduce risk within the application layer without impacting performance
+  - Focuses on the security posture of monitored applications
 
 <KeyPointCallout title="Complementary Security Approach">
-  Within Cisco's unified observability approach, AppDynamics contributes to security by safeguarding application runtime and providing security event data, which can then be integrated with Splunk's broader security analytics. This gives organizations both application-level security monitoring and enterprise-wide security intelligence.
+  Within Cisco's unified observability approach, AppDynamics contributes to security by safeguarding
+  application runtime and providing security event data, which can then be integrated with Splunk's
+  broader security analytics. This gives organizations both application-level security monitoring
+  and enterprise-wide security intelligence.
 </KeyPointCallout>
 
 ## Integration and Extensibility
@@ -181,48 +219,48 @@ Integrations and extensibility are critical for modern observability tools, allo
 ### **AppDynamics Ecosystem**
 
 - **Cloud & Infrastructure Integrations**:
-    - Provides extensions for AWS, Azure, and Google Cloud that pull in CloudWatch or Azure Monitor metrics
-    - Correlates cloud service metrics (AWS Lambda, DynamoDB, Azure App Services) with application performance
-    - Monitors containerized environments through specialized agents for Docker and Kubernetes
-    - Offers comprehensive visibility across hybrid infrastructure environments
+  - Provides extensions for AWS, Azure, and Google Cloud that pull in CloudWatch or Azure Monitor metrics
+  - Correlates cloud service metrics (AWS Lambda, DynamoDB, Azure App Services) with application performance
+  - Monitors containerized environments through specialized agents for Docker and Kubernetes
+  - Offers comprehensive visibility across hybrid infrastructure environments
 - **Extensions & APIs**:
-    - Features 130+ extensions for databases, message queues, and specific frameworks
-    - Provides robust REST APIs for data extraction, automation, and custom integrations
-    - Enables integration with CI/CD pipelines (Jenkins, Azure DevOps) for deployment health monitoring
-    - Connects with incident management tools like PagerDuty and Slack for alert notifications
+  - Features 130+ extensions for databases, message queues, and specific frameworks
+  - Provides robust REST APIs for data extraction, automation, and custom integrations
+  - Enables integration with CI/CD pipelines (Jenkins, Azure DevOps) for deployment health monitoring
+  - Connects with incident management tools like PagerDuty and Slack for alert notifications
 
 ### **Splunk's Integration Capabilities**
 
 - **Cloud & [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/)**:
-    - Offers official add-ons for AWS, Azure, and Google Cloud that ingest logs, events, and metrics
-    - Provides Infrastructure Monitoring module specifically designed for cloud environments
-    - Deploys OpenTelemetry Collector or native agents to gather data from Kubernetes pods and orchestrators
-    - Enables comprehensive monitoring beyond application code into cloud service performance
+  - Offers official add-ons for AWS, Azure, and Google Cloud that ingest logs, events, and metrics
+  - Provides Infrastructure Monitoring module specifically designed for cloud environments
+  - Deploys OpenTelemetry Collector or native agents to gather data from Kubernetes pods and orchestrators
+  - Enables comprehensive monitoring beyond application code into cloud service performance
 - **Extensive Marketplace**:
-    - Features **SplunkBase** with hundreds of pre-built apps and add-ons for diverse use cases
-    - Covers DevOps tools (Jenkins, Docker), configuration management, and specialized monitoring needs
-    - Includes Splunk On-Call (formerly VictorOps) for integrated incident response
-    - Integrates with ticketing systems like ServiceNow for streamlined workflow management
+  - Features **SplunkBase** with hundreds of pre-built apps and add-ons for diverse use cases
+  - Covers DevOps tools (Jenkins, Docker), configuration management, and specialized monitoring needs
+  - Includes Splunk On-Call (formerly VictorOps) for integrated incident response
+  - Integrates with ticketing systems like ServiceNow for streamlined workflow management
 
 ### **Community & Ecosystem Comparison**
 
 - **AppDynamics**:
-    - Maintains AppDynamics Exchange marketplace for extensions
-    - Offers a focused community centered on performance monitoring use cases
-    - Provides extensions primarily targeting APM-related technologies and integrations
+  - Maintains AppDynamics Exchange marketplace for extensions
+  - Offers a focused community centered on performance monitoring use cases
+  - Provides extensions primarily targeting APM-related technologies and integrations
 - **Splunk**:
-    - Boasts a larger community and marketplace with broader use cases
-    - Features community-contributed apps covering security, IoT, analytics, and specialized data sources
-    - Provides integration options for virtually any data source through community-built add-ons
-    - Hosts regular community events including the annual Splunk .conf conference
+  - Boasts a larger community and marketplace with broader use cases
+  - Features community-contributed apps covering security, IoT, analytics, and specialized data sources
+  - Provides integration options for virtually any data source through community-built add-ons
+  - Hosts regular community events including the annual Splunk .conf conference
 
 ### **Cisco Full-Stack Observability Integration**
 
 - **Combined Future**:
-    - With Cisco's acquisition of both [AppDynamics and Splunk](https://signoz.io/comparisons/appdynamics-vs-splunk/#how-appdynamics-fits-into-the-splunk-ecosystem), integration between the platforms is increasing
-    - Cisco's Full-Stack Observability (FSO) vision combines AppDynamics' APM strengths with Splunk's log analytics
-    - Features like Log Observer Connect allow users to jump from AppDynamics traces directly to related Splunk logs
-    - Organizations can now leverage both tools as complementary solutions under Cisco's unified approach
+  - With Cisco's acquisition of both [AppDynamics and Splunk](https://signoz.io/comparisons/appdynamics-vs-splunk/#how-appdynamics-fits-into-the-splunk-ecosystem), integration between the platforms is increasing
+  - Cisco's Full-Stack Observability (FSO) vision combines AppDynamics' APM strengths with Splunk's log analytics
+  - Features like Log Observer Connect allow users to jump from AppDynamics traces directly to related Splunk logs
+  - Organizations can now leverage both tools as complementary solutions under Cisco's unified approach
 
 Both platforms offer robust integration capabilities, with AppDynamics providing deep APM-focused integrations and Splunk offering an exceptionally broad ecosystem covering diverse IT and business needs. Cisco's acquisition has created new opportunities for these tools to work together more seamlessly.
 
@@ -233,47 +271,47 @@ The user interface (UI) and ease of use can significantly impact the adoption an
 ### **AppDynamics UI & Experience**
 
 - **Flow Map Visualization**:
-    - Auto-detects interactions between components as soon as agents are installed
-    - Creates intuitive diagrams showing services calling other services, databases, and external APIs
-    - Helps new users quickly grasp system topology and health at a glance
+  - Auto-detects interactions between components as soon as agents are installed
+  - Creates intuitive diagrams showing services calling other services, databases, and external APIs
+  - Helps new users quickly grasp system topology and health at a glance
 - **Navigation & Dashboards**:
-    - Enables straightforward drilling down by clicking on nodes or transactions to see deeper metrics
-    - Provides customizable dashboards with sensible defaults showing key application KPIs
-    - Displays critical metrics like response time, error rate, throughput, and health rule violations
+  - Enables straightforward drilling down by clicking on nodes or transactions to see deeper metrics
+  - Provides customizable dashboards with sensible defaults showing key application KPIs
+  - Displays critical metrics like response time, error rate, throughput, and health rule violations
 - **Learning Curve**:
-    - Features a relatively gentle learning curve for basic use cases
-    - Allows DevOps engineers to identify performance issues soon after installation
-    - Offers powerful comparison features (before/after deployments, business impact) without requiring scripting
+  - Features a relatively gentle learning curve for basic use cases
+  - Allows DevOps engineers to identify performance issues soon after installation
+  - Offers powerful comparison features (before/after deployments, business impact) without requiring scripting
 
 ### **Splunk UI & Experience**
 
 - **Dual Interface Approach**:
-    - Traditional log search interface is text-centric with SPL query bar and configurable results
-    - Modern Observability Cloud provides more intuitive, point-and-click interfaces for APM and monitoring
-    - Presents service maps showing calls between services similar to AppDynamics' flow map
+  - Traditional log search interface is text-centric with SPL query bar and configurable results
+  - Modern Observability Cloud provides more intuitive, point-and-click interfaces for APM and monitoring
+  - Presents service maps showing calls between services similar to AppDynamics' flow map
 - **Search & Analysis Capabilities**:
-    - Powers advanced data analysis through the Search Processing Language (SPL)
-    - Enables users to calculate custom SLOs, correlate unusual events, and perform statistical analysis
-    - Allows investigation of performance spikes by clicking chart points to see related traces or logs
+  - Powers advanced data analysis through the Search Processing Language (SPL)
+  - Enables users to calculate custom SLOs, correlate unusual events, and perform statistical analysis
+  - Allows investigation of performance spikes by clicking chart points to see related traces or logs
 - **Customization & Learning**:
-    - Supports highly customizable dashboards with charts, tables, and text for different team needs
-    - Requires more learning to fully exploit its flexibility and advanced capabilities
-    - Provides extensive documentation and active community support for users
+  - Supports highly customizable dashboards with charts, tables, and text for different team needs
+  - Requires more learning to fully exploit its flexibility and advanced capabilities
+  - Provides extensive documentation and active community support for users
 
 ### **Comparative Usability**
 
 - **AppDynamics Advantage**:
-    - Offers more polished, graphical representation of performance data
-    - Enables quicker diagnosis of issues without writing queries
-    - Provides purpose-built UI for APM with less configuration time
+  - Offers more polished, graphical representation of performance data
+  - Enables quicker diagnosis of issues without writing queries
+  - Provides purpose-built UI for APM with less configuration time
 - **Splunk Advantage**:
-    - Delivers exceptional flexibility for slicing and dicing data during deep investigations
-    - Excels in custom analytics and unified dashboards across diverse data types
-    - Balances power-user capabilities with increasingly intuitive interfaces in newer offerings
+  - Delivers exceptional flexibility for slicing and dicing data during deep investigations
+  - Excels in custom analytics and unified dashboards across diverse data types
+  - Balances power-user capabilities with increasingly intuitive interfaces in newer offerings
 - **Integration Benefits**:
-    - Cisco's [unified observability](https://signoz.io/unified-observability/) approach now allows teams to benefit from both interfaces
-    - Deep linking between platforms lets users maintain context when moving between tools
-    - Access to the right interface for the right task improves overall user experience
+  - Cisco's [unified observability](https://signoz.io/unified-observability/) approach now allows teams to benefit from both interfaces
+  - Deep linking between platforms lets users maintain context when moving between tools
+  - Access to the right interface for the right task improves overall user experience
 
 AppDynamics generally provides a more streamlined experience for pure application monitoring use cases, while Splunk offers greater analytical depth for users willing to invest in learning its query language and customization options. The integration between them now gives users the best of both worlds.
 
@@ -284,43 +322,43 @@ Performance and scalability are critical factors when deploying observability so
 ### **AppDynamics Performance & Scalability**
 
 - **System Resource Requirements**:
-    - Introduces 2-5% CPU overhead on monitored systems
-    - Requires 16GB RAM for Controller in small deployments (up to 50 agents)
-    - Demands low-latency disk I/O for optimal Controller performance
-    - Consumes variable network bandwidth based on agent count and metrics
+  - Introduces 2-5% CPU overhead on monitored systems
+  - Requires 16GB RAM for Controller in small deployments (up to 50 agents)
+  - Demands low-latency disk I/O for optimal Controller performance
+  - Consumes variable network bandwidth based on agent count and metrics
 - **Scalability Characteristics**:
-    - Supports up to 1,000,000 metrics per minute across ~1,500 agents in medium deployments
-    - Requires 8 CPU cores and 128GB RAM for medium-sized implementations
-    - Needs 5TB of SSD-based storage for medium deployments
-    - Benefits from high-availability configurations in enterprise environments
+  - Supports up to 1,000,000 metrics per minute across ~1,500 agents in medium deployments
+  - Requires 8 CPU cores and 128GB RAM for medium-sized implementations
+  - Needs 5TB of SSD-based storage for medium deployments
+  - Benefits from high-availability configurations in enterprise environments
 
 ### **Splunk Performance & Scalability**
 
 - **System Resource Requirements**:
-    - Recommends 16 CPU cores and 64GB RAM for indexers in medium deployments
-    - Requires high-performance storage (SSDs preferred) for indexing operations
-    - Demands high network throughput for data ingestion and cluster replication
-    - Performs optimally with dedicated resources rather than virtualized environments
+  - Recommends 16 CPU cores and 64GB RAM for indexers in medium deployments
+  - Requires high-performance storage (SSDs preferred) for indexing operations
+  - Demands high network throughput for data ingestion and cluster replication
+  - Performs optimally with dedicated resources rather than virtualized environments
 - **Scalability Characteristics**:
-    - Handles up to 200GB/day per indexer for certain data sources like CloudTrail
-    - Requires 16 CPU cores and 64GB RAM for indexer nodes
-    - Benefits from SSD storage for search heads with high query loads
-    - Utilizes indexer clusters with replication for enhanced availability
+  - Handles up to 200GB/day per indexer for certain data sources like CloudTrail
+  - Requires 16 CPU cores and 64GB RAM for indexer nodes
+  - Benefits from SSD storage for search heads with high query loads
+  - Utilizes indexer clusters with replication for enhanced availability
 
 ### **Comparative Performance**
 
 - **AppDynamics Advantage**:
-    - Offers lower overhead on monitored systems
-    - Provides real-time application performance insights with minimal impact
-    - Delivers optimized performance for APM-specific workloads
+  - Offers lower overhead on monitored systems
+  - Provides real-time application performance insights with minimal impact
+  - Delivers optimized performance for APM-specific workloads
 - **Splunk Advantage**:
-    - Excels at handling massive data volumes across diverse sources
-    - Scales horizontally through distributed architecture
-    - Supports extensive data retention and historical analysis
+  - Excels at handling massive data volumes across diverse sources
+  - Scales horizontally through distributed architecture
+  - Supports extensive data retention and historical analysis
 - **Unified Architecture Benefits**:
-    - Organizations can optimize resource allocation based on workload types
-    - Integration enables efficient data sharing without duplicate storage
-    - Cisco's unified approach helps minimize overall resource requirements
+  - Organizations can optimize resource allocation based on workload types
+  - Integration enables efficient data sharing without duplicate storage
+  - Cisco's unified approach helps minimize overall resource requirements
 
 AppDynamics is optimized for [real-time application monitoring](https://signoz.io/application-performance-monitoring/) with minimal system impact, while Splunk is engineered for large-scale data ingestion and analytics across diverse IT environments. Together, they offer complementary approaches to enterprise-scale observability.
 
@@ -329,11 +367,18 @@ AppDynamics is optimized for [real-time application monitoring](https://signoz.i
 With AppDynamics now part of Splunk's portfolio under Cisco, the question shifts from "which one" to "how to best leverage both." However, understanding their distinct strengths helps optimize your observability strategy.
 
 <KeyPointCallout title="AppDynamics-Focused Approach">
-Best when your primary goal is deep application performance monitoring with out-of-the-box code-level insights. It's ideal for teams that want a guided APM solution with automatic visualization of complex distributed applications. AppDynamics excels when you need to quickly identify slow transactions, get method-level diagnostics, and connect application performance to business metrics.
+  Best when your primary goal is deep application performance monitoring with out-of-the-box
+  code-level insights. It's ideal for teams that want a guided APM solution with automatic
+  visualization of complex distributed applications. AppDynamics excels when you need to quickly
+  identify slow transactions, get method-level diagnostics, and connect application performance to
+  business metrics.
 </KeyPointCallout>
 
 <KeyPointCallout title="Splunk-Focused Approach">
-Optimal when log management is critical to your operations or when you need a unified platform for logs, metrics, traces, and security events. It's perfect for SREs who frequently move between metrics and logs during investigations and for organizations seeking to integrate observability with security practices.
+  Optimal when log management is critical to your operations or when you need a unified platform for
+  logs, metrics, traces, and security events. It's perfect for SREs who frequently move between
+  metrics and logs during investigations and for organizations seeking to integrate observability
+  with security practices.
 </KeyPointCallout>
 
 ### Leveraging the Unified Approach
@@ -347,7 +392,11 @@ With Cisco's acquisition bringing these tools together, many organizations are n
 3. **Tiered Deployment:** Deploy AppDynamics for your most critical business applications while using Splunk to monitor your broader IT infrastructure and security posture.
 
 <KeyPointCallout title="Bottom Line">
-Evaluate based on your primary challenges and team structure. Leverage AppDynamics' strength in application performance and user experience monitoring alongside Splunk's powerful log analytics and security capabilities. The integration between these platforms now allows you to build a comprehensive observability strategy that draws on the best of both tools while maintaining workflow continuity.
+  Evaluate based on your primary challenges and team structure. Leverage AppDynamics' strength in
+  application performance and user experience monitoring alongside Splunk's powerful log analytics
+  and security capabilities. The integration between these platforms now allows you to build a
+  comprehensive observability strategy that draws on the best of both tools while maintaining
+  workflow continuity.
 </KeyPointCallout>
 
 ## Splunk Observability vs. Other APM Solutions
@@ -368,7 +417,11 @@ Each platform offers a broad set of features that can monitor modern application
 
 [SigNoz](https://signoz.io/docs/architecture/) is a modern, open-source observability platform that provides Application Performance Monitoring (APM), metrics, logs, and [distributed tracing](https://signoz.io/blog/distributed-tracing/) in a unified solution. Built on OpenTelemetry, it offers comprehensive insights into application performance without the licensing fees associated with proprietary tools.
 
-<Figure src="/img/unified-observability/unified-observability-apm.webp" alt="SigNoz dashboard" caption="SigNoz dashboard" />
+<Figure
+  src="/img/unified-observability/unified-observability-apm.webp"
+  alt="SigNoz dashboard"
+  caption="SigNoz dashboard"
+/>
 
 **Key Features Comparison:**
 
@@ -414,4 +467,4 @@ Commercial alternatives include Datadog, New Relic, and Dynatrace. Open-source o
 
 ### How does the Cisco acquisition affect pricing and licensing?
 
-While specific pricing strategies continue to evolve, Cisco is working to create more integrated licensing options that allow customers to leverage both AppDynamics and Splunk capabilities efficiently. Contact your account representative for the latest pricing information.
\ No newline at end of file
+While specific pricing strategies continue to evolve, Cisco is working to create more integrated licensing options that allow customers to leverage both AppDynamics and Splunk capabilities efficiently. Contact your account representative for the latest pricing information.
diff --git a/data/comparisons/availability-vs-reliability.mdx b/data/comparisons/availability-vs-reliability.mdx
index e269ece7c..170d41eee 100644
--- a/data/comparisons/availability-vs-reliability.mdx
+++ b/data/comparisons/availability-vs-reliability.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Availability vs. Reliability - Key Differences in System Design
-slug: availability-vs-reliability
 date: 2024-11-29
 tags: [SRE, devops]
 authors: [soumya_gupta]
 description: Explore the crucial differences between availability and reliability in system design. Learn how to measure, improve, and balance these key metrics for optimal performance.
-keywords: [availability, reliability, system design, uptime, fault tolerance, performance metrics, maintainability, monitoring]
-
+keywords:
+  [
+    availability,
+    reliability,
+    system design,
+    uptime,
+    fault tolerance,
+    performance metrics,
+    maintainability,
+    monitoring,
+  ]
 ---
 
 System design hinges on two critical concepts: availability and reliability. These metrics shape the user experience, operational efficiency, and overall success of any digital infrastructure. While often used interchangeably, availability and reliability represent distinct aspects of system performance. Understanding their differences — and how they interplay — is crucial for developers, system architects, and IT professionals aiming to build robust, high-performing systems.
@@ -20,11 +27,11 @@ Reliability, on the other hand, measures the likelihood of a system consistently
 
 Key differences between availability and reliability include:
 
-| Key Differences | Availability | Reliability |
-| --- | --- | --- |
-| Focus | Availability centers on accessibility | Reliability emphasizes consistent performance. |
-| Measurement | Availability is measured as a percentage of uptime | Reliability is often expressed as a probability or mean time between failures (MTBF). |
-| Time frame | Availability is typically measured over extended period | Reliability can be assessed for specific operational durations. |
+| Key Differences | Availability                                            | Reliability                                                                           |
+| --------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| Focus           | Availability centers on accessibility                   | Reliability emphasizes consistent performance.                                        |
+| Measurement     | Availability is measured as a percentage of uptime      | Reliability is often expressed as a probability or mean time between failures (MTBF). |
+| Time frame      | Availability is typically measured over extended period | Reliability can be assessed for specific operational durations.                       |
 
 ### High Availability and Strong Reliability
 
@@ -34,9 +41,13 @@ Achieving the right balance between these two is vital for designing systems tha
 
 ## How to Measure Availability in System Design
 
-Measuring availability offers a clear picture of a system's uptime and accessibility, often reflecting its resilience to failures. The required level of availability varies based on the system's purpose. 
+Measuring availability offers a clear picture of a system's uptime and accessibility, often reflecting its resilience to failures. The required level of availability varies based on the system's purpose.
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image.webp" alt="Availability vs Fault tolerance" caption="Availability vs Fault tolerance" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image.webp"
+  alt="Availability vs Fault tolerance"
+  caption="Availability vs Fault tolerance"
+/>
 
 Critical systems like Air Traffic Control demand exceptionally high availability due to the severe consequences of even a single failure. In contrast, less critical systems can function effectively with lower availability requirements. Ultimately, achieving high availability involves costs, so optimizing it to align with specific needs is key.
 
@@ -65,33 +76,45 @@ System designers often use the concept of "nines" to express availability target
 - Four nines (99.99%): 52.56 minutes of downtime per year
 - Five nines (99.999%): 5.26 minutes of downtime per year
 
-Let’s see step-by-step on how we calculated the downtime per year for five nines for example, 
+Let’s see step-by-step on how we calculated the downtime per year for five nines for example,
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%201.webp" alt="Steps for calculating downtime per year for five nines" caption="Steps for calculating downtime per year for five nines" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%201.webp"
+  alt="Steps for calculating downtime per year for five nines"
+  caption="Steps for calculating downtime per year for five nines"
+/>
 
 ### Common Availability Targets
 
 Different systems require varying levels of availability based on their purpose and criticality. Highly critical systems often require extremely high availability to ensure continuous operation, while less critical systems can function effectively with lower availability thresholds. These requirements are typically defined by the system's role and the potential impact of downtime.
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%202.webp" alt="Common Availability Targets" caption="Common Availability Targets" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%202.webp"
+  alt="Common Availability Targets"
+  caption="Common Availability Targets"
+/>
 
 ### Factors Affecting Availability Measurements
 
 Several factors can impact availability calculations:
 
-| Factors | Explanation |
-| --- | --- |
-| Planned maintenance | Some organizations exclude scheduled downtime from availability calculations. |
-| Geographic distribution | Systems spread across multiple regions may have different availability levels in each location. |
-| Service dependencies | The availability of dependent services can affect overall system availability. |
-| Measurement granularity | The frequency of uptime checks can influence availability calculations. |
-| Sequence vs Parallel |  Overall availability decreases when two components are arranged in sequence but increases when they are configured in parallel. |
+| Factors                 | Explanation                                                                                                                     |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| Planned maintenance     | Some organizations exclude scheduled downtime from availability calculations.                                                   |
+| Geographic distribution | Systems spread across multiple regions may have different availability levels in each location.                                 |
+| Service dependencies    | The availability of dependent services can affect overall system availability.                                                  |
+| Measurement granularity | The frequency of uptime checks can influence availability calculations.                                                         |
+| Sequence vs Parallel    | Overall availability decreases when two components are arranged in sequence but increases when they are configured in parallel. |
 
 ### Real-world Examples of Availability Metrics
 
 Availability metrics are crucial for understanding how reliable a service will be in terms of uptime. They provide service providers and customers with a clear understanding of the expected system performance and potential downtime.
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%203.webp" alt="Real world examples: Amazon EC2, Microsoft Azure, Google Cloud Platform" caption="Real world examples: Amazon EC2, Microsoft Azure, Google Cloud Platform" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%203.webp"
+  alt="Real world examples: Amazon EC2, Microsoft Azure, Google Cloud Platform"
+  caption="Real world examples: Amazon EC2, Microsoft Azure, Google Cloud Platform"
+/>
 
 - Amazon Web Services (AWS): Amazon EC2 (Elastic Compute Cloud) is a web service provided by Amazon Web Services (AWS) that allows users to rent virtual servers (called instances) in the cloud. AWS offers a service level agreement (SLA) of 99.99% availability for its EC2 service, which means customers can expect only about 4.38 minutes of downtime per month. This high level of availability ensures that businesses can rely on AWS for critical workloads.
 - Google Cloud Platform: Google Cloud’s Compute Engine service guarantees 99.95% of availability, which equates to about 4.38 hours of downtime per year. This SLA ensures that customers can expect minimal disruption, even during peak usage times.
@@ -103,11 +126,15 @@ These examples highlight the high standards set by major cloud providers and the
 
 Reliability measures a system's ability to perform its intended functions consistently over time. Unlike availability, which focuses on uptime, reliability emphasizes the quality and consistency of system performance
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%204.webp" alt="Reliability Engineering Principles" caption="Reliability Engineering Principles" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%204.webp"
+  alt="Reliability Engineering Principles"
+  caption="Reliability Engineering Principles"
+/>
 
 ### Reliability Calculation
 
-Reliability calculations are essential for understanding and ensuring that systems can meet their operational goals without failure. 
+Reliability calculations are essential for understanding and ensuring that systems can meet their operational goals without failure.
 
 The primary metric for measuring reliability is Mean Time Between Failures (MTBF) which represents the average time between two consecutive failures of a system. MTBF helps predict a system's expected uptime, allowing engineers to plan maintenance and assess the system's overall reliability.
 
@@ -116,7 +143,11 @@ MTBF = Total Operating Time / Number of Failures
 
 ```
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%205.webp" alt="MTBF visual" caption="MTBF visual" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%205.webp"
+  alt="MTBF visual"
+  caption="MTBF visual"
+/>
 
 For instance, if a system operates for 1000 hours and experiences 5 failures:
 
@@ -129,7 +160,7 @@ This means the system, on average, operates for 200 hours before experiencing a
 
 ### Components of Reliability
 
-Reliability encompasses three main factors: 
+Reliability encompasses three main factors:
 
 1. Hardware reliability: This refers to the ability of physical components to function properly without failure over time. For example, servers and hard drives that are designed with redundancy and failover mechanisms can handle hardware failures without causing system downtime. An example of this is using RAID (Redundant Array of Independent Disks) in storage systems, which ensures data availability even if one disk fails.
 2. Software reliability: This involves the ability of software systems to operate without crashes or errors, even under stressful conditions. For example, a banking application that handles millions of transactions per day needs to be free from bugs and ensure accurate processing. An example of improving software reliability is automated testing (unit tests, integration tests) that helps identify and fix bugs before deployment.
@@ -204,17 +235,17 @@ This approach demonstrates redundancy by ensuring only active servers handle req
 
 ### 2. Use fault tolerance techniques
 
-Design systems to continue functioning despite partial failures. 
+Design systems to continue functioning despite partial failures.
 
 - Replication: Duplicate critical components or data (e.g., database replication) to ensure availability during failures.
 - Failover mechanisms: Automatically switch to a backup system when the primary system fails (e.g., cloud load balancers).
 - Circuit breakers: Prevent cascading failures by isolating problematic components.
 
-We’ll learn more about this further in this article. 
+We’ll learn more about this further in this article.
 
 ### 3. Conduct thorough testing
 
- Implement comprehensive test suites, including unit tests, integration tests, and stress tests.
+Implement comprehensive test suites, including unit tests, integration tests, and stress tests.
 
 ```python
 # Example: Unit test for a critical function
@@ -256,18 +287,22 @@ Implement continuous monitoring to identify and address issues proactively:
 
 ## The Relationship Between Availability and Reliability
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%206.webp" alt="Relationship between reliability and availability" caption="Relationship between reliability and availability" /> 
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%206.webp"
+  alt="Relationship between reliability and availability"
+  caption="Relationship between reliability and availability"
+/>
 
 Availability and reliability are closely interconnected but distinct concepts in system design:
 
 1. Reliability contributes to availability: A reliable system fails less often, which naturally results in higher availability. For instance, a reliable database engine with fault-tolerant mechanisms ensures fewer interruptions, boosting system uptime.
 2. High reliability doesn't guarantee high availability: Even if a system operates flawlessly when functional, frequent or lengthy maintenance periods can reduce availability. For example, a reliable on-premises server might need extended downtime for hardware upgrades, reducing overall availability.
 3. Balancing act: System designers must weigh the trade-offs between reliability, availability, and cost.
-    - Improving reliability: Often involves redundancy or using higher-quality components, which can be costly. For example, an aerospace system may use redundant hardware and extensive testing to ensure reliability, driving up expenses.
-    - Enhancing availability: Distributed architectures or cloud-based solutions can maintain services during failures. For instance, Netflix uses microservices and cloud regions to keep its platform available, even during localized outages.
+   - Improving reliability: Often involves redundancy or using higher-quality components, which can be costly. For example, an aerospace system may use redundant hardware and extensive testing to ensure reliability, driving up expenses.
+   - Enhancing availability: Distributed architectures or cloud-based solutions can maintain services during failures. For instance, Netflix uses microservices and cloud regions to keep its platform available, even during localized outages.
 4. Scenarios of imbalance:
-    - High reliability, low availability: A system with near-perfect reliability (99.999%) but scheduled downtime for updates (e.g., nightly backups) might reduce availability to 90%. For example, a legacy banking system may be reliable but unavailable during maintenance windows.
-    - High availability, low reliability: A highly available system might remain operational but experience performance degradation under heavy loads. For instance, an e-commerce platform that remains online during a sale might show slow response times, reducing user trust and perceived reliability.
+   - High reliability, low availability: A system with near-perfect reliability (99.999%) but scheduled downtime for updates (e.g., nightly backups) might reduce availability to 90%. For example, a legacy banking system may be reliable but unavailable during maintenance windows.
+   - High availability, low reliability: A highly available system might remain operational but experience performance degradation under heavy loads. For instance, an e-commerce platform that remains online during a sale might show slow response times, reducing user trust and perceived reliability.
 
 ## Maintainability: The Third Pillar of System Performance
 
@@ -276,32 +311,31 @@ Maintainability complements availability and reliability in system design. It me
 ### Key Maintainability Metrics
 
 1. Mean Time To Repair (MTTR): The average time required to fix a failed system. MTTR measures the average time needed to restore a failed system or component to normal operation. It reflects how quickly your team can respond to and resolve issues, which directly impacts system uptime. A lower MTTR indicates better maintainability and faster recovery.
-    
-    ```
-    MTTR = Total Repair Time / Number of Repairs
-    
-    ```
-    
+
+   ```
+   MTTR = Total Repair Time / Number of Repairs
+
+   ```
+
 2. Mean Time To Detect (MTTD): The average time it takes to identify a system issue. MTTD gauges the average time taken to identify a problem in the system after it occurs. It highlights the efficiency of monitoring and alerting mechanisms. Shorter MTTD values indicate that issues are being detected quickly, reducing their potential impact on users and services.
 
 ### Strategies for Improving System Maintainability
 
 1. Modular Design
-    
-    A modular system architecture divides the application into loosely coupled, self-contained components. This approach allows teams to update, replace, or repair specific parts of the system without impacting others. For example, if a payment service in an e-commerce platform needs an update, it can be modified independently without affecting the user interface or inventory systems. This not only reduces downtime but also makes it easier to test and deploy changes.
-    
+
+   A modular system architecture divides the application into loosely coupled, self-contained components. This approach allows teams to update, replace, or repair specific parts of the system without impacting others. For example, if a payment service in an e-commerce platform needs an update, it can be modified independently without affecting the user interface or inventory systems. This not only reduces downtime but also makes it easier to test and deploy changes.
+
 2. Comprehensive Documentation
-    
-    Maintaining detailed and up-to-date documentation ensures that all aspects of the system—such as configurations, workflows, and troubleshooting steps—are clearly outlined. Runbooks, which provide step-by-step instructions for handling specific issues or tasks, are particularly valuable during incidents. This documentation speeds up onboarding for new team members and minimizes confusion during critical moments, enabling teams to resolve problems more efficiently.
-    
+
+   Maintaining detailed and up-to-date documentation ensures that all aspects of the system—such as configurations, workflows, and troubleshooting steps—are clearly outlined. Runbooks, which provide step-by-step instructions for handling specific issues or tasks, are particularly valuable during incidents. This documentation speeds up onboarding for new team members and minimizes confusion during critical moments, enabling teams to resolve problems more efficiently.
+
 3. Automated Deployment and Rollback
-    
-    Continuous Integration and Continuous Deployment (CI/CD) pipelines automate the process of building, testing, and deploying code. These pipelines not only reduce human error but also allow quick rollbacks in case a deployment introduces bugs or causes failures. For instance, if a new release breaks functionality, an automated rollback can swiftly restore the previous stable version, minimizing disruptions and ensuring service continuity.
-    
+
+   Continuous Integration and Continuous Deployment (CI/CD) pipelines automate the process of building, testing, and deploying code. These pipelines not only reduce human error but also allow quick rollbacks in case a deployment introduces bugs or causes failures. For instance, if a new release breaks functionality, an automated rollback can swiftly restore the previous stable version, minimizing disruptions and ensuring service continuity.
+
 4. Monitoring and Logging
-    
-    Implementing robust monitoring and logging solutions helps teams keep a close watch on the system's health. Monitoring tools can track performance metrics like CPU usage, memory consumption, and response times, while logging tools capture detailed events within the system. Together, they enable proactive issue detection and rapid root-cause analysis, allowing teams to address problems before they escalate into major outages.
-    
+
+   Implementing robust monitoring and logging solutions helps teams keep a close watch on the system's health. Monitoring tools can track performance metrics like CPU usage, memory consumption, and response times, while logging tools capture detailed events within the system. Together, they enable proactive issue detection and rapid root-cause analysis, allowing teams to address problems before they escalate into major outages.
 
 ## Monitoring Availability and Reliability with SigNoz
 
@@ -311,7 +345,7 @@ SigNoz offers a comprehensive solution for monitoring system availability and re
 
 <GetStartedSigNoz />
 
-1. Instrument your application: Add the SigNoz SDK to your application code. Refer to [this](https://signoz.io/guides/flask-logging/) article. 
+1. Instrument your application: Add the SigNoz SDK to your application code. Refer to [this](https://signoz.io/guides/flask-logging/) article.
 2. Configure custom metrics: It involves defining specific performance indicators for availability and reliability that are tailored to your system's needs. In the SigNoz dashboard, you can set up and track these metrics to monitor key aspects like uptime, response time, and error rates, ensuring your system operates within desired performance standards.
 3. Set up alerts: It involves configuring custom thresholds for system availability and [reliability metrics](https://signoz.io/guides/reliability-metrics/), ensuring that you are notified when performance deviates from expected levels. This helps proactively manage issues by alerting the team in real time, based on specific parameters like response times or downtime. For example, SigNoz provides an intuitive alert configuration interface to easily define and manage these alert conditions.
 
@@ -328,46 +362,65 @@ While availability and reliability often go hand in hand, certain scenarios may
 
 ### Architectural Considerations for High Availability
 
-1. Load balancing: Distribute traffic across multiple servers to prevent single points of failure. 
-    
-    <Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%207.webp" alt="Load balancing across multiple servers" caption="Load balancing across multiple servers" />
-    
-    A key principle of high availability is removing single points of failure. A single point of failure refers to any system component whose failure would lead to the entire system malfunctioning.
-    
-    An example of this is load balancing across multiple servers.
-    
+1. Load balancing: Distribute traffic across multiple servers to prevent single points of failure.
+
+   <Figure
+     src="/img/comparisons/2024/11/availability-vs-reliability-image%207.webp"
+     alt="Load balancing across multiple servers"
+     caption="Load balancing across multiple servers"
+   />
+
+   A key principle of high availability is removing single points of failure. A single point of failure refers to any system component whose failure would lead to the entire system malfunctioning.
+
+   An example of this is load balancing across multiple servers.
+
 2. Geographic distribution: To enhance high availability, deploy services across multiple regions to minimize the impact of location-specific outages. Hosting in different geographic zones can help maintain service continuity if a server experiences an issue. The February 2017 AWS outage highlighted the significant impact a regional failure can have, demonstrating the importance of geographic redundancy in maintaining availability.
 3. Autoscaling: Autoscaling ensures high availability by dynamically adjusting resources based on real-time demand. During traffic spikes, it automatically adds resources (like virtual machines or containers) to handle the load, and during low-demand periods, it scales down to reduce costs. This flexibility helps maintain consistent performance and prevents system outages due to resource exhaustion.
 4. Microservices: Infrastructure as a single system houses all application components together, simplifying management but creating a single point of failure. Microservices address this by breaking applications into independent services, improving resilience if one fails. However, this approach increases complexity, requiring more tools, resources, and effort to manage and maintain.
 
 ### Design Patterns for Improving System Reliability
 
-Patterns are repeatable solutions that combine components to address common challenges. They promote best practices, ensuring consistency and helping users achieve their goals effectively. 
+Patterns are repeatable solutions that combine components to address common challenges. They promote best practices, ensuring consistency and helping users achieve their goals effectively.
 
-Let’s look at few design patterns that aim to improve system reliability: 
+Let’s look at few design patterns that aim to improve system reliability:
 
 1. Circuit Breaker Pattern: The circuit breaker pattern helps prevent cascading system failures. It operates similarly to an electrical circuit breaker, temporarily disabling failing services to avoid causing further issues across the system.
-    
-    <Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%208.webp" alt="Circuit Breaker Pattern" caption="Circuit Breaker Pattern" />
-    
-2. Retry Pattern: This pattern automatically retries operations that fail, enabling recovery from temporary issues without causing immediate system failure. It helps handle transient faults by re-executing failed tasks. 
-    
-    <Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%209.webp" alt="Retry Pattern" caption="Retry Pattern" />
-    
-    For an example, let’s take an application that attempts to perform an operation on the hosted service, but the initial request fails with an HTTP 500 (Internal Server Error). The application waits for a longer interval before trying again, and this time, the request succeeds with an HTTP 200 (OK).
-    
-3. Bulkhead Pattern: The bulkhead pattern isolates components to prevent failures from spreading across the system. 
-    
-    <Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%2010.webp" alt="Bulkhead pattern" caption="Bulkhead pattern" />
-    
-    Similar to partitions in a ship’s hull, if one section fails, others continue to operate, ensuring the system remains functional. This design helps limit the impact of failures.
-    
+
+   <Figure
+     src="/img/comparisons/2024/11/availability-vs-reliability-image%208.webp"
+     alt="Circuit Breaker Pattern"
+     caption="Circuit Breaker Pattern"
+   />
+
+2. Retry Pattern: This pattern automatically retries operations that fail, enabling recovery from temporary issues without causing immediate system failure. It helps handle transient faults by re-executing failed tasks.
+
+   <Figure
+     src="/img/comparisons/2024/11/availability-vs-reliability-image%209.webp"
+     alt="Retry Pattern"
+     caption="Retry Pattern"
+   />
+
+   For an example, let’s take an application that attempts to perform an operation on the hosted service, but the initial request fails with an HTTP 500 (Internal Server Error). The application waits for a longer interval before trying again, and this time, the request succeeds with an HTTP 200 (OK).
+
+3. Bulkhead Pattern: The bulkhead pattern isolates components to prevent failures from spreading across the system.
+
+   <Figure
+     src="/img/comparisons/2024/11/availability-vs-reliability-image%2010.webp"
+     alt="Bulkhead pattern"
+     caption="Bulkhead pattern"
+   />
+
+   Similar to partitions in a ship’s hull, if one section fails, others continue to operate, ensuring the system remains functional. This design helps limit the impact of failures.
 
 ### A Netflix Case Study: High-Availability and High-Reliability Systems
 
 Netflix serves as a benchmark for building high-availability and high-reliability systems, leveraging cutting-edge practices and technologies to maintain seamless service. At the core of its strategy lies a microservices architecture, which divides the platform into smaller, independent services. This design ensures that a failure in one component doesn’t cascade through the system, preserving overall functionality.
 
-<Figure src="/img/comparisons/2024/11/availability-vs-reliability-image%2011.webp" alt="Netflix: Geographically Distributed Data Centers" caption="Netflix: Geographically Distributed Data Centers" />
+<Figure
+  src="/img/comparisons/2024/11/availability-vs-reliability-image%2011.webp"
+  alt="Netflix: Geographically Distributed Data Centers"
+  caption="Netflix: Geographically Distributed Data Centers"
+/>
 
 1. Chaos Engineering: Netflix employs chaos engineering to proactively test system resilience. Tools like Chaos Monkey deliberately cause controlled disruptions, such as disabling random instances in the cloud infrastructure. This practice validates the platform's ability to withstand unexpected outages while ensuring uninterrupted user experiences.
 2. Geographically Distributed Data Centers: The company further bolsters reliability through geographically distributed data centers, which reduce the impact of regional outages. Load balancing distributes traffic evenly across servers, preventing overloading and ensuring consistent service. Multi-region backups enable rapid data recovery during disasters, minimizing downtime and safeguarding availability.
@@ -404,4 +457,4 @@ Popular tools include:
 - SigNoz for comprehensive APM and tracing
 - Prometheus for metrics collection
 - Grafana for visualization
-- PagerDuty for incident management
\ No newline at end of file
+- PagerDuty for incident management
diff --git a/data/comparisons/aws-alternatives.mdx b/data/comparisons/aws-alternatives.mdx
index b90df056a..82f7c9bcc 100644
--- a/data/comparisons/aws-alternatives.mdx
+++ b/data/comparisons/aws-alternatives.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top 10 AWS Alternatives - Cost-Effective Cloud Solutions
-slug: aws-alternatives
 date: 2024-08-14
 tags: [tools-comparision]
 authors: [manjunath_irukulla]
 description: Discover cost-effective AWS alternatives for your cloud computing needs. Compare features, pricing, and use cases of top cloud providers to optimize your IT infrastructure.
-keywords: [aws alternatives, cloud computing, cost-effective cloud solutions, cloud providers, cloud migration]
-
+keywords:
+  [
+    aws alternatives,
+    cloud computing,
+    cost-effective cloud solutions,
+    cloud providers,
+    cloud migration,
+  ]
 ---
 
 Cloud computing has revolutionized how businesses manage their IT infrastructure by providing cloud services across the globe like compute engines, storages, Gen AI (recently) and with other resilient features, Amazon Web Services (AWS) has long been the dominant player in this space. However, many organizations are now seeking AWS alternatives to reduce costs, simplify operations, or access specialized features. This article explores the top 10 cost-effective AWS alternatives, helping you make an informed decision for your cloud computing needs.
@@ -41,13 +45,21 @@ When assessing AWS alternatives, it’s important to evaluate three critical ele
 4. Scalability: Ensure the platform can grow with your business and handle increasing workloads. Look for providers that offer flexible scaling options to match demand.
 5. Security: Check for compliance with industry standards and regulations. Evaluate the provider’s security features and practices to protect your data.
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-aws_alter.webp" alt="Key factors to consider when choosing AWS Alternatives" caption="Key factors to consider when choosing AWS Alternatives" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-aws_alter.webp"
+  alt="Key factors to consider when choosing AWS Alternatives"
+  caption="Key factors to consider when choosing AWS Alternatives"
+/>
 
 ## Top 10 AWS Alternatives for Cost-Effective Cloud Solutions
 
 ### 1. Google Cloud Platform (GCP)
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-gcp.webp" alt="Google Cloud Provider (GCP) Dashboard" caption="Google Cloud Provider (GCP) Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-gcp.webp"
+  alt="Google Cloud Provider (GCP) Dashboard"
+  caption="Google Cloud Provider (GCP) Dashboard"
+/>
 
 Google Cloud Platform provides an extensive range of cloud services at affordable prices, making it typically more cost-effective than AWS, particularly for specific workloads.
 
@@ -75,7 +87,11 @@ AWS Comparison:
 
 ### 2. Microsoft Azure
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-Azure_for_Students_-_1.webp" alt="Microsoft Azure Dashboard" caption="Microsoft Azure Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-Azure_for_Students_-_1.webp"
+  alt="Microsoft Azure Dashboard"
+  caption="Microsoft Azure Dashboard"
+/>
 
 Microsoft Azure is a strong competitor to AWS, especially for enterprises already using Microsoft products. Its integration capabilities and hybrid cloud solutions make it an attractive option for some business scenarios.
 
@@ -104,7 +120,11 @@ AWS Comparison:
 
 ### 3. Digital Ocean
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-digital_ocean.webp" alt="Digital Ocean Dashboard" caption="Digital Ocean Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-digital_ocean.webp"
+  alt="Digital Ocean Dashboard"
+  caption="Digital Ocean Dashboard"
+/>
 
 Digital Ocean is known for its simplicity and developer-friendly approach, making it an attractive option for small to medium-sized projects that prioritize ease of use.
 
@@ -134,7 +154,11 @@ Ideal Use Case:
 
 ### 4. IBM Cloud
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-ibm_cloud.webp" alt="IBM Cloud Dashboard" caption="IBM Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-ibm_cloud.webp"
+  alt="IBM Cloud Dashboard"
+  caption="IBM Cloud Dashboard"
+/>
 
 IBM Cloud caters to enterprise demands, with an emphasis on hybrid and multi-cloud environments, and offers comprehensive solutions for enterprises in regulated industries.
 
@@ -163,7 +187,11 @@ AWS Comparison
 
 ### 5. Oracle Cloud Infrastructure (OCI)
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-infrastructureconsoledashboard.webp" alt="Oracle Cloud Infrastructure (OCI) Dashboard" caption="Oracle Cloud Infrastructure (OCI) Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-infrastructureconsoledashboard.webp"
+  alt="Oracle Cloud Infrastructure (OCI) Dashboard"
+  caption="Oracle Cloud Infrastructure (OCI) Dashboard"
+/>
 
 Oracle Cloud Infrastructure is optimized for Oracle workloads, offering high-performance computing and database services to businesses that rely heavily on Oracle technology.
 
@@ -192,7 +220,11 @@ AWS Comparison
 
 ### 6. Alibaba Cloud
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-0_8yOezbgqnMu9Iv6k.webp" alt="Alibaba Cloud Dashboard" caption="Alibaba Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-0_8yOezbgqnMu9Iv6k.webp"
+  alt="Alibaba Cloud Dashboard"
+  caption="Alibaba Cloud Dashboard"
+/>
 
 Alibaba Cloud has an extensive presence in Asia and emerging countries, making it an excellent strategic choice for organizations in these regions.
 
@@ -221,7 +253,11 @@ AWS Comparison
 
 ### 7. Linode
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-Cloud-Manager-old-dashboard.webp" alt="Linode Cloud Dashboard" caption="Linode Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-Cloud-Manager-old-dashboard.webp"
+  alt="Linode Cloud Dashboard"
+  caption="Linode Cloud Dashboard"
+/>
 
 Linode provides a clear, developer-friendly cloud platform with a simple price structure, making it suitable for developers and small enterprises.
 
@@ -250,7 +286,11 @@ AWS Comparison
 
 ### 8. OVHcloud
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-public_cloud-compute-03-public-cloud-interface-walk-me-images-main-menu.webp" alt="OVH Cloud Dashboard" caption="OVH Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-public_cloud-compute-03-public-cloud-interface-walk-me-images-main-menu.webp"
+  alt="OVH Cloud Dashboard"
+  caption="OVH Cloud Dashboard"
+/>
 
 OVHcloud prioritizes data sovereignty and European compliance, making it an ideal alternative for enterprises with stringent data residency obligations in the EU.
 
@@ -279,7 +319,11 @@ AWS Comparison:
 
 ### 9. Vultr
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-Screenshot_2024-08-11_154827.webp" alt="Vultr Cloud Dashboard" caption="Vultr Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-Screenshot_2024-08-11_154827.webp"
+  alt="Vultr Cloud Dashboard"
+  caption="Vultr Cloud Dashboard"
+/>
 
 Vultr offers high-performance cloud computing at low pricing, ensuring a balance of cost-effectiveness and performance.
 
@@ -308,7 +352,11 @@ AWS Comparison:
 
 ### 10. Heroku
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-3798-imported-1711543534-initiate-sync-to-pg.webp" alt="Heroku Cloud Dashboard" caption="Heroku Cloud Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-3798-imported-1711543534-initiate-sync-to-pg.webp"
+  alt="Heroku Cloud Dashboard"
+  caption="Heroku Cloud Dashboard"
+/>
 
 Heroku is a Platform as a Service (PaaS) that streamlines application deployment, that streamlines application deployment, making it perfect for developers that prioritize quick application development.
 
@@ -345,7 +393,11 @@ For example, if you observe significant latency in your application, you may imm
 
 Additionally, [SigNoz](https://signoz.io/docs/introduction/) provides extensive views of tracing data via Flamegraphs and Gantt charts, which improves the visibility of services and events. Users can build custom dashboards to visualize critical performance metrics, and the alerting tools enable proactive issue solutions.
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-Untitled.webp" alt="SigNoz Monitoring Dashboard" caption="SigNoz Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-Untitled.webp"
+  alt="SigNoz Monitoring Dashboard"
+  caption="SigNoz Monitoring Dashboard"
+/>
 
 Comparison with CloudWatch
 
@@ -413,7 +465,11 @@ Migrating from AWS to another cloud provider needs careful strategy and executio
 | Phase - 2 | Gradually migrate essential applications and data | Ensure stability and minimize disruptions |
 | Phase - 3 | Fine-tune the setup on the new platform           | Enhance performance and cost efficiency   |
 
-<Figure src="/img/comparisons/2024/08/aws-alternatives-napkin-selection_(2).webp" alt="Factors to consider while migrating from AWS" caption="Factors to consider while migrating from AWS" />
+<Figure
+  src="/img/comparisons/2024/08/aws-alternatives-napkin-selection_(2).webp"
+  alt="Factors to consider while migrating from AWS"
+  caption="Factors to consider while migrating from AWS"
+/>
 
 Factors to consider while migrating from AWS
 
diff --git a/data/comparisons/aws-monitoring-tools.mdx b/data/comparisons/aws-monitoring-tools.mdx
index 0b713a25c..24fcdf05c 100644
--- a/data/comparisons/aws-monitoring-tools.mdx
+++ b/data/comparisons/aws-monitoring-tools.mdx
@@ -1,17 +1,12 @@
 ---
-
 title: Top 10 AWS Monitoring Tools in 2025 — Native & Third-Party Compared
-slug: aws-monitoring-tools
 date: 2025-04-29
 tags: [tools-comparison, aws, monitoring]
 authors: [hridyesh_bisht, sarafadeen_ibrahim]
 description: Confused between AWS CloudWatch, X-Ray, and third-party tools like SigNoz or Datadog? Discover the top 10 AWS monitoring tools in 2025 to boost performance, security, and visibility across cloud workloads.
 image: /img/blog/2024/04/aws-monitoring-tools-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [aws-monitoring-tools,aws,opentelemetry,open-source,monitoring-tools,signoz]
-
+keywords: [aws-monitoring-tools, aws, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
 Managing various AWS resources can be challenging since a single misconfigured service can degrade performance or increase costs. This makes it difficult to identify issues without effective monitoring.
@@ -23,9 +18,8 @@ Monitoring AWS environments ensures your applications function correctly and eff
 - **High Availability:** Monitoring critical components ensures system reliability and helps meet service level agreements (SLAs) by detecting and resolving issues before they impact availability.
 - **Enhanced Security and Compliance**: Monitoring security metrics, such as access logs and configuration changes, helps detect threats, improve security posture, and ensure compliance with industry regulations.
 
-<KeyPointCallout title="In this article, we have listed down two categories of AWS monitoring tools:" >
-- AWS native monitoring tools.
-- Third-party monitoring tools.
+<KeyPointCallout title="In this article, we have listed down two categories of AWS monitoring tools:">
+  - AWS native monitoring tools. - Third-party monitoring tools.
 </KeyPointCallout>
 
 ## AWS Native Monitoring Tools
@@ -38,7 +32,11 @@ Key benefits of using AWS native monitoring tools:
 - Built-in security and compliance features
 - Automated monitoring and alerting
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-diff-monitor-usecase.webp" alt="An image with different AWS native monitoring tools" caption="Different AWS native monitoring tools" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-diff-monitor-usecase.webp"
+  alt="An image with different AWS native monitoring tools"
+  caption="Different AWS native monitoring tools"
+/>
 
 ## 1. AWS CloudWatch
 
@@ -50,7 +48,11 @@ Key features:
 - Search and filter logs using CloudWatch Logs Insights for real-time log pattern analysis.
 - Set metric thresholds to trigger CloudWatch Alarms to send notifications or run automated actions. Use CloudWatch Events to respond to changes or schedule tasks automatically.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-DotNet_runtime-metrics.webp" alt="An image of CloudWatch dashboard" caption="An image of CloudWatch dashboard, credit: Amazon Blog." />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-DotNet_runtime-metrics.webp"
+  alt="An image of CloudWatch dashboard"
+  caption="An image of CloudWatch dashboard, credit: Amazon Blog."
+/>
 
 CloudWatch integrates seamlessly with most AWS services. It automatically receives metrics and logs without requiring additional setup. You can also connect CloudWatch with other services, such as AWS Lambda or Amazon SNS, to trigger responses to alarms or events.
 
@@ -91,7 +93,11 @@ Key features:
 - Supports integration with Amazon CloudWatch Logs for near real-time alerting on specific activities.
 - Enables tracking of changes to resources, user access, and operational actions.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-cloudtrail.webp" alt="An image displaying CloudTrail logs" caption="An image displaying CloudTrail logs" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-cloudtrail.webp"
+  alt="An image displaying CloudTrail logs"
+  caption="An image displaying CloudTrail logs"
+/>
 
 ### Pricing
 
@@ -101,7 +107,7 @@ CloudTrail provides a free tier that includes management events for the last 90
 - CloudTrail Lake queries and storage.
 - CloudTrail Insights.
 
- For more information, refer to <a href="https://aws.amazon.com/cloudtrail/pricing/" rel="noopener noreferrer nofollow" target="_blank">CloudTrail pricing</a>.
+For more information, refer to <a href="https://aws.amazon.com/cloudtrail/pricing/" rel="noopener noreferrer nofollow" target="_blank">CloudTrail pricing</a>.
 
 ### Pros
 
@@ -111,18 +117,18 @@ CloudTrail provides a free tier that includes management events for the last 90
 
 ### Cons
 
-- CloudTrail Insights takes ~36 hours to detect anomalies.  This makes CloudTrail not ideal for real-time monitoring.
+- CloudTrail Insights takes ~36 hours to detect anomalies. This makes CloudTrail not ideal for real-time monitoring.
 - Requires integration with other tools (e.g., CloudWatch, AWS Athena ) for advanced queries and alerts.
 
 ### Ideal Use Cases
 
-Best suited for AWS environments where tracking user activity and API calls is essential for auditing, compliance, or security investigations. Ideal for security, DevOps, or governance teams who need to understand **who did what, when, and from where** across services. 
+Best suited for AWS environments where tracking user activity and API calls is essential for auditing, compliance, or security investigations. Ideal for security, DevOps, or governance teams who need to understand **who did what, when, and from where** across services.
 
 If you want a native AWS solution to maintain a reliable audit trail, CloudTrail is a good solution.
 
 ## 3. AWS Config
 
-AWS Config is a configuration auditing tool that tracks AWS resource configurations and changes over time. It helps you understand how resources are related and whether they comply with your internal rules or industry standards. While CloudTrail logs *who* made a change, Config verifies whether the change follows policy rules.
+AWS Config is a configuration auditing tool that tracks AWS resource configurations and changes over time. It helps you understand how resources are related and whether they comply with your internal rules or industry standards. While CloudTrail logs _who_ made a change, Config verifies whether the change follows policy rules.
 
 Key features:
 
@@ -131,7 +137,11 @@ Key features:
 - Enables visual resource relationships with configuration timelines.
 - Integrates with AWS Systems Manager and AWS Organizations for multi-account reporting.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-51a9bce0-6b07-40ee-8b65-082c49386dcc.webp" alt="An image displaying AWS Config" caption="An image displaying AWS Config" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-51a9bce0-6b07-40ee-8b65-082c49386dcc.webp"
+  alt="An image displaying AWS Config"
+  caption="An image displaying AWS Config"
+/>
 
 ### Pricing
 
@@ -174,7 +184,11 @@ Key features:
 - Uses the Common Vulnerabilities and Exposures (CVE) database for risk scoring.
 - Automatically prioritizes findings based on exploitability and exposure.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-1_Mmtbhu0ITXbk5skQ_xoUmg.webp" alt="An image displaying AWS inspector" caption="An image displaying AWS inspector" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-1_Mmtbhu0ITXbk5skQ_xoUmg.webp"
+  alt="An image displaying AWS inspector"
+  caption="An image displaying AWS inspector"
+/>
 
 ### Pricing
 
@@ -201,7 +215,7 @@ For more information, refer to <a href="https://aws.amazon.com/inspector/pricing
 
 ### Ideal Use Cases
 
-Best for AWS workloads requiring **continuous vulnerability scanning and risk visibility** across EC2 instances, Lambda functions and container images. Ideal for security or DevSecOps teams who want automatic CVE detection and risk scoring without external scanners. 
+Best for AWS workloads requiring **continuous vulnerability scanning and risk visibility** across EC2 instances, Lambda functions and container images. Ideal for security or DevSecOps teams who want automatic CVE detection and risk scoring without external scanners.
 
 If you already run workloads on AWS and want a native way to embed security checks into your deployment lifecycle, Inspector is a strong fit.
 
@@ -215,7 +229,11 @@ Key benefits:
 - Helps identify performance bottlenecks or failure points in APIs, Lambda functions, and EC2 instances.
 - Integrates with CloudWatch for monitoring and alerting.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-my-function-2-v2.webp" alt="An image displaying AWS X-Ray" caption="An image displaying AWS X-Ray" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-my-function-2-v2.webp"
+  alt="An image displaying AWS X-Ray"
+  caption="An image displaying AWS X-Ray"
+/>
 
 image credit: AWS Blog.
 
@@ -246,7 +264,7 @@ Microservice architectures on AWS needing [distributed tracing](https://signoz.i
 
 ## 6. AWS Security Hub
 
-AWS Security Hub aggregates, organizes, and prioritizes security findings from AWS services and third-party tools. It provides a unified view of your security risks and compliance status. 
+AWS Security Hub aggregates, organizes, and prioritizes security findings from AWS services and third-party tools. It provides a unified view of your security risks and compliance status.
 
 Key features:
 
@@ -254,7 +272,11 @@ Key features:
 - Supports AWS Foundational Security Best Practices and CIS AWS Foundations Benchmark.
 - Provides insights across multiple AWS accounts and Regions.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-part-3-image-8.webp" alt="An image displaying AWS Security Hub Dashboard" caption="An image displaying AWS Security Hub Dashboard" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-part-3-image-8.webp"
+  alt="An image displaying AWS Security Hub Dashboard"
+  caption="An image displaying AWS Security Hub Dashboard"
+/>
 
 Image credit: AWS documentation.
 
@@ -289,9 +311,13 @@ While AWS offers native monitoring tools, third-party solutions provide advanced
 
 ## 1. SigNoz
 
-[SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability platform. It provides a unified solution for [monitoring logs](https://signoz.io/blog/log-monitoring/), metrics, and traces. Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) and other open-source components, SigNoz offers developers and SREs a self-hosted alternative to commercial tools like Datadog. 
+[SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability platform. It provides a unified solution for [monitoring logs](https://signoz.io/blog/log-monitoring/), metrics, and traces. Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) and other open-source components, SigNoz offers developers and SREs a self-hosted alternative to commercial tools like Datadog.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-CleanShot_2025-04-07_at_14.37.092x.webp" alt="An image displaying SigNoz dashb" caption="An image displaying SigNoz dashb" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-CleanShot_2025-04-07_at_14.37.092x.webp"
+  alt="An image displaying SigNoz dashb"
+  caption="An image displaying SigNoz dashb"
+/>
 
 Image credit: [SigNoz documentation.](https://signoz.io/img/features/metrics/metrics-overview1.webp)
 
@@ -306,18 +332,22 @@ Key features:
 
 For example, consider you have a web app hosted on AWS. It consists of frontend, backend and a database. You might integrate the following AWS services with SigNoz
 
-| AWS Service | Purpose | Integration with SigNoz |
-| --- | --- | --- |
-| **Amazon ECS** | Runs the Node.js backend | Instrument using OpenTelemetry SDK and export traces/logs to SigNoz |
-| **Amazon API Gateway** | Manages public API endpoints | Export access logs to **CloudWatch**, then forward logs to SigNoz via the CloudWatch Receiver |
-| **AWS Lambda** | Handles async tasks or light logic | Enable X-Ray tracing and send data to SigNoz using the **AWS X-Ray Receiver** |
-| **Amazon RDS** | Manages the database | Monitor DB metrics via **CloudWatch**, then use CloudWatch Receiver to ingest into SigNoz |
-| **Amazon CloudWatch Logs** | Collects logs across services | Use the <a href="https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awscloudwatchreceiver" rel="noopener noreferrer nofollow" target="_blank">CloudWatch Logs Receiver</a> in the OpenTelemetry Collector to forward to SigNoz |
-| **AWS X-Ray** | Tracing backend and Lambda | Use <a href="https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awsxrayreceiver" rel="noopener noreferrer nofollow" target="_blank">AWS X-Ray Receiver</a> in the OpenTelemetry Collector to integrate with SigNoz |
+| AWS Service                | Purpose                            | Integration with SigNoz                                                                                                                                                                                                                                          |
+| -------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Amazon ECS**             | Runs the Node.js backend           | Instrument using OpenTelemetry SDK and export traces/logs to SigNoz                                                                                                                                                                                              |
+| **Amazon API Gateway**     | Manages public API endpoints       | Export access logs to **CloudWatch**, then forward logs to SigNoz via the CloudWatch Receiver                                                                                                                                                                    |
+| **AWS Lambda**             | Handles async tasks or light logic | Enable X-Ray tracing and send data to SigNoz using the **AWS X-Ray Receiver**                                                                                                                                                                                    |
+| **Amazon RDS**             | Manages the database               | Monitor DB metrics via **CloudWatch**, then use CloudWatch Receiver to ingest into SigNoz                                                                                                                                                                        |
+| **Amazon CloudWatch Logs** | Collects logs across services      | Use the <a href="https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awscloudwatchreceiver" rel="noopener noreferrer nofollow" target="_blank">CloudWatch Logs Receiver</a> in the OpenTelemetry Collector to forward to SigNoz |
+| **AWS X-Ray**              | Tracing backend and Lambda         | Use <a href="https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awsxrayreceiver" rel="noopener noreferrer nofollow" target="_blank">AWS X-Ray Receiver</a> in the OpenTelemetry Collector to integrate with SigNoz             |
 
 You want centralized observability (logs, metrics, traces) using SigNoz. Your solution would be:
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-inte-aws-signoz.webp" alt="Integrating AWS with SigNoz" caption="Integrating AWS with SigNoz" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-inte-aws-signoz.webp"
+  alt="Integrating AWS with SigNoz"
+  caption="Integrating AWS with SigNoz"
+/>
 
 <GetStartedSigNoz />
 
@@ -325,10 +355,10 @@ You want centralized observability (logs, metrics, traces) using SigNoz. Your so
 
 SigNoz is free and open source when self-hosted. The software uses the Apache 2.0 license, so there are no licensing costs.
 
-| Option | Description |
-| --- | --- |
-| **Self-Hosted** | Free. You only pay for infrastructure (e.g., EC2, EKS, ClickHouse storage). |
-| **Managed Service** | Starts at $49/month (includes support and simplified deployment). |
+| Option              | Description                                                                 |
+| ------------------- | --------------------------------------------------------------------------- |
+| **Self-Hosted**     | Free. You only pay for infrastructure (e.g., EC2, EKS, ClickHouse storage). |
+| **Managed Service** | Starts at $49/month (includes support and simplified deployment).           |
 
 Compared to SaaS tools like Datadog or New Relic that charge per host or per GB, SigNoz offers significant cost savings. You can sign up for a [free account on SigNoz Cloud](https://signoz.io/teams/) and get 30 days of unlimited access to all features. For more information, refer to [SigNoz’s pricing.](https://signoz.io/pricing/)
 
@@ -344,9 +374,18 @@ SigNoz works best for:
 
 ## 2. Datadog
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> is a third-party cloud monitoring and observability platform. It offers a comprehensive SaaS solution that unifies infrastructure monitoring, APM, log management, and more.  It supports monitoring across AWS, hybrid, and multi-cloud environments.
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+is a third-party cloud monitoring and observability platform. It offers a comprehensive SaaS
+solution that unifies infrastructure monitoring, APM, log management, and more. It supports
+monitoring across AWS, hybrid, and multi-cloud environments.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-datadog.webp" alt="An image displaying Datadog dashboard" caption="An image displaying Datadog dashboard, credit: Datadog documentation." />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-datadog.webp"
+  alt="An image displaying Datadog dashboard"
+  caption="An image displaying Datadog dashboard, credit: Datadog documentation."
+/>
 
 Key features:
 
@@ -373,9 +412,18 @@ Datadog is best suited for organizations running cloud-native, microservices-bas
 
 ## 3. New Relic
 
-<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">New Relic</a> is an observability and APM platform that helps you monitor applications and infrastructure end-to-end. The unified New Relic One platform consolidates metrics, events, logs, and traces to provide a comprehensive view of system performance.
+<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a>
+is an observability and APM platform that helps you monitor applications and infrastructure
+end-to-end. The unified New Relic One platform consolidates metrics, events, logs, and traces to
+provide a comprehensive view of system performance.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-dashboards_screenshot-full_multi-page-dashboard.webp" alt="An image of New Relic dashboard" caption="An image of New Relic dashboard" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-dashboards_screenshot-full_multi-page-dashboard.webp"
+  alt="An image of New Relic dashboard"
+  caption="An image of New Relic dashboard"
+/>
 
 Key features:
 
@@ -389,7 +437,7 @@ Key features:
 
 Free Tier includes 1 full user with access to all features, unlimited basic users, and 100 GB/month of data ingestion.
 
-You pay per GB after the free 100 GB/month. Prices range from ~$0.25–$0.50/GB depending on your plan. Full users cost approximately $99/user/month. New Relic charges based on data ingestion and user seats.  For more information, refer to <a href="https://newrelic.com/pricing?_gl=1*gstfzn*_up*MQ..*_gs*MQ..&gclid=CjwKCAjw47i_BhBTEiwAaJfPpg8ZIIOgoDE6Q0nFyyVyZMSUs8iVOkKFgI1XZqN4PpTY1Zlsoq1pChoCs1oQAvD_BwE" rel="noopener noreferrer nofollow" target="_blank">New Relic's pricing</a>.
+You pay per GB after the free 100 GB/month. Prices range from ~$0.25–$0.50/GB depending on your plan. Full users cost approximately $99/user/month. New Relic charges based on data ingestion and user seats. For more information, refer to <a href="https://newrelic.com/pricing?_gl=1*gstfzn*_up*MQ..*_gs*MQ..&gclid=CjwKCAjw47i_BhBTEiwAaJfPpg8ZIIOgoDE6Q0nFyyVyZMSUs8iVOkKFgI1XZqN4PpTY1Zlsoq1pChoCs1oQAvD_BwE" rel="noopener noreferrer nofollow" target="_blank">New Relic's pricing</a>.
 
 ### Ideal Use Cases
 
@@ -397,9 +445,18 @@ New Relic works best for application-centric monitoring. It's well suited for de
 
 ## 4. Dynatrace
 
-<a href="https://www.dynatrace.com/" rel="noopener noreferrer nofollow" target="_blank">Dynatrace</a> is an observability platform that uses automation and AI to provide full-stack monitoring. It covers infrastructure, APM, logs, user experience, and more. Dynatrace is well-suited for large, complex environments that require automation at scale.
+<a href="https://www.dynatrace.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Dynatrace
+</a>
+is an observability platform that uses automation and AI to provide full-stack monitoring. It covers
+infrastructure, APM, logs, user experience, and more. Dynatrace is well-suited for large, complex
+environments that require automation at scale.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-01.webp" alt="An image displaying Dynatrace dashboard" caption="An image displaying Dynatrace dashboard" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-01.webp"
+  alt="An image displaying Dynatrace dashboard"
+  caption="An image displaying Dynatrace dashboard"
+/>
 
 image credit: <a href="https://www.google.com/url?sa=i&url=https%3A%2F%2Fwww.dynatrace.com%2Fnews%2Fblog%2Flevel-up-your-kubernetes-experience-with-new-dynatrace-dashboards%2F&psig=AOvVaw39OUMFDyjfzlWHkkz8Jv98&ust=1743830648921000&source=images&cd=vfe&opi=89978449&ved=0CBQQjRxqFwoTCLD_us7RvYwDFQAAAAAdAAAAABAE" rel="noopener noreferrer nofollow" target="_blank">Dynatrace blog</a>.
 
@@ -409,9 +466,9 @@ Key features:
 - **AI-Powered Root Cause Analysis:** Dynatrace’s Davis AI detects anomalies and identifies root causes by analyzing service dependencies. When an issue occurs, Davis highlights the most probable cause, helping you troubleshoot faster and reduce [alert fatigue](https://signoz.io/blog/alert-fatigue/).
 - **Cloud and Container Monitoring:** Dynatrace provides deep support for Kubernetes, containers, and serverless workloads. It auto-injects into pods and integrates with orchestration platforms to track dynamic environments.
 - **AWS Integration:** Dynatrace integrates with AWS in following ways:
-    - **CloudWatch Metrics**: Dynatrace pulls CloudWatch metrics after linking an AWS account. It includes services like S3 and DynamoDB in its AI-driven analysis.
-    - **OneAgent Deployment on AWS**: You can deploy OneAgent to AWS compute services using Systems Manager or scripts. Once installed, OneAgent sends infrastructure and application data to Dynatrace.
-    - **Service Recognition**: Dynatrace identifies AWS services in traces.
+  - **CloudWatch Metrics**: Dynatrace pulls CloudWatch metrics after linking an AWS account. It includes services like S3 and DynamoDB in its AI-driven analysis.
+  - **OneAgent Deployment on AWS**: You can deploy OneAgent to AWS compute services using Systems Manager or scripts. Once installed, OneAgent sends infrastructure and application data to Dynatrace.
+  - **Service Recognition**: Dynatrace identifies AWS services in traces.
 
 ### Pricing
 
@@ -430,9 +487,18 @@ Dynatrace is ideal for large-scale microservice environments, such as Kubernetes
 
 ## 5. Sematext
 
-<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">Sematext</a> is a unified monitoring and log management platform designed for modern DevOps and SRE teams. It offers infrastructure monitoring, log management, and alerting. Sematext emphasizes flexibility, ease of use, and affordability, making it suitable for both startups and growing enterprises.
+<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Sematext
+</a>
+is a unified monitoring and log management platform designed for modern DevOps and SRE teams. It
+offers infrastructure monitoring, log management, and alerting. Sematext emphasizes flexibility,
+ease of use, and affordability, making it suitable for both startups and growing enterprises.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-logsene-ui.webp" alt="An image displaying Sematext dashboard" caption="An image displaying Sematext dashboard" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-logsene-ui.webp"
+  alt="An image displaying Sematext dashboard"
+  caption="An image displaying Sematext dashboard"
+/>
 
 Image credit: <a href="https://sematext.com/docs/images/logs/logsene-ui.webp" rel="noopener noreferrer nofollow" target="_blank">Sematext documentation.</a>
 
@@ -442,10 +508,10 @@ Key features:
 - **Log Management:** Sematext Logs is a [centralized log management](https://signoz.io/blog/centralized-logging/) solution that collects, parses, and indexes logs from various sources. It supports structured and unstructured logs, offers full-text search, and allows you to build alert rules and dashboards on top of log data.
 - **Container and Kubernetes Monitoring**: Sematext supports Docker and Kubernetes monitoring out of the box. It collects container metrics, logs, and events and correlates them in unified dashboards. You can deploy the Sematext Agent as a DaemonSet in Kubernetes to monitor nodes, pods, and clusters with minimal setup.
 - **AWS Integration:** Sematext integrates with AWS through CloudWatch and log shippers:
-    - **CloudWatch Metrics**: Pulls metrics for services like EC2, RDS, and S3 via IAM access.
-    - **Log Shipping**: Supports collecting logs from CloudWatch Logs and forwarding them to Sematext Logs.
-    - **EC2 Agent**: You can install the Sematext Agent on EC2 instances for detailed metrics, logs, and system-level events.
-    - **Lambda and S3 Support**: Collect logs from Lambda or push data from S3 via ingestion APIs or collectors.
+  - **CloudWatch Metrics**: Pulls metrics for services like EC2, RDS, and S3 via IAM access.
+  - **Log Shipping**: Supports collecting logs from CloudWatch Logs and forwarding them to Sematext Logs.
+  - **EC2 Agent**: You can install the Sematext Agent on EC2 instances for detailed metrics, logs, and system-level events.
+  - **Lambda and S3 Support**: Collect logs from Lambda or push data from S3 via ingestion APIs or collectors.
 
 ### Pricing
 
@@ -471,7 +537,11 @@ Use AWS-native tools when:
 - You require minimal setup and native service integration.
 - You want to respond to AWS service events in real time (e.g., using EventBridge or CloudWatch Alarms).
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-select-aws-monitor.webp" alt="An image displaying how to choose AWS monitoring solution" caption="An image displaying how to choose AWS monitoring solution" />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-select-aws-monitor.webp"
+  alt="An image displaying how to choose AWS monitoring solution"
+  caption="An image displaying how to choose AWS monitoring solution"
+/>
 
 Use third-party tools when:
 
@@ -482,10 +552,14 @@ Use third-party tools when:
 
 By combining AWS-native tools with third-party platforms, you gain both the seamless integration of AWS and the advanced features of external observability solutions, enabling end-to-end visibility, faster troubleshooting, and improved system reliability.
 
-<Figure src="/img/comparisons/2025/04/aws-monitoring-tools-integrate-aws-signoz.webp" alt="An image about integrating AWS and SigNoz." caption="An image about integrating AWS and SigNoz." />
+<Figure
+  src="/img/comparisons/2025/04/aws-monitoring-tools-integrate-aws-signoz.webp"
+  alt="An image about integrating AWS and SigNoz."
+  caption="An image about integrating AWS and SigNoz."
+/>
 
 Benefits from a hybrid approach:
 
 - Feed AWS-native telemetry into third-party platforms such as SigNoz, Datadog, or New Relic for centralized monitoring.
 - Use AWS-native alerts to trigger incident response or automate remediation using AWS Lambda or EventBridge.
-- Visualize AWS and non-AWS environments together by sending all observability data to a single third-party backend.
\ No newline at end of file
+- Visualize AWS and non-AWS environments together by sending all observability data to a single third-party backend.
diff --git a/data/comparisons/aws-vs-gcp-vs-azure.mdx b/data/comparisons/aws-vs-gcp-vs-azure.mdx
index b4cfce6e6..9acab1c99 100644
--- a/data/comparisons/aws-vs-gcp-vs-azure.mdx
+++ b/data/comparisons/aws-vs-gcp-vs-azure.mdx
@@ -1,16 +1,22 @@
 ---
-
 title: AWS vs GCP vs Azure - Choosing the Right Cloud Platform
-slug: aws-vs-gcp-vs-azure
 date: 2024-08-27
 tags: [tools-comparisions]
 authors: [manjunath_irukulla]
 description: Comprehensive comparison of AWS, GCP, and Azure cloud platforms. Learn key features, pricing, performance, and how to choose the right platform for your needs.
-keywords: [aws vs gcp vs azure, cloud comparison, cloud platforms, IaaS, cloud computing, cloud services, cloud infrastructure]
-
+keywords:
+  [
+    aws vs gcp vs azure,
+    cloud comparison,
+    cloud platforms,
+    IaaS,
+    cloud computing,
+    cloud services,
+    cloud infrastructure,
+  ]
 ---
 
-Cloud computing has transformed business operations, providing unprecedented flexibility, scalability, and innovation. Among the leading cloud platforms, Amazon Web Services (AWS), Google Cloud Platform (GCP), and Microsoft Azure stand out for their extensive service offerings. Choosing the right platform can be challenging, given their unique strengths and capabilities. 
+Cloud computing has transformed business operations, providing unprecedented flexibility, scalability, and innovation. Among the leading cloud platforms, Amazon Web Services (AWS), Google Cloud Platform (GCP), and Microsoft Azure stand out for their extensive service offerings. Choosing the right platform can be challenging, given their unique strengths and capabilities.
 
 This comprehensive guide will help you understand the key differences between AWS, GCP, and Azure, enabling you to make an informed decision that aligns with your organization’s needs and goals.
 
@@ -18,7 +24,7 @@ This comprehensive guide will help you understand the key differences between AW
 
 Cloud computing revolutionizes the way businesses access technology. Instead of managing physical hardware, companies can now tap into a pool of on-demand computing resources like servers, storage, databases, and artificial intelligence tools. Using the cloud, businesses can scale quickly, cut costs, and innovate without the overhead of maintaining their IT infrastructure.
 
-One of the key offerings of cloud -platforms is Infrastructure as a Service (IaaS). This service model lets you rent virtualized computing resources, such as virtual machines, storage, and networking, on a pay-as-you-go basis. With IaaS, companies gain the flexibility to adjust their infrastructure based on current needs, avoiding the long-term commitments and costs associated with physical servers. This capability supports dynamic scaling, enabling businesses to respond efficiently to changing demands. 
+One of the key offerings of cloud -platforms is Infrastructure as a Service (IaaS). This service model lets you rent virtualized computing resources, such as virtual machines, storage, and networking, on a pay-as-you-go basis. With IaaS, companies gain the flexibility to adjust their infrastructure based on current needs, avoiding the long-term commitments and costs associated with physical servers. This capability supports dynamic scaling, enabling businesses to respond efficiently to changing demands.
 
 ### History and Market Share
 
@@ -26,13 +32,21 @@ One of the key offerings of cloud -platforms is Infrastructure as a Service (Iaa
 - Azure: Microsoft introduced Azure in 2010, building on its vast enterprise software ecosystem. It’s now the second-largest cloud platform, holding a 25% share of the market.
 - GCP (Google Cloud Platform): Google entered the cloud arena in 2011, focusing on innovation and data analytics. GCP has grown steadily, capturing around 10% of the market.
 
-<Figure src="/img/comparisons/2024/08/aws-vs-gcp-vs-azure-9eaa89d2-61e9-4308-9751-41d3b0192a37.webp" alt="Market Share of Leading Cloud Service Providers" caption="Market Share of Leading Cloud Service Providers" />
+<Figure
+  src="/img/comparisons/2024/08/aws-vs-gcp-vs-azure-9eaa89d2-61e9-4308-9751-41d3b0192a37.webp"
+  alt="Market Share of Leading Cloud Service Providers"
+  caption="Market Share of Leading Cloud Service Providers"
+/>
 
 ## Comparing AWS, GCP, and Azure: Key Features
 
-<Figure src="/img/comparisons/2024/08/aws-vs-gcp-vs-azure-Untitled_design.webp" alt="AWS, GCP and Azure Logo" caption="AWS, GCP and Azure Logo" />
+<Figure
+  src="/img/comparisons/2024/08/aws-vs-gcp-vs-azure-Untitled_design.webp"
+  alt="AWS, GCP and Azure Logo"
+  caption="AWS, GCP and Azure Logo"
+/>
 
-When choosing a cloud platform, it’s essential to understand the strengths and unique offerings of each provider. Here’s a breakdown of key features across compute services, storage solutions, database offerings, and networking capabilities for AWS, GCP, and Azure. 
+When choosing a cloud platform, it’s essential to understand the strengths and unique offerings of each provider. Here’s a breakdown of key features across compute services, storage solutions, database offerings, and networking capabilities for AWS, GCP, and Azure.
 
 ### Compute Services
 
@@ -40,11 +54,11 @@ When choosing a cloud platform, it’s essential to understand the strengths and
 - GCP Compute Engine: Google takes a different approach with custom machine types, giving you granular control over CPU and memory configurations. This means you can fine-tune your resources to precisely fit your workloads, avoiding over-provisioning and saving costs.
 - Azure Virtual Machines: Azure seamlessly integrates with Microsoft’s extensive product suite, making it an ideal choice for enterprises that rely on Windows Server, SQL Server, and other Microsoft technologies. It’s built for a smooth experience for users already within the Microsoft ecosystem.
 
-| Feature | AWS EC2 | GCP Compute Engine | Azure Virtual Machines |
-| --- | --- | --- | --- |
-| Instance Variety | Extensive array of instances for various workloads | Custom machine types for granular control | Wide range of VMs with seamless Microsoft integration |
-| Customization  | Predefined instance types | Customizable CPU and memory configurations | Predefined VMs with Microsoft software integration |
-| Best For | General-purpose, compute-optimized and memory-intensive tasks. | Precise workload tailoring and cost-efficiency | Microsoft ecosystem users |
+| Feature          | AWS EC2                                                        | GCP Compute Engine                             | Azure Virtual Machines                                |
+| ---------------- | -------------------------------------------------------------- | ---------------------------------------------- | ----------------------------------------------------- |
+| Instance Variety | Extensive array of instances for various workloads             | Custom machine types for granular control      | Wide range of VMs with seamless Microsoft integration |
+| Customization    | Predefined instance types                                      | Customizable CPU and memory configurations     | Predefined VMs with Microsoft software integration    |
+| Best For         | General-purpose, compute-optimized and memory-intensive tasks. | Precise workload tailoring and cost-efficiency | Microsoft ecosystem users                             |
 
 ### Storage Solutions
 
@@ -52,23 +66,23 @@ When choosing a cloud platform, it’s essential to understand the strengths and
 - GCP Cloud Storage: Google Cloud Storage stands out with its strong consistency and geo-redundancy, ensuring that your data is available and secure across multiple regions. It’s particularly well-suited for global applications that demand high availability.
 - Azure Blob Storage: Azure Blob Storage excels when it comes to integrating with other Azure services. It’s optimized for large-scale object storage and is a natural fit for businesses that are already leveraging Azure’s wide array of tools and services.
 
-| Feature | AWS S3 | GCP Cloud Storage | Azure Blob Storage |
-| --- | --- | --- | --- |
-| Durability & Scalability | Unmatched durability and virtually unlimited storage | Strong consistency and geo-redundancy | Optimized for integration with Azure services |
-| Global Availability  | Highly available, robust protection features | Secure data availability across regions | Ideal for large-scale object storage |
-| Best For | Reliable object storage | Global applications requiring high availability | Businesses leveraging Azure’s tools and services |
+| Feature                  | AWS S3                                               | GCP Cloud Storage                               | Azure Blob Storage                               |
+| ------------------------ | ---------------------------------------------------- | ----------------------------------------------- | ------------------------------------------------ |
+| Durability & Scalability | Unmatched durability and virtually unlimited storage | Strong consistency and geo-redundancy           | Optimized for integration with Azure services    |
+| Global Availability      | Highly available, robust protection features         | Secure data availability across regions         | Ideal for large-scale object storage             |
+| Best For                 | Reliable object storage                              | Global applications requiring high availability | Businesses leveraging Azure’s tools and services |
 
 ### Relational Database Offerings
 
 - AWS RDS (Relational Database Service): AWS RDS supports multiple database engines, including MySQL, PostgreSQL, Oracle, and SQL Server, giving you flexibility in choosing the right database for your application. Its managed service takes care of backups, patching, and scaling, so you can focus on your data.
 - GCP Cloud SQL: Google’s Cloud SQL offers high performance and automatic replication, making it a strong choice for applications that need reliable and fast access to relational databases. It’s designed for scalability and ease of management, with built-in redundancy to ensure data availability.
-- Azure SQL Database:  Azure’s SQL Database stands out with intelligent performance recommendations, using AI to optimize your database queries and improve overall efficiency. It’s a fully managed service that integrates smoothly with other Azure tools, making it a powerful option for data-driven applications.
+- Azure SQL Database: Azure’s SQL Database stands out with intelligent performance recommendations, using AI to optimize your database queries and improve overall efficiency. It’s a fully managed service that integrates smoothly with other Azure tools, making it a powerful option for data-driven applications.
 
-| Feature | AWS RDS | GCP Cloud SQL | Azure SQL Database |
-| --- | --- | --- | --- |
-| Supported Engines | MySQL, PostgreSQL, Oracle, SQL Server | High performance with automatic replication | AI-powered performance recommendations |
-| Management | Fully managed, includes backups and scaling | Scalable with built-in redundance | Fully managed, integrates with Azure tools |
-| Best For | Flexibility in database choice | Reliable and fast access to relational databases | Data-driven applications within Azure ecosystem |
+| Feature           | AWS RDS                                     | GCP Cloud SQL                                    | Azure SQL Database                              |
+| ----------------- | ------------------------------------------- | ------------------------------------------------ | ----------------------------------------------- |
+| Supported Engines | MySQL, PostgreSQL, Oracle, SQL Server       | High performance with automatic replication      | AI-powered performance recommendations          |
+| Management        | Fully managed, includes backups and scaling | Scalable with built-in redundance                | Fully managed, integrates with Azure tools      |
+| Best For          | Flexibility in database choice              | Reliable and fast access to relational databases | Data-driven applications within Azure ecosystem |
 
 ### Non-Relational Database Offerings
 
@@ -76,11 +90,11 @@ When choosing a cloud platform, it’s essential to understand the strengths and
 - GCP Firestore & Bigtable: Google offers two key non-relational database services, Firestore for real-time, document-based NoSQL databases and Bigtable for large-scale, low-latency workloads. Firestore excels in mobile and web app development, while Bigtable is designed for massive analytical and operational workloads.
 - Azure Cosmos DB: Azure CosmosDB is a globally distributed, multi-model database service that provides trunked global distribution and horizontal scaling. It supports multiple data models, including document, key-value, graph, and column-family, making it highly versatile for a wide range of applications.
 
-| Feature | AWS DynamoDB | GCP Firestore & Bigtable | Azure Cosmos DB |
-| --- | --- | --- | --- |
-| Data Model | Key-value and document | Firestore: Document-based, Bigtable: Wide-column store | Document, key-value, graph, column-family |
-| Scalability | Seamless scaling with automatic capacity management | Firestore: Automatic scaling; Bigtable: Horizontal scaling for large datasets | Global distribution with automatic horizontal scaling |
-| Best For | Consistent, low-latency applications | Firestore: Mobile/web apps; Bigtable: Analytical/operational workloads | Global apps, real-time data, and analytical processing |
+| Feature     | AWS DynamoDB                                        | GCP Firestore & Bigtable                                                      | Azure Cosmos DB                                        |
+| ----------- | --------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------ |
+| Data Model  | Key-value and document                              | Firestore: Document-based, Bigtable: Wide-column store                        | Document, key-value, graph, column-family              |
+| Scalability | Seamless scaling with automatic capacity management | Firestore: Automatic scaling; Bigtable: Horizontal scaling for large datasets | Global distribution with automatic horizontal scaling  |
+| Best For    | Consistent, low-latency applications                | Firestore: Mobile/web apps; Bigtable: Analytical/operational workloads        | Global apps, real-time data, and analytical processing |
 
 ### Networking Capabilities
 
@@ -88,21 +102,21 @@ When choosing a cloud platform, it’s essential to understand the strengths and
 - GCP VPC (Virtual Private Cloud): Google’s global VPC is designed for simplicity and efficiency, offering seamless management across multiple regions. It’s a strong choice for businesses with a global presence, as it allows for easy scaling and centralized network management.
 - Azure Virtual Network: Azure’s Virtual Network integrates effortlessly with on-premises networks, making it a top choice for hybrid cloud environments. It’s designed to work hand-in-hand with Azure’s other networking and security services, providing a cohesive and secure cloud experience.
 
-| Feature | AWS VPC | GCP VPC | Azure Virtual Network |
-| --- | --- | --- | --- |
-| Customization | Extensive options for network architecture | Simplified management across multiple regions | Seamless integration with on-premises networks |
-| Network Isolation | Robust security for sensitive workloads | Easy scaling and centralized management | Ideal for hybrid cloud environments |
-| Best For | Highly customizable network configurations | Global presence with centralized management | Hybrid cloud setups leveraging Azure services |
+| Feature           | AWS VPC                                    | GCP VPC                                       | Azure Virtual Network                          |
+| ----------------- | ------------------------------------------ | --------------------------------------------- | ---------------------------------------------- |
+| Customization     | Extensive options for network architecture | Simplified management across multiple regions | Seamless integration with on-premises networks |
+| Network Isolation | Robust security for sensitive workloads    | Easy scaling and centralized management       | Ideal for hybrid cloud environments            |
+| Best For          | Highly customizable network configurations | Global presence with centralized management   | Hybrid cloud setups leveraging Azure services  |
 
 ## Pricing Models and Cost Optimization
 
-Understanding the pricing models offered by cloud platforms is crucial for managing costs effectively and maximizing value. Each provider offers a range of options tailored to different usage patterns, along with tools designed to help you monitor and optimize your spending. 
+Understanding the pricing models offered by cloud platforms is crucial for managing costs effectively and maximizing value. Each provider offers a range of options tailored to different usage patterns, along with tools designed to help you monitor and optimize your spending.
 
 ### Cloud platforms provide flexible pricing to match different needs:
 
-1. On-Demand Instances: Pay by the hour with no long-term commitment, ideal for variable workloads. 
+1. On-Demand Instances: Pay by the hour with no long-term commitment, ideal for variable workloads.
 2. Reserved Instances: Save significantly by committing to 1-3 years, perfect for predictable usage.
-3. Spot instances (AWS) preemptible VMs (GCP) / Spot VMs (Azure): Get steep discounts for interruptible tasks, great for cost-conscious projects. 
+3. Spot instances (AWS) preemptible VMs (GCP) / Spot VMs (Azure): Get steep discounts for interruptible tasks, great for cost-conscious projects.
 
 ### Free Tiers:
 
@@ -118,17 +132,17 @@ Understanding the pricing models offered by cloud platforms is crucial for manag
 
 ## Performance and Scalability
 
-The performance and scalability of cloud services are heavily influenced by the infrastructure that supports them. This infrastructure, consisting of regions and availability zones, is essential for ensuring high availability, low latency, and redundancy. 
+The performance and scalability of cloud services are heavily influenced by the infrastructure that supports them. This infrastructure, consisting of regions and availability zones, is essential for ensuring high availability, low latency, and redundancy.
 
 - AWS operates across 26 regions with 84 availability zones, providing a solid foundation for reliable performance.
 - With 29 regions and 88 availability zones, Google Cloud ensures extensive global coverage.
 - Azure leads with over 60 regions and 140 availability zones, offering unparalleled geographical reach.
 
-Each platform also provides advanced auto-scaling and load-balancing services, which dynamically adjust resources based on demand. However, performance can differ depending on specific workloads and use cases. To achieve the best results, it’s advisable to conduct benchmarks tailored to your application’s needs. This approach will help you choose the right cloud provider and configuration for optimal performance and scalability. 
+Each platform also provides advanced auto-scaling and load-balancing services, which dynamically adjust resources based on demand. However, performance can differ depending on specific workloads and use cases. To achieve the best results, it’s advisable to conduct benchmarks tailored to your application’s needs. This approach will help you choose the right cloud provider and configuration for optimal performance and scalability.
 
 ## Security and Compliance
 
-Security is a top priority in cloud computing, and each platform offers robust features to protect your data and applications: 
+Security is a top priority in cloud computing, and each platform offers robust features to protect your data and applications:
 
 - Identity and Access Management (IAM): Control who can access your resources and what they can do with them.
 - Encryption: Data is encrypted both at rest and in transit, ensuring that sensitive information is secure.
@@ -143,7 +157,7 @@ Cloud platforms are tailored to modern development and DevOps practices, offerin
 - Containerization: All platforms offer seamless support for Kubernetes, whether it’s EKS (AWS), GKE (GCP), or AKS (Azure), ensuring scalable and efficient container orchestration.
 - Serverless Computing: Write and deploy code without managing servers using AWS Lambda, GCP Cloud Functions, or Azure Functions, ideal for microservices and event-driven architectures.
 
-Additionally, AI and machine learning services are becoming integral to application development: 
+Additionally, AI and machine learning services are becoming integral to application development:
 
 - AWS SageMaker simplifies the building, training, and deployment of machine learning models.
 - GCP leverages TensorFlow-based AI services for advanced machine learning capabilities.
@@ -162,36 +176,50 @@ Effective monitoring is critical for managing complex cloud environments. [SigNo
 
 ## Migration and Hybrid Cloud Strategies
 
-Migrating workloads to the cloud requires careful planning and the right tools. Each major cloud platform offers solutions to simplify this process: 
+Migrating workloads to the cloud requires careful planning and the right tools. Each major cloud platform offers solutions to simplify this process:
 
 - AWS Migration Hub: It provides centralized tracking of your migration projects.
 - GCP Cloud Migration Center: Streamlines the process of migrating to Google Cloud.
 - Azure Migrate: Comprehensive migration tools for seamless transitions to Azure.
 
-For organizations with existing on-premises infrastructure, hybrid cloud solutions offer the flexibility to integrate and extend their current environment: 
+For organizations with existing on-premises infrastructure, hybrid cloud solutions offer the flexibility to integrate and extend their current environment:
 
 - AWS Outposts: Bring AWS services on-premises for a consistent hybrid experience.
 - GCP Anthos: IT manages hybrid and multi-cloud environments with Kubernetes.
 - Azure Stack: extends Azure services to your data centre for hybrid cloud deployment.
 
-Multi-cloud strategies are increasingly popular, allowing you to mitigate vendor lock-in risks and leverage the uniqueness of each platform to meet diverse business needs. 
+Multi-cloud strategies are increasingly popular, allowing you to mitigate vendor lock-in risks and leverage the uniqueness of each platform to meet diverse business needs.
 
 ## Choosing the Right Cloud Platform
 
-Selecting the most suitable cloud platform requires a comprehensive evaluation of several key factors: 
-
-1. Organizational Needs: Understand your specific business goals, industry requirements, and compliance mandates. 
-2. Technical Requirements: Consider your current technology stack, your teams' expertise, and any existing integrations. 
-3. Scalability: Evaluate how each platform can support your organization’s growth and evolving workloads over time. 
-4. Total Cost of Ownership (TCO): Analyze the long-term costs, including infrastructure, support, and training.  
-
-To make an informed decision, utilize the TCO calculators provided by each cloud provider: 
-
-- <a href="https://calculator.aws/#/" rel="noopener noreferrer nofollow" target="_blank">AWS Pricing Calculator</a>
-- <a href="https://cloud.google.com/products/calculator" rel="noopener noreferrer nofollow" target="_blank">GCP Pricing Calculator</a>
-- <a href="https://azure.microsoft.com/en-us/pricing/calculator/" rel="noopener noreferrer nofollow" target="_blank">Azure Pricing Calculator</a>
-
-By thoroughly assessing these aspects, you can choose the cloud platform that aligns best with your organization’s goals and technical landscape. 
+Selecting the most suitable cloud platform requires a comprehensive evaluation of several key factors:
+
+1. Organizational Needs: Understand your specific business goals, industry requirements, and compliance mandates.
+2. Technical Requirements: Consider your current technology stack, your teams' expertise, and any existing integrations.
+3. Scalability: Evaluate how each platform can support your organization’s growth and evolving workloads over time.
+4. Total Cost of Ownership (TCO): Analyze the long-term costs, including infrastructure, support, and training.
+
+To make an informed decision, utilize the TCO calculators provided by each cloud provider:
+
+- <a href="https://calculator.aws/#/" rel="noopener noreferrer nofollow" target="_blank">
+    AWS Pricing Calculator
+  </a>
+- <a
+    href="https://cloud.google.com/products/calculator"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    GCP Pricing Calculator
+  </a>
+- <a
+    href="https://azure.microsoft.com/en-us/pricing/calculator/"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    Azure Pricing Calculator
+  </a>
+
+By thoroughly assessing these aspects, you can choose the cloud platform that aligns best with your organization’s goals and technical landscape.
 
 ## Key Takeaways
 
@@ -204,23 +232,23 @@ By thoroughly assessing these aspects, you can choose the cloud platform that al
 
 ### What are the main differences between AWS, GCP, and Azure?
 
-AWS offers the broadest range of services and global coverage, making it suitable for various applications and industries. 
+AWS offers the broadest range of services and global coverage, making it suitable for various applications and industries.
 
-Azure provides seamless integration with Microsoft products and strong hybrid cloud capabilities, making it ideal for businesses heavily invested in Microsoft technologies. 
+Azure provides seamless integration with Microsoft products and strong hybrid cloud capabilities, making it ideal for businesses heavily invested in Microsoft technologies.
 
-GCP specializes in data analytics and machine learning, with powerful tools for data-driven insights and advanced AI applications.  
+GCP specializes in data analytics and machine learning, with powerful tools for data-driven insights and advanced AI applications.
 
 ### Which cloud platform is best for startups?
 
-AWS: It is known for its mature ecosystem and extensive resources, which can support rapid scaling and innovation. 
+AWS: It is known for its mature ecosystem and extensive resources, which can support rapid scaling and innovation.
 
-GCP: It is attractive for startups due to its generous free credits and strong focus on data and machine learning services. 
+GCP: It is attractive for startups due to its generous free credits and strong focus on data and machine learning services.
 
-Azure: It offers excellent support for startups already using Microsoft products, with comprehensive tools and services to accelerate development. 
+Azure: It offers excellent support for startups already using Microsoft products, with comprehensive tools and services to accelerate development.
 
 ### How do the pricing models compare between the three platforms?
 
-All platforms use a pay-as-you-go model with options for reserved capacity discounts. GCP offers unique benefits like per-second billing and sustained use discounts, potentially reducing costs for long-running workloads. 
+All platforms use a pay-as-you-go model with options for reserved capacity discounts. GCP offers unique benefits like per-second billing and sustained use discounts, potentially reducing costs for long-running workloads.
 
 ### Can I use multiple cloud platforms in a single project?
 
diff --git a/data/comparisons/azure-alternatives.mdx b/data/comparisons/azure-alternatives.mdx
index bcf1679ca..8ea92c22e 100644
--- a/data/comparisons/azure-alternatives.mdx
+++ b/data/comparisons/azure-alternatives.mdx
@@ -1,46 +1,73 @@
 ---
-
 title: Top 10 Azure Alternatives - Cloud Solutions for 2025
-slug: azure-alternatives
 date: 2025-01-02
 tags: [tools-comparisons]
 authors: [manjunath_irukulla]
 description: Discover the top 10 Azure alternatives for 2024, offering diverse cloud solutions to meet your specific needs. Compare features, pricing, and performance.
-keywords: [azure alternatives, cloud computing, AWS, Google Cloud, IBM Cloud, Oracle Cloud, DigitalOcean, Linode, Vultr, OVHcloud, Scaleway, Hetzner]
-
+keywords:
+  [
+    azure alternatives,
+    cloud computing,
+    AWS,
+    Google Cloud,
+    IBM Cloud,
+    Oracle Cloud,
+    DigitalOcean,
+    Linode,
+    Vultr,
+    OVHcloud,
+    Scaleway,
+    Hetzner,
+  ]
 ---
 
-Choosing the right cloud platform is crucial, and while Microsoft Azure is a top player in the industry, it might not be the perfect fit for every business. Depending on your needs, whether you’re after better pricing, unique features, or improved performance, there are other excellent options out there. 
+Choosing the right cloud platform is crucial, and while Microsoft Azure is a top player in the industry, it might not be the perfect fit for every business. Depending on your needs, whether you’re after better pricing, unique features, or improved performance, there are other excellent options out there.
 
-In this guide, we’ll explore the top 10 Azure alternatives for 2024, giving you a clear picture of what each one brings to the table. This way, you can find the best match for your business and its goals. 
+In this guide, we’ll explore the top 10 Azure alternatives for 2024, giving you a clear picture of what each one brings to the table. This way, you can find the best match for your business and its goals.
 
 ## Understanding Azure and the Need for Alternatives
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-408adc5f-7938-4f04-b794-4654cd8b347f.webp" alt="Microsoft Azure Logo" caption="Microsoft Azure Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-408adc5f-7938-4f04-b794-4654cd8b347f.webp"
+  alt="Microsoft Azure Logo"
+  caption="Microsoft Azure Logo"
+/>
 
-Microsoft Azure is a comprehensive cloud platform offering a wide range of services, making it a popular choice for many businesses. However, Azure may not always be the ideal solution for every organization. 
+Microsoft Azure is a comprehensive cloud platform offering a wide range of services, making it a popular choice for many businesses. However, Azure may not always be the ideal solution for every organization.
 
 Some common challenges with Azure include:
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-image.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-image.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
-1. Unpredictable Costs: Azure’s pricing can be difficult to predict, with various services charged on different metrics such as storage, compute time, and data transfer. This can lead to unexpected costs, especially as usage scales. 
-2. Complicated Pricing Tiers: Many pricing tiers and options can make it challenging for organizations as usage scales. While Azure provides various support plans, the cost of premium support can be high, which might be prohibitive for smaller organizations. 
-3. Diverse Services and Tools: Azure offers a wide range of services, each with its own set of configurations and management requirements. This can be overwhelming for teams that are new to the platform. 
-4. Frequent Updates: Azure’s constant stream of updates and new features is like Windows Update on high - just when you think you’ve got everything running smoothly, there’s another “mandatory” update waiting to keep your IT team on their toes. It requires continuous learning and adaptation by IT teams. 
+1. Unpredictable Costs: Azure’s pricing can be difficult to predict, with various services charged on different metrics such as storage, compute time, and data transfer. This can lead to unexpected costs, especially as usage scales.
+2. Complicated Pricing Tiers: Many pricing tiers and options can make it challenging for organizations as usage scales. While Azure provides various support plans, the cost of premium support can be high, which might be prohibitive for smaller organizations.
+3. Diverse Services and Tools: Azure offers a wide range of services, each with its own set of configurations and management requirements. This can be overwhelming for teams that are new to the platform.
+4. Frequent Updates: Azure’s constant stream of updates and new features is like Windows Update on high - just when you think you’ve got everything running smoothly, there’s another “mandatory” update waiting to keep your IT team on their toes. It requires continuous learning and adaptation by IT teams.
 5. Service Constraints: Some Azure services have limited customization capabilities, making it difficult for organizations with specific needs to fully tailor the platform to their requirements.
-6. Potential Vendor Lock-In: Organizations that heavily integrate Azure-specific tools and services may find it challenging to migrate to other cloud providers in the future, leading to vendor lock-in. Moving workloads to Azure may involve significant re-architecting, which carries risks and requires careful planning. 
+6. Potential Vendor Lock-In: Organizations that heavily integrate Azure-specific tools and services may find it challenging to migrate to other cloud providers in the future, leading to vendor lock-in. Moving workloads to Azure may involve significant re-architecting, which carries risks and requires careful planning.
 7. Performance Issues: Depending on the geographic location and specific services used, some organizations may experience latency or service outages that impact their operations.
 
 ## Top 10 Azure Alternatives for 2024
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-155f0050-17e8-4b68-afca-7f04a8f468f2.webp" alt="Azure Alternatives" caption="Azure Alternatives" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-155f0050-17e8-4b68-afca-7f04a8f468f2.webp"
+  alt="Azure Alternatives"
+  caption="Azure Alternatives"
+/>
 
 ### 1. Amazon Web Services (AWS)
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-Amazon_Web_Services-Logo.wine.webp" alt="Amazon Web Services Logo" caption="Amazon Web Services Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-Amazon_Web_Services-Logo.wine.webp"
+  alt="Amazon Web Services Logo"
+  caption="Amazon Web Services Logo"
+/>
 
-AWS is the leader in the cloud computing market, known for its extensive range of services and unmatched global reach. 
+AWS is the leader in the cloud computing market, known for its extensive range of services and unmatched global reach.
 
 Key Features:
 
@@ -48,31 +75,39 @@ Key Features:
 - Global Infrastructure: AWS operates a vast network of data centres across the globe, ensuring low-latency access and high availability, no matter where your business is located.
 - Innovation as Its Core: AWS constantly evolves, introducing cutting-edge services and features that keep it at the forefront of cloud technology.
 
-Pricing: AWS uses a pay-as-you-go model, where you only pay for what you use. They also offer various discounting options, like Reserved Instances and Savings plans, to help optimize costs. 
+Pricing: AWS uses a pay-as-you-go model, where you only pay for what you use. They also offer various discounting options, like Reserved Instances and Savings plans, to help optimize costs.
 
-Ideal Use Case: AWS is ideal for a wide range of organizations, from large enterprises to agile startups. It’s particularly suited for companies that need a broad array of cloud services and are looking for scalability and global reach. 
+Ideal Use Case: AWS is ideal for a wide range of organizations, from large enterprises to agile startups. It’s particularly suited for companies that need a broad array of cloud services and are looking for scalability and global reach.
 
 ### 2. Google Cloud Platform (GCP)
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-e09ca85b-c82b-42a7-9b0d-47741a01cb06.webp" alt="Google Cloud Platform Logo" caption="Google Cloud Platform Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-e09ca85b-c82b-42a7-9b0d-47741a01cb06.webp"
+  alt="Google Cloud Platform Logo"
+  caption="Google Cloud Platform Logo"
+/>
 
 Google Cloud Platform provides an extensive range of cloud services at affordable prices, making it typically more cost-effective than Azure, particularly for specific workloads. GCP harnesses Google’s innovative technology and extensive global network.
 
-Key Features: 
+Key Features:
 
 - Advanced-Data Analytics and Machine Learning Tools: Offers powerful tools like BigQuery for data analytics and TensorFlow for machine learning.
 - Robust Networking Capabilities: Utilizes Google’s global network infrastructure to provide high-speed, reliable connectivity.
 - Seamless Integration with Google Workspace: Integrates effortlessly with Google Workspace (formerly G Suite), enhancing productivity and collaboration.
 
-Pricing: Competitive pricing with options for sustained use discounts, and a pay-as-you-go model that helps manage costs effectively. 
+Pricing: Competitive pricing with options for sustained use discounts, and a pay-as-you-go model that helps manage costs effectively.
 
-Ideal Use Case: Organizations focused on data analytics and machine learning, and those already utilizing Google’s suite of productivity tools 
+Ideal Use Case: Organizations focused on data analytics and machine learning, and those already utilizing Google’s suite of productivity tools
 
 ### 3. IBM Cloud
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-IBM_Cloud_Logo.webp" alt="IBM Cloud Logo" caption="IBM Cloud Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-IBM_Cloud_Logo.webp"
+  alt="IBM Cloud Logo"
+  caption="IBM Cloud Logo"
+/>
 
-IBM Cloud specializes in hybrid and multi-cloud environments, offering robust solutions for complex enterprise needs. 
+IBM Cloud specializes in hybrid and multi-cloud environments, offering robust solutions for complex enterprise needs.
 
 Key Features:
 
@@ -80,13 +115,17 @@ Key Features:
 - Advanced AI and quantum computing offerings: Leverages IBM Watson for AI-driven insights and IBM Q for exploring quantum computing.
 - Industry-specific cloud solutions: IBM provides tailored solutions like IBM Cloud for Financial Services and IBM Cloud for Healthcare to meet regulatory and operational needs.
 
-Pricing: Offers flexible pricing options, allowing businesses to choose from public, private, or hybrid cloud setups, with tools like IBM Cloud Pak for easy management across environments.  
+Pricing: Offers flexible pricing options, allowing businesses to choose from public, private, or hybrid cloud setups, with tools like IBM Cloud Pak for easy management across environments.
 
-Ideal Use Case: Enterprises with complex infrastructure needs, such as those requiring hybrid cloud setups, or those in industries with specific regulatory or operational requirements. 
+Ideal Use Case: Enterprises with complex infrastructure needs, such as those requiring hybrid cloud setups, or those in industries with specific regulatory or operational requirements.
 
 ### 4. Oracle Cloud Infrastructure (OCI)
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-52d1c4c3-1f68-4e36-9edd-ac26f0db8c80.webp" alt="Oracle Cloud Infrastructure Logo" caption="Oracle Cloud Infrastructure Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-52d1c4c3-1f68-4e36-9edd-ac26f0db8c80.webp"
+  alt="Oracle Cloud Infrastructure Logo"
+  caption="Oracle Cloud Infrastructure Logo"
+/>
 
 OCI focuses on high-performance computing and seamless Oracle database integration, making it a strong choice for businesses reliant on Oracle technologies.
 
@@ -96,15 +135,19 @@ Key Features:
 - Bare Metal and GPU Instances: Provides high-performance computing with Oracle Bare Metal Servers and NVIDIA GPU instances, ideal for demanding workloads such as AI, machine learning, and big data analytics.
 - Advanced Security Features: Offers comprehensive security through Oracle Cloud Guard and Oracle Data Sage, ensuring robust protection for your data and applications.
 
-Pricing: OCI offers competitive pricing with flexible options, including Bring-Your-Own-License which allows you to use existing Oracle licenses on the cloud, reducing costs. 
+Pricing: OCI offers competitive pricing with flexible options, including Bring-Your-Own-License which allows you to use existing Oracle licenses on the cloud, reducing costs.
 
-Ideal Use Case: Organizations heavily invested in Oracle technologies, particularly those requiring high-performance computing, advanced database capabilities, and robust security features. 
+Ideal Use Case: Organizations heavily invested in Oracle technologies, particularly those requiring high-performance computing, advanced database capabilities, and robust security features.
 
 ### 5. DigitalOcean
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-a7436aa3-8e7c-4ba0-a71e-cd3e4f11db45.webp" alt="Digital Ocean Logo" caption="Digital Ocean Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-a7436aa3-8e7c-4ba0-a71e-cd3e4f11db45.webp"
+  alt="Digital Ocean Logo"
+  caption="Digital Ocean Logo"
+/>
 
-DigitalOcean is designed with developers in mind, offering simplicity, ease of use, and transparent pricing. 
+DigitalOcean is designed with developers in mind, offering simplicity, ease of use, and transparent pricing.
 
 Key Features:
 
@@ -112,15 +155,19 @@ Key Features:
 - Managed Kubernetes: The DigitalOcean Kubernetes (DOKS) service offers a managed Kubernetes environment, allowing developers to deploy, manage, and scale containerized applications without complexity.
 - App Platform For Easy Deployments: The DigitalOcean App Platform enables developers to build, deploy, and scale applications with minimal setup, supporting popular languages and frameworks like Node.js, Python and Ruby.
 
-Pricing: Offers simple, predictable pricing with options for hourly billing, ensuring that developers know exactly what they’ll pay, with no hidden fees. 
+Pricing: Offers simple, predictable pricing with options for hourly billing, ensuring that developers know exactly what they’ll pay, with no hidden fees.
 
-Ideal Use Case: Perfect for startups, individual developers, and small to medium-sized businesses looking for a straightforward cloud platform with essential features and clear pricing. 
+Ideal Use Case: Perfect for startups, individual developers, and small to medium-sized businesses looking for a straightforward cloud platform with essential features and clear pricing.
 
 ### 6. Linode
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-Linode-Logo-2012-v1-LightBG.webp" alt="Linode Cloud Logo" caption="Linode Cloud Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-Linode-Logo-2012-v1-LightBG.webp"
+  alt="Linode Cloud Logo"
+  caption="Linode Cloud Logo"
+/>
 
-Linode specializes in high-performance computing and developer-friendly tools, making it a popular choice for developers and those with compute-intensive needs. 
+Linode specializes in high-performance computing and developer-friendly tools, making it a popular choice for developers and those with compute-intensive needs.
 
 Key features:
 
@@ -128,31 +175,39 @@ Key features:
 - GPU Instances: Linode offers GPU instances optimized for tasks like machine learning, AI, and video processing, providing the power needed for resource-intensive applications.
 - Object Storage: It allows developers to store and manage unstructured data, such as images, videos, and backups, with easy scalability and accessibility.
 
-Pricing: Linode is known for its transparent, competitive rates, with a straightforward hourly billing model that ensures cost predictability.  
+Pricing: Linode is known for its transparent, competitive rates, with a straightforward hourly billing model that ensures cost predictability.
 
-Ideal Use Case: Ideal for compute-intensive applications and developers who prioritize simplicity, and businesses seeking high-performance infrastructure without the complexity. 
+Ideal Use Case: Ideal for compute-intensive applications and developers who prioritize simplicity, and businesses seeking high-performance infrastructure without the complexity.
 
 ### 7. Vultr
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-56827d6e-eb57-4e8f-8973-7e57cae6d10e.webp" alt="Vultr Logo" caption="Vultr Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-56827d6e-eb57-4e8f-8973-7e57cae6d10e.webp"
+  alt="Vultr Logo"
+  caption="Vultr Logo"
+/>
 
-Vultr provides a global network of data centers with customizable cloud solutions, catering to a wide range of performance needs. 
+Vultr provides a global network of data centers with customizable cloud solutions, catering to a wide range of performance needs.
 
 Unique offerings:
 
 - Bare Metal Servers: Vultr’s Bare Metal instances deliver dedicated server performance, ideal for high-intensity workloads without the overhead of virtualization.
-- Cloud GPU Instances: Vultr offers cloud GPU instances designed for tasks like deep learning, AI  and graphics rendering, providing the computational power necessary for demanding applications.
+- Cloud GPU Instances: Vultr offers cloud GPU instances designed for tasks like deep learning, AI and graphics rendering, providing the computational power necessary for demanding applications.
 - Block Storage: Vultr Block Storage allows for scalable and persistent storage that can be attached to any compute instance, ensuring flexibility and reliability for your data needs.
 
-Pricing: Features straightforward hourly billing with competitive rates, offering cost-effective options for various cloud services. 
+Pricing: Features straightforward hourly billing with competitive rates, offering cost-effective options for various cloud services.
 
-Ideal Use Case: Best suited for global applications that require low-latency, high-performance computing, and businesses needing customizable cloud solutions across a geographically distributed infrastructure. 
+Ideal Use Case: Best suited for global applications that require low-latency, high-performance computing, and businesses needing customizable cloud solutions across a geographically distributed infrastructure.
 
 ### 8. OVHcloud
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-5aa186b2-9908-4969-8300-5ae2296d41d2.webp" alt="OVHcloud Logo" caption="OVHcloud Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-5aa186b2-9908-4969-8300-5ae2296d41d2.webp"
+  alt="OVHcloud Logo"
+  caption="OVHcloud Logo"
+/>
 
-OVHcloud provides European-based cloud services with a focus on data sovereignty and privacy, making it a strong choice for organizations with strict data protection requirements. 
+OVHcloud provides European-based cloud services with a focus on data sovereignty and privacy, making it a strong choice for organizations with strict data protection requirements.
 
 Key features:
 
@@ -160,13 +215,17 @@ Key features:
 - Bare Metal Servers: OVHCloud offers Bare Metal Servers for high-performance computing, providing dedicated resources for workloads, that require maximum processing power and security.
 - OpenStack-Based Public Cloud: OVHCloud’s OpenStack-based public cloud allows for scalable flexible cloud environments that are fully open-source, giving users more control over their infrastructure.
 
-Pricing: OVHCloud provides competitive rates with a predictable billing structure, making it easier for businesses to manage costs. 
+Pricing: OVHCloud provides competitive rates with a predictable billing structure, making it easier for businesses to manage costs.
 
-Best for: Ideal for organizations that prioritize data privacy, especially those requiring European hosting to comply with GDPR or other data protection regulations. 
+Best for: Ideal for organizations that prioritize data privacy, especially those requiring European hosting to comply with GDPR or other data protection regulations.
 
 ### 9. Scaleway
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-1757ac98-7f1e-45ef-9d05-4d4ced32298f.webp" alt="Scaleway Logo" caption="Scaleway Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-1757ac98-7f1e-45ef-9d05-4d4ced32298f.webp"
+  alt="Scaleway Logo"
+  caption="Scaleway Logo"
+/>
 
 Scaleway is known for its innovative hardware solutions and commitment to eco-friendly cloud services, making it a popular choice for businesses focused on sustainability.
 
@@ -176,15 +235,19 @@ Key Features:
 - Kubernetes Kapsule: The kubernetes kapsule service allows for easy deployment and management of containerized applications offering a fully managed Kubernetes experience.
 - Serverless Containers: Scaleway’s serverless containers enable developers to run containers without managing the underlying infrastructure, simplifying the deployment of scalable applications.
 
-Pricing: Scaleway offers competitive rates with a particular focus on the European market, making it an attractive option for businesses looking for cost-effective cloud solutions. 
+Pricing: Scaleway offers competitive rates with a particular focus on the European market, making it an attractive option for businesses looking for cost-effective cloud solutions.
 
-Ideal for: Startups and businesses seeking cost-effective, eco-friendly cloud solutions that align with sustainability goals. 
+Ideal for: Startups and businesses seeking cost-effective, eco-friendly cloud solutions that align with sustainability goals.
 
 ### 10. Hetzner
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-image%201.webp" alt="Hetzner Cloud Logo" caption="Hetzner Cloud Logo" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-image%201.webp"
+  alt="Hetzner Cloud Logo"
+  caption="Hetzner Cloud Logo"
+/>
 
-Hetzner provides budget-friendly dedicated and cloud solutions, offering excellent value for cost-conscious businesses and developers. 
+Hetzner provides budget-friendly dedicated and cloud solutions, offering excellent value for cost-conscious businesses and developers.
 
 Key Features:
 
@@ -192,28 +255,28 @@ Key Features:
 - Dedicated Servers and Cloud Instances: Offers dedicated servers for robust performance and cloud instances for scalable, flexible computing environments, catering to various needs from basic hosting to complex applications.
 - Data Centres in Germany and Finland: Operates data centres in Germany and Finland, providing reliable and geographically diverse options for hosting and data management.
 
-Pricing: Known for some of the most competitive rates in the industry, making it an attractive choice for those seeking high value at lower costs. 
+Pricing: Known for some of the most competitive rates in the industry, making it an attractive choice for those seeking high value at lower costs.
 
 Best suited for Ideal for cost-conscious businesses and developers who need reliable and affordable dedicated or cloud infrastructure solutions.
 
-Tabular comparison of all Azure Alternatives 
-
-| Cloud Provider | Key Features | Pricing Model | Ideal For |
-| --- | --- | --- | --- |
-| Azure | Extensive range of services, AI/ML DevOps integration, and strong enterprise support | Pay-as-you-go, Reserved Instances, and hybrid options | Enterprises needing a broad suite of services and tools |
-| AWS | Largest service portfolio (200+), global infrastructure, strong focus on innovation | Pay-as-you-go, Reserved Instances, Savings Plans | Large enterprises, startups, diverse cloud needs |
-| IBM Cloud | Hybrid and multi-cloud focus, AI/quantum computing, legacy system support | Flexible pricing for public, private, and hybrid setups | Enterprises with complex infrastructure needs |
-| Oracle Cloud | Optimize for Oracle workloads, bare metal and GPU instances, and advanced security. | Competitive rates, bring-your-own-license options | Organizations using Oracle technologies extensively |
-| DigitalOcean | Simple VMs (Droplets), Managed Kubernetes, App Platform | Simple, predictable pricing with hourly billing | Startups, individual developers, SBMs |
-| Linode | High-performance computing, developer-friendly tools, GPU instances | Transparent, competitive rates with hourly billing | Compute-intensive applications, simplicity-seeking developers |
-| Vultr | Global data centers, customizable solutions, and bare metal servers | Hourly billing, competitive rates | Global apps requiring low-latency, high-performance computing |
-| OVHCloud | GDPR-compliant, European data centers, OpenStack-based cloud | Competitive rates, predictable billing | Organizations prioritising data privacy, European hosting |
-| Scaleway | Innovative hardware, eco-friendly services, Arm-based instances | Competitive rates, European market focus | Startups, businesses seeking green cloud solutions |
-| Hetzner | Budget-friendly dedicated servers, cloud instances, German/Finland data centers | Industry’s most competitive rates | Cost-conscious businesses and developers |
+Tabular comparison of all Azure Alternatives
+
+| Cloud Provider | Key Features                                                                         | Pricing Model                                           | Ideal For                                                     |
+| -------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------------------------------- |
+| Azure          | Extensive range of services, AI/ML DevOps integration, and strong enterprise support | Pay-as-you-go, Reserved Instances, and hybrid options   | Enterprises needing a broad suite of services and tools       |
+| AWS            | Largest service portfolio (200+), global infrastructure, strong focus on innovation  | Pay-as-you-go, Reserved Instances, Savings Plans        | Large enterprises, startups, diverse cloud needs              |
+| IBM Cloud      | Hybrid and multi-cloud focus, AI/quantum computing, legacy system support            | Flexible pricing for public, private, and hybrid setups | Enterprises with complex infrastructure needs                 |
+| Oracle Cloud   | Optimize for Oracle workloads, bare metal and GPU instances, and advanced security.  | Competitive rates, bring-your-own-license options       | Organizations using Oracle technologies extensively           |
+| DigitalOcean   | Simple VMs (Droplets), Managed Kubernetes, App Platform                              | Simple, predictable pricing with hourly billing         | Startups, individual developers, SBMs                         |
+| Linode         | High-performance computing, developer-friendly tools, GPU instances                  | Transparent, competitive rates with hourly billing      | Compute-intensive applications, simplicity-seeking developers |
+| Vultr          | Global data centers, customizable solutions, and bare metal servers                  | Hourly billing, competitive rates                       | Global apps requiring low-latency, high-performance computing |
+| OVHCloud       | GDPR-compliant, European data centers, OpenStack-based cloud                         | Competitive rates, predictable billing                  | Organizations prioritising data privacy, European hosting     |
+| Scaleway       | Innovative hardware, eco-friendly services, Arm-based instances                      | Competitive rates, European market focus                | Startups, businesses seeking green cloud solutions            |
+| Hetzner        | Budget-friendly dedicated servers, cloud instances, German/Finland data centers      | Industry’s most competitive rates                       | Cost-conscious businesses and developers                      |
 
 ## Comparing Azure Alternatives: What to Look For
 
-Choosing the right cloud provider isn’t just about picking the cheapest option - it’s about finding the one that fits your specific needs. Here’s a quick guide to help you make the right choice: 
+Choosing the right cloud provider isn’t just about picking the cheapest option - it’s about finding the one that fits your specific needs. Here’s a quick guide to help you make the right choice:
 
 ### Performance: Does It Deliver the Speed You Need?
 
@@ -246,13 +309,17 @@ Migrating from Azure to another cloud provider requires meticulous planning and
 
 ### Best Practices:
 
-1. Assess Your Current Environment: Thoroughly document all Azure resources, services, and dependencies to understand what needs to be migrated. 
-2. Plan Your Migration Strategy: Choose the right approach, whether it’s a lift-and-shift (rehosting) or re-architecting applications for the new platform. 
-3. Test Compatibility: Validate that your applications and workloads are compatible with the new cloud provider by conducting thorough testing before the full migration. 
-4. Data Transfer: Utilize reliable tools and methods for secure and efficient data transfer, ensuring data integrity throughout the process. 
-5. Avoid Downtime: Implement a phased migration approach to minimise service disruptions and ensure continuous availability during the transition. 
+1. Assess Your Current Environment: Thoroughly document all Azure resources, services, and dependencies to understand what needs to be migrated.
+2. Plan Your Migration Strategy: Choose the right approach, whether it’s a lift-and-shift (rehosting) or re-architecting applications for the new platform.
+3. Test Compatibility: Validate that your applications and workloads are compatible with the new cloud provider by conducting thorough testing before the full migration.
+4. Data Transfer: Utilize reliable tools and methods for secure and efficient data transfer, ensuring data integrity throughout the process.
+5. Avoid Downtime: Implement a phased migration approach to minimise service disruptions and ensure continuous availability during the transition.
 
-<Figure src="/img/comparisons/2024/08/azure-alternatives-migration-best-practices.webp" alt="Migrating from Azure: Best Practices" caption="Migrating from Azure: Best Practices" />
+<Figure
+  src="/img/comparisons/2024/08/azure-alternatives-migration-best-practices.webp"
+  alt="Migrating from Azure: Best Practices"
+  caption="Migrating from Azure: Best Practices"
+/>
 
 ### Common Challenges:
 
@@ -262,7 +329,7 @@ Migrating from Azure to another cloud provider requires meticulous planning and
 
 ## Monitoring and Optimizing Your New Cloud Environment with SigNoz
 
-Once you’ve migrated to an Azure alternative, effective monitoring is key to maintaining and optimizing performance. That’s where SigNoz comes in a powerful, cloud-agnostic observability platform that gives you the insights you need to keep your systems running at their best. 
+Once you’ve migrated to an Azure alternative, effective monitoring is key to maintaining and optimizing performance. That’s where SigNoz comes in a powerful, cloud-agnostic observability platform that gives you the insights you need to keep your systems running at their best.
 
 ### Key Monitoring Features:
 
@@ -273,7 +340,7 @@ Once you’ve migrated to an Azure alternative, effective monitoring is key to m
 
 ### How does SigNoz Optimize Your Cloud?
 
-Once you have visibility into your cloud environment, SigNoz helps you take action: 
+Once you have visibility into your cloud environment, SigNoz helps you take action:
 
 - Identify Bottlenecks: Find the slow parts of your applications and optimize them to improve performance.
 - Track Resource Usage: Monitor how much CPU, memory, and bandwidth your services are consuming. Avoid overprovisioning and save costs.
@@ -284,31 +351,31 @@ Once you have visibility into your cloud environment, SigNoz helps you take acti
 
 Integrating SigNoz into your cloud environment is straightforward:
 
-<GetStartedSigNoz/>
+<GetStartedSigNoz />
 
-1. After the installation, configure your applications to send data to SigNoz. 
-2. Start monitoring your system with custom dashboards tailored to your needs.  
+1. After the installation, configure your applications to send data to SigNoz.
+2. Start monitoring your system with custom dashboards tailored to your needs.
 
 ## Key Takeaways
 
-1. Explore Alternatives: Azure alternatives provide a wide range of solutions tailored to various needs and budgets, offering flexibility and customization. 
-2. Evaluate Wisely: When selecting a cloud provider, consider factors like performance, cost, scalability, and features to ensure the best fit for your organization. 
-3. Thorough Migration Planning: A well-planned migration strategy is crucial to avoid common pitfalls, such as service disruptions and unexpected costs. 
-4. Optimize with Monitoring: Implement comprehensive monitoring tools like SigNoz to enhance performance and optimize your cloud environment post-migration. 
+1. Explore Alternatives: Azure alternatives provide a wide range of solutions tailored to various needs and budgets, offering flexibility and customization.
+2. Evaluate Wisely: When selecting a cloud provider, consider factors like performance, cost, scalability, and features to ensure the best fit for your organization.
+3. Thorough Migration Planning: A well-planned migration strategy is crucial to avoid common pitfalls, such as service disruptions and unexpected costs.
+4. Optimize with Monitoring: Implement comprehensive monitoring tools like SigNoz to enhance performance and optimize your cloud environment post-migration.
 
 ## FAQs
 
 ### What are the main reasons to consider Azure alternatives?
 
-Organizations explore Azure alternatives for reasons such as cost savings, better performance for specific workloads, enhanced data privacy, or access to unique features that Azure may not offer. 
+Organizations explore Azure alternatives for reasons such as cost savings, better performance for specific workloads, enhanced data privacy, or access to unique features that Azure may not offer.
 
 ### How do Azure alternatives stack up in terms of pricing?
 
-Pricing varies significantly among providers, Budget-friendly options like Hetzner and Vultr offer low-cost services, while AWS and GCP are more competitive for large-scale enterprise needs. It’s different providers, which reduces the risk of vendor lock-in. However, this strategy requires careful management and can add complexity. 
+Pricing varies significantly among providers, Budget-friendly options like Hetzner and Vultr offer low-cost services, while AWS and GCP are more competitive for large-scale enterprise needs. It’s different providers, which reduces the risk of vendor lock-in. However, this strategy requires careful management and can add complexity.
 
 ### Is it possible to use multiple cloud providers at the same time?
 
-Yes, many organizations implement a multi-cloud strategy to capitalize on the strengths of different providers and reduce the risk of vendor lock-in. However, this strategy requires careful management and can add complexity. 
+Yes, many organizations implement a multi-cloud strategy to capitalize on the strengths of different providers and reduce the risk of vendor lock-in. However, this strategy requires careful management and can add complexity.
 
 ### What are the key challenges when migrating away from Azure?
 
diff --git a/data/comparisons/best-frontend-cloud-logging-tools.mdx b/data/comparisons/best-frontend-cloud-logging-tools.mdx
index e2966b87c..9823c49d4 100644
--- a/data/comparisons/best-frontend-cloud-logging-tools.mdx
+++ b/data/comparisons/best-frontend-cloud-logging-tools.mdx
@@ -1,20 +1,28 @@
 ---
-title: "Best Frontend Cloud Logging Tools: Top 6 Compared [2025]"
-slug: "best-frontend-cloud-logging-tools"
-date: "2025-09-01"
+title: 'Best Frontend Cloud Logging Tools: Top 6 Compared [2025]'
+date: '2025-09-01'
 tags: [logging, javascript]
-authors: ["yuvraj"]
-description: "Best frontend cloud logging tools in 2025. We tested Sentry, LogRocket, Datadog, New Relic, Grafana, and SigNoz for setup, performance, privacy, and pricing."
-keywords: [best frontend cloud logging tool, frontend logging tools, javascript error tracking, web application monitoring, cloud logging solutions, frontend error monitoring tools, browser logging services]
+authors: ['yuvraj']
+description: 'Best frontend cloud logging tools in 2025. We tested Sentry, LogRocket, Datadog, New Relic, Grafana, and SigNoz for setup, performance, privacy, and pricing.'
+keywords:
+  [
+    best frontend cloud logging tool,
+    frontend logging tools,
+    javascript error tracking,
+    web application monitoring,
+    cloud logging solutions,
+    frontend error monitoring tools,
+    browser logging services,
+  ]
 ---
 
 You're sitting at your desk when Slack explodes with messages. Production is down. Users are reporting a critical error that only happens for 1% of users, only on Safari, only when they're using dark mode on mobile devices. Your backend logs show nothing. The error is somewhere in your 500KB minified JavaScript bundle, and you have exactly zero visibility into what's happening.
 
-Sound familiar? 
+Sound familiar?
 
 If you've ever tried debugging production JavaScript errors with just console.log and user screenshots, you know the pain. Modern web applications run complex code across thousands of different browser environments, device types, and network conditions. When something breaks, finding the root cause without proper frontend logging is like performing surgery in the dark.
 
-The good news? Frontend logging tools have evolved far beyond simple error catchers. 
+The good news? Frontend logging tools have evolved far beyond simple error catchers.
 In this guide, we've tested and analyzed 6 leading frontend logging tools with real NextJS applications. Whether you're a startup watching every dollar or an enterprise needing bulletproof observability, you'll find exactly what you need to make an informed decision.
 
 ## How We Evaluated These Tools
@@ -29,7 +37,11 @@ Before diving into the tools, let's be transparent about our testing methodology
 
 If GitHub stars determined logging tools, Sentry would win by a landslide. With over 40,000 stars and a massive community, Sentry has become the de facto standard for error tracking among developers.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-sentry-dashboard.webp" alt="Sentry dashboard showing an example error page." caption="Sentry dashboard showing an example error page." />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-sentry-dashboard.webp"
+  alt="Sentry dashboard showing an example error page."
+  caption="Sentry dashboard showing an example error page."
+/>
 
 **What Makes Sentry Stand Out:**
 
@@ -42,12 +54,13 @@ The session replay feature, while newer than competitors, integrates seamlessly
 Setting up Sentry took just 8 minutes from signup to first error captured. The wizard automatically detected our NextJS project and provided copy-paste configuration. Within minutes, we had errors flowing in with full stack traces and logs.
 
 This is how the key implemenation part of sentry looks like:
+
 ```javascript
 // NextJS implementation with Sentry
-import * as Sentry from "@sentry/nextjs";
+import * as Sentry from '@sentry/nextjs'
 
 Sentry.init({
-  dsn: "YOUR_DSN_HERE",
+  dsn: 'YOUR_DSN_HERE',
   tracesSampleRate: 1.0,
   replaysSessionSampleRate: 0.1,
   replaysOnErrorSampleRate: 1.0,
@@ -57,12 +70,17 @@ Sentry.init({
       blockAllMedia: true,
     }),
   ],
-});
+})
 ```
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-sentry-error-details.webp" alt="Sentry logs dashboard showing errors coming from Chrome browser." caption="Sentry logs dashboard showing errors coming from Chrome browser." />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-sentry-error-details.webp"
+  alt="Sentry logs dashboard showing errors coming from Chrome browser."
+  caption="Sentry logs dashboard showing errors coming from Chrome browser."
+/>
 
 **Pros:**
+
 - Generous free tier (50,000 errors/month, 50 replays)
 - Excellent developer experience with 100+ SDK integrations
 - Strong open-source community and self-hosted option
@@ -70,12 +88,14 @@ Sentry.init({
 - New native logging features (Sentry.logger API)
 
 **Cons:**
+
 - Complex pricing at scale (multiple meters for errors, replays, performance)
 - Can be overwhelming for simple logging needs
 - Session replay still maturing compared to specialized tools
 - Performance monitoring adds significant bundle size
 
 **Pricing Reality Check:**
+
 - **1K users**: Free tier covers most needs
 - **10K users**: ~$29-79/month depending on error volume
 - **100K users**: $200-500+/month with performance monitoring
@@ -84,7 +104,11 @@ Sentry.init({
 
 LogRocket takes a different approach: instead of just logging errors, it records everything. Think of it as having a screen recorder for every user session, but with developer tools attached.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-logrocket-session-replay.webp" alt="LogRocket error details and alert channel illustration." caption="LogRocket error details and alert channel illustration. (Credits: LogRocket)" />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-logrocket-session-replay.webp"
+  alt="LogRocket error details and alert channel illustration."
+  caption="LogRocket error details and alert channel illustration. (Credits: LogRocket)"
+/>
 
 **What Makes LogRocket Stand Out:**
 
@@ -95,31 +119,33 @@ LogRocket's session replay is unmatched in detail. It captures the full DOM, Red
 LogRocket's default installation captures everything, which felt invasive initially. We spent considerable time configuring privacy settings to redact sensitive data. The Redux integration was seamless, allowing us to see state changes alongside user actions.
 
 This is how the key implementation part of LogRocket looks like:
+
 ```javascript
 // LogRocket implementation
-import LogRocket from 'logrocket';
+import LogRocket from 'logrocket'
 
 LogRocket.init('YOUR_APP_ID', {
   console: {
-    shouldAggregateConsoleErrors: true
+    shouldAggregateConsoleErrors: true,
   },
   network: {
-    requestSanitizer: request => {
+    requestSanitizer: (request) => {
       // Redact sensitive headers
       if (request.headers['Authorization']) {
-        request.headers['Authorization'] = '[REDACTED]';
+        request.headers['Authorization'] = '[REDACTED]'
       }
-      return request;
-    }
-  }
-});
+      return request
+    },
+  },
+})
 
 // Redux integration
-import setupLogRocketReact from 'logrocket-react';
-setupLogRocketReact(LogRocket);
+import setupLogRocketReact from 'logrocket-react'
+setupLogRocketReact(LogRocket)
 ```
 
 **Pros:**
+
 - Unparalleled debugging context with full session replay
 - Excellent Redux/Vuex state inspection
 - Product analytics features included
@@ -127,6 +153,7 @@ setupLogRocketReact(LogRocket);
 - Easy integration with other tools
 
 **Cons:**
+
 - Expensive at scale ($69/month minimum for paid plans)
 - Privacy concerns with default "capture everything" approach
 - Larger performance impact on bundle size
@@ -134,6 +161,7 @@ setupLogRocketReact(LogRocket);
 - Limited to 1,000 sessions on free plan
 
 **Pricing Reality Check:**
+
 - **1K users**: Free tier (1,000 sessions)
 - **10K users**: $69-299/month
 - **100K users**: $500-2000+/month depending on session volume
@@ -142,7 +170,11 @@ setupLogRocketReact(LogRocket);
 
 When your frontend logs need to talk to your backend traces, Datadog Real User Monitoring (RUM) shines. It's part of Datadog's comprehensive observability platform, bridging the gap between frontend and backend monitoring.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-datadog-rum-dashboard.webp" alt="Datadog dashboard showing a sample error." caption="Datadog dashboard showing a sample error." />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-datadog-rum-dashboard.webp"
+  alt="Datadog dashboard showing a sample error."
+  caption="Datadog dashboard showing a sample error."
+/>
 
 **What Makes Datadog Stand Out:**
 
@@ -153,9 +185,10 @@ The killer feature is end-to-end tracing. Click on a frontend error, and you can
 Datadog's setup was straightforward for teams already using Datadog. The integration with backend APM was seamless. However, the pricing calculator was complex, and costs can escalate quickly with high-traffic applications.
 
 This is how the key implementation part of Datadog RUM looks like:
+
 ```javascript
 // Datadog RUM implementation
-import { datadogRum } from '@datadog/browser-rum';
+import { datadogRum } from '@datadog/browser-rum'
 
 datadogRum.init({
   applicationId: 'YOUR_APP_ID',
@@ -169,17 +202,22 @@ datadogRum.init({
   trackUserInteractions: true,
   trackResources: true,
   trackLongTasks: true,
-  defaultPrivacyLevel: 'mask-user-input'
-});
+  defaultPrivacyLevel: 'mask-user-input',
+})
 
 // Capture custom logs
-datadogRum.addLoggerGlobalContext('user_id', userId);
-datadogLogs.logger.info('User action', { action: 'checkout', amount: 99.99 });
+datadogRum.addLoggerGlobalContext('user_id', userId)
+datadogLogs.logger.info('User action', { action: 'checkout', amount: 99.99 })
 ```
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-datadog-pricing.webp" alt="Datadog pricing calculator showing complex multi-tier pricing structure" caption="Datadog pricing calculator showing complex multi-tier pricing structure" />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-datadog-pricing.webp"
+  alt="Datadog pricing calculator showing complex multi-tier pricing structure"
+  caption="Datadog pricing calculator showing complex multi-tier pricing structure"
+/>
 
 **Pros:**
+
 - Complete observability platform beyond just frontend
 - Excellent backend correlation with distributed tracing
 - Flexible usage-based pricing
@@ -187,6 +225,7 @@ datadogLogs.logger.info('User action', { action: 'checkout', amount: 99.99 });
 - Heat maps and user journey visualization
 
 **Cons:**
+
 - Can get expensive quickly at scale
 - Steep learning curve for the full platform
 - Overkill for frontend-only monitoring needs
@@ -201,6 +240,7 @@ Datadog's log management uses a "two-part tariff" that looks inexpensive initial
 - **Index**: \$1.70 per million log events to make them searchable
 
 The problem? You pay twice for the same data. For a modest 200 GB/month (≈100M events):
+
 - Ingest cost: \$20 (200 GB × \$0.10)
 - Indexing cost: \$170 (100M events × \$1.70)
 - **Total: $190/month**
@@ -208,6 +248,7 @@ The problem? You pay twice for the same data. For a modest 200 GB/month (≈100M
 This forces teams to choose between cost and visibility. Many only index 20% of logs to save money, meaning 80% of critical debugging data isn't searchable during incidents when you need it most. [Read more about Datadog's pricing challenges here](https://signoz.io/blog/datadog-pricing/#you-pay-twice-for-log-management).
 
 **Pricing Reality Check:**
+
 - **1K users**: ~$15-30/month with basic RUM
 - **10K users**: \$150-500/month (including log indexing)
 - **100K users**: \$1,500-5,000+/month (varies significantly by log volume)
@@ -216,7 +257,11 @@ This forces teams to choose between cost and visibility. Many only index 20% of
 
 New Relic Browser is part of New Relic's all-in-one monitoring platform. It's the Swiss Army knife of monitoring, now with frontend capabilities that rival specialized tools.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-newrelic-browser.webp" alt="New Relic Dashboard showing browser logs." caption="New Relic Dashboard showing browser logs." />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-newrelic-browser.webp"
+  alt="New Relic Dashboard showing browser logs."
+  caption="New Relic Dashboard showing browser logs."
+/>
 
 **What Makes New Relic Stand Out:**
 
@@ -227,34 +272,36 @@ New Relic's unified platform approach means you get frontend monitoring, backend
 New Relic's browser agent was easy to implement, but the UI feels dated compared to newer tools. The wealth of features can be overwhelming initially, but the documentation is comprehensive. Session replay works well but is an add-on feature.
 
 This is how the key implementation part of New Relic Browser looks like:
+
 ```javascript
 // New Relic Browser implementation
 // Can be added via NPM or script tag
 import { BrowserAgent } from '@newrelic/browser-agent/loaders/browser-agent'
 
 const options = {
-  init: { 
+  init: {
     distributed_tracing: { enabled: true },
     privacy: { cookies_enabled: true },
     ajax: { deny_list: ['bam.nr-data.net'] },
-    session_replay: { enabled: true, mask_all_inputs: true }
+    session_replay: { enabled: true, mask_all_inputs: true },
   },
-  info: { 
+  info: {
     beacon: 'bam.nr-data.net',
     errorBeacon: 'bam.nr-data.net',
     licenseKey: 'YOUR_LICENSE_KEY',
     applicationID: 'YOUR_APP_ID',
   },
-  loader: 'spa'
+  loader: 'spa',
 }
 
 new BrowserAgent(options)
 
 // Manual log capture
-newrelic.log('User completed checkout', {level: 'info'})
+newrelic.log('User completed checkout', { level: 'info' })
 ```
 
 **Pros:**
+
 - Generous free tier (100GB/month)
 - Unified platform for all monitoring needs
 - Excellent documentation and support
@@ -262,12 +309,14 @@ newrelic.log('User completed checkout', {level: 'info'})
 - [Distributed tracing](https://signoz.io/distributed-tracing/) across frontend and backend
 
 **Cons:**
+
 - UI feels dated compared to modern alternatives
 - Can be complex for small teams
 - Session replay is an additional cost
 - Learning curve for the full platform
 
 **Pricing Reality Check:**
+
 - **1K users**: Free tier usually sufficient
 - **10K users**: Free to $99/month depending on data volume
 - **100K users**: $200-500+/month with additional user seats
@@ -276,7 +325,11 @@ newrelic.log('User completed checkout', {level: 'info'})
 
 Grafana's Frontend Observability brings the power of Grafana's visualization to frontend monitoring, with a focus on open standards and flexibility.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-grafana-dashboard.webp" alt="Sample Grafana dashboard showing logs." caption="Sample Grafana dashboard showing logs." />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-grafana-dashboard.webp"
+  alt="Sample Grafana dashboard showing logs."
+  caption="Sample Grafana dashboard showing logs."
+/>
 
 **What Makes Grafana Stand Out:**
 
@@ -287,16 +340,17 @@ Grafana's strength lies in its incredible visualization capabilities and open ar
 Grafana's setup requires more technical knowledge than other tools. You need to understand Grafana's ecosystem, but once configured, the flexibility is unmatched. The ability to correlate frontend data with infrastructure metrics in custom dashboards is powerful.
 
 This is how the key implementation part of Grafana Faro looks like:
+
 ```javascript
 // Grafana Faro implementation
-import { initializeFaro } from '@grafana/faro-web-sdk';
+import { initializeFaro } from '@grafana/faro-web-sdk'
 
 const faro = initializeFaro({
   url: 'https://collector-endpoint/collect/{app-key}',
   app: {
     name: 'my-app',
     version: '1.0.0',
-    environment: 'production'
+    environment: 'production',
   },
   instrumentations: [
     // Automatically included: console, errors, web-vitals, session
@@ -304,18 +358,19 @@ const faro = initializeFaro({
   consoleInstrumentation: {
     consoleErrorAsLog: true,
     // Disable noisy log levels
-    captureConsoleDisabledLevels: ['debug', 'trace']
-  }
-});
+    captureConsoleDisabledLevels: ['debug', 'trace'],
+  },
+})
 
 // Custom logging
 faro.api.pushLog(['User action'], {
   level: 'info',
-  context: { userId: '123', action: 'checkout' }
-});
+  context: { userId: '123', action: 'checkout' },
+})
 ```
 
 **Pros:**
+
 - Incredible visualization and dashboard capabilities
 - Open standards based ([OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/))
 - Flexible data storage and querying
@@ -323,12 +378,14 @@ faro.api.pushLog(['User action'], {
 - Good documentation for instrumentation
 
 **Cons:**
+
 - Steeper learning curve than purpose-built tools
 - No built-in session replay
 - Requires more setup and configuration
 - Less out-of-the-box functionality
 
 **Pricing Reality Check:**
+
 - **1K users**: ~$50/month for Grafana Cloud
 - **10K users**: $200-400/month
 - **100K users**: Custom pricing, typically $1000+/month
@@ -339,7 +396,11 @@ faro.api.pushLog(['User action'], {
 
 SigNoz brings a fresh perspective as an OpenTelemetry-native observability platform. It's not just about logging, it's about complete observability with traces, metrics, and logs in one place.
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-signoz-logs.webp" alt="SigNoz Logs Dashboard showing unified observability with traces, metrics, and logs" caption="SigNoz Logs Dashboard showing unified observability with traces, metrics, and logs" />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-signoz-logs.webp"
+  alt="SigNoz Logs Dashboard showing unified observability with traces, metrics, and logs"
+  caption="SigNoz Logs Dashboard showing unified observability with traces, metrics, and logs"
+/>
 
 **What Makes SigNoz Stand Out:**
 
@@ -350,19 +411,20 @@ SigNoz brings a fresh perspective as an OpenTelemetry-native observability platf
 SigNoz required more initial setup than SaaS alternatives, but the OpenTelemetry foundation means excellent flexibility. The ability to correlate frontend logs with backend traces using trace IDs was incredibly valuable for debugging.
 
 This is how the key implementation part of SigNoz looks like:
+
 ```javascript
 // SigNoz implementation with OpenTelemetry
-import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import { logs } from '@opentelemetry/api-logs';
-import { Resource } from '@opentelemetry/resources';
+import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs'
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http'
+import { logs } from '@opentelemetry/api-logs'
+import { Resource } from '@opentelemetry/resources'
 
 const loggerProvider = new LoggerProvider({
   resource: new Resource({
     'service.name': 'frontend-app',
     'service.version': '1.0.0',
   }),
-});
+})
 
 loggerProvider.addLogRecordProcessor(
   new SimpleLogRecordProcessor(
@@ -373,12 +435,12 @@ loggerProvider.addLogRecordProcessor(
       },
     })
   )
-);
+)
 
-logs.setGlobalLoggerProvider(loggerProvider);
+logs.setGlobalLoggerProvider(loggerProvider)
 
 // Create logger and use it
-const logger = logs.getLogger('frontend-logger');
+const logger = logs.getLogger('frontend-logger')
 
 // Log with severity and attributes
 logger.emit({
@@ -388,14 +450,19 @@ logger.emit({
   attributes: {
     userId: '123',
     action: 'checkout',
-    amount: 99.99
-  }
-});
+    amount: 99.99,
+  },
+})
 ```
 
-<Figure src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-signoz-trace-correlation.webp" alt="SigNoz Trace Correlation view showing frontend logs connected to backend traces" caption="SigNoz Trace Correlation view showing frontend logs connected to backend traces" />
+<Figure
+  src="/img/comparisons/2025/09/best-frontend-cloud-logging-tools-signoz-trace-correlation.webp"
+  alt="SigNoz Trace Correlation view showing frontend logs connected to backend traces"
+  caption="SigNoz Trace Correlation view showing frontend logs connected to backend traces"
+/>
 
 **Pros:**
+
 - Full [observability stack](https://signoz.io/guides/observability-stack/) (logs, metrics, traces)
 - OpenTelemetry native with no vendor lock-in
 - Cost-effective at scale
@@ -403,6 +470,7 @@ logger.emit({
 - Active open-source community
 
 **Cons:**
+
 - Requires more setup than SaaS alternatives
 - No built-in session replay
 - Newer platform with fewer integrations
@@ -411,18 +479,20 @@ logger.emit({
 **Pricing Reality Check:**
 
 SigNoz pricing is based on actual data ingested:
+
 - **Traces**: $0.30/GB ingested
-- **Logs**: $0.30/GB ingested  
+- **Logs**: $0.30/GB ingested
 - **Metrics**: $0.10 per million samples
 
 **Estimated costs:**
+
 - **Self-hosted**: Free (plus infrastructure costs)
 - **1K users**: ~$10-30/month for cloud (based on actual usage)
-- **10K users**: $50-150/month 
+- **10K users**: $50-150/month
 - **100K users**: $200-600/month (significantly cheaper than alternatives)
 
-
 **Learn More:**
+
 - [Frontend Logging with SigNoz](https://signoz.io/docs/frontend-monitoring/sending-logs/) - Complete guide to sending logs from your frontend application to SigNoz
 - [Frontend Tracing with SigNoz](https://signoz.io/docs/frontend-monitoring/sending-traces/) - Step-by-step instructions for sending traces and understanding user interactions
 - [Web Vitals Monitoring](https://signoz.io/docs/frontend-monitoring/opentelemetry-web-vitals/) - Monitor Core Web Vitals (LCP, FID, CLS) using OpenTelemetry and SigNoz
@@ -435,7 +505,6 @@ Those who have data privacy concerns and can't send their data outside their inf
 
 Those who have the expertise to manage SigNoz themselves or just want to start with a free self-hosted option can use our [community edition](https://signoz.io/docs/install/self-host/).
 
-
 ## Conclusion
 
 Choosing the right frontend logging tool isn't about finding the "best" tool, it's about finding the right fit for your specific needs. Here's what we learned from our hands-on testing:
@@ -454,4 +523,4 @@ The frontend logging landscape will continue evolving, but one thing remains con
 
 Hope we answered all your questions regarding frontend logging tools. If you have more questions, feel free to use the SigNoz AI chatbot, or join our [slack community](https://signoz.io/slack/).
 
-You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
\ No newline at end of file
+You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
diff --git a/data/comparisons/chronosphere-vs-datadog.mdx b/data/comparisons/chronosphere-vs-datadog.mdx
index ad1de3327..9f408824f 100644
--- a/data/comparisons/chronosphere-vs-datadog.mdx
+++ b/data/comparisons/chronosphere-vs-datadog.mdx
@@ -1,11 +1,20 @@
 ---
-title: "Chronosphere vs Datadog: Which Observability Platform is Right for You in 2025?"
-slug: "chronosphere-vs-datadog"
-date: "2025-10-13"
+title: 'Chronosphere vs Datadog: Which Observability Platform is Right for You in 2025?'
+date: '2025-10-13'
 tags: [datadog, observability-tools]
 authors: [yuvraj]
-description: "An in-depth comparison of Chronosphere and Datadog on cost, architecture, open-source compatibility, and ease of use to help you choose the right observability tool."
-keywords: [chronosphere, datadog, observability, monitoring, cloud-native, prometheus, opentelemetry, cost control]
+description: 'An in-depth comparison of Chronosphere and Datadog on cost, architecture, open-source compatibility, and ease of use to help you choose the right observability tool.'
+keywords:
+  [
+    chronosphere,
+    datadog,
+    observability,
+    monitoring,
+    cloud-native,
+    prometheus,
+    opentelemetry,
+    cost control,
+  ]
 ---
 
 As organizations adopt cloud-native architectures like microservices and Kubernetes, they face an explosion of telemetry data. This data is essential for understanding system health, but it also brings significant challenges: soaring costs, tool fragmentation, and persistent alert fatigue for on-call engineers.
@@ -18,16 +27,16 @@ This article provides a detailed comparison of Chronosphere and Datadog to help
 
 Here’s a high-level summary of how the two platforms stack up on key features.
 
-| Feature Area                  | Chronosphere                                         | Datadog                                                                                                                                                                                                                                 |
-| ----------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Primary Focus**             | Cost control & reliability for cloud-native scale    | All-in-one observability for a broad range of use cases                                                                                                                                                                                 |
-| **Cost Model**                | Predictable, based on valuable data after filtering  | Consumption-based across many SKUs, can be complex                                                                                                                                                                                      |
+| Feature Area                  | Chronosphere                                         | Datadog                                                                                                                                                                                                                              |
+| ----------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Primary Focus**             | Cost control & reliability for cloud-native scale    | All-in-one observability for a broad range of use cases                                                                                                                                                                              |
+| **Cost Model**                | Predictable, based on valuable data after filtering  | Consumption-based across many SKUs, can be complex                                                                                                                                                                                   |
 | **Data Control**              | Granular control plane to filter/aggregate at ingest | Provides robust but different controls. For example Metrics without Limits™, custom-metrics governance and cardinality tooling, though much of the shaping happens before or at indexing rather than as an at-ingest control plane. |
-| **Open-Source Compatibility** | Native Prometheus & OpenTelemetry support            | Supports OTel, but ecosystem favors proprietary agents                                                                                                                                                                             |
-| **Platform Breadth**          | Focused on Metrics, Logs, Traces (MELT)              | Extensive: MELT, RUM, Synthetics, Security, and more (1,000+ integrations)                                                                                                                                                         |
-| **Alerting Philosophy**       | Opinionated, SLO-driven to reduce noise              | Flexible, but can easily lead to alert fatigue if unmanaged                                                                                                                                                                             |
-| **Ease of Initial Setup**     | More upfront configuration required                  | Very fast time-to-value with agents & pre-built integrations                                                                                                                                                                            |
-| **High Cardinality Handling** | Architected for high-cardinality data           | Can become very expensive at high cardinality                                                                                                                                                                                      |
+| **Open-Source Compatibility** | Native Prometheus & OpenTelemetry support            | Supports OTel, but ecosystem favors proprietary agents                                                                                                                                                                               |
+| **Platform Breadth**          | Focused on Metrics, Logs, Traces (MELT)              | Extensive: MELT, RUM, Synthetics, Security, and more (1,000+ integrations)                                                                                                                                                           |
+| **Alerting Philosophy**       | Opinionated, SLO-driven to reduce noise              | Flexible, but can easily lead to alert fatigue if unmanaged                                                                                                                                                                          |
+| **Ease of Initial Setup**     | More upfront configuration required                  | Very fast time-to-value with agents & pre-built integrations                                                                                                                                                                         |
+| **High Cardinality Handling** | Architected for high-cardinality data                | Can become very expensive at high cardinality                                                                                                                                                                                        |
 
 ## Core Philosophies: Different Approaches to Observability
 
@@ -35,10 +44,10 @@ The biggest difference between Chronosphere and Datadog lies in their core philo
 
 ### Datadog: The "Collect-Then-Pay" Model (Pre-Ingest Control)
 
-<Figure 
-  src="/img/comparisons/2025/10/chronosphere-vs-datadog-datadog-architecture.webp" 
-  alt="Datadog tracing dashboard" 
-  caption="Datadog's tracing dashboard (credits: Datadog)" 
+<Figure
+  src="/img/comparisons/2025/10/chronosphere-vs-datadog-datadog-architecture.webp"
+  alt="Datadog tracing dashboard"
+  caption="Datadog's tracing dashboard (credits: Datadog)"
 />
 
 Datadog’s philosophy is to be a single platform for all your observability needs. Its strength is its **plug-and-play nature**; you install an agent and immediately get value from pre-built dashboards and integrations.
@@ -49,14 +58,14 @@ The model is simple: if data reaches Datadog's platform, you are generally <a hr
 - **Observability Pipelines:** Utilizing tools like Datadog's Observability Pipelines to filter, sample, or transform data before forwarding it.
 - **DIY Pipelines:** Some teams build and maintain their own intermediary pipelines (e.g., using OpenTelemetry Collectors) for pre-processing.
 
-While Datadog offers in-product controls like  <a href="https://www.datadoghq.com/blog/logging-without-limits/" target="_blank" rel="nofollow noreferrer">**Logging without Limits™**</a> (which decouples log ingest from indexing) and <a href="https://www.datadoghq.com/blog/metrics-without-limits/" target="_blank" rel="nofollow noreferrer">**Metrics without Limits™**</a> (for metric tag governance), the fundamental strategy for cost-conscious users heavily relies on shaping data before it fully enters Datadog's billable storage. The trade-off for Datadog's initial simplicity can be a more reactive and complex approach to cost management, often necessitating actions outside or prior to the main platform.
+While Datadog offers in-product controls like <a href="https://www.datadoghq.com/blog/logging-without-limits/" target="_blank" rel="nofollow noreferrer">**Logging without Limits™**</a> (which decouples log ingest from indexing) and <a href="https://www.datadoghq.com/blog/metrics-without-limits/" target="_blank" rel="nofollow noreferrer">**Metrics without Limits™**</a> (for metric tag governance), the fundamental strategy for cost-conscious users heavily relies on shaping data before it fully enters Datadog's billable storage. The trade-off for Datadog's initial simplicity can be a more reactive and complex approach to cost management, often necessitating actions outside or prior to the main platform.
 
 ### Chronosphere: The "Collect-and-Shape" Model (At-Ingest Control)
 
-<Figure 
-  src="/img/comparisons/2025/10/chronosphere-vs-datadog-chronosphere-architecture.webp" 
-  alt="Chronosphere's Trace Control Plane" 
-  caption="Chronosphere's Trace Control Plane (credits: Chronosphere)" 
+<Figure
+  src="/img/comparisons/2025/10/chronosphere-vs-datadog-chronosphere-architecture.webp"
+  alt="Chronosphere's Trace Control Plane"
+  caption="Chronosphere's Trace Control Plane (credits: Chronosphere)"
 />
 
 Chronosphere was founded by the creators of <a href="https://m3db.io/" target="_blank" rel="nofollow noreferrer">M3, the open-source metrics engine built at Uber to handle massive scale</a>. It is built around a core problem: **not all telemetry data is equally valuable**, yet traditional platforms force you to pay for all of it.
@@ -87,7 +96,7 @@ This is the most significant differentiator between the two platforms.
 
 **Datadog** follows a traditional consumption-based pricing model. You pay per host, per GB of ingested logs, for custom metrics, and for various other product SKUs. This model is complex and can lead to surprise bills. Cost control is a manual and reactive process, often requiring engineers to remove instrumentation or build custom pre-processing pipelines to reduce the data sent to Datadog.
 
-**Chronosphere's** core value proposition is its **telemetry control plane**. It analyzes all incoming data in real-time and provides tools to dynamically filter, aggregate, or drop low-value data at the point of ingestion. 
+**Chronosphere's** core value proposition is its **telemetry control plane**. It analyzes all incoming data in real-time and provides tools to dynamically filter, aggregate, or drop low-value data at the point of ingestion.
 
 For example, you can choose to retain a metric at 10-second resolution for alerting but only store it at 1-minute resolution for long-term trending. This approach can lead to **<a href="https://chronosphere.io/solutions/control-costs/" target="_blank" rel="nofollow noreferrer">significant cost savings</a>** by separating data collection from data storage, allowing you to pay only for the data you actually use.
 
@@ -133,7 +142,6 @@ SigNoz can save you up to [80% on your Datadog bill](https://signoz.io/blog/pric
 - **No Host-Based Pricing:** Datadog's per-host pricing model often forces teams to pack more services onto a single host just to control costs. SigNoz has no per-host charges, allowing you to architect your systems for performance, not to appease a vendor's pricing model.
 - **Granular Cost Controls:** You can control infrastructure monitoring costs by choosing exactly which metrics to send from the OpenTelemetry Collector. Features like Ingest Guard allow you to set data ingestion limits for different <a href="https://signoz.io/blog/introducing-ingest-guard-feature/" target="_blank" rel="nofollow noreferrer">teams or environments</a>.
 
-
 ### Flexible Deployment Options
 
 SigNoz offers deployment models to fit any need, from a free open-source community edition to a fully-managed cloud service and a self-hosted enterprise version for organizations with strict data privacy requirements.
@@ -159,4 +167,3 @@ The right platform depends on your organization's scale, technical maturity, and
 Hope we answered all your questions regarding Chronosphere vs Datadog. If you have more questions, feel free to use the SigNoz AI chatbot, or join our [slack community](https://signoz.io/slack/).
 
 You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
-
diff --git a/data/comparisons/clickhouse-alternatives.mdx b/data/comparisons/clickhouse-alternatives.mdx
index 5c12d411e..abd1998c0 100644
--- a/data/comparisons/clickhouse-alternatives.mdx
+++ b/data/comparisons/clickhouse-alternatives.mdx
@@ -1,6 +1,5 @@
 ---
 title: Top 5 ClickHouse Alternatives for High-Performance Analytics
-slug: clickhouse-alternatives
 date: 2025-01-09
 tags: [clickhouse, analytics]
 authors: [abdulsalaam_noibi]
@@ -53,10 +52,12 @@ Now, let’s look at the top 5 ClickHouse Alternatives for High-performance Anal
 
 ## 1. Google BigQuery
 
-<a href="https://cloud.google.com/bigquery" rel="noopener noreferrer nofollow" target="_blank">Google BigQuery</a> is a fully managed, serverless data warehouse designed for high-performance analytics. It is
-built on Google Cloud Platform (GCP), it eliminates the need for database administration,
-infrastructure provisioning, and maintenance, allowing developers to focus entirely on analyzing
-data.
+<a href="https://cloud.google.com/bigquery" rel="noopener noreferrer nofollow" target="_blank">
+  Google BigQuery
+</a>
+is a fully managed, serverless data warehouse designed for high-performance analytics. It is built
+on Google Cloud Platform (GCP), it eliminates the need for database administration, infrastructure
+provisioning, and maintenance, allowing developers to focus entirely on analyzing data.
 
 <Figure
   src="/img/comparisons/2025/01/clickhouse-alternatives-images3.webp"
@@ -86,19 +87,16 @@ Google BigQuery showing the overview section
 1. Ad-hoc Analytics with Variable Workloads
 
    BigQuery is particularly well-suited for ad-hoc analytics, where query demands can be unpredictable and vary significantly over time.
-
    - Example Use Case: A marketing team needs to analyze user behavior data from a recent campaign. Using BigQuery, they can run SQL queries on petabyte-scale datasets without setting up infrastructure. When the campaign ends, they stop querying and incur no further charges.
 
 2. Machine Learning Workload
 
    BigQuery seamlessly integrates with machine learning tools, making it an excellent choice for building and deploying ML models directly within the data warehouse.
-
    - Example Use Case: A retail company uses BigQuery ML to predict sales trends based on historical data. They build and test a regression model in SQL, deploy it for production predictions, and integrate the results with their dashboards for real-time insights.
 
 3. GCP-Native Environments
 
    BigQuery is deeply integrated into the Google Cloud Platform (GCP) ecosystem, making it the ideal choice for organizations already leveraging GCP services.
-
    - Example Use Case: A financial services company builds its data warehouse entirely on GCP. They ingest data from Google Cloud Storage into BigQuery, process transformations using Dataflow, and visualize insights through Looker. This end-to-end workflow minimizes compatibility issues and reduces development time.
 
 Google BigQuery Configuration Example
@@ -137,9 +135,12 @@ def stream_data(data):
 
 ## 2. Snowflake
 
-<a href="https://www.snowflake.com/en/" rel="noopener noreferrer nofollow" target="_blank">Snowflake</a> is a cloud-based data platform that simplifies data storage, processing, and analysis. It
-offers a fully managed service that eliminates the need for hardware provisioning, software
-configuration, and manual optimization.
+<a href="https://www.snowflake.com/en/" rel="noopener noreferrer nofollow" target="_blank">
+  Snowflake
+</a>
+is a cloud-based data platform that simplifies data storage, processing, and analysis. It offers a
+fully managed service that eliminates the need for hardware provisioning, software configuration,
+and manual optimization.
 
 <Figure
   src="/img/comparisons/2025/01/clickhouse-alternatives-images10.webp"
@@ -147,7 +148,6 @@ configuration, and manual optimization.
   caption="Overview of Snowflake dashboard"
 />
 
-
 ### Key Features of Snowflake
 
 1. Secure Data Sharing: Snowflake’s Secure Data Sharing feature simplifies collaboration across teams and organizations without the need for complex ETL (extract, transform, and load) pipelines or data duplication.
@@ -217,9 +217,12 @@ def insert_data(data):
 
 ## 3. Amazon Redshift
 
-<a href="https://aws.amazon.com/redshift/" rel="noopener noreferrer nofollow" target="_blank">Amazon Redshift</a> is a fully managed data warehouse service provided by Amazon Web Services (AWS). It is designed
-to handle large-scale data analytics and business intelligence (BI) workloads efficiently. Redshift
-is optimized for online analytical processing (OLAP), enabling organizations to analyze massive
+<a href="https://aws.amazon.com/redshift/" rel="noopener noreferrer nofollow" target="_blank">
+  Amazon Redshift
+</a>
+is a fully managed data warehouse service provided by Amazon Web Services (AWS). It is designed to
+handle large-scale data analytics and business intelligence (BI) workloads efficiently. Redshift is
+optimized for online analytical processing (OLAP), enabling organizations to analyze massive
 datasets and extract insights quickly.
 
 <Figure
@@ -301,10 +304,13 @@ def insert_data(data):
 
 ## 4. Databricks
 
-<a href="https://www.databricks.com/" rel="noopener noreferrer nofollow" target="_blank">Databricks</a> is a cloud-based analytics platform built on Apache Spark, designed to process massive datasets
-for batch and streaming workloads. It combines data engineering, data science, and machine learning
-(ML) in a unified workspace, making it an attractive choice for teams handling advanced analytics
-and AI projects.
+<a href="https://www.databricks.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Databricks
+</a>
+is a cloud-based analytics platform built on Apache Spark, designed to process massive datasets for
+batch and streaming workloads. It combines data engineering, data science, and machine learning (ML)
+in a unified workspace, making it an attractive choice for teams handling advanced analytics and AI
+projects.
 
 <Figure
   src="/img/comparisons/2025/01/clickhouse-alternatives-6576ba80f2c374d506f50085_Databricks_Hero.webp"
@@ -375,8 +381,11 @@ def insert_data(data):
 
 ## 5. StarRocks
 
-<a href="https://www.starrocks.io/" rel="noopener noreferrer nofollow" target="_blank">StarRocks</a> is an emerging analytical database designed to deliver high-performance, real-time analytics.
-Built with a vectorized execution engine, it shares similarities with ClickHouse but offers distinct
+<a href="https://www.starrocks.io/" rel="noopener noreferrer nofollow" target="_blank">
+  StarRocks
+</a>
+is an emerging analytical database designed to deliver high-performance, real-time analytics. Built
+with a vectorized execution engine, it shares similarities with ClickHouse but offers distinct
 advantages in areas like query performance, real-time updates, and handling complex joins.
 
 <Figure
@@ -452,7 +461,6 @@ This table shows a high-level evaluation of database platforms based on features
   caption=""
 />
 
-
 ## Factors to Consider When Choosing a ClickHouse Alternative
 
 1. Scalability and Performance Requirements: The ability of a database to handle increasing workloads without performance degradation is critical.
diff --git a/data/comparisons/cloud-monitoring-tools.mdx b/data/comparisons/cloud-monitoring-tools.mdx
index fcb71c082..efce00ab7 100644
--- a/data/comparisons/cloud-monitoring-tools.mdx
+++ b/data/comparisons/cloud-monitoring-tools.mdx
@@ -1,25 +1,25 @@
 ---
 title: Top 11 Cloud Monitoring Tools [Updated 2025 Guide]
-slug: cloud-monitoring-tools
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [gargi]
 description: Cloud monitoring tools allow you to keep your cloud resources in check and ensure that they are healthy and performant. This includes your infrastructure, applications, databases, network, disk usage, and more...
 image: /img/blog/2024/04/cloud-monitoring-tools-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [cloud-monitoring-tools,cloud-monitoring,opentelemetry,opensource,monitoring-tools,signoz]
+keywords:
+  [cloud-monitoring-tools, cloud-monitoring, opentelemetry, opensource, monitoring-tools, signoz]
 ---
-Cloud monitoring tools allow you to keep your cloud resources in check and ensure that they are healthy and performant. This includes your infrastructure, applications, databases, network, disk usage, and more.
-
 
+Cloud monitoring tools allow you to keep your cloud resources in check and ensure that they are healthy and performant. This includes your infrastructure, applications, databases, network, disk usage, and more.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 As dependence on cloud providers rises, it’s important that you have the right tool to monitor performance, find issues, triage, and remove bottlenecks. There are many different cloud monitoring tools suitable for different use cases. Choosing the correct one can provide your business with a competitive advantage.
 
 ## Why Not Use In-Built Cloud Monitoring Tools?
@@ -40,13 +40,20 @@ While In-Built Cloud Monitoring tools might be an easy solution for your initial
 
 ### 1. SigNoz
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-signoz.webp" alt="SigNoz distributed tracing dashboard that shows a breakdown of user requests across services"/>
-    <figcaption><i>SigNoz distributed tracing dashboard that shows a breakdown of user requests across services</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-signoz.webp"
+    alt="SigNoz distributed tracing dashboard that shows a breakdown of user requests across services"
+  />
+  <figcaption>
+    <i>
+      SigNoz distributed tracing dashboard that shows a breakdown of user requests across services
+    </i>
+  </figcaption>
 </figure>
 
-
-[SigNoz](https://signoz.io/) is a one-stop observability solution that provides you with application monitoring, metrics, log management, exception monitoring, distributed tracing, custom dashboards, and setting up alerts. You get a service topology and complete dashboards right out of the box along with the most common metrics like p90, p99, request rates, and error rates. 
+[SigNoz](https://signoz.io/) is a one-stop observability solution that provides you with application monitoring, metrics, log management, exception monitoring, distributed tracing, custom dashboards, and setting up alerts. You get a service topology and complete dashboards right out of the box along with the most common metrics like p90, p99, request rates, and error rates.
 
 SigNoz is OpenTelemetry-native, so there is no vendor lock-in. Based on your use case, you can instrument your application with OpenTelemetry and switch to any [OpenTelemetry-compatible backend](https://signoz.io/blog/opentelemetry-backend/).
 
@@ -70,147 +77,204 @@ SigNoz is available both as an open-source software and a cloud offering. [SigNo
 
 ### 2. Dynatrace
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-dynatrace.webp" alt="Dynatrace dashboard (Source: Dynatrace website)"/>
-    <figcaption><i>Dynatrace dashboard (Source: Dynatrace website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-dynatrace.webp"
+    alt="Dynatrace dashboard (Source: Dynatrace website)"
+  />
+  <figcaption>
+    <i>Dynatrace dashboard (Source: Dynatrace website)</i>
+  </figcaption>
 </figure>
 
-
 An end-to-end cloud monitoring platform, [Dynatrace](https://www.dynatrace.com/platform/cloud-monitoring/)
-<a href = "https://www.dynatrace.com/platform/cloud-monitoring" rel="noopener noreferrer nofollow" target="_blank" >Dynatrace</a> offers easy and automatic deployment for all cloud environments. In fact, it offers full gap-free observability across all your nodes, transactions, users, OS-level, and crucial network metrics. 
 
-With a user-friendly interface, it meets most APM monitoring needs while also providing advanced root cause capabilities for more in-depth analysis. 
+<a
+  href="https://www.dynatrace.com/platform/cloud-monitoring"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Dynatrace
+</a>
+offers easy and automatic deployment for all cloud environments. In fact, it offers full gap-free
+observability across all your nodes, transactions, users, OS-level, and crucial network metrics.
+
+With a user-friendly interface, it meets most APM monitoring needs while also providing advanced root cause capabilities for more in-depth analysis.
 
 Available in on-premise models and SaaS, Dynatrace provides comprehensive dashboarding, a wide range of seamless integrations, and support for advanced log analysis.
 
-**Pros:** 
+**Pros:**
 
 1. Enables constant auto-discovery of hosts, logs, events, containers, VMs, and more.
-2. Has AI-supported algorithms to set up predictive alerts for proactive resolution. 
+2. Has AI-supported algorithms to set up predictive alerts for proactive resolution.
 3. Offers a sophisticated integration library to monitor cloud apps and logs.
-4. Excellent UI that aids in fast problem-solving with easy agent installation, even for beginners. 
+4. Excellent UI that aids in fast problem-solving with easy agent installation, even for beginners.
 
-**Cons:** 
+**Cons:**
 
 1. Pricing can be confusing and varies depending on features, host, and the amount of RAM you’re using.
-2. No free trial is available for Dynatrace. 
+2. No free trial is available for Dynatrace.
 
 ### 3. Datadog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-datadog.webp" alt="Datadog showing service map"/>
-    <figcaption><i>Datadog showing service map (Source: Datadog Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-datadog.webp"
+    alt="Datadog showing service map"
+  />
+  <figcaption>
+    <i>Datadog showing service map (Source: Datadog Website)</i>
+  </figcaption>
 </figure>
 
+<a
+  href="https://www.datadoghq.com/monitoring/cloud-monitoring"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Datadog
+</a>
+is a SaaS-based centralized cloud monitoring solution that allows access to 700+ data sources and
+vendor-backed integrations. Great for breaking down information silos and dealing with complex data
+points, Datadog reduces downtime in cloud, on-premise, or hybrid environments.
 
-<a href = "https://www.datadoghq.com/monitoring/cloud-monitoring" rel="noopener noreferrer nofollow" target="_blank" >Datadog</a> is a SaaS-based centralized cloud monitoring solution that allows access to 700+ data sources and vendor-backed integrations. Great for breaking down information silos and dealing with complex data points, Datadog reduces downtime in cloud, on-premise, or hybrid environments. 
-
-Datadog has exceptional features: built-in anomaly detection for issues, advanced filtering, live trace search, error tracking for real-time resolution, and a continuous profiler for performance optimization. 
+Datadog has exceptional features: built-in anomaly detection for issues, advanced filtering, live trace search, error tracking for real-time resolution, and a continuous profiler for performance optimization.
 
-You can unify real-time metrics across logs, events, and traces from your applications, cloud-scale infrastructure, and other third-party services. In addition, their interactive out-of-the-box dashboards are seamless and support bulk actions. 
+You can unify real-time metrics across logs, events, and traces from your applications, cloud-scale infrastructure, and other third-party services. In addition, their interactive out-of-the-box dashboards are seamless and support bulk actions.
 
-**Pros:** 
+**Pros:**
 
-1. Datadog’s Watchdog can detect performance issues using advanced ML algorithms. 
+1. Datadog’s Watchdog can detect performance issues using advanced ML algorithms.
 2. Has detailed documentation with responsive customer support to help troubleshoot faster.
 3. Comprehensive [hybrid cloud monitoring](https://signoz.io/guides/hybrid-cloud-monitoring/) enables better collaboration among teams.
-4. Rest API functionalities, fast UI, and seamless integrations make it an ideal choice for APM. 
+4. Rest API functionalities, fast UI, and seamless integrations make it an ideal choice for APM.
 
-**Cons:** 
+**Cons:**
 
 1. Configuration can be confusing for beginners.
-2. Plans are expensive for dealing with high-volume data. 
+2. Plans are expensive for dealing with high-volume data.
 3. Filtered tags are slow, and most plugins provide no more than basic functionalities.
 
 ### 4. NewRelic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-newrelic.webp" alt="New Relic dashboard"/>
-    <figcaption><i>New Relic dashboard (Source: NewRelic Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-newrelic.webp"
+    alt="New Relic dashboard"
+  />
+  <figcaption>
+    <i>New Relic dashboard (Source: NewRelic Website)</i>
+  </figcaption>
 </figure>
 
-
 New Relic can be a good choice for a cloud-monitoring tool. It offers an array of tools for application monitoring and observability that can help you monitor your cloud services.
 
-Using the data cloud, you enjoy multiple capabilities like unified metrics, logs, and traces, to [high cardinality](https://signoz.io/blog/high-cardinality-data/), multi-cloud functionalities, and continuous relationship mapping. 
+Using the data cloud, you enjoy multiple capabilities like unified metrics, logs, and traces, to [high cardinality](https://signoz.io/blog/high-cardinality-data/), multi-cloud functionalities, and continuous relationship mapping.
 
-You can also visualize and analyze all the data stored in the cloud, check for error rates, page load times, and slow transactions from a unified source, set up your own alerts, check database performance with SQL queries, and do more with observability. It fulfills most needs of APM, cloud infrastructure monitoring, log management with incident management, and open ingest APIs. 
+You can also visualize and analyze all the data stored in the cloud, check for error rates, page load times, and slow transactions from a unified source, set up your own alerts, check database performance with SQL queries, and do more with observability. It fulfills most needs of APM, cloud infrastructure monitoring, log management with incident management, and open ingest APIs.
 
-**Pros:** 
+**Pros:**
 
 1. You can write custom queries to analyze collected data using NRQL, NewRelic query language.
 2. Advanced error handling with a more efficient correlation between alerts and defined logic allows for reduced downtime.
-3. Strong integration network with 700+ options, and you can build your own with flex integration builder. 
-4. Has business-level metrics support and rich visualization features to graph metrics and logs. 
+3. Strong integration network with 700+ options, and you can build your own with flex integration builder.
+4. Has business-level metrics support and rich visualization features to graph metrics and logs.
 
-**Cons:** 
+**Cons:**
 
-1. Agent management functionality is unavailable, which makes installation and configuration harder. 
-2. Inconsistent UI experience across 30+ capabilities, with legacy interface slips here and there. 
+1. Agent management functionality is unavailable, which makes installation and configuration harder.
+2. Inconsistent UI experience across 30+ capabilities, with legacy interface slips here and there.
 3. User-based pricing can break your bill
 
 ### 5. Appdynamics
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-appdynamics.webp" alt="Appdynamics Dashboard"/>
-    <figcaption><i>Appdynamics Dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-appdynamics.webp"
+    alt="Appdynamics Dashboard"
+  />
+  <figcaption>
+    <i>Appdynamics Dashboard</i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.appdynamics.com/partners/technology-partners/google-cloud-platform" rel="noopener noreferrer nofollow" target="_blank" >Appdynamics</a>
 
-<a href = "https://appdynamics-wem.cisco.com/product/infrastructure-monitoring/cloud-monitoring" rel="noopener noreferrer nofollow" target="_blank" >Appdynamics</a> can make collecting, assessing, and correlating data across cloud apps, providers, and containers seamless. Find and fix issues faster with an experience that’s rooted in a dynamic view of all your cloud environments.
+<a
+  href="https://appdynamics-wem.cisco.com/product/infrastructure-monitoring/cloud-monitoring"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Appdynamics
+</a>
+can make collecting, assessing, and correlating data across cloud apps, providers, and containers
+seamless. Find and fix issues faster with an experience that’s rooted in a dynamic view of all your
+cloud environments.
 
-In fact, you can optimize end-user experiences by analyzing cross-domain MELT telemetry. You can also leverage business transaction insights to cut through the noise and identify business-critical transactions when applications start behaving abnormally. 
+In fact, you can optimize end-user experiences by analyzing cross-domain MELT telemetry. You can also leverage business transaction insights to cut through the noise and identify business-critical transactions when applications start behaving abnormally.
 
 Appdynamics has useful features like AI-assisted correlations, intelligent alerting, root cause analysis, and complete health monitoring for faster resolution.
 
-**Pros:** 
+**Pros:**
 
-1. Has strong community support and extensive documentation for each implementation. 
+1. Has strong community support and extensive documentation for each implementation.
 2. Automatically adjusts performance baselines, ensuring that abnormal behavior is quickly detected.
 3. Great for evaluating app scalability and transaction timings, mistake rates, and transaction outcomes for specific transactions.
 4. Has real-time insights, dashboarding, insight provision, contextual trace visualization, [distributed tracing](https://signoz.io/blog/distributed-tracing/) to drive business outcomes.
 
-**Cons:** 
+**Cons:**
 
 1. Initial setup is complex, and collaboration among large teams can be better.
-2. Application flow map isn’t the most helpful. 
-3. Search and filtering features could be more developed. 
+2. Application flow map isn’t the most helpful.
+3. Search and filtering features could be more developed.
 
 ### 6. Grafana Cloud
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-grafana.webp" alt="Grafana dashboard"/>
-    <figcaption><i>Grafana dashboard (Source: Grafana Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-grafana.webp"
+    alt="Grafana dashboard"
+  />
+  <figcaption>
+    <i>Grafana dashboard (Source: Grafana Website)</i>
+  </figcaption>
 </figure>
 
-
 Grafana started as a data visualization tool whose primary strength lies in its integration with various data sources. It is primarily used for monitoring metrics and data visualization. For application observability, Grafana provides Loki, Mimir, and Tempo. All these tools are available as open-source software.
 
 The disadvantage of using the [LGTM stack](https://signoz.io/docs/migration/migrate-from-grafana-to-signoz/) is managing multiple backends, which can be cumbersome.
 
 Grafana also offers Grafana Cloud to get you started easily.
 
-**Pros:** 
+**Pros:**
 
 1. Leverages Grafana Loki’s minimal indexing architecture for storing more logs using less storage.
 2. Allows extensive performance testing using Grafana k6 to prevent system failures.
-3. Provides advanced metrics support with seamless integrations and community support. 
+3. Provides advanced metrics support with seamless integrations and community support.
 
-**Cons:** 
+**Cons:**
 
 1. Multiple backends which can be operationally tough to manage if you’re using the open-source version
 2. Less suited as a cloud monitoring tool, better suited for data visualization
 
 ### 7. Honeycomb
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-honeycomb.webp" alt="Honeycomb dashboard"/>
-    <figcaption><i>Honeycomb dashboard (Source: Honeycomb website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-honeycomb.webp"
+    alt="Honeycomb dashboard"
+  />
+  <figcaption>
+    <i>Honeycomb dashboard (Source: Honeycomb website)</i>
+  </figcaption>
 </figure>
 
-
 Honeycomb is a cloud monitoring tool that offers unique insights into system performance and behavior, catering to the needs of modern cloud-native applications. With its innovative approach to observability, Honeycomb provides a comprehensive platform for understanding and troubleshooting complex systems.
 
 Its strength lies in its ability to provide high-resolution telemetry data, allowing you to drill down into specific events and anomalies with unparalleled detail. By capturing and analyzing rich data sets, Honeycomb enables you to identify patterns, correlations, and root causes of issues with ease.
@@ -228,36 +292,46 @@ Its strength lies in its ability to provide high-resolution telemetry data, allo
 
 ### 8. Elastic APM
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-elasticapm.webp" alt="Elastic APM dashboard"/>
-    <figcaption><i>Elastic APM dashboard (Source: Elastic website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-elasticapm.webp"
+    alt="Elastic APM dashboard"
+  />
+  <figcaption>
+    <i>Elastic APM dashboard (Source: Elastic website)</i>
+  </figcaption>
 </figure>
 
-
 Elastic APM is part of the Elastic Observability solution, which also includes infrastructure and log monitoring, enhancing overall application and system observability. It can be a good choice as a cloud monitoring tool.
 
 The easiest way to use Elastic APM is by subscribing to the hosted Elasticsearch service on Elastic Cloud. You can also opt to self-manage the Elastic stack, where you need to decide how to run and configure the APM server.
 
-**Pros:** 
+**Pros:**
 
 1. Has a highly flexible Query API that integrates real-time analytics with search seamlessly.
 2. Integrated solutions simplify data ingestion from multiple sources with a robust multi-language support like Java, Python, and more.
-3. Best fit for real-time analytics, customized visualization, and large-scale search functionalities. 
+3. Best fit for real-time analytics, customized visualization, and large-scale search functionalities.
 4. Built-in recovery mechanism to reduce downtime and latency with rapid search responses.
 
-**Cons:** 
+**Cons:**
 
 1. Costs for computing and data sources of high volumes of data can be exorbitant.
-2. Steep learning curve, even for experienced developers. 
+2. Steep learning curve, even for experienced developers.
 
 ### 9. Splunk
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-splunk.webp" alt="Splunk dashboard"/>
-    <figcaption><i>Splunk dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-splunk.webp"
+    alt="Splunk dashboard"
+  />
+  <figcaption>
+    <i>Splunk dashboard</i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.splunk.com/en_us/blog/platform/access-the-cloud-monitoring-console-from-anywhere.html" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a>
 
 **<a href = "https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a>** is a comprehensive cloud monitoring tool that offers multiple products, including:
@@ -273,28 +347,38 @@ Splunk allows you to collect all traces instead of a sample set. It also provide
 
 Splunk's observability Cloud for Enterprise editions starts at \$95 per host per month if billed annually.
 
-**Pros:** 
+**Pros:**
 
-1. Great documentation with detailed guides and smart AI-powered assistants. 
+1. Great documentation with detailed guides and smart AI-powered assistants.
 2. Intuitive indexing, powerful query language, and a powerful library of preconfigured modules for instant insight.
 3. Pre-built, so every functionality is a click away and doesn’t require a steep learning curve.
 4. Strong community with enterprise security and ticketing integration makes it a better choice.
 
-**Cons:** 
+**Cons:**
 
 1. Pricing is on the higher side.
 2. New users might struggle to optimize Splunk for speed.
-3. Limited integration support for popular apps and services. 
+3. Limited integration support for popular apps and services.
 
 ### 10. Sematext Cloud
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-sematext.webp" alt="Sematext dashboard"/>
-    <figcaption><i>Sematext dashboard (Source: Sematext website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-sematext.webp"
+    alt="Sematext dashboard"
+  />
+  <figcaption>
+    <i>Sematext dashboard (Source: Sematext website)</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://sematext.com/cloud" rel="noopener noreferrer nofollow" target="_blank" >Sematext Cloud</a> offers a comprehensive set of cloud monitoring tools that lets you monitor private, public, and hybrid cloud environments. With the performance monitoring software, you can collect application-specific metrics and visualize them in pre-built or custom dashboards.
+<a href="https://sematext.com/cloud" rel="noopener noreferrer nofollow" target="_blank">
+  Sematext Cloud
+</a>
+offers a comprehensive set of cloud monitoring tools that lets you monitor private, public, and
+hybrid cloud environments. With the performance monitoring software, you can collect
+application-specific metrics and visualize them in pre-built or custom dashboards.
 
 For your cloud-based log management needs, Sematext Cloud features a log management tool that lets you collect all system and application logs in a central place for faster analysis and troubleshooting.
 
@@ -316,13 +400,28 @@ In addition, you get Sematext Experience which lets you add real user monitoring
 
 ## 11. Sumo Logic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/cloud-monitoring-tools-sumo-logic.webp" alt="Sumo Logic Dashboard"/>
-    <figcaption><i>Sumo Logic Dashboard (Source: Sumlogic website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/cloud-monitoring-tools-sumo-logic.webp"
+    alt="Sumo Logic Dashboard"
+  />
+  <figcaption>
+    <i>Sumo Logic Dashboard (Source: Sumlogic website)</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.sumologic.com/solutions/cloud-monitoring" rel="noopener noreferrer nofollow" target="_blank" >Sumo Logic</a>'s strength lies in its ability to ingest data from various sources within your cloud environment, including public cloud providers (AWS, Azure, GCP), on-premises infrastructure, and applications. It centralizes log management, infrastructure monitoring, and application performance monitoring (APM) into a single platform, streamlining data collection, analysis, and troubleshooting workflows.
+<a
+  href="https://www.sumologic.com/solutions/cloud-monitoring"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Sumo Logic
+</a>
+'s strength lies in its ability to ingest data from various sources within your cloud environment,
+including public cloud providers (AWS, Azure, GCP), on-premises infrastructure, and applications. It
+centralizes log management, infrastructure monitoring, and application performance monitoring (APM)
+into a single platform, streamlining data collection, analysis, and troubleshooting workflows.
 
 Sumo Logic leverages machine learning to analyze vast amounts of log data. These advanced analytics can automatically detect patterns and anomalies, allowing for proactive problem detection and faster root cause analysis.
 
diff --git a/data/comparisons/continuous-monitoring-tools.mdx b/data/comparisons/continuous-monitoring-tools.mdx
index 6c8531533..3ba9ca84f 100644
--- a/data/comparisons/continuous-monitoring-tools.mdx
+++ b/data/comparisons/continuous-monitoring-tools.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top 10 Continuous Monitoring Tools for Enhanced Security
-slug: continuous-monitoring-tools
 date: 2024-11-29
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover the top 10 continuous monitoring tools for enhanced cybersecurity. Learn how to implement effective strategies and overcome common challenges.
-keywords: [continuous monitoring tools, cybersecurity, network security, real-time monitoring, threat detection]
-
+keywords:
+  [
+    continuous monitoring tools,
+    cybersecurity,
+    network security,
+    real-time monitoring,
+    threat detection,
+  ]
 ---
 
 Nowadays cybersecurity threats are becoming increasingly advanced and widespread, making it essential for enterprises to take a proactive approach to security. Continuous monitoring has become a cornerstone of current security measures, allowing for real-time identification of vulnerabilities and attacks.
@@ -24,7 +28,7 @@ For example, continuous monitoring might detect unauthorized access attempts as
 
 - Real-time Data Collection: Combining logs, metrics, and traces from numerous sources to provide an extensive viewpoint. You may utilize tools like SigNoz to facilitate smooth data intake from dispersed systems, resulting in a unified view of logs, traces, and metrics. You may also use platforms such as Prometheus, which is primarily focused on metrics, whereas SigNoz mixes distributed tracing and metrics analysis, providing a broader perspective.
 - Automated Analysis: Advanced algorithms and machine learning are used to correlate events and find abnormalities or possible risks. SigNoz includes a built-in query method for deep analysis, reducing the need for additional integrations.
-You may also utilize programs like Nagios, although they require substantial customization for equivalent functionality.
+  You may also utilize programs like Nagios, although they require substantial customization for equivalent functionality.
 - Alerting and Reporting: Receive immediate notifications based on pre-defined criteria or discovered abnormalities, guaranteeing a quick reaction. SigNoz specializes in configurable alerting, allowing teams to prioritize according to effect and immediacy. You may also utilize Datadog, which has extensive alerting capabilities but is expensive for small-scale applications.
 
 ### Importance of Real-Time Threat Detection and Response
@@ -43,12 +47,12 @@ While periodic assessments give a snapshot in time, continuous monitoring provid
 
 Let’s see their differences.
 
-| Aspect | Continuous Monitoring | Periodic Assessments |
-| --- | --- | --- |
-| Timeframe | Real-time data collection and analysis | Snapshot of data at a specific point in time |
-| Response Time | Immediate, reducing the window of opportunity for attackers | Delayed, based on review schedules |
-| Threat Detection | Detects anomalies and threats as they occur | May miss threats that arise between assessments |
-| Best Use Case | Dynamic environments with constant threat activity | Stable environments with lower risk profiles |
+| Aspect           | Continuous Monitoring                                       | Periodic Assessments                            |
+| ---------------- | ----------------------------------------------------------- | ----------------------------------------------- |
+| Timeframe        | Real-time data collection and analysis                      | Snapshot of data at a specific point in time    |
+| Response Time    | Immediate, reducing the window of opportunity for attackers | Delayed, based on review schedules              |
+| Threat Detection | Detects anomalies and threats as they occur                 | May miss threats that arise between assessments |
+| Best Use Case    | Dynamic environments with constant threat activity          | Stable environments with lower risk profiles    |
 
 ## Why Continuous Monitoring Tools are Essential for Modern Security
 
@@ -71,7 +75,11 @@ Let's now take a look at the top 10 continuous monitoring tools.
 
 [SigNoz](https://signoz.io/) stands out as an innovative, open-source application performance monitoring (APM) tool intended for easy integration with distributed systems. SigNoz, based on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), provides detailed insights into application performance via distributed tracing, metrics analysis, and logs.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image.webp" alt="SigNoz home page" caption="SigNoz home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image.webp"
+  alt="SigNoz home page"
+  caption="SigNoz home page"
+/>
 
 Key Features
 
@@ -99,11 +107,20 @@ Assume you're running a microservices-based e-commerce application where respons
 
 Visualizing Distributed Traces in SigNoz
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.002x.webp" alt="" caption="" />### 2. Splunk
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.002x.webp"
+  alt=""
+  caption=""
+/>
+### 2. Splunk
 
 Splunk remains the market leader in real-time log management and analytics, making it essential for businesses managing complex IT infrastructures.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%201.webp" alt="Splunk home page" caption="Splunk home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%201.webp"
+  alt="Splunk home page"
+  caption="Splunk home page"
+/>
 
 Key Features
 
@@ -124,7 +141,11 @@ Limitations
 
 Qualys excels in providing real-time security monitoring and vulnerability management for enterprise networks.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%202.webp" alt="Qualys home page" caption="Qualys home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%202.webp"
+  alt="Qualys home page"
+  caption="Qualys home page"
+/>
 
 Key Features
 
@@ -146,7 +167,11 @@ Limitations
 
 Datadog is popular among DevOps teams because it offers a comprehensive solution for [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), application performance management (APM), and log management.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%203.webp" alt="Datadog home page" caption="Datadog home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%203.webp"
+  alt="Datadog home page"
+  caption="Datadog home page"
+/>
 
 Key Features
 
@@ -168,7 +193,11 @@ Limitations
 
 Nagios has long been a trusted brand in infrastructure and network monitoring, known for its robust plugin ecosystem and dependability.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%204.webp" alt="Nagios home page" caption="Nagios home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%204.webp"
+  alt="Nagios home page"
+  caption="Nagios home page"
+/>
 
 Key Features
 
@@ -190,7 +219,11 @@ Limitations
 
 Prometheus is a popular open-source tool that is ideal for monitoring containerized and cloud-native systems.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%205.webp" alt="Prometheus home page" caption="Prometheus home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%205.webp"
+  alt="Prometheus home page"
+  caption="Prometheus home page"
+/>
 
 Key Features
 
@@ -212,7 +245,11 @@ Limitations
 
 BitSight is known for managing third-party cyber risks, providing visibility into vendor security and external attack surfaces.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%206.webp" alt="BitSight home page" caption="BitSight home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%206.webp"
+  alt="BitSight home page"
+  caption="BitSight home page"
+/>
 
 Key Features
 
@@ -233,7 +270,11 @@ Limitations
 
 CrowdStrike Falcon excels at endpoint detection and response (EDR), making it an excellent choice for current cybersecurity organizations.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%207.webp" alt="CrowdStrike Falcon home page" caption="CrowdStrike Falcon home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%207.webp"
+  alt="CrowdStrike Falcon home page"
+  caption="CrowdStrike Falcon home page"
+/>
 
 Key Features
 
@@ -255,7 +296,11 @@ Limitations
 
 Lansweeper specializes in asset management and IT inventory tracking, ensuring enterprises have complete visibility into their IT landscape.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%208.webp" alt="Lansweeper home page" caption="Lansweeper home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%208.webp"
+  alt="Lansweeper home page"
+  caption="Lansweeper home page"
+/>
 
 Key Features
 
@@ -276,7 +321,11 @@ Limitations
 
 Monit is a lightweight monitoring tool ideal for small-scale setups, providing essential features without unnecessary complexity.
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-image%209.webp" alt="Monit home page" caption="Monit home page" />
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-image%209.webp"
+  alt="Monit home page"
+  caption="Monit home page"
+/>
 
 Key Features
 
@@ -298,21 +347,25 @@ Limitations
 To get the most out of continuous monitoring tools, you can follow these steps.
 
 1. Identify critical assets and systems to monitor.
-    - Start by mapping out your organization's core systems and applications.
-    - For an e-commerce website, prioritize payment gateways, databases, and customer-facing services.
+   - Start by mapping out your organization's core systems and applications.
+   - For an e-commerce website, prioritize payment gateways, databases, and customer-facing services.
 2. Define Key Performance Indicators (KPIs) and Metrics.
-    - Select metrics that are relevant to your company objectives, such as latency, error rates, or CPU utilization.
-    - For example, use measures like '99.9% uptime' and ‘response times under 200ms' to assess customer satisfaction.
+   - Select metrics that are relevant to your company objectives, such as latency, error rates, or CPU utilization.
+   - For example, use measures like '99.9% uptime' and ‘response times under 200ms' to assess customer satisfaction.
 3. Establish Baseline Behavior for Normal Operations
-    - Collect data over a defined period to understand normal performance patterns.
-    - Diagram Example:
-        
-        <Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.132x.webp" alt="" caption="" />4. Develop and Test Incident Response Procedures
-    - Create a step-by-step strategy for managing alarms to reduce downtime.
-    - For example, simulate DDoS attacks to fine-tune response methods.
-5. Conduct regular reviews and updates to monitoring strategies
-    - Evaluate and change plans regularly to deal with evolving threats.
-    - For example, integrate new tools or KPIs in response to corporate expansion.
+   - Collect data over a defined period to understand normal performance patterns.
+   - Diagram Example:
+     <Figure
+       src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.132x.webp"
+       alt=""
+       caption=""
+     />
+     4. Develop and Test Incident Response Procedures
+   - Create a step-by-step strategy for managing alarms to reduce downtime.
+   - For example, simulate DDoS attacks to fine-tune response methods.
+4. Conduct regular reviews and updates to monitoring strategies
+   - Evaluate and change plans regularly to deal with evolving threats.
+   - For example, integrate new tools or KPIs in response to corporate expansion.
 
 Pro Tip: Effective implementation necessitates an iterative approach; tweak and adjust as you go.
 
@@ -345,15 +398,15 @@ Pro Tip: Effective implementation necessitates an iterative approach; tweak and
 - Challenge: Teams may lack competence in managing advanced monitoring tools.
 - Solution: Invest in skill development and certification.
 
-Pro tip:  Overcoming such challenges makes sure your monitoring strategy remains robust and effective.
+Pro tip: Overcoming such challenges makes sure your monitoring strategy remains robust and effective.
 
-| Challenge | Solution | Example |
-| --- | --- | --- |
-| Data Overload | Use tools like SigNoz for efficient data aggregation and visualization. | Use data filters to focus primarily on high-impact metrics. |
-| Alert Fatigue | Configure alerts with appropriate thresholds to reduce false positives. | Send CPU use alerts only when it surpasses 80% for five minutes. |
-| Data Privacy | Ensure data security using role-based access controls (RBAC) and encryption. | Avoid storing sensitive data in plain text. |
-| Tool Integration | Choose technologies with comprehensive APIs and prebuilt integrations (e.g., SigNoz, Datadog). | Centralize data collection using integrated dashboards. |
-| Skill Gaps | Invest in skill development and certification. | Provide training sessions on monitoring tools. |
+| Challenge        | Solution                                                                                       | Example                                                          |
+| ---------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| Data Overload    | Use tools like SigNoz for efficient data aggregation and visualization.                        | Use data filters to focus primarily on high-impact metrics.      |
+| Alert Fatigue    | Configure alerts with appropriate thresholds to reduce false positives.                        | Send CPU use alerts only when it surpasses 80% for five minutes. |
+| Data Privacy     | Ensure data security using role-based access controls (RBAC) and encryption.                   | Avoid storing sensitive data in plain text.                      |
+| Tool Integration | Choose technologies with comprehensive APIs and prebuilt integrations (e.g., SigNoz, Datadog). | Centralize data collection using integrated dashboards.          |
+| Skill Gaps       | Invest in skill development and certification.                                                 | Provide training sessions on monitoring tools.                   |
 
 ## SigNoz: A Comprehensive Solution for Application Monitoring
 
@@ -367,31 +420,36 @@ Pro tip:  Overcoming such challenges makes sure your monitoring strategy remains
 
 ### Example Architecture: Monitoring Microservices with SigNoz
 
-<Figure src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.272x.webp" alt="" caption="" />## Best Practices for Increasing the Value of Continuous Monitoring Tools
+<Figure
+  src="/img/comparisons/2024/11/continuous-monitoring-tools-CleanShot_2024-11-29_at_15.57.272x.webp"
+  alt=""
+  caption=""
+/>
+## Best Practices for Increasing the Value of Continuous Monitoring Tools
 
 1. Implement a Layered Security Approach
-    - Continuous monitoring is most effective when paired with additional security measures, including firewalls, intrusion detection systems, and endpoint protection solutions.
-    - For example, use monitoring tools such as SigNoz and CrowdStrike Falcon to track threats at both the application and endpoint levels.
+   - Continuous monitoring is most effective when paired with additional security measures, including firewalls, intrusion detection systems, and endpoint protection solutions.
+   - For example, use monitoring tools such as SigNoz and CrowdStrike Falcon to track threats at both the application and endpoint levels.
 2. Prioritize Alerts Based on Risk
-    - Not every alert requires equal attention. Use risk-based prioritizing to prioritize the most important items first.
-    - As an example, set severity levels:
-    - High severity: Unauthorized access attempts or critical service disruptions.
-    - Medium severity: Multiple unsuccessful login attempts.
-    - Low severity: routine system updates.
+   - Not every alert requires equal attention. Use risk-based prioritizing to prioritize the most important items first.
+   - As an example, set severity levels:
+   - High severity: Unauthorized access attempts or critical service disruptions.
+   - Medium severity: Multiple unsuccessful login attempts.
+   - Low severity: routine system updates.
 3. Automate Response Actions
-    - Automating repetitive activities saves time and reduces human error.
-    - For example, use Ansible or AWS Lambda to automatically scale up resources when CPU consumption exceeds a certain threshold.
-    - Another example is to restart a failing service in a Kubernetes pod using pre-defined scripts.
+   - Automating repetitive activities saves time and reduces human error.
+   - For example, use Ansible or AWS Lambda to automatically scale up resources when CPU consumption exceeds a certain threshold.
+   - Another example is to restart a failing service in a Kubernetes pod using pre-defined scripts.
 4. Conduct regular training
-    - Conduct regular training to equip your team with knowledge of tools and emerging dangers.
-    - For example, hold quarterly workshops on using tools like Splunk or Prometheus for real-time data visualization and alerting.
+   - Conduct regular training to equip your team with knowledge of tools and emerging dangers.
+   - For example, hold quarterly workshops on using tools like Splunk or Prometheus for real-time data visualization and alerting.
 5. Continuously Update Monitoring Rules
-    - Regularly update regulations to reflect new technologies, procedures, and cyber dangers.
-    - For example, if you're shifting to a microservices architecture, start monitoring API request rates, latencies, and errors.
+   - Regularly update regulations to reflect new technologies, procedures, and cyber dangers.
+   - For example, if you're shifting to a microservices architecture, start monitoring API request rates, latencies, and errors.
 6. Integrate Monitoring into DevOps Pipelines
-    - Include monitoring tools early in the development process to identify potential issues during deployment.
+   - Include monitoring tools early in the development process to identify potential issues during deployment.
 7. Collaborate Across Teams
-    - Encourage communication across development, operations, and security teams to improve monitoring efficiency.
+   - Encourage communication across development, operations, and security teams to improve monitoring efficiency.
 
 Pro Tip: Review your plan semi-annually to verify it is in line with business goals and compliance needs.
 
@@ -437,4 +495,4 @@ While continuous monitoring is essential, it does have challenges:
 - High Initial Costs: Advanced technologies such as Splunk or Datadog necessitate a large investment in setup and licensing. Mitigation: For cost efficiency, use open-source technologies such as SigNoz.
 - Skill Gaps: Teams may lack the knowledge to configure and evaluate monitoring data. Mitigation: Regular training and certifications might help close the gap.
 - Alert Fatigue: A constant barrage of notifications can de-sensitize teams, causing vital issues to be overlooked. Mitigation: Use intelligent alerts and prioritize according to severity.
-- Data Privacy Concerns: Monitoring tools may mistakenly disclose sensitive information. Mitigation: Encrypt data and use role-based access controls.
\ No newline at end of file
+- Data Privacy Concerns: Monitoring tools may mistakenly disclose sensitive information. Mitigation: Encrypt data and use role-based access controls.
diff --git a/data/comparisons/database-monitoring-tools.mdx b/data/comparisons/database-monitoring-tools.mdx
index 3e16bfc7c..8ff8aebf4 100644
--- a/data/comparisons/database-monitoring-tools.mdx
+++ b/data/comparisons/database-monitoring-tools.mdx
@@ -1,22 +1,27 @@
 ---
-
 title: Top 10 Database Monitoring Tools for Optimal Performance
-slug: database-monitoring-tools
 date: 2025-02-28
 tags: [Database, Monitoring, Performance, Tools]
 authors: [manjunath_irukulla]
 description: Discover the best database monitoring tools to optimize performance, ensure reliability, and enhance security in modern data-driven environments.
-keywords: [database monitoring, performance optimization, SQL monitoring, NoSQL monitoring, database management, query analysis]
-
+keywords:
+  [
+    database monitoring,
+    performance optimization,
+    SQL monitoring,
+    NoSQL monitoring,
+    database management,
+    query analysis,
+  ]
 ---
 
 Database performance can make or break an application's user experience. Slow queries or downtime can lead to frustrated users and lost revenue. That's why database monitoring tools are essential for software developers and SREs who need to ensure reliability and peak performance. These tools continuously track your database's health and speed, providing alerts and insights to prevent issues before they escalate​.
 
-This guide explores the core aspects of database monitoring, highlights its critical importance, and introduces the top 10 tools to enhance your database management approach in 2025 and beyond.  
+This guide explores the core aspects of database monitoring, highlights its critical importance, and introduces the top 10 tools to enhance your database management approach in 2025 and beyond.
 
 ## Understanding Database Monitoring
 
-Database monitoring tracks and analyzes key performance metrics to ensure databases run efficiently. Unlike general system monitoring, which primarily focuses on CPU and memory usage (hardware level), database monitoring targets critical aspects of database health and efficiency, including: 
+Database monitoring tracks and analyzes key performance metrics to ensure databases run efficiently. Unlike general system monitoring, which primarily focuses on CPU and memory usage (hardware level), database monitoring targets critical aspects of database health and efficiency, including:
 
 - **Query Performance:** How fast and efficiently queries execute.
 - **Transaction Integrity:** Ensuring reliable and consistent processing of transactions.
@@ -24,49 +29,52 @@ Database monitoring tracks and analyzes key performance metrics to ensure databa
 - **Table Lock Contention:** Identifying and resolving conflicts from concurrent data access.
 - **Other Database-Specific Metrics:** Monitoring delays in syncing data between primary and replica databases.
 
-Providing this level of visibility allows businesses to avoid costly downtime, maintain data reliability, and optimize resources.  
+Providing this level of visibility allows businesses to avoid costly downtime, maintain data reliability, and optimize resources.
 
 <InterlinkCard href="/guides/database-monitoring/" title="Learn more about Database Monitoring" />
 
-Key factors to consider when choosing a database monitoring tool include **compatibility, ease of use, and cost.** 
+Key factors to consider when choosing a database monitoring tool include **compatibility, ease of use, and cost.**
 
 - First, you need to ensure the tool supports your database systems (whether SQL or NoSQL) and your deployment environment (on-premise or cloud)​
 - You'll also want a solution that's easy to install and use day-to-day, with clear dashboards and minimal overhead. Integration capabilities are important too – the tool should blend into your existing stack (alerting systems, team chat, etc.)​
-- Finally, consider pricing and scalability. Some tools are open-source (free but self-managed) while others are commercial products with licensing costs. 
+- Finally, consider pricing and scalability. Some tools are open-source (free but self-managed) while others are commercial products with licensing costs.
 
 The optimal choice depends on your team's needs: a startup might favor a cost-effective open-source tool, whereas an enterprise might prioritize advanced features despite higher costs.
 
-
 ## Top 10 Database Monitoring Tools for 2025
 
 Selecting the right database monitoring tool is key to ensuring performance and reliability. This section highlights the top ten tools suited for different environments, from open-source to enterprise solutions.
 
-| **Tool** | **Strength** | **Weakness** |
-|----------|-------------|--------------|
-| **1. SigNoz** | • Open-source with database monitoring capabilities<br/>• Real-time tracking of database calls and query performance<br/>• Visualization of database metrics in customizable dashboards<br/>• Database error monitoring and correlation with application traces | • Open Source version requires you to manage the infra. |
-| **2. SolarWinds Database Performance Analyzer** | • Wait-time analysis pinpoints exact bottlenecks<br/>• Supports a wide range of databases<br/>• Anomaly detection tool for improved database performance | • Can be expensive for smaller organizations<br/>• Requires dedicated resources for setup and management<br/>• Separate products needed for complete database estate monitoring |
-| **3. Datadog** | • Real-time query profiling and execution plans<br/>• Automatic correlation between database and application issues<br/>• Supports both self-hosted and managed cloud versions of PostgreSQL, MySQL, SQL Server, Oracle, and MongoDB | • Higher licensing costs for extensive use<br/>• Can be overkill for small teams or on-prem setups |
-| **4. Percona Monitoring and Management (PMM)** | • Open-source and highly flexible<br/>• Deep MySQL, PostgreSQL, and MongoDB performance insights<br/>• Query analytics with execution plan visualization | • Requires technical expertise for setup<br/>• Limited advanced features for non-open-source databases |
-| **5. Oracle Enterprise Manager** | • Comprehensive Oracle database optimization advisors<br/>• Automated tuning and maintenance for Oracle environments<br/>• Deep integration with Oracle's Autonomous Database features | • Exclusive to Oracle environments, limiting versatility<br/>• Not suitable for heterogeneous database ecosystems |
-| **6. IBM Instana Observability** | • Automated discovery and monitoring of database clusters<br/>• AI-assisted root cause detection for complex systems<br/>• Real-time observability for dynamic microservices | • Less specialized for traditional RDBMS monitoring<br/>• Higher cost for small database environments<br/>• More focused on cloud-native databases |
-| **7. ManageEngine Applications Manager** | • Affordable solution with holistic application and database monitoring<br/>• Correlates database and infrastructure metrics effectively | • UI can feel less polished compared to competitors<br/>• Limited support for custom integrations |
-| **8. Prometheus & Grafana (Open-Source Stack)** | • Time-series database optimized for metrics collection<br/>• Rich visualization with customizable dashboards<br/>• Flexible query language (PromQL) and built-in alerting<br/>• 100% open-source with strong community support | • Requires manual setup and maintenance<br/>• Needs technical expertise to configure properly<br/>• Additional tools needed for logs and traces |
-| **9. Site24x7** | • Monitors MySQL, PostgreSQL, MongoDB, Redis, Oracle<br/>• Real-time performance tracking with customizable alerts | • Limited advanced query analysis capabilities |
-| **10. pgAdmin** | • Lightweight and easy to use<br/>• Ideal for PostgreSQL environments<br/>• Free and open-source | • Basic monitoring capabilities only<br/>• Lacks advanced analytics and visualization features |
+| **Tool**                                        | **Strength**                                                                                                                                                                                                                                                    | **Weakness**                                                                                                                                                                    |
+| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **1. SigNoz**                                   | • Open-source with database monitoring capabilities<br/>• Real-time tracking of database calls and query performance<br/>• Visualization of database metrics in customizable dashboards<br/>• Database error monitoring and correlation with application traces | • Open Source version requires you to manage the infra.                                                                                                                         |
+| **2. SolarWinds Database Performance Analyzer** | • Wait-time analysis pinpoints exact bottlenecks<br/>• Supports a wide range of databases<br/>• Anomaly detection tool for improved database performance                                                                                                        | • Can be expensive for smaller organizations<br/>• Requires dedicated resources for setup and management<br/>• Separate products needed for complete database estate monitoring |
+| **3. Datadog**                                  | • Real-time query profiling and execution plans<br/>• Automatic correlation between database and application issues<br/>• Supports both self-hosted and managed cloud versions of PostgreSQL, MySQL, SQL Server, Oracle, and MongoDB                            | • Higher licensing costs for extensive use<br/>• Can be overkill for small teams or on-prem setups                                                                              |
+| **4. Percona Monitoring and Management (PMM)**  | • Open-source and highly flexible<br/>• Deep MySQL, PostgreSQL, and MongoDB performance insights<br/>• Query analytics with execution plan visualization                                                                                                        | • Requires technical expertise for setup<br/>• Limited advanced features for non-open-source databases                                                                          |
+| **5. Oracle Enterprise Manager**                | • Comprehensive Oracle database optimization advisors<br/>• Automated tuning and maintenance for Oracle environments<br/>• Deep integration with Oracle's Autonomous Database features                                                                          | • Exclusive to Oracle environments, limiting versatility<br/>• Not suitable for heterogeneous database ecosystems                                                               |
+| **6. IBM Instana Observability**                | • Automated discovery and monitoring of database clusters<br/>• AI-assisted root cause detection for complex systems<br/>• Real-time observability for dynamic microservices                                                                                    | • Less specialized for traditional RDBMS monitoring<br/>• Higher cost for small database environments<br/>• More focused on cloud-native databases                              |
+| **7. ManageEngine Applications Manager**        | • Affordable solution with holistic application and database monitoring<br/>• Correlates database and infrastructure metrics effectively                                                                                                                        | • UI can feel less polished compared to competitors<br/>• Limited support for custom integrations                                                                               |
+| **8. Prometheus & Grafana (Open-Source Stack)** | • Time-series database optimized for metrics collection<br/>• Rich visualization with customizable dashboards<br/>• Flexible query language (PromQL) and built-in alerting<br/>• 100% open-source with strong community support                                 | • Requires manual setup and maintenance<br/>• Needs technical expertise to configure properly<br/>• Additional tools needed for logs and traces                                 |
+| **9. Site24x7**                                 | • Monitors MySQL, PostgreSQL, MongoDB, Redis, Oracle<br/>• Real-time performance tracking with customizable alerts                                                                                                                                              | • Limited advanced query analysis capabilities                                                                                                                                  |
+| **10. pgAdmin**                                 | • Lightweight and easy to use<br/>• Ideal for PostgreSQL environments<br/>• Free and open-source                                                                                                                                                                | • Basic monitoring capabilities only<br/>• Lacks advanced analytics and visualization features                                                                                  |
 
 ## 1. SigNoz
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-redis_dashboard_signoz.webp" alt="SigNoz Database Monitoring Dashboard" caption="SigNoz Database Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-redis_dashboard_signoz.webp"
+  alt="SigNoz Database Monitoring Dashboard"
+  caption="SigNoz Database Monitoring Dashboard"
+/>
 
 [SigNoz](https://signoz.io/) is an open-source observability platform that enables real-time database monitoring using OpenTelemetry. It allows tracking of database calls, query performance, and error monitoring while visualizing key database metrics in customizable dashboards.
 
 ### Strengths
 
-SigNoz stands out for its open-source flexibility and real-time monitoring capabilities. It is **built natively on OpenTelemetry standards**, which means it can ingest telemetry data (metrics and traces) with minimal overhead and high compatibility​. 
+SigNoz stands out for its open-source flexibility and real-time monitoring capabilities. It is **built natively on OpenTelemetry standards**, which means it can ingest telemetry data (metrics and traces) with minimal overhead and high compatibility​.
 
-For database monitoring, SigNoz can track query performance by **collecting database metrics** (for example, using [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) instrumentation for MySQL or PostgreSQL) and **correlate them with application traces**. One of SigNoz's powerful features is distributed tracing – you can get an end-to-end view of a user request across services, including the database calls involved, visualized through flame graphs and Gantt charts​. This helps in pinpointing slow database queries in the context of overall application performance. 
+For database monitoring, SigNoz can track query performance by **collecting database metrics** (for example, using [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) instrumentation for MySQL or PostgreSQL) and **correlate them with application traces**. One of SigNoz's powerful features is distributed tracing – you can get an end-to-end view of a user request across services, including the database calls involved, visualized through flame graphs and Gantt charts​. This helps in pinpointing slow database queries in the context of overall application performance.
 
-SigNoz provides custom dashboards where you can visualize any metrics you choose, and it stores data efficiently using a columnar database for fast querying of large volumes of data​. 
+SigNoz provides custom dashboards where you can visualize any metrics you choose, and it stores data efficiently using a columnar database for fast querying of large volumes of data​.
 
 Because it's open-source, teams can host it on their own infrastructure, avoiding vendor lock-in and hefty recurring costs​. It's essentially designed to offer low overhead in terms of both performance (efficient data handling) and cost (free to use except your hosting) compared to proprietary alternatives.
 
@@ -84,16 +92,28 @@ You can also use SigNoz cloud and avoid the hassle of setting the infra yourself
 
 SigNoz is a strong choice for modern engineering teams that want an observability solution similar to Datadog or New Relic, but self-hosted and open-source. If your stack is microservices-heavy and you value features like [distributed tracing](https://signoz.io/distributed-tracing/), SigNoz will appeal to you. It's ideal for startups and mid-size companies that are cloud-native and are conscious of cost, since you won't have to pay per host or per GB of logs to a third party. It's also great for anyone embracing OpenTelemetry standards – SigNoz will easily fit in as it natively understands that data. In summary, if you're looking for a full-stack monitoring tool that you can own and adapt, SigNoz stands out as an attractive option.
 
-
 ## 2. SolarWinds Database Performance Analyzer
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-SolarWind-DB-Monitoring.webp" alt="SolarWinds Database Monitoring Dashboard" caption="SolarWinds Database Monitoring Dashboard" />
-
-<a href="https://www.solarwinds.com/database-performance-analyzer/use-cases/mysql-optimization" rel="noopener noreferrer nofollow" target="_blank">SolarWinds Database Performance Analyzer (DPA)</a> is celebrated for its robust monitoring capabilities and cross-platform support, enabling users to oversee various database platforms through a unified interface. It provides real-time and historical data analysis, allowing proactive identification and resolution of performance issues.
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-SolarWind-DB-Monitoring.webp"
+  alt="SolarWinds Database Monitoring Dashboard"
+  caption="SolarWinds Database Monitoring Dashboard"
+/>
+
+<a
+  href="https://www.solarwinds.com/database-performance-analyzer/use-cases/mysql-optimization"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  SolarWinds Database Performance Analyzer (DPA)
+</a>
+is celebrated for its robust monitoring capabilities and cross-platform support, enabling users to
+oversee various database platforms through a unified interface. It provides real-time and historical
+data analysis, allowing proactive identification and resolution of performance issues.
 
 ### Strengths
 
-SolarWinds DPA uses a wait-based analysis approach to identify what queries are waiting on (CPU, disk, locks, etc.), which helps in diagnosing performance issues quickly​. It supports multiple database platforms – SQL Server, Oracle, MySQL, MariaDB, and more across on-premises and cloud environments​. 
+SolarWinds DPA uses a wait-based analysis approach to identify what queries are waiting on (CPU, disk, locks, etc.), which helps in diagnosing performance issues quickly​. It supports multiple database platforms – SQL Server, Oracle, MySQL, MariaDB, and more across on-premises and cloud environments​.
 
 One of its strong suits is historical data analysis: you can look at both real-time and long-term trends to find intermittent problems​.
 
@@ -101,38 +121,60 @@ DPA also provides expert tuning advisors that give guidance on how to improve qu
 
 ### Weaknesses
 
-While DPA is powerful, the interface can be a bit dated and sometimes complex to navigate for new users​. In some cases, drilling down to see the top SQL statements can be tricky due to GUI quirks​. Additionally, as an on-premise software, it requires you to manage the installation and might consume resources for its repository. 
+While DPA is powerful, the interface can be a bit dated and sometimes complex to navigate for new users​. In some cases, drilling down to see the top SQL statements can be tricky due to GUI quirks​. Additionally, as an on-premise software, it requires you to manage the installation and might consume resources for its repository.
 
 ### Best Use
 
 SolarWinds DPA is excellent for database administrators (DBAs) or DevOps engineers who primarily care about database efficiency. If your main concern is optimizing SQL queries and you want detailed insight into what the database is doing internally (wait events, locks, etc.), DPA is a strong choice. It's commonly used in environments with heavy transactional loads where every millisecond of query time matters.
 
-
 ## 3. Datadog
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-Screenshot_2025-02-21_at_14.34.23.webp" alt="Datadog Database Monitoring Dashboard" caption="Datadog Database Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-Screenshot_2025-02-21_at_14.34.23.webp"
+  alt="Datadog Database Monitoring Dashboard"
+  caption="Datadog Database Monitoring Dashboard"
+/>
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> is a cloud-based monitoring and security platform that includes robust database monitoring. It provides query performance insights, anomaly detection, customizable dashboards and alerting systems, and integrates with multiple cloud services.
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+is a cloud-based monitoring and security platform that includes robust database monitoring. It
+provides query performance insights, anomaly detection, customizable dashboards and alerting
+systems, and integrates with multiple cloud services.
 
 ### Strengths
 
-Datadog offers deep visibility into database query performance and lets you correlate it with application behavior​. It can pinpoint long-running queries, track query throughput, and even tie query metrics to specific code traces. With over 450 integrations (covering everything from MySQL and PostgreSQL to MongoDB, Redis, and cloud services), Datadog can monitor virtually any part of your stack​. 
+Datadog offers deep visibility into database query performance and lets you correlate it with application behavior​. It can pinpoint long-running queries, track query throughput, and even tie query metrics to specific code traces. With over 450 integrations (covering everything from MySQL and PostgreSQL to MongoDB, Redis, and cloud services), Datadog can monitor virtually any part of your stack​.
 
-The platform provides easy-to-create dashboards and supports real-time alerting on query metrics. 
+The platform provides easy-to-create dashboards and supports real-time alerting on query metrics.
 
 ### Weaknesses
+
 The main concern with Datadog is cost; as you enable more integrations and collect high volumes of data (especially logs or many database instances), it "might become expensive when you try to scale"​.
 
 ### Best Use
 
 Datadog is ideal for DevOps teams and SREs at startups or mid-size companies that are building on cloud infrastructure. If you want a single pane of glass for servers, apps, and databases without running your own monitoring servers, Datadog fits well. It's particularly strong for SQL monitoring in cloud environments, where you can quickly identify slow queries and even get index recommendations to optimize them
 
-
 ## 4. Percona Monitoring and Management (PMM)
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-PMM_Main_Dashboard.webp" alt="Percona Monitoring and Management -  Database Monitoring Dashboard" caption="Percona Monitoring and Management -  Database Monitoring Dashboard" />
-
-<a href="https://www.percona.com/software/database-tools/percona-monitoring-and-management" rel="noopener noreferrer nofollow" target="_blank">Percona Monitoring and Management (PMM)</a> is a free, open-source tool designed for comprehensive database monitoring and management. Supporting MySQL, PostgreSQL, MongoDB, and other open-source databases, PMM delivers real-time metrics, query analytics, and customizable dashboards, empowering administrators to optimize database health and performance.
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-PMM_Main_Dashboard.webp"
+  alt="Percona Monitoring and Management -  Database Monitoring Dashboard"
+  caption="Percona Monitoring and Management -  Database Monitoring Dashboard"
+/>
+
+<a
+  href="https://www.percona.com/software/database-tools/percona-monitoring-and-management"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Percona Monitoring and Management (PMM)
+</a>
+is a free, open-source tool designed for comprehensive database monitoring and management.
+Supporting MySQL, PostgreSQL, MongoDB, and other open-source databases, PMM delivers real-time
+metrics, query analytics, and customizable dashboards, empowering administrators to optimize
+database health and performance.
 
 ### Strengths
 
@@ -148,9 +190,22 @@ PMM is ideal for organizations primarily using open-source databases like MySQL,
 
 ## 5. Oracle Enterprise Manager
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-oracle-enterprise-manager-express.webp" alt="Oracle Enterprise Manager - Database Monitoring Dashboard" caption="Oracle Enterprise Manager - Database Monitoring Dashboard" />
-
-<a href="https://www.oracle.com/enterprise-manager/" rel="noopener noreferrer nofollow" target="_blank">Oracle Enterprise Manager (OEM)</a> is a robust database monitoring and management tool tailored for Oracle database environments. It provides in-depth performance insights, real-time monitoring, and advanced automation capabilities, making it a go-to solution for organizations leveraging Oracle's database technologies.
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-oracle-enterprise-manager-express.webp"
+  alt="Oracle Enterprise Manager - Database Monitoring Dashboard"
+  caption="Oracle Enterprise Manager - Database Monitoring Dashboard"
+/>
+
+<a
+  href="https://www.oracle.com/enterprise-manager/"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Oracle Enterprise Manager (OEM)
+</a>
+is a robust database monitoring and management tool tailored for Oracle database environments. It
+provides in-depth performance insights, real-time monitoring, and advanced automation capabilities,
+making it a go-to solution for organizations leveraging Oracle's database technologies.
 
 ### Strengths
 
@@ -166,9 +221,19 @@ Oracle Enterprise Manager is best suited for large enterprises heavily invested
 
 ## 6. IBM Instana Observability
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-IBM_Instana_Database_Monitoring.webp" alt="IBM Instana Database Monitoring Dashboard" caption="IBM Instana Database Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-IBM_Instana_Database_Monitoring.webp"
+  alt="IBM Instana Database Monitoring Dashboard"
+  caption="IBM Instana Database Monitoring Dashboard"
+/>
 
-<a href="https://www.ibm.com/products/instana" rel="noopener noreferrer nofollow" target="_blank">IBM Instana</a> is an observability platform that provides real-time monitoring and detailed insights into database performance. It excels in visualizing database metrics, detecting anomalies, and pinpointing root causes, making it a preferred tool for teams aiming to ensure optimal database operations and minimal downtime.
+<a href="https://www.ibm.com/products/instana" rel="noopener noreferrer nofollow" target="_blank">
+  IBM Instana
+</a>
+is an observability platform that provides real-time monitoring and detailed insights into database
+performance. It excels in visualizing database metrics, detecting anomalies, and pinpointing root
+causes, making it a preferred tool for teams aiming to ensure optimal database operations and
+minimal downtime.
 
 ### Strengths
 
@@ -184,9 +249,23 @@ IBM Instana is best suited for organizations running modern, cloud-native applic
 
 ## 7. ManageEngine Applications Manager
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-Manage_Engine_Application_Manager.webp" alt="ManageEngine Database Monitoring Dashboard" caption="ManageEngine Database Monitoring Dashboard" />
-
-<a href="https://www.manageengine.com/products/applications_manager/" rel="noopener noreferrer nofollow" target="_blank">ManageEngine Applications Manager</a> is an all-in-one performance monitoring tool that covers applications, servers, and databases. It's a more affordable, on-premise alternative to the big-name APM suites, providing comprehensive monitoring capabilities for both SQL and NoSQL databases alongside application performance from a single unified platform.
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-Manage_Engine_Application_Manager.webp"
+  alt="ManageEngine Database Monitoring Dashboard"
+  caption="ManageEngine Database Monitoring Dashboard"
+/>
+
+<a
+  href="https://www.manageengine.com/products/applications_manager/"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  ManageEngine Applications Manager
+</a>
+is an all-in-one performance monitoring tool that covers applications, servers, and databases. It's
+a more affordable, on-premise alternative to the big-name APM suites, providing comprehensive
+monitoring capabilities for both SQL and NoSQL databases alongside application performance from a
+single unified platform.
 
 ### Strengths
 
@@ -202,7 +281,11 @@ ManageEngine Applications Manager is ideal for organizations seeking a practical
 
 ## 8. Prometheus & Grafana (Open-Source Stack)
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-Screenshot_2025-02-24_at_03.37.57.webp" alt="Prometheus & Grafana Database Monitoring Dashboard" caption="Prometheus & Grafana Database Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-Screenshot_2025-02-24_at_03.37.57.webp"
+  alt="Prometheus & Grafana Database Monitoring Dashboard"
+  caption="Prometheus & Grafana Database Monitoring Dashboard"
+/>
 
 Prometheus and Grafana are open-source tools that together form a powerful monitoring and visualization stack. While not exclusively for databases, they are widely used to monitor database performance by collecting metrics and displaying them on custom dashboards.
 
@@ -224,9 +307,20 @@ The Prometheus & Grafana stack is best for organizations that want full control
 
 ## 9. Site24x7
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-Site24x7.webp" alt="Site 24x7 Database Monitoring Dashboard" caption="Site 24x7 Database Monitoring Dashboard" />
-
-<a href="https://www.site24x7.com/" rel="noopener noreferrer nofollow" target="_blank">Site24x7's</a> database monitoring tool stands out for its user-friendly interface and comprehensive monitoring capabilities. It provides real-time performance evaluation, enabling immediate insights into database health and operations. The tool supports multiple database types, including NoSQL options like MongoDB, DynamoDB, CouchDB, and Firebase, allowing effective monitoring across diverse environments. Its cloud-based nature enhances accessibility and scalability for users.
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-Site24x7.webp"
+  alt="Site 24x7 Database Monitoring Dashboard"
+  caption="Site 24x7 Database Monitoring Dashboard"
+/>
+
+<a href="https://www.site24x7.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Site24x7's
+</a>
+database monitoring tool stands out for its user-friendly interface and comprehensive monitoring
+capabilities. It provides real-time performance evaluation, enabling immediate insights into
+database health and operations. The tool supports multiple database types, including NoSQL options
+like MongoDB, DynamoDB, CouchDB, and Firebase, allowing effective monitoring across diverse
+environments. Its cloud-based nature enhances accessibility and scalability for users.
 
 ### Strengths
 
@@ -242,9 +336,19 @@ Site24x7 is ideal for organizations seeking a user-friendly, cloud-based monitor
 
 ## 10. pgAdmin (for PostgreSQL)
 
-<Figure src="/img/comparisons/2025/03/database-monitoring-tools-pg-admin.webp" alt="pgAdmin -  Database Monitoring Dashboard" caption="pgAdmin -  Database Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/database-monitoring-tools-pg-admin.webp"
+  alt="pgAdmin -  Database Monitoring Dashboard"
+  caption="pgAdmin -  Database Monitoring Dashboard"
+/>
 
-<a href="https://www.pgadmin.org/" rel="noopener noreferrer nofollow" target="_blank">pgAdmin</a> is a widely used open-source tool for managing and monitoring PostgreSQL databases. With a user-friendly interface and a range of features, it caters to database administrators and developers for tasks such as query execution, database design, and performance monitoring. Its web-based accessibility and multi-platform support make it a versatile choice for PostgreSQL users.
+<a href="https://www.pgadmin.org/" rel="noopener noreferrer nofollow" target="_blank">
+  pgAdmin
+</a>
+is a widely used open-source tool for managing and monitoring PostgreSQL databases. With a
+user-friendly interface and a range of features, it caters to database administrators and developers
+for tasks such as query execution, database design, and performance monitoring. Its web-based
+accessibility and multi-platform support make it a versatile choice for PostgreSQL users.
 
 ### Strengths
 
@@ -262,46 +366,36 @@ pgAdmin is best suited for PostgreSQL-focused teams that need a straightforward,
 
 An effective database monitoring tool does more than track basic metrics—it provides deep visibility into performance, optimizes resource usage, and ensures system reliability. Here are key features to look out for:
 
-1. **Real-Time Performance Tracking & Alerts**: 
-    
-    The tool should provide real-time monitoring of query metrics with minimal latency and support customizable alerting mechanisms to notify teams of performance anomalies promptly. 
-    
-2. **Query Analysis & Optimization Recommendations**: 
-    
-    Advanced tools offer automated suggestions for optimizing queries, such as recommending missing indexes or restructuring suboptimal query plans, thereby enhancing overall database performance.
-    
-3. **Resource Utilization Monitoring**: 
-    
-    Comprehensive tracking of CPU, memory, disk I/O, and network usage is essential to identify and address system-level constraints that may affect database performance. 
-    
-4. **Historical Data Analysis & Trend Forecasting**: 
-    
-    Retaining and analyzing historical metrics is vital for diagnosing long-term issues, understanding usage trends, and making informed decisions about capacity planning and resource allocation.
-    
+1. **Real-Time Performance Tracking & Alerts**:
+
+   The tool should provide real-time monitoring of query metrics with minimal latency and support customizable alerting mechanisms to notify teams of performance anomalies promptly.
+
+2. **Query Analysis & Optimization Recommendations**:
+
+   Advanced tools offer automated suggestions for optimizing queries, such as recommending missing indexes or restructuring suboptimal query plans, thereby enhancing overall database performance.
+
+3. **Resource Utilization Monitoring**:
+
+   Comprehensive tracking of CPU, memory, disk I/O, and network usage is essential to identify and address system-level constraints that may affect database performance.
+
+4. **Historical Data Analysis & Trend Forecasting**:
+
+   Retaining and analyzing historical metrics is vital for diagnosing long-term issues, understanding usage trends, and making informed decisions about capacity planning and resource allocation.
 
 ### Advanced Capabilities to Consider
 
-Advanced monitoring capabilities enable teams to handle complex database environments with precision. From multi-database support to machine learning-driven anomaly detection, these features elevate monitoring from reactive to proactive management.  
+Advanced monitoring capabilities enable teams to handle complex database environments with precision. From multi-database support to machine learning-driven anomaly detection, these features elevate monitoring from reactive to proactive management.
 
-Below are some key advanced functionalities to look for in a robust database monitoring tool: 
+Below are some key advanced functionalities to look for in a robust database monitoring tool:
 
 - **Multi-Database Support**:
-    
-    Tools that support a variety of database engines (e.g., MySQL, PostgreSQL, MongoDB) facilitate unified monitoring across diverse database environments. 
-    
+  Tools that support a variety of database engines (e.g., MySQL, PostgreSQL, MongoDB) facilitate unified monitoring across diverse database environments.
 - **Machine Learning–Driven Anomaly Detection**:
-    
-    Leveraging machine learning algorithms to identify subtle performance degradations that static thresholds might miss enhances proactive issue detection. 
-    
+  Leveraging machine learning algorithms to identify subtle performance degradations that static thresholds might miss enhances proactive issue detection.
 - **Customizable Dashboards & Reporting**:
-    
-    Flexible visualization options including heatmaps and correlation charts empower engineers to gain deeper insights into database performance metrics. 
-    
+  Flexible visualization options including heatmaps and correlation charts empower engineers to gain deeper insights into database performance metrics.
 - **Integration with Other IT/DevOps Tools**:
-    
-    Seamless integration with CI/CD pipelines, incident management systems, and collaboration tools enhances efficiency and incident response times. 
-    
-
+  Seamless integration with CI/CD pipelines, incident management systems, and collaboration tools enhances efficiency and incident response times.
 
 ## Leveraging SigNoz for Comprehensive Database Monitoring
 
@@ -309,28 +403,28 @@ SigNoz is a modern, open-source observability solution that is tailored for moni
 
 ### Enhanced Database Monitoring with Distributed Tracing
 
-Distributed tracing enhances database monitoring by offering a clear view of query execution across microservices. This allows teams to identify slow queries, analyze service interactions, and optimize performance efficiently. 
+Distributed tracing enhances database monitoring by offering a clear view of query execution across microservices. This allows teams to identify slow queries, analyze service interactions, and optimize performance efficiently.
 
 - **Pinpoint Slow Queries:** Visualize the execution path of queries across microservices to identify and address performance bottlenecks.
 - **Service-Level Insights:** Determine the exact service or layer contributing to database time spikes, facilitating targeted optimizations.
 
 ### Setting Up SigNoz for DB Performance Tracking
 
-1. **Installation**: 
-    - [**Self-Hosted Option:**](https://signoz.io/docs/operate/) Offers complete control over the monitoring environment.
-    - [**SigNoz Cloud:**](https://signoz.io/docs/cloud/) Provides a managed service with scalable infrastructure and reduced maintenance overhead.
-2. **Configure OpenTelemetry**: 
-    - **Instrumentation:** Integrate OpenTelemetry to instrument database queries, track connection statistics, and log slow queries.
-    - **Data Collection:** Ensure comprehensive data capture for accurate performance analysis.
-3. **Custom Dashboards & Alerts**: 
-    - **Dashboard Customization:** Create database-specific dashboards tailored to your monitoring needs.
-    - **Alert Thresholds:** Set precise alert thresholds to detect anomalies and trigger notifications effectively.
+1. **Installation**:
+   - [**Self-Hosted Option:**](https://signoz.io/docs/operate/) Offers complete control over the monitoring environment.
+   - [**SigNoz Cloud:**](https://signoz.io/docs/cloud/) Provides a managed service with scalable infrastructure and reduced maintenance overhead.
+2. **Configure OpenTelemetry**:
+   - **Instrumentation:** Integrate OpenTelemetry to instrument database queries, track connection statistics, and log slow queries.
+   - **Data Collection:** Ensure comprehensive data capture for accurate performance analysis.
+3. **Custom Dashboards & Alerts**:
+   - **Dashboard Customization:** Create database-specific dashboards tailored to your monitoring needs.
+   - **Alert Thresholds:** Set precise alert thresholds to detect anomalies and trigger notifications effectively.
 
 For a detailed walkthrough, check out our [Database Monitoring with SigNoz guide](https://signoz.io/guides/database-monitoring/#database-monitoring-using-signoz) to learn how to set up monitoring, analyze performance metrics, and optimize database health effectively.
 
 ### Benefits of SigNoz Cloud
 
-SigNoz cloud simplifies database monitoring by offering a fully managed, scalable infrastructure. With automated updates and real-time metrics streaming, it minimizes operational overhead while delivering actionable insights. 
+SigNoz cloud simplifies database monitoring by offering a fully managed, scalable infrastructure. With automated updates and real-time metrics streaming, it minimizes operational overhead while delivering actionable insights.
 
 - **Managed Infrastructure:**Eliminates the need for on-premises maintenance, allowing teams to focus on core activities.
 - **Automated Updates:**Ensures that the monitoring platform remains up-to-date with the latest features and security patches.
@@ -339,7 +433,6 @@ SigNoz cloud simplifies database monitoring by offering a fully managed, scalabl
 
 <GetStartedSigNoz />
 
-
 ## Key Takeaways
 
 - Database monitoring is critical for maintaining optimal performance, ensuring data integrity, and preventing data loss.
@@ -351,16 +444,16 @@ SigNoz cloud simplifies database monitoring by offering a fully managed, scalabl
 
 ### What is the difference between database monitoring and database management?
 
-Monitoring focuses on performance tracking, while management includes broader tasks like backups, patches, and user administration. 
+Monitoring focuses on performance tracking, while management includes broader tasks like backups, patches, and user administration.
 
 ### How often should I review my database monitoring metrics?
 
-For critical workloads, metrics should be reviewed in near real-time to facilitate prompt incident response. At a minimum, conduct weekly or monthly in-depth reviews to identify trends, plan capacity, and implement performance optimizations. 
+For critical workloads, metrics should be reviewed in near real-time to facilitate prompt incident response. At a minimum, conduct weekly or monthly in-depth reviews to identify trends, plan capacity, and implement performance optimizations.
 
-### Can database monitoring tools help with compliance requirements? 
+### Can database monitoring tools help with compliance requirements?
 
-Yes, many database monitoring tools offer audit logs, anomaly detection, and role-based access control features that assist in demonstrating compliance with regulations like GDPR and HIPAA by providing necessary documentation and security controls. 
+Yes, many database monitoring tools offer audit logs, anomaly detection, and role-based access control features that assist in demonstrating compliance with regulations like GDPR and HIPAA by providing necessary documentation and security controls.
 
 ### Is it better to use a specialized DB monitoring tool or an all-in-one IT monitoring solution?
 
-The choice depends on your organization's size and complexity. Specialized tools provide deeper insights into database performance, while all-in-one solutions offer a broader overview of the entire IT infrastructure. Many organizations adopt a hybrid approach, integrating specialized database monitoring tools with generalist IT monitoring solutions to achieve comprehensive coverage.
\ No newline at end of file
+The choice depends on your organization's size and complexity. Specialized tools provide deeper insights into database performance, while all-in-one solutions offer a broader overview of the entire IT infrastructure. Many organizations adopt a hybrid approach, integrating specialized database monitoring tools with generalist IT monitoring solutions to achieve comprehensive coverage.
diff --git a/data/comparisons/datadog-vs-appdynamics.mdx b/data/comparisons/datadog-vs-appdynamics.mdx
index 7e712e666..da90e32b3 100644
--- a/data/comparisons/datadog-vs-appdynamics.mdx
+++ b/data/comparisons/datadog-vs-appdynamics.mdx
@@ -1,50 +1,58 @@
 ---
 title: Datadog vs AppDynamics - Which Monitoring Tool to Choose? [2025 Guide]
-slug: datadog-vs-appdynamics
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Datadog stands out for its comprehensive approach to system performance observability. AppDynamics, on the other hand, specializes in deep application performance and business transaction monitoring...
 image: /img/blog/2024/04/datadog-vs-appdynamics-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [datadog-vs-appdynamics,datadog,appdynamics,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [
+    datadog-vs-appdynamics,
+    datadog,
+    appdynamics,
+    opentelemetry,
+    open-source,
+    monitoring-tools,
+    signoz,
+  ]
 ---
+
 Datadog and AppDynamics are observability and monitoring tools that provide visibility into the performance and reliability of applications and systems.
 
 Datadog stands out for its comprehensive approach to system performance observability. It provides a broad spectrum of monitoring capabilities, including [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), application performance monitoring (APM), log management, and real user monitoring (RUM).
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/datadog-vs-appdynamics-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/datadog-vs-appdynamics-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 AppDynamics, on the other hand, specializes in deep application performance and business transaction monitoring. It offers advanced features for application performance monitoring, including detailed insights into transaction performance, network monitoring, and end-user experience monitoring.
 
 In this article, we’ll compare Datadog and AppDynamics side by side, looking at their features and differences to help you choose the right tool for your monitoring needs.
 
 ## Datadog vs AppDynamics**: At a glance**
 
-| Features | Datadog | AppDynamics |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Log management | ✅ | ✅ |
-| Infrastructure Monitoring | ✅ | ✅  |
-| Application Security | ✅ | ✅  |
-| Incident Management | ✅ | ❌ |
-| ML capabilities | ✅ | ✅ |
-| OpenTelemetry Support | 🟡  | 🟡  |
-| SAP Monitoring | ✅ | ✅ |
-| Continuous Profiling | ✅ | ❌ |
-| Session replay | ✅ | ✅ |
-| Network Monitoring | ✅ | ✅  |
-| Cloud SIEM | ✅ | ❌ |
-| Real User Monitoring | ✅ | ✅  |
-| SLA Monitoring | ✅ | ❌ |
-| Free trial | 🟡 (14-days) | 🟡 (15-days) |
+| Features                  | Datadog      | AppDynamics  |
+| ------------------------- | ------------ | ------------ |
+| APM                       | ✅           | ✅           |
+| Log management            | ✅           | ✅           |
+| Infrastructure Monitoring | ✅           | ✅           |
+| Application Security      | ✅           | ✅           |
+| Incident Management       | ✅           | ❌           |
+| ML capabilities           | ✅           | ✅           |
+| OpenTelemetry Support     | 🟡           | 🟡           |
+| SAP Monitoring            | ✅           | ✅           |
+| Continuous Profiling      | ✅           | ❌           |
+| Session replay            | ✅           | ✅           |
+| Network Monitoring        | ✅           | ✅           |
+| Cloud SIEM                | ✅           | ❌           |
+| Real User Monitoring      | ✅           | ✅           |
+| SLA Monitoring            | ✅           | ❌           |
+| Free trial                | 🟡 (14-days) | 🟡 (15-days) |
 
 ✅ - Available
 
@@ -59,66 +67,62 @@ Datadog is a cloud-based Software as a Service (SaaS) platform offering comprehe
 ### Key features of Datadog
 
 - **Application Performance Monitoring (APM)**<br/>
-    
-    Datadog offers end-to-end performance monitoring, ensuring that every aspect of your application's performance is tracked and analyzed.
-    
+  Datadog offers end-to-end performance monitoring, ensuring that every aspect of your application's performance is tracked and analyzed.
 - **Log Management**<br/>
-    
-    It offers deep visibility into application logs, correlating them with traces, metrics, and other telemetry data for comprehensive analysis and troubleshooting.
-    
+  It offers deep visibility into application logs, correlating them with traces, metrics, and other telemetry data for comprehensive analysis and troubleshooting.
 - **Synthetic Monitoring**<br/>
-    
-    Synthetic monitoring enables the simulation of user interactions with your applications through code-free API, browser, and mobile tests. This ensures that your applications are functioning as intended from the user's perspective.
-    
+  Synthetic monitoring enables the simulation of user interactions with your applications through code-free API, browser, and mobile tests. This ensures that your applications are functioning as intended from the user's perspective.
 - **Application Security Management**<br/>
-    
-    Datadog is equipped with continuous threat detection and defense mechanisms, offering detailed insights into vulnerabilities and security risks.
-    
+  Datadog is equipped with continuous threat detection and defense mechanisms, offering detailed insights into vulnerabilities and security risks.
 - **Infrastructure Monitoring**<br/>
-    
-    It provides complete visibility into the health and performance of infrastructure components, including servers, databases, and cloud services.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/datadog-vs-appdynamics-datadog.webp" alt="Datadog’s dashboard for host monitoring"/>
-    <figcaption><i>Datadog’s dashboard for host monitoring</i></figcaption>
+  It provides complete visibility into the health and performance of infrastructure components, including servers, databases, and cloud services.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/datadog-vs-appdynamics-datadog.webp"
+    alt="Datadog’s dashboard for host monitoring"
+  />
+  <figcaption>
+    <i>Datadog’s dashboard for host monitoring</i>
+  </figcaption>
 </figure>
 
-
 ## What is AppDynamics?
 
-<a href = "https://www.appdynamics.com" rel="noopener noreferrer nofollow" target="_blank" >AppDynamics</a> is an application and business monitoring platform that provides deep visibility into application performance and business metrics. It empowers businesses to monitor, analyze, and optimize their applications and infrastructure in real-time.
+<a href="https://www.appdynamics.com" rel="noopener noreferrer nofollow" target="_blank">
+  AppDynamics
+</a>
+is an application and business monitoring platform that provides deep visibility into application
+performance and business metrics. It empowers businesses to monitor, analyze, and optimize their
+applications and infrastructure in real-time.
 
-AppDynamics is tailored for enterprise-level businesses that require comprehensive monitoring solutions to manage their complex IT environments effectively. 
+AppDynamics is tailored for enterprise-level businesses that require comprehensive monitoring solutions to manage their complex IT environments effectively.
 
 ### Key features of AppDynamics
 
 - **Application Performance Monitoring:** <br/>
-    
-    AppDynamics' APM provides comprehensive real-time visibility into application performance, enabling the quick identification of root causes of application problems.
-    
+  AppDynamics' APM provides comprehensive real-time visibility into application performance, enabling the quick identification of root causes of application problems.
 - **Network Monitoring:**<br/>
-    
-    This provides visibility into the live network connections in your Kubernetes workloads. It also provides insight into the performance of the networks utilized by your applications.
-    
+  This provides visibility into the live network connections in your Kubernetes workloads. It also provides insight into the performance of the networks utilized by your applications.
 - **Application Security:** <br/>
-    
-    It provides detailed insights into vulnerabilities and security risks that may impact your application and offers continuous threat detection and real-time defense against attacks.
-    
+  It provides detailed insights into vulnerabilities and security risks that may impact your application and offers continuous threat detection and real-time defense against attacks.
 - **End User Monitoring:**<br/>
-    
-    This allows businesses to monitor user sessions across various devices, providing a comprehensive view of user interactions and engagement.
-    
+  This allows businesses to monitor user sessions across various devices, providing a comprehensive view of user interactions and engagement.
 - **Business Transaction Monitoring:**<br/>
-    
-    It gathers data on business transactions, including the impact of these transactions on the business, such as revenue generated and customer satisfaction levels.
-    
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/datadog-vs-appdynamics-appdynamics.webp" alt="Appdynamics observability platform for full visibility of application performance"/>
-    <figcaption><i>Appdynamics observability platform for full visibility of application performance</i></figcaption>
+  It gathers data on business transactions, including the impact of these transactions on the business, such as revenue generated and customer satisfaction levels.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/datadog-vs-appdynamics-appdynamics.webp"
+    alt="Appdynamics observability platform for full visibility of application performance"
+  />
+  <figcaption>
+    <i>Appdynamics observability platform for full visibility of application performance</i>
+  </figcaption>
 </figure>
 
-
 ## Datadog vs AppDynamics: Key Differences
 
 **Ease of use:**
@@ -179,4 +183,3 @@ Some of the key features of SigNoz are:
 [SigNoz - Open-source alternative to Datadog](https://signoz.io/blog/open-source-datadog-alternative/)
 
 [SigNoz - Open-source alternative to AppDynamics](https://signoz.io/blog/appdynamics-alternative/)
-
diff --git a/data/comparisons/datadog-vs-dynatrace.mdx b/data/comparisons/datadog-vs-dynatrace.mdx
index f14d92949..05a2527ff 100644
--- a/data/comparisons/datadog-vs-dynatrace.mdx
+++ b/data/comparisons/datadog-vs-dynatrace.mdx
@@ -1,14 +1,11 @@
 ---
-title: "Datadog vs Dynatrace: Which is Better in 2025? [Hands-On Testing]"
-slug: "datadog-vs-dynatrace"
-date: "2025-09-11"
+title: 'Datadog vs Dynatrace: Which is Better in 2025? [Hands-On Testing]'
+date: '2025-09-11'
 tags: [datadog, dynatrace]
 authors: [debanjan]
-description: "Compare Datadog vs Dynatrace with hands-on testing results. Real pricing examples, AI capabilities, and honest recommendations."
-image: "/img/blog/2024/03/datadog-vs-dynatrace-cover.webp"
+description: 'Compare Datadog vs Dynatrace with hands-on testing results. Real pricing examples, AI capabilities, and honest recommendations.'
+image: '/img/blog/2024/03/datadog-vs-dynatrace-cover.webp'
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
 keywords:
   [datadog-vs-dynatrace, datadog, dynatrace, opentelemetry, open-source, monitoring-tools, signoz]
 ---
@@ -21,20 +18,20 @@ Datadog and Dynatrace are popular tools when it comes to monitoring and observab
 
 Here's a comparison of the main features between Datadog and Dynatrace.
 
-|Feature|Datadog|Dynatrace|
-|---|---|---|
-|Infrastructure monitoring|✅|✅|
-|APM|✅|✅|
-|Log monitoring|✅|✅|
-|Real-User monitoring|✅|✅|
-|SLA Monitoring|✅|✅|
-|OpenTelemetry support|✅|✅|
-|Free tier|✅ (5 hosts)|❌|
-|On premise|❌|✅|
-|Cloud SIEM|✅|✅|
-|Workflow Automation|✅|✅|
-|AIOps|✅ (Watchdog)|✅ (Davis AI)|
-|Access control|✅|✅|
+| Feature                   | Datadog       | Dynatrace     |
+| ------------------------- | ------------- | ------------- |
+| Infrastructure monitoring | ✅            | ✅            |
+| APM                       | ✅            | ✅            |
+| Log monitoring            | ✅            | ✅            |
+| Real-User monitoring      | ✅            | ✅            |
+| SLA Monitoring            | ✅            | ✅            |
+| OpenTelemetry support     | ✅            | ✅            |
+| Free tier                 | ✅ (5 hosts)  | ❌            |
+| On premise                | ❌            | ✅            |
+| Cloud SIEM                | ✅            | ✅            |
+| Workflow Automation       | ✅            | ✅            |
+| AIOps                     | ✅ (Watchdog) | ✅ (Davis AI) |
+| Access control            | ✅            | ✅            |
 
 ✅ - Available &nbsp;&nbsp;&nbsp;&nbsp;❌ - Not Available
 
@@ -309,6 +306,7 @@ One of the key differentiators between these platforms is their approach to arti
 ### Dynatrace Davis AI
 
 Dynatrace's Davis AI is widely recognized as the industry leader in AIOps. It provides:
+
 - **Automated Root Cause Analysis**: Davis AI automatically identifies the root cause of issues without manual investigation
 - **Predictive Problem Detection**: Identifies anomalies before they impact users
 - **Auto-remediation**: Can automatically fix known issues based on predefined playbooks
@@ -317,6 +315,7 @@ Dynatrace's Davis AI is widely recognized as the industry leader in AIOps. It pr
 ### Datadog Watchdog
 
 Datadog's Watchdog takes a different approach:
+
 - **Anomaly Detection**: Identifies unusual patterns across metrics and logs
 - **Alert Correlation**: Groups related alerts to reduce noise
 - **Suggested Dashboards**: Recommends relevant dashboards during incidents
@@ -333,13 +332,15 @@ After testing both platforms, I wanted to understand the actual costs organizati
 Let me break down what you might expect to pay:
 
 **Datadog Costs:**
+
 - [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/): \$15/host = \$1,500/month
-- APM: \$40/host = \$4,000/month  
+- APM: \$40/host = \$4,000/month
 - Log Management: \$0.10/GB ingested = \$5,000/month
 - Custom Metrics: Often adds 30-50% to your bill
 - **Estimated Total: ~\$13,000-15,000/month**
 
 **Dynatrace Costs:**
+
 - Full-Stack Monitoring: \$58/host = \$5,800/month
 - Includes APM, logs, RUM, and infrastructure
 - No separate charges for custom metrics
@@ -350,12 +351,14 @@ For a detailed breakdown of Datadog's pricing complexities and hidden costs, che
 ### What to Watch Out For
 
 **With Datadog:**
+
 - Custom metrics can explode costs (each tag combination creates a new metric)
 - 99th percentile billing means brief spikes can affect your entire month's bill
 - Log ingestion and indexing are charged separately
 - Each module (APM, Infrastructure, Logs) has its own pricing
 
 **With Dynatrace:**
+
 - Higher base price per host compared to individual Datadog modules
 - Less flexibility if you only need specific features
 - Additional training might be needed due to the steeper learning curve
@@ -393,18 +396,19 @@ Both Datadog and Dynatrace have a good amount of official documentation. Between
 
 Datadog also has a lot of explainer videos on YouTube that might help you set things up faster.
 
-
 ## Datadog vs Dynatrace: Final Verdict
 
 After using both tools and analyzing real-world experiences, here's the bottom line:
 
 **Dynatrace wins on**:
+
 - Total cost of ownership (3x cheaper at scale)
 - AI-powered automation (Davis AI is superior)
 - Unified platform approach
 - Enterprise readiness
 
 **Datadog wins on**:
+
 - Developer experience and ease of use
 - Ecosystem and integrations
 - Dashboard flexibility
@@ -433,6 +437,7 @@ SigNoz is a unified observability platform that provides:
 - **Advanced features**: [Distributed tracing](https://signoz.io/blog/distributed-tracing/), service maps, custom dashboards
 
 Key advantages over Datadog and Dynatrace:
+
 - **No per-host pricing**: Scale without worrying about host count
 - **Predictable costs**: Simple usage-based pricing
 - **Open-source option**: Self-host for complete control
@@ -444,6 +449,6 @@ Teams report 70-90% cost savings compared to Datadog while maintaining full obse
 
 You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features.
 
-Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).  
+Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
-Those who have the expertise to manage SigNoz themselves or just want to start with a free self-hosted option can use our [community edition](https://signoz.io/docs/install/self-host/).
\ No newline at end of file
+Those who have the expertise to manage SigNoz themselves or just want to start with a free self-hosted option can use our [community edition](https://signoz.io/docs/install/self-host/).
diff --git a/data/comparisons/datadog-vs-elasticstack.mdx b/data/comparisons/datadog-vs-elasticstack.mdx
index 4e197f1fb..f62b866ff 100644
--- a/data/comparisons/datadog-vs-elasticstack.mdx
+++ b/data/comparisons/datadog-vs-elasticstack.mdx
@@ -1,14 +1,11 @@
 ---
 title: Datadog vs Elastic stack - In-Depth Comparison Guide [2025]
-slug: datadog-vs-elasticstack
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Datadog provides a comprehensive platform for monitoring and analyzing system performance and errors, while ELK (Elasticsearch, Logstash, and Kibana) offers a powerful open-source stack for log management and analytics...
 image: /img/blog/2024/04/datadog-vs-elasticstack-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
 keywords:
   [
     datadog-vs-elasticstack,
@@ -20,6 +17,7 @@ keywords:
     signoz,
   ]
 ---
+
 Datadog and Elastic Stack are both widely used platforms for monitoring and analyzing data, offering comprehensive solutions for various use cases including log management, infrastructure monitoring, application performance monitoring, and more.
 
 <figure data-zoomable align="center">
diff --git a/data/comparisons/datadog-vs-sentry.mdx b/data/comparisons/datadog-vs-sentry.mdx
index 14bc1f90a..b0bd07df4 100644
--- a/data/comparisons/datadog-vs-sentry.mdx
+++ b/data/comparisons/datadog-vs-sentry.mdx
@@ -1,16 +1,14 @@
 ---
 title: Datadog vs Sentry - Which Monitoring Tool to Choose? [2025 Guide]
-slug: datadog-vs-sentry
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Datadog is tailored towards application performance and full stack observability of systems while Sentry specializes in identifying and reporting application errors...
 image: /img/blog/2024/04/datadog-vs-sentry-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
 keywords: [datadog-vs-sentry, datadog, sentry, opentelemetry, open-source, monitoring-tools, signoz]
 ---
+
 Datadog and Sentry are monitoring tools but with different use cases. Datadog is tailored towards application performance and full stack observability of systems while Sentry specializes in identifying and reporting application errors.
 
 In this post, I have compared Datadog and Sentry on important features like error monitoring, APM, log management, etc.
diff --git a/data/comparisons/datadog-vs-splunk.mdx b/data/comparisons/datadog-vs-splunk.mdx
index 99b78fa56..fc7b8877d 100644
--- a/data/comparisons/datadog-vs-splunk.mdx
+++ b/data/comparisons/datadog-vs-splunk.mdx
@@ -1,14 +1,11 @@
 ---
 title: Datadog vs Splunk - Which Observability Tool Fits Your Needs?
-slug: datadog-vs-splunk
 date: 2024-08-08
 tags: [tools-comparison]
 authors: [daniel]
 description: DataDog and Splunk are popular observability tools. If you are looking for observability and monitoring, you should choose Datadog over Splunk. Splunk also provides good observability and monitoring, but it is best suited for log management...
 image: /img/blog/2024/03/datadog-vs-splunk-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
 keywords: [datadog-vs-splunk, datadog, splunk, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
diff --git a/data/comparisons/digitalocean-alternatives.mdx b/data/comparisons/digitalocean-alternatives.mdx
index 48d8d48bb..63cc51f9e 100644
--- a/data/comparisons/digitalocean-alternatives.mdx
+++ b/data/comparisons/digitalocean-alternatives.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top 10 DigitalOcean Alternatives - Cheaper and More Scalable
-slug: digitalocean-alternatives
 date: 2024-08-23
 tags: [tools-comparision]
 authors: [sushant_gaurav]
 description: Discover 10 cost-effective and scalable DigitalOcean alternatives for your cloud infrastructure needs. Compare features, pricing, and performance.
-keywords: [digitalocean alternatives, cloud hosting, cloud infrastructure, scalable hosting, affordable cloud providers]
-
+keywords:
+  [
+    digitalocean alternatives,
+    cloud hosting,
+    cloud infrastructure,
+    scalable hosting,
+    affordable cloud providers,
+  ]
 ---
 
 Cloud infrastructure enables innovative applications, but selecting the correct provider can be difficult. While DigitalOcean has long been a favourite among developers and small businesses because of its simplicity and developer-friendly features, the cloud world is continuously changing. This evolution generates a variety of possibilities that may better meet your increasing or changing requirements. This article examines 10 [DigitalOcean alternatives](https://signoz.io/comparisons/digitalocean-alternatives/#4-google-cloud-platform), concentrating on cost-effectiveness and scalability. We'll look at each provider's unique features, pricing strategies, and optimal use cases, so you can make an informed decision about your cloud infrastructure needs.
@@ -37,27 +41,34 @@ Unlike traditional hosting, which frequently involves renting physical servers w
 
 ## Overview: Comparison Table
 
-| Tool | Type | Key Features | Best For | Drawbacks | Comparison with DigitalOcean |
-|------|------|--------------|----------|-----------|------------------------------|
-| Vultr | Cloud Infrastructure | • 100% SSD storage<br />• High-performance compute<br />• Wide range of pricing options | Developers needing global data centers | Limited managed services compared to other platforms | • More granular billing options<br />• Better performance in I/O tasks<br />• More global data center locations |
-| Linode | Cloud Infrastructure | • Extensive documentation<br />• API-first approach<br />• Advanced networking features | Developers requiring high customization | Interface less user-friendly than competitors | • Superior customer support<br />• Better for advanced users<br />• Comparable network performance but region-dependent |
-| AWS | Cloud Infrastructure | • Extensive service portfolio<br />• Global availability<br />• Advanced AI and ML tools | Large-scale enterprises | Complexity and cost can be overwhelming for small projects | • Unmatched scalability and service variety<br />• More expensive and complex<br />• Better suited for large projects |
-| Google Cloud | Cloud Infrastructure | • Powerful AI and ML capabilities<br />• Generous free tier<br />• Global network | Data-driven applications, AI/ML projects | Can be complex to configure for small teams | • Superior AI/ML tools<br />• More extensive free tier<br />• Global coverage but more extensive infrastructure |
-| Microsoft Azure | Cloud Infrastructure | • Seamless Microsoft product integration<br />• Advanced enterprise features<br />• Extensive global network | Enterprises using Microsoft products | The steeper learning curve, especially for non-Microsoft users | • Better enterprise integration<br />• A wider array of services<br />• More complex and expensive for smaller projects |
-| Kamatera | Cloud Infrastructure | • Flexible server customization<br />• Personalized support<br />• Wide range of configurations | Custom server setups | Less beginner-friendly interface | • More customization options<br />• More personalized support<br />• Flexible billing but less intuitive than DigitalOcean |
-| Hostwinds | Managed Hosting | • 24/7 live support<br />• Custom server configurations<br />• DDoS protection included | Managed hosting for businesses | Fewer data center locations compared to larger providers | • More customer-centric support<br />• Additional features like free migrations<br />• Less global presence |
-| OVHcloud | Cloud Infrastructure | • Strong European presence<br />• Affordable pricing<br />• High-performance servers | European businesses | Limited global presence outside Europe | • Better for EU-based users<br />• More competitive pricing in Europe<br />• Offers more customized setups in certain regions |
-| Hetzner Cloud | Cloud Infrastructure | • Highly competitive pricing<br />• High-performance hardware<br />• Strong presence in Europe | Cost-conscious developers targeting Europe | Primarily Europe-based, limiting global reach | • Cheaper for larger deployments<br />• More region-specific options<br />• Less user-friendly interface than DigitalOcean |
-| Cloudways | Managed Cloud Hosting | • Managed services across multiple providers<br />• Simple setup for non-technical users<br />• Performance optimization tools | Small to medium-sized businesses seeking managed hosting | Less control over the underlying infrastructure | • Managed services vs. DIY on DigitalOcean<br />• Less customization but easier to manage<br />• Performance depends on the chosen provider |
+| Tool            | Type                  | Key Features                                                                                                                   | Best For                                                 | Drawbacks                                                      | Comparison with DigitalOcean                                                                                                                |
+| --------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Vultr           | Cloud Infrastructure  | • 100% SSD storage<br />• High-performance compute<br />• Wide range of pricing options                                        | Developers needing global data centers                   | Limited managed services compared to other platforms           | • More granular billing options<br />• Better performance in I/O tasks<br />• More global data center locations                             |
+| Linode          | Cloud Infrastructure  | • Extensive documentation<br />• API-first approach<br />• Advanced networking features                                        | Developers requiring high customization                  | Interface less user-friendly than competitors                  | • Superior customer support<br />• Better for advanced users<br />• Comparable network performance but region-dependent                     |
+| AWS             | Cloud Infrastructure  | • Extensive service portfolio<br />• Global availability<br />• Advanced AI and ML tools                                       | Large-scale enterprises                                  | Complexity and cost can be overwhelming for small projects     | • Unmatched scalability and service variety<br />• More expensive and complex<br />• Better suited for large projects                       |
+| Google Cloud    | Cloud Infrastructure  | • Powerful AI and ML capabilities<br />• Generous free tier<br />• Global network                                              | Data-driven applications, AI/ML projects                 | Can be complex to configure for small teams                    | • Superior AI/ML tools<br />• More extensive free tier<br />• Global coverage but more extensive infrastructure                             |
+| Microsoft Azure | Cloud Infrastructure  | • Seamless Microsoft product integration<br />• Advanced enterprise features<br />• Extensive global network                   | Enterprises using Microsoft products                     | The steeper learning curve, especially for non-Microsoft users | • Better enterprise integration<br />• A wider array of services<br />• More complex and expensive for smaller projects                     |
+| Kamatera        | Cloud Infrastructure  | • Flexible server customization<br />• Personalized support<br />• Wide range of configurations                                | Custom server setups                                     | Less beginner-friendly interface                               | • More customization options<br />• More personalized support<br />• Flexible billing but less intuitive than DigitalOcean                  |
+| Hostwinds       | Managed Hosting       | • 24/7 live support<br />• Custom server configurations<br />• DDoS protection included                                        | Managed hosting for businesses                           | Fewer data center locations compared to larger providers       | • More customer-centric support<br />• Additional features like free migrations<br />• Less global presence                                 |
+| OVHcloud        | Cloud Infrastructure  | • Strong European presence<br />• Affordable pricing<br />• High-performance servers                                           | European businesses                                      | Limited global presence outside Europe                         | • Better for EU-based users<br />• More competitive pricing in Europe<br />• Offers more customized setups in certain regions               |
+| Hetzner Cloud   | Cloud Infrastructure  | • Highly competitive pricing<br />• High-performance hardware<br />• Strong presence in Europe                                 | Cost-conscious developers targeting Europe               | Primarily Europe-based, limiting global reach                  | • Cheaper for larger deployments<br />• More region-specific options<br />• Less user-friendly interface than DigitalOcean                  |
+| Cloudways       | Managed Cloud Hosting | • Managed services across multiple providers<br />• Simple setup for non-technical users<br />• Performance optimization tools | Small to medium-sized businesses seeking managed hosting | Less control over the underlying infrastructure                | • Managed services vs. DIY on DigitalOcean<br />• Less customization but easier to manage<br />• Performance depends on the chosen provider |
 
 ## Top 10 DigitalOcean Alternatives
 
 ### 1. Vultr
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image.webp" alt="Vultr" caption="Vultr (credits: vultr)" />
-
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image.webp"
+  alt="Vultr"
+  caption="Vultr (credits: vultr)"
+/>
 
-<a href="https://www.vultr.com/" rel="noopener noreferrer nofollow" target="_blank">Vultr</a> offers an easily understood and user-friendly cloud platform, making it a viable option against Digital Ocean for individuals who value simplicity and cost-effectiveness.
+<a href="https://www.vultr.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Vultr
+</a>
+offers an easily understood and user-friendly cloud platform, making it a viable option against
+Digital Ocean for individuals who value simplicity and cost-effectiveness.
 
 - Pricing: Vultr plans start at $2.50 per month, making them one of the cheapest solutions accessible. This cost can be especially useful for smaller projects or those just getting started, as it provides a low barrier to entry.
 - Features: In addition to standard compute instances, Vultr provides bare metal servers for improved performance, dedicated GPU instances for AI and machine learning operations, and block storage for scalable data storage.
@@ -71,10 +82,17 @@ Comparison with DigitalOcean:
 
 ### 2. Linode (Akamai Connected Cloud)
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%201.webp" alt="Linode" caption="Linode (credits: linode)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%201.webp"
+  alt="Linode"
+  caption="Linode (credits: linode)"
+/>
 
-
-<a href="https://www.linode.com/" rel="noopener noreferrer nofollow" target="_blank">Linode</a>, which just joined Akamai's worldwide network, combines its developer-focused cloud architecture with Akamai's increased performance and reach.
+<a href="https://www.linode.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Linode
+</a>
+, which just joined Akamai's worldwide network, combines its developer-focused cloud architecture
+with Akamai's increased performance and reach.
 
 - Services: Linode provides a variety of cloud services, such as virtual machines, Kubernetes for container orchestration, and managed databases, making it suitable for a wide range of use cases.
 - Pricing: Linode's pricing remains competitive, with basic instances starting at $5 per month. This pricing is equivalent to DigitalOcean but includes Akamai's worldwide content delivery capabilities.
@@ -88,10 +106,17 @@ Comparison with DigitalOcean:
 
 ### 3. AWS (Amazon Web Services)
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%202.webp" alt="AWS" caption="AWS (credits: aws.amazon)" />
-
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%202.webp"
+  alt="AWS"
+  caption="AWS (credits: aws.amazon)"
+/>
 
-<a href="https://aws.amazon.com/" rel="noopener noreferrer nofollow" target="_blank">AWS</a> is the industry leader in cloud services, providing the most complete and scalable solutions for projects of all sizes and types.
+<a href="https://aws.amazon.com/" rel="noopener noreferrer nofollow" target="_blank">
+  AWS
+</a>
+is the industry leader in cloud services, providing the most complete and scalable solutions for
+projects of all sizes and types.
 
 - Scalability: AWS's scalability is unparalleled, enabling everything from small websites to large enterprise applications with ease. Netflix, for example, uses AWS to accommodate millions of concurrent users throughout the world.
 - Pricing: While AWS's pricing strategy can be complex, it provides cost-saving opportunities through reserved instances, spot instances, and a range of pricing plans. However, to minimize unforeseen charges, usage should be properly managed and monitored.
@@ -105,9 +130,17 @@ Comparison with DigitalOcean:
 
 ### 4. Google Cloud Platform
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%203.webp" alt="Google Cloud Platform" caption="Google Cloud Platform (credits: cloud.google)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%203.webp"
+  alt="Google Cloud Platform"
+  caption="Google Cloud Platform (credits: cloud.google)"
+/>
 
-<a href="https://cloud.google.com/" rel="noopener noreferrer nofollow" target="_blank">Google Cloud</a> excels at providing advanced functionality, notably in the areas of big data, machine learning, and AI, making it an excellent choice for data-driven applications.
+<a href="https://cloud.google.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Google Cloud
+</a>
+excels at providing advanced functionality, notably in the areas of big data, machine learning, and
+AI, making it an excellent choice for data-driven applications.
 
 - Connection: One of Google Cloud's primary benefits is its seamless connection with the Google ecosystem, which includes services like Google Workspace, BigQuery for data analytics, and TensorFlow for machine learning. This is especially advantageous for firms who currently use other Google services.
 - Pricing: Google Cloud has a generous free tier, making it suitable for startups and small projects. Furthermore, its competitive cost for compute instances enables organizations to scale efficiently.
@@ -121,9 +154,17 @@ Comparison with DigitalOcean:
 
 ### 5. Microsoft Azure
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%204.webp" alt="Azure" caption="Azure (credits: azure.microsoft)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%204.webp"
+  alt="Azure"
+  caption="Azure (credits: azure.microsoft)"
+/>
 
-<a href="https://azure.microsoft.com/" rel="noopener noreferrer nofollow" target="_blank">Azure</a> excels at catering to corporations, particularly those that are already integrated into the Microsoft ecosystem, making it a good alternative for large organizations.
+<a href="https://azure.microsoft.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Azure
+</a>
+excels at catering to corporations, particularly those that are already integrated into the
+Microsoft ecosystem, making it a good alternative for large organizations.
 
 - Hybrid capabilities: Azure's strong support for hybrid cloud configurations enables enterprises to seamlessly combine on-premises infrastructure with the cloud. This is especially useful for businesses in highly regulated industries or with legacy systems that cannot be completely transferred to the cloud.
 - Enterprise focus: Azure provides powerful identity management and compliance solutions, such as Azure Active Directory and Azure Policy, that are essential for ensuring enterprise security and compliance.
@@ -137,9 +178,17 @@ Comparison with DigitalOcean:
 
 ### 6. Kamatera
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%205.webp" alt="Kamaters" caption="Kamaters (credits: kamatera)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%205.webp"
+  alt="Kamaters"
+  caption="Kamaters (credits: kamatera)"
+/>
 
-<a href="https://www.kamatera.com/" rel="noopener noreferrer nofollow" target="_blank">Kamatera</a> stands out for its great level of flexibility, allowing users to build their cloud architecture to their specific requirements.
+<a href="https://www.kamatera.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Kamatera
+</a>
+stands out for its great level of flexibility, allowing users to build their cloud architecture to
+their specific requirements.
 
 - Flexibility: Kamatera enables customers to design bespoke server configurations, including the exact amount of CPU, RAM, storage, and networking resources required. This granularity can result in significant cost savings, especially for firms that have precise performance requirements.
 - Quick deployment: Kamatera's infrastructure enables quick server deployment, with fresh instances accessible in minutes. This speed makes it excellent for companies that need to rapidly grow resources or start new projects.
@@ -153,10 +202,17 @@ Comparison with DigitalOcean:
 
 ### 7. Hostwinds
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%206.webp" alt="Hostwinds" caption="Hostwinds (credits: hostwinds)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%206.webp"
+  alt="Hostwinds"
+  caption="Hostwinds (credits: hostwinds)"
+/>
 
-
-<a href="https://www.hostwinds.com/" rel="noopener noreferrer nofollow" target="_blank">Hostwinds</a> offers a wide range of hosting solutions, from simple shared hosting to more advanced cloud services, making it a good alternative for enterprises with varying needs.
+<a href="https://www.hostwinds.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Hostwinds
+</a>
+offers a wide range of hosting solutions, from simple shared hosting to more advanced cloud
+services, making it a good alternative for enterprises with varying needs.
 
 - Variety: Hostwinds provides a diverse selection of services, including shared hosting, VPS, and dedicated servers, in addition to cloud choices. Because of its diversity, it serves as a one-stop shop for businesses at any stage of development.
 - Customer service: Hostwinds is well-known for offering prompt and courteous customer service 24 hours a day, seven days a week. This can be a significant advantage for businesses that require continuous, round-the-clock service.
@@ -170,10 +226,17 @@ Comparison with DigitalOcean:
 
 ### 8. OVHcloud
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%207.webp" alt="OVHcoud" caption="OVHcoud (credits: ovhcloud)" />
-
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%207.webp"
+  alt="OVHcoud"
+  caption="OVHcoud (credits: ovhcloud)"
+/>
 
-<a href="https://www.ovhcloud.com" rel="noopener noreferrer nofollow" target="_blank">OVHcloud</a> is a European provider, that excels in data sovereignty and compliance, making it an excellent alternative for enterprises with stringent data residency needs.
+<a href="https://www.ovhcloud.com" rel="noopener noreferrer nofollow" target="_blank">
+  OVHcloud
+</a>
+is a European provider, that excels in data sovereignty and compliance, making it an excellent
+alternative for enterprises with stringent data residency needs.
 
 - Data sovereignty: OVHcloud's European roots make it a good choice for enterprises that must comply with data residency rules like GDPR. It provides data centers in a variety of European countries, guaranteeing that data remains inside certain geographical bounds.
 - Bare metal: OVHcloud provides both cloud and bare metal servers, enabling high-performance solutions for resource-intensive applications. This makes it ideal for enterprises that demand dedicated hardware, such as gaming companies or those with enormous databases.
@@ -187,10 +250,17 @@ Comparison with DigitalOcean:
 
 ### 9. Hetzner Cloud
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%208.webp" alt="Hetzner Cloud" caption="Hetzner Cloud (credits: hetzner)" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%208.webp"
+  alt="Hetzner Cloud"
+  caption="Hetzner Cloud (credits: hetzner)"
+/>
 
-
-<a href="https://www.hetzner.com/cloud/" rel="noopener noreferrer nofollow" target="_blank">Hetzner Cloud</a> is well-known for its low prices and reliable performance, making it a popular choice for cost-conscious enterprises.
+<a href="https://www.hetzner.com/cloud/" rel="noopener noreferrer nofollow" target="_blank">
+  Hetzner Cloud
+</a>
+is well-known for its low prices and reliable performance, making it a popular choice for
+cost-conscious enterprises.
 
 - Cost-effective: Hetzner Cloud has among the industry's lowest pricing for comparable resources, making it a good choice for startups and small enterprises.
 - Performance: Despite its reduced price, Hetzner Cloud delivers high-quality performance. It consistently performs well in performance standards, making it a dependable option for enterprises seeking economical yet strong infrastructure.
@@ -204,10 +274,17 @@ Comparison with DigitalOcean:
 
 ### 10. Cloudways (Managed Cloud Hosting)
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%209.webp" alt="Cloudways" caption="Cloudways (credits: cloudways)" />
-
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%209.webp"
+  alt="Cloudways"
+  caption="Cloudways (credits: cloudways)"
+/>
 
-<a href="https://www.cloudways.com/" rel="noopener noreferrer nofollow" target="_blank">Cloudways</a> is a managed cloud hosting platform that makes cloud management easier by abstracting away much of the underlying complexity.
+<a href="https://www.cloudways.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Cloudways
+</a>
+is a managed cloud hosting platform that makes cloud management easier by abstracting away much of
+the underlying complexity.
 
 - Simplicity: Cloudways controls the underlying cloud infrastructure for you, including server maintenance, security, and backups. This enables you to concentrate on your applications rather than infrastructure administration.
 - Choice: Cloudways enables you to deploy your apps across many cloud providers, including AWS, Google Cloud, DigitalOcean, and others. This flexibility allows you to select the optimal infrastructure for your requirements while still benefiting from Cloudways' managed services.
@@ -277,7 +354,11 @@ Migrating from DigitalOcean to another cloud provider involves several steps to
 
 Regardless of the cloud provider you use, monitoring your infrastructure is critical for sustaining performance and minimizing expenses. A well-monitored environment helps to guarantee that your applications run smoothly and without unexpected downtimes or performance issues, which can have a direct influence on the end-user experience.
 
-<Figure src="/img/comparisons/2024/08/digitalocean-alternatives-image%2010.webp" alt="SigNoz" caption="SigNoz" />
+<Figure
+  src="/img/comparisons/2024/08/digitalocean-alternatives-image%2010.webp"
+  alt="SigNoz"
+  caption="SigNoz"
+/>
 
 [SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability tool that provides a full view of your cloud resources. It is designed to interact with modern, distributed systems, making it ideal for cloud-native applications.
 
diff --git a/data/comparisons/docker-alternatives.mdx b/data/comparisons/docker-alternatives.mdx
index 66b5f9177..07269515e 100644
--- a/data/comparisons/docker-alternatives.mdx
+++ b/data/comparisons/docker-alternatives.mdx
@@ -1,11 +1,27 @@
 ---
-title: "15 Best Docker Alternatives for 2025: Complete Guide with Pros, Cons & Migration"
-slug: "docker-alternatives"
-date: "2025-07-23"
+title: '15 Best Docker Alternatives for 2025: Complete Guide with Pros, Cons & Migration'
+date: '2025-07-23'
 tags: [docker]
 authors: [manjunath_irukulla]
-description: "Discover the top 15 Docker alternatives for 2025 with detailed pros, cons, migration guides, and performance comparisons. Choose the perfect containerization solution for your specific needs."
-keywords: [docker alternatives, containerization, podman, containerd, kubernetes, container runtime, oci compliance, rootless containers, daemonless architecture, docker migration, cri-o, lxc, buildah, rancher desktop, openshift]
+description: 'Discover the top 15 Docker alternatives for 2025 with detailed pros, cons, migration guides, and performance comparisons. Choose the perfect containerization solution for your specific needs.'
+keywords:
+  [
+    docker alternatives,
+    containerization,
+    podman,
+    containerd,
+    kubernetes,
+    container runtime,
+    oci compliance,
+    rootless containers,
+    daemonless architecture,
+    docker migration,
+    cri-o,
+    lxc,
+    buildah,
+    rancher desktop,
+    openshift,
+  ]
 ---
 
 For years, Docker has been the go-to tool for containerization, but the landscape is evolving. Today, many developers and organizations are exploring Docker alternatives to address concerns around security, cost, and complexity.
@@ -18,11 +34,11 @@ This guide will walk you through 15 of the best [Docker alternatives](https://si
 
 While Docker made containers popular, some of its design choices have led users to seek other options:
 
-*   **Security Risks**: Docker's architecture relies on a central daemon that runs with root privileges. If this daemon is ever compromised, an attacker could gain control over every container on the system, creating a single point of failure.
+- **Security Risks**: Docker's architecture relies on a central daemon that runs with root privileges. If this daemon is ever compromised, an attacker could gain control over every container on the system, creating a single point of failure.
 
-*   **Licensing Costs**: Docker Desktop, the popular version of Docker for Windows and macOS, now requires a paid subscription for use in larger businesses. This has pushed many to look for free, open-source alternatives.
+- **Licensing Costs**: Docker Desktop, the popular version of Docker for Windows and macOS, now requires a paid subscription for use in larger businesses. This has pushed many to look for free, open-source alternatives.
 
-*   **Resource Usage**: The [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) can be resource-intensive, consuming memory and CPU that could otherwise be used by applications. In large-scale deployments, this overhead can add up.
+- **Resource Usage**: The [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) can be resource-intensive, consuming memory and CPU that could otherwise be used by applications. In large-scale deployments, this overhead can add up.
 
 ## Will My Existing Images Still Work with Docker Alternatives?
 
@@ -30,19 +46,28 @@ Yes, almost certainly. The good news is that you won't have to rebuild all your
 
 Because Docker and all the major alternatives follow these OCI standards, you can use the same container images you built with Docker on a different runtime. This prevents vendor lock-in and makes switching tools much easier.
 
-## Top 15 Docker Alternatives 
+## Top 15 Docker Alternatives
 
-<Figure src="/img/comparisons/2024/08/docker-alternatives-Thumb.webp" alt="Comprehensive overview of Docker alternative containerization tools" caption="15 Docker alternatives offering enhanced security, performance, and flexibility for containerized applications" />
+<Figure
+  src="/img/comparisons/2024/08/docker-alternatives-Thumb.webp"
+  alt="Comprehensive overview of Docker alternative containerization tools"
+  caption="15 Docker alternatives offering enhanced security, performance, and flexibility for containerized applications"
+/>
 
 ### 1. Podman - A Secure, Daemonless Alternative
 
-<Figure src="/img/comparisons/2025/07/podman-desktop-python-app.webp" alt="Podman Desktop Screenshot" caption="Podman Desktop provides a graphical interface for managing containers. Image credit: podman-desktop.io" />
+<Figure
+  src="/img/comparisons/2025/07/podman-desktop-python-app.webp"
+  alt="Podman Desktop Screenshot"
+  caption="Podman Desktop provides a graphical interface for managing containers. Image credit: podman-desktop.io"
+/>
 
 Podman is a popular Docker alternative that was designed with security as a top priority. Its main advantage is that it is **daemonless**, meaning it runs containers without a central background service. This, combined with its ability to run in **rootless** mode, makes it one of the most secure container runtimes available.
 
 **Architecture**: Podman runs containers as direct child processes of the user's session. This simple design eliminates the central daemon, which is a common attack vector in Docker.
 
 **Key Features:**
+
 - **Rootless by Default**: Runs containers as a regular user, not as the powerful "root" user.
 - **Pod Support**: Can manage groups of related containers together in "pods," similar to Kubernetes.
 - **Docker CLI Compatibility**: You can often use `podman` as a drop-in replacement for the `docker` command.
@@ -50,6 +75,7 @@ Podman is a popular Docker alternative that was designed with security as a top
 - **Docker Compose Support**: Can run multi-container applications defined in `docker-compose.yml` files.
 
 **Pros:**
+
 - More secure because it has no central daemon and runs without root privileges.
 - Uses less memory than Docker.
 - Integrates well with modern Linux systems.
@@ -57,6 +83,7 @@ Podman is a popular Docker alternative that was designed with security as a top
 - Backed by Red Hat, ensuring long-term support.
 
 **Cons:**
+
 - Networking in rootless mode can be slower in some high-performance scenarios.
 - Does not support Docker Swarm.
 - Support for Windows is still catching up to Docker Desktop.
@@ -67,13 +94,18 @@ Podman is a popular Docker alternative that was designed with security as a top
 
 ### 2. Containerd - The Engine Under the Hood
 
-<Figure src="/img/comparisons/2024/08/docker-alternatives-Untitled.webp" alt="`nerdctl` Command Line client for containerd" caption="`nerdctl` Command Line client for containerd" />
+<Figure
+  src="/img/comparisons/2024/08/docker-alternatives-Untitled.webp"
+  alt="`nerdctl` Command Line client for containerd"
+  caption="`nerdctl` Command Line client for containerd"
+/>
 
 `containerd` is the core container runtime that was originally extracted from the Docker project. Today, it is the industry-standard engine that powers many container platforms, including Docker itself, as well as major Kubernetes services from Google, AWS, and Microsoft.
 
 **Architecture**: A minimal, efficient runtime focused on the core tasks of managing the container lifecycle (starting, stopping, etc.). It is designed to be embedded into larger systems.
 
 **Key Features:**
+
 - **Minimal and Efficient**: A streamlined runtime with a small resource footprint.
 - **The Kubernetes Standard**: The default container runtime for most Kubernetes distributions.
 - **OCI Compliant**: Fully supports the OCI standards for images and runtimes.
@@ -81,12 +113,14 @@ Podman is a popular Docker alternative that was designed with security as a top
 - **Industry-Standard**: Used and trusted by all major cloud providers.
 
 **Pros:**
+
 - Very lightweight and fast, with low resource usage.
 - Proven to be stable and reliable in massive production environments.
 - Backed by the Cloud Native Computing Foundation (CNCF).
 - Integrates seamlessly with Kubernetes without any extra layers.
 
 **Cons:**
+
 - Not designed to be user-friendly on its own; it lacks a built-in command-line interface like Docker's.
 - To use it directly, you need an additional tool like `nerdctl` to provide a familiar experience.
 - Has fewer high-level features than a full-featured tool like Docker or Podman.
@@ -102,6 +136,7 @@ LXC and its management layer, LXD, create **system containers**, which are diffe
 **Architecture**: Uses Linux kernel features (namespaces and cgroups) to provide OS-level virtualization, isolating a complete operating system instead of just a single application.
 
 **Key Features:**
+
 - **Full OS Containers**: Run complete Linux distributions with their own init systems.
 - **Unprivileged Mode**: Can run without root privileges for better security.
 - **Live Migration**: Move running containers between different machines with no downtime.
@@ -109,12 +144,14 @@ LXC and its management layer, LXD, create **system containers**, which are diffe
 - **REST API**: LXD provides a modern API for management and clustering.
 
 **Pros:**
+
 - Performance is close to a native installation, with less overhead than a full VM.
 - Strong isolation between the container and the host system.
 - Ideal for moving older applications into a container-like workflow.
 - Mature and stable technology with a long history.
 
 **Cons:**
+
 - A different approach from Docker, which may require a mindset shift.
 - Steeper learning curve for those accustomed to application containers.
 - Primarily focused on Linux, with limited support for other platforms.
@@ -130,6 +167,7 @@ CRI-O is a lightweight container runtime created specifically for Kubernetes. It
 **Architecture**: A lean implementation of the CRI that uses OCI-compliant runtimes like `runc` to launch containers. It is designed to be a simple bridge between Kubernetes and the container runtime.
 
 **Key Features:**
+
 - **Kubernetes Native**: Built from the ground up to work with Kubernetes.
 - **Minimalist Design**: Strips out any features not required by Kubernetes, reducing its footprint.
 - **Multi-Runtime Support**: Can use different OCI runtimes as its backend.
@@ -137,12 +175,14 @@ CRI-O is a lightweight container runtime created specifically for Kubernetes. It
 - **CNCF Project**: Maintained by the Cloud Native Computing Foundation, ensuring community support.
 
 **Pros:**
+
 - Highly optimized for Kubernetes, resulting in lower resource usage and faster performance.
 - A smaller attack surface because it has fewer features.
 - Strong security model with support for various security policies.
 - Avoids features that could lead to vulnerabilities.
 
 **Cons:**
+
 - Only works within a Kubernetes environment; it cannot be used as a standalone tool.
 - Lacks the user-friendly management tools found in Docker.
 - Requires Kubernetes to be useful.
@@ -158,6 +198,7 @@ Buildah is a specialized tool that focuses on one thing: building OCI-compliant
 **Architecture**: A daemonless command-line tool that lets you build images from a Dockerfile or from scratch using shell scripts. It gives you fine-grained control over the image layers.
 
 **Key Features:**
+
 - **Daemonless Building**: Builds images without needing a background service.
 - **Scriptable**: Can be easily integrated into automated scripts for complex builds.
 - **Fine-Grained Control**: Allows you to mount a container's filesystem and modify it directly.
@@ -165,12 +206,14 @@ Buildah is a specialized tool that focuses on one thing: building OCI-compliant
 - **Multi-Architecture Support**: Can build images for different CPU architectures.
 
 **Pros:**
+
 - More secure because it runs without a daemon and can operate in rootless mode.
 - Highly flexible, allowing for complex build logic through scripting.
 - Uses fewer resources compared to Docker's build process.
 - Integrates well with CI/CD systems.
 
 **Cons:**
+
 - Only builds images; it does not run or manage containers.
 - Can have a learning curve, especially for its advanced scripting features.
 - Primarily for Linux, with no native support for Windows or macOS.
@@ -181,13 +224,18 @@ Buildah is a specialized tool that focuses on one thing: building OCI-compliant
 
 ### 6. Rancher Desktop - A Docker Desktop Alternative with a GUI
 
-<Figure src="/img/comparisons/2024/08/docker-alternatives-a8d78763-1427-461e-9322-a22f6061c368.webp" alt="Rancher Desktop GUI" caption="Rancher Desktop GUI" />
+<Figure
+  src="/img/comparisons/2024/08/docker-alternatives-a8d78763-1427-461e-9322-a22f6061c368.webp"
+  alt="Rancher Desktop GUI"
+  caption="Rancher Desktop GUI"
+/>
 
 Rancher Desktop is a free and open-source application for Mac, Windows, and Linux that provides a graphical user interface (GUI) for container management. It's a popular alternative to Docker Desktop, especially for developers.
 
 **Architecture**: A desktop application that manages container runtimes like `containerd` and provides a built-in Kubernetes cluster (K3s) for local development.
 
 **Key Features:**
+
 - **Intuitive GUI**: A user-friendly interface for managing containers and Kubernetes.
 - **Choice of Runtimes**: Lets you choose between `containerd` and Docker's Moby engine.
 - **Local Kubernetes**: Includes the lightweight K3s distribution for easy local Kubernetes development.
@@ -195,12 +243,14 @@ Rancher Desktop is a free and open-source application for Mac, Windows, and Linu
 - **Extensible**: Supports extensions for adding more functionality.
 
 **Pros:**
+
 - Easy to learn, especially for those who prefer a graphical interface.
 - No commercial licensing fees, unlike Docker Desktop.
 - Simplifies local Kubernetes development.
 - Actively developed and supported by a strong community.
 
 **Cons:**
+
 - Best suited for local development, not production.
 - The reliance on a GUI makes it less suitable for automation.
 - Uses more resources than command-line-only tools.
@@ -216,6 +266,7 @@ OpenShift is a comprehensive container platform built on top of Kubernetes. It i
 **Architecture**: An extended version of Kubernetes that adds a suite of integrated tools, including a container registry, automated build pipelines (Source-to-Image), and advanced security policies.
 
 **Key Features:**
+
 - **Built on Kubernetes**: Starts with a standard Kubernetes core and adds enterprise features.
 - **Integrated CI/CD**: Provides built-in tools for continuous integration and deployment.
 - **Security-First**: Implements strict security policies and role-based access control (RBAC) by default.
@@ -223,12 +274,14 @@ OpenShift is a comprehensive container platform built on top of Kubernetes. It i
 - **Multi-Cloud Support**: Can be deployed consistently across different cloud providers and on-premise data centers.
 
 **Pros:**
+
 - A complete, all-in-one platform with commercial support from Red Hat.
 - Strong security features suitable for regulated industries.
 - Streamlines both development and operations workflows.
 - Access to professional training and certification.
 
 **Cons:**
+
 - Can be expensive, with significant licensing costs.
 - May be too complex for smaller projects or teams.
 - Requires more system resources than a standard Kubernetes installation.
@@ -245,18 +298,21 @@ OpenShift is a comprehensive container platform built on top of Kubernetes. It i
 **Architecture**: A minimal command-line tool that creates and runs containers according to the OCI standard. It focuses solely on the container's lifecycle and does not include features like image management or networking.
 
 **Key Features:**
+
 - **OCI Standard**: The official reference implementation of the OCI Runtime Specification.
 - **Lightweight**: Has a very small footprint and minimal dependencies.
 - **Core Component**: Serves as the foundation for most higher-level container platforms.
 - **Secure**: Supports standard Linux security features like namespaces and cgroups.
 
 **Pros:**
+
 - Extremely low resource usage and minimal attack surface.
 - Proven in production as the core of major container platforms.
 - Offers direct control over how containers are executed.
 - High performance with almost no overhead.
 
 **Cons:**
+
 - Not intended for direct use by most developers; it requires significant expertise.
 - Lacks user-friendly features for image or network management.
 - Requires custom tooling to be used effectively.
@@ -272,6 +328,7 @@ Nomad is a workload orchestrator from HashiCorp, the creators of Terraform and V
 **Architecture**: A single binary that can be run as a server or a client. It is designed for multi-region and multi-cloud deployments and uses a flexible scheduling algorithm.
 
 **Key Features:**
+
 - **Multi-Workload Support**: Can orchestrate containers, virtual machines, and other applications.
 - **Simple Architecture**: Consists of a single binary, making it easy to deploy and manage.
 - **Multi-Region Federation**: Natively supports connecting clusters across different regions.
@@ -279,12 +336,14 @@ Nomad is a workload orchestrator from HashiCorp, the creators of Terraform and V
 - **HashiCorp Ecosystem**: Integrates seamlessly with other HashiCorp tools like Consul and Vault.
 
 **Pros:**
+
 - Simpler to set up and manage than Kubernetes.
 - Highly efficient in its resource usage.
 - Well-suited for multi-region and edge computing scenarios.
 - A single tool for orchestrating diverse types of workloads.
 
 **Cons:**
+
 - Has a smaller community and ecosystem than Kubernetes.
 - Fewer third-party tools and integrations are available.
 - Requires learning HashiCorp-specific concepts.
@@ -301,18 +360,21 @@ Lima (short for **Li**nux on **Ma**c) is a tool that simplifies running containe
 **Architecture**: A command-line tool that sets up a Linux VM with automatic file sharing and port forwarding, making it easy to run containers on macOS without the overhead of a full desktop application.
 
 **Key Features:**
+
 - **Automatic VM Management**: Handles the creation and configuration of the Linux VM.
 - **Multi-Runtime Support**: Works with `containerd`, Docker, and Podman.
 - **Seamless Integration**: Provides file sharing and port forwarding between macOS and the VM.
 - **Apple Silicon Support**: Works on both Intel and Apple Silicon (M1/M2) Macs.
 
 **Pros:**
+
 - A lightweight and open-source alternative to Docker Desktop for macOS.
 - No commercial licensing fees.
 - Good performance, especially on Apple Silicon Macs.
 - Simple to configure and use.
 
 **Cons:**
+
 - Only for macOS users.
 - Still has the overhead of a VM, unlike native Linux containers.
 - A smaller community and feature set compared to Docker Desktop.
@@ -328,18 +390,21 @@ Finch is an open-source command-line tool from Amazon Web Services (AWS) for con
 **Architecture**: An integrated client that uses Lima to manage a Linux VM, `containerd` as the runtime, and `nerdctl` to provide a Docker-compatible CLI.
 
 **Key Features:**
+
 - **Backed by AWS**: Maintained and supported by Amazon Web Services.
 - **`containerd` Inside**: Uses the industry-standard `containerd` runtime.
 - **Docker-Compatible CLI**: The `nerdctl` component provides a familiar command-line experience.
 - **Optimized for macOS**: Designed specifically for container development on macOS.
 
 **Pros:**
+
 - Strong backing from AWS ensures its continued development.
 - Good performance on macOS.
 - Easy to learn for those already familiar with Docker commands.
 - Potential for future integration with AWS services.
 
 **Cons:**
+
 - Only for macOS users.
 - A relatively new tool with a smaller community.
 - Primarily for development, not production.
@@ -355,6 +420,7 @@ Firecracker is a **Virtual Machine Monitor (VMM)** that creates ultra-lightweigh
 **Architecture**: A specialized VMM that launches minimal micro-VMs with extremely fast boot times and low memory overhead. It provides hardware-level isolation, which is more secure than traditional containers.
 
 **Key Features:**
+
 - **Micro-VMs**: Creates lightweight VMs that are more efficient than traditional VMs.
 - **Fast Startup**: Can launch a micro-VM in under a second.
 - **Hardware Isolation**: Provides strong security by using hardware virtualization.
@@ -362,12 +428,14 @@ Firecracker is a **Virtual Machine Monitor (VMM)** that creates ultra-lightweigh
 - **Used by AWS**: Powers major AWS services, proving its stability at scale.
 
 **Pros:**
+
 - Extremely fast boot times (under 100ms).
 - Strong security isolation, making it ideal for running untrusted code.
 - Very low resource usage per micro-VM.
 - Battle-tested in AWS's production environments.
 
 **Cons:**
+
 - Only works on Linux with KVM virtualization.
 - Requires specialized knowledge to implement and manage.
 - Focused on serverless and function-based workloads, not general-purpose containers.
@@ -383,6 +451,7 @@ gVisor is a security-focused tool from Google that adds an extra layer of isolat
 **Architecture**: A user-space kernel that acts as a middleman between the container and the host OS. It filters system calls to limit the container's privileges and reduce the host's attack surface.
 
 **Key Features:**
+
 - **User-Space Kernel**: An application-specific kernel that runs in user space for better isolation.
 - **System Call Interception**: Catches and handles system calls made by the container.
 - **OCI Compatible**: Works with existing container tools like Docker and Kubernetes.
@@ -390,12 +459,14 @@ gVisor is a security-focused tool from Google that adds an extra layer of isolat
 - **Developed by Google**: Actively maintained and used by Google.
 
 **Pros:**
+
 - Significantly improves security by isolating the container from the host kernel.
 - Reduces the attack surface of the host system.
 - Compatible with existing container workflows.
 - Backed by Google, ensuring its quality and longevity.
 
 **Cons:**
+
 - Can introduce performance overhead because it has to process every system call.
 - May not be compatible with applications that need direct access to specific kernel features.
 - Can make debugging more complex.
@@ -411,18 +482,21 @@ Colima (**Co**ntainer **Li**nux **Ma**chines) is a command-line tool that provid
 **Architecture**: A simple tool for managing container runtimes. It can be configured to use Docker, `containerd`, or even Kubernetes as its backend.
 
 **Key Features:**
+
 - **Minimal Setup**: Designed to be easy to install and configure.
 - **Multiple Backends**: Supports different container runtimes.
 - **Resource Management**: Allows you to configure CPU, memory, and disk space.
 - **Developer-Focused**: Optimized for local development workflows.
 
 **Pros:**
+
 - Very simple to set up and use.
 - Good performance with low resource overhead.
 - No licensing fees or restrictions.
 - Actively developed by the community.
 
 **Cons:**
+
 - Primarily for development, not production.
 - Has a smaller community and feature set than larger projects.
 - Documentation is not as extensive as some alternatives.
@@ -438,6 +512,7 @@ Kata Containers is a project that combines the security of virtual machines with
 **Architecture**: An OCI-compliant runtime that launches each container in a dedicated micro-VM. This provides hardware isolation while still using standard container APIs and workflows.
 
 **Key Features:**
+
 - **VM-Based Isolation**: Uses hardware virtualization for strong security.
 - **Standard Container Interface**: Works with existing container tools and orchestrators.
 - **Multiple Hypervisors**: Supports different VMMs, including QEMU and Firecracker.
@@ -445,12 +520,14 @@ Kata Containers is a project that combines the security of virtual machines with
 - **Backed by OpenInfra Foundation**: Supported by a major open-source foundation.
 
 **Pros:**
+
 - Provides the strongest security isolation available for containers.
 - Suitable for running untrusted or sensitive applications.
 - Compatible with existing container management tools.
 - Backed by a strong open-source community.
 
 **Cons:**
+
 - Uses more system resources due to the overhead of running a VM for each container.
 - Slower container startup times compared to traditional containers.
 - Can be complex to set up and configure.
@@ -464,42 +541,49 @@ Kata Containers is a project that combines the security of virtual machines with
 Here is a general comparison of how these alternatives perform. Actual performance will vary based on your specific workload and hardware.
 
 ### Container Startup Performance
-*   **Fastest**: LXC, CRI-O, `containerd` (typically under 200ms)
-*   **Moderate**: Docker, Podman (typically 200-300ms)
-*   **Specialized**: Firecracker (very fast for micro-VMs), Kata Containers (slower due to VM overhead)
+
+- **Fastest**: LXC, CRI-O, `containerd` (typically under 200ms)
+- **Moderate**: Docker, Podman (typically 200-300ms)
+- **Specialized**: Firecracker (very fast for micro-VMs), Kata Containers (slower due to VM overhead)
 
 ### Memory Footprint (Idle)
-*   **Minimal**: Buildah, Podman, CRI-O (under 70MB)
-*   **Efficient**: `containerd`, `runC` (under 100MB)
-*   **Higher**: Docker, OpenShift (150MB+)
+
+- **Minimal**: Buildah, Podman, CRI-O (under 70MB)
+- **Efficient**: `containerd`, `runC` (under 100MB)
+- **Higher**: Docker, OpenShift (150MB+)
 
 ### CPU Efficiency
-*   **Near-Native**: `runC`, LXC (very little overhead)
-*   **Optimized**: `containerd`, CRI-O, Podman (efficient for most workloads)
-*   **Overhead**: Docker (due to the daemon), gVisor (due to system call interception)
+
+- **Near-Native**: `runC`, LXC (very little overhead)
+- **Optimized**: `containerd`, CRI-O, Podman (efficient for most workloads)
+- **Overhead**: Docker (due to the daemon), gVisor (due to system call interception)
 
 ## How to Choose the Right Alternative
 
 Choosing the best Docker alternative depends on your specific needs. Here are some recommendations based on common use cases:
 
 ### For Security-Focused Environments
-*   **Podman**: Best for general-purpose, secure containers due to its rootless design.
-*   **gVisor**: Ideal for running untrusted code with an extra layer of isolation.
-*   **Kata Containers**: Use when you need the strongest possible isolation, with hardware-level security.
+
+- **Podman**: Best for general-purpose, secure containers due to its rootless design.
+- **gVisor**: Ideal for running untrusted code with an extra layer of isolation.
+- **Kata Containers**: Use when you need the strongest possible isolation, with hardware-level security.
 
 ### For Kubernetes Production Deployments
-*   **`containerd`**: The industry standard, offering a good balance of features and performance.
-*   **CRI-O**: A minimal and efficient choice if you are running exclusively on Kubernetes.
+
+- **`containerd`**: The industry standard, offering a good balance of features and performance.
+- **CRI-O**: A minimal and efficient choice if you are running exclusively on Kubernetes.
 
 ### For Development Workflows
-*   **Rancher Desktop**: A great all-in-one GUI tool, especially if you need a local Kubernetes cluster.
-*   **Lima/Colima**: Lightweight and simple options for macOS and Linux developers.
-*   **Podman Desktop**: A good choice for developers who want a GUI but also prioritize security.
+
+- **Rancher Desktop**: A great all-in-one GUI tool, especially if you need a local Kubernetes cluster.
+- **Lima/Colima**: Lightweight and simple options for macOS and Linux developers.
+- **Podman Desktop**: A good choice for developers who want a GUI but also prioritize security.
 
 ### For Performance-Critical Applications
-*   **`containerd`**: A high-performance runtime for Kubernetes environments.
-*   **`runC`**: Offers maximum performance if you are willing to build your own tooling.
-*   **LXC**: Provides near-native performance for full system containers.
+
+- **`containerd`**: A high-performance runtime for Kubernetes environments.
+- **`runC`**: Offers maximum performance if you are willing to build your own tooling.
+- **LXC**: Provides near-native performance for full system containers.
 
 ## Monitoring Your Container Environment
 
@@ -566,6 +650,6 @@ This depends on the tool you choose. For Podman, you can often just create an al
 
 ### Which alternative is best for production?
 
-*   For **Kubernetes production**, **`containerd`** or **CRI-O** are the top choices.
-*   For **non-Kubernetes production**, **Podman** is a strong, secure option.
-*   For **enterprise needs**, **Red Hat OpenShift** provides a fully supported platform.
\ No newline at end of file
+- For **Kubernetes production**, **`containerd`** or **CRI-O** are the top choices.
+- For **non-Kubernetes production**, **Podman** is a strong, secure option.
+- For **enterprise needs**, **Red Hat OpenShift** provides a fully supported platform.
diff --git a/data/comparisons/dynatrace-vs-appdynamics.mdx b/data/comparisons/dynatrace-vs-appdynamics.mdx
index 85236566f..a4a0263f1 100644
--- a/data/comparisons/dynatrace-vs-appdynamics.mdx
+++ b/data/comparisons/dynatrace-vs-appdynamics.mdx
@@ -1,45 +1,53 @@
 ---
 title: Dynatrace vs AppDynamics - In-depth Comparison Guide [2025]
-slug: dynatrace-vs-appdynamics
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Dynatrace and AppDynamics are both leading providers of application performance monitoring (APM) and digital experience monitoring (DEXM) solutions. Dynatrace excels in automation and AI-driven analytics, while AppDynamics specializes in providing comprehensive visibility into application performance and business metrics...
 image: /img/blog/2024/04/dynatrace-vs-appdynamics-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [dynatrace-vs-appdynamics,appdynamics,dynatrace,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [
+    dynatrace-vs-appdynamics,
+    appdynamics,
+    dynatrace,
+    opentelemetry,
+    open-source,
+    monitoring-tools,
+    signoz,
+  ]
 ---
-Dynatrace and AppDynamics are both leading providers of application performance monitoring (APM) and digital experience monitoring (DEM) solutions. They provide visibility into application health, databases, networks, infrastructure, and services, but they differ in their approach.
-
 
+Dynatrace and AppDynamics are both leading providers of application performance monitoring (APM) and digital experience monitoring (DEM) solutions. They provide visibility into application health, databases, networks, infrastructure, and services, but they differ in their approach.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/dynatrace-vs-appdynamics-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/dynatrace-vs-appdynamics-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 Dynatrace excels in automation and AI-driven analytics, while AppDynamics specializes in providing comprehensive visibility into application performance and business metrics.
 
 In this article, we’ll compare Dynatrace and AppDynamics side by side, looking at their features and differences to help you choose the right monitoring tool.
 
 ## Dynatrace vs AppDynamics: At a glance
 
-| Features | Dynatrace | AppDynamics |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Log management | ✅ | ✅ |
-| Application Security | ✅ | ✅  |
-| AI-Driven Analytics | ✅ | 🟡 |
-| ML capabilities | ✅ | ✅ |
-| Infrastructure Monitoring | ✅ | ✅  |
-| Learning curve | 🟡 | ✅ |
-| Network Monitoring | ✅ | ✅  |
-| Real-User Monitoring | ✅ | 🟡  |
-| SLA Monitoring | ✅ | ❌ |
-| Free Forever Plan | ❌ | ❌ |
-| 15-day Free trial | ✅ | ✅ |
+| Features                  | Dynatrace | AppDynamics |
+| ------------------------- | --------- | ----------- |
+| APM                       | ✅        | ✅          |
+| Log management            | ✅        | ✅          |
+| Application Security      | ✅        | ✅          |
+| AI-Driven Analytics       | ✅        | 🟡          |
+| ML capabilities           | ✅        | ✅          |
+| Infrastructure Monitoring | ✅        | ✅          |
+| Learning curve            | 🟡        | ✅          |
+| Network Monitoring        | ✅        | ✅          |
+| Real-User Monitoring      | ✅        | 🟡          |
+| SLA Monitoring            | ✅        | ❌          |
+| Free Forever Plan         | ❌        | ❌          |
+| 15-day Free trial         | ✅        | ✅          |
 
 ✅ - Available
 
@@ -54,32 +62,27 @@ Dynatrace is an AI-powered, full-stack analytics and automation tool designed to
 ### Key features of Dynatrace
 
 - **Application Performance Monitoring** <br/>
-    
-    Dynatrace offers in-depth visibility into application performance in real-time, allowing for swift resolution of performance or availability issues before they affect customers. 
-    
+  Dynatrace offers in-depth visibility into application performance in real-time, allowing for swift resolution of performance or availability issues before they affect customers.
 - **AI-Driven Analytics**<br/>
-    
-    Using its AI engine, Dynatrace automatically analyzes data and detects anomalies in application performance, infrastructure, and security.
-    
+  Using its AI engine, Dynatrace automatically analyzes data and detects anomalies in application performance, infrastructure, and security.
 - **Real User Experience Monitoring**<br/>
-    
-    Dynatrace offers complete visibility into user experiences across web, mobile, and custom apps, without any data sampling. It measures user satisfaction and business impact in real-time, allowing for immediate identification of areas for improvement.
-    
+  Dynatrace offers complete visibility into user experiences across web, mobile, and custom apps, without any data sampling. It measures user satisfaction and business impact in real-time, allowing for immediate identification of areas for improvement.
 - **Application Security**<br/>
-    
-    Dynatrace's application security feature analyzes third-party and code-level vulnerabilities, as well as security attacks. It offers real-time insights into application security posture and risks, helping to identify and address security threats promptly.
-    
+  Dynatrace's application security feature analyzes third-party and code-level vulnerabilities, as well as security attacks. It offers real-time insights into application security posture and risks, helping to identify and address security threats promptly.
 - **[Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/)**<br/>
-    
-    Dynatrace monitors the health and performance of servers, virtual machines, containers, and cloud infrastructure, providing insights into resource utilization and infrastructure dependencies.
-    
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/dynatrace-vs-appdynamics-dynatrace.webp" alt="Dynatrace in-depth insights into your whole application stack"/>
-    <figcaption><i>Dynatrace in-depth insights into your whole application stack</i></figcaption>
+  Dynatrace monitors the health and performance of servers, virtual machines, containers, and cloud infrastructure, providing insights into resource utilization and infrastructure dependencies.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/dynatrace-vs-appdynamics-dynatrace.webp"
+    alt="Dynatrace in-depth insights into your whole application stack"
+  />
+  <figcaption>
+    <i>Dynatrace in-depth insights into your whole application stack</i>
+  </figcaption>
 </figure>
 
-
-
 ### What is AppDynamics?
 
 AppDynamics is a leading application performance monitoring (APM) and observability platform that offers comprehensive insights into the performance, availability, and user experience of applications and IT infrastructure. It delivers application and business performance at scale, from code to customer experience.
@@ -87,58 +90,51 @@ AppDynamics is a leading application performance monitoring (APM) and observabil
 ### Key Features of AppDynamics
 
 - **Application Performance Monitoring**<br/>
-    
-    AppDynamics provides end-to-end observability of applications, accurately identifying the root causes of application issues in real-time.
-    
+  AppDynamics provides end-to-end observability of applications, accurately identifying the root causes of application issues in real-time.
 - **Network Monitoring**<br/>
-    
-    AppDynamics monitors network performance and identifies network issues that could impact application performance, by providing real-time visibility into application network interactions.
-    
+  AppDynamics monitors network performance and identifies network issues that could impact application performance, by providing real-time visibility into application network interactions.
 - **Application Security**<br/>
-    
-    AppDynamics offers security monitoring capabilities that help in identifying and mitigating security threats and vulnerabilities.
-    
+  AppDynamics offers security monitoring capabilities that help in identifying and mitigating security threats and vulnerabilities.
 - **End User Monitoring**<br/>
-    
-    It provides deep insights into how users interact with your applications, identifying areas for improvement to optimize the user experience.
-    
+  It provides deep insights into how users interact with your applications, identifying areas for improvement to optimize the user experience.
 - **Database Monitoring**<br/>
-    
-    AppDynamics assists in pinpointing and resolving database issues that impact microservices by identifying their root cause. 
-    
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/dynatrace-vs-appdynamics-appdynamics.webp" alt="Appdynamics observability platform for full visibility of application performance"/>
-    <figcaption><i>Appdynamics observability platform for full visibility of application performance</i></figcaption>
+  AppDynamics assists in pinpointing and resolving database issues that impact microservices by identifying their root cause.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/dynatrace-vs-appdynamics-appdynamics.webp"
+    alt="Appdynamics observability platform for full visibility of application performance"
+  />
+  <figcaption>
+    <i>Appdynamics observability platform for full visibility of application performance</i>
+  </figcaption>
 </figure>
 
-
-
 ## Dynatrace vs AppDynamics: Key Differences
 
 **AI-Driven Analytics:** <br/>
 
 - **Dynatrace:** Dynatrace sets itself apart with its powerful AI engine, Davis AI, in analyzing vast amounts of data in real-time. This allows it to perform automatic root cause analysis, auto application topology discovery, auto-coded workflows, and AIOps.
 
-- **AppDynamics:** AppDynamics also offers AI-driven analytics features, including  AIOps, anomaly detection, and performance insights but Dynatrace's AI capabilities provide a more automated and intelligent approach.
-    
+- **AppDynamics:** AppDynamics also offers AI-driven analytics features, including AIOps, anomaly detection, and performance insights but Dynatrace's AI capabilities provide a more automated and intelligent approach.
+
 **Real User Monitoring:**<br/>
-    
+
 - **Dynatrace:** Dynatrace captures full visibility of customer experience across every digital transaction, mapping the whole user journey, not just bits and pieces. It leverages its AI to pinpoint issues and root causes. It also provides a <a href = "https://www.dynatrace.com/platform/digital-experience-monitoring/visually-complete" rel="noopener noreferrer nofollow" target="_blank" >Visually complete and Speed index</a> feature that eliminates user experience blind spots and provides the most accurate and relevant measurement of user experience.
 
 - **AppDynamics:** AppDynamics monitors key metrics across user devices. It provides Experience Journey Mapping (ExJM), automatically identifying the most frequented user journeys and tracking evolving user behaviors within the application. ExJM also visualizes the most trafficked application paths and assesses their performance in real-time.
-    
+
 **Cost:**<br/>
-    
+
 - **Dynatrace:** Dynatrace offers a transparent and straightforward pricing model. The pricing is host-based, with discounts available for larger commitments. This model can be cost-effective for businesses with consistent or predictable usage patterns. However, for large deployments or those requiring extensive monitoring capabilities, Dynatrace can get expensive quickly. This is because the cost scales with the number of hosts being monitored.
 
 - **AppDynamics:** AppDynamics pricing is more straightforward, with fixed monthly rates. This makes budgeting easier, especially for businesses with a fixed number of servers or cores. However, for large deployments, costs can also add up. Both Dynatrace and AppDynamics can be very expensive.
-    
+
 **Learning Curve:**<br/>
-    
+
 - **Dynatrace:** Dynatrace has a steep learning curve for new users, due to its extensive features and UI.
-    
 - **AppDynamics:** It has a clean modern UI and is easier to navigate compared to Dynatrace.
-    
 
 ## Dynatrace vs AppDynamics: Final Verdict
 
@@ -167,4 +163,4 @@ SigNoz is available both as an [open-source software](https://github.com/SigNoz
 
 [SigNoz - Open-source alternative to Dynatrace](https://signoz.io/blog/dynatrace-alternative/)
 
-[SigNoz - Open-source alternative to AppDynamics](https://signoz.io/blog/appdynamics-alternative/)
\ No newline at end of file
+[SigNoz - Open-source alternative to AppDynamics](https://signoz.io/blog/appdynamics-alternative/)
diff --git a/data/comparisons/dynatrace-vs-newrelic.mdx b/data/comparisons/dynatrace-vs-newrelic.mdx
index 8fcbbb9a2..f664077e3 100644
--- a/data/comparisons/dynatrace-vs-newrelic.mdx
+++ b/data/comparisons/dynatrace-vs-newrelic.mdx
@@ -1,42 +1,43 @@
 ---
 title: Dynatrace vs New Relic - A Detailed Comparison for 2025
-slug: dynatrace-vs-newrelic
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: We have compared Dynatrace and New Relic by sending data from a sample Python application to both platforms and comparing our experience. Check out Dynatrace vs New Relic across key aspects like getting started, data integration, UI/UX, pricing...
 image: /img/blog/2024/02/dynatrace-vs-newrelic-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [dynatrace,newrelic,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [dynatrace, newrelic, opentelemetry, open-source, monitoring-tools, signoz]
 ---
+
 Dynatrace and New Relic are monitoring tools that provide a wide range of products and services for monitoring. In this post, I have compared Dynatrace and New Relic on important features like APM, log management, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), etc.
 
 <Admonition type="info">
-💡 I instrumented a sample Python application and sent data to Dynatrace and New Relic to evaluate my experience. Some takeaways are subjective and based on personal preference.
+  💡 I instrumented a sample Python application and sent data to Dynatrace and New Relic to evaluate
+  my experience. Some takeaways are subjective and based on personal preference.
 </Admonition>
 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 ## Dynatrace vs New Relic: Overview
 
-| Features | Dynatrace | New Relic |
-| --- | --- | --- |
-| Getting Started | ✅ ✅ | ✅ ✅ |
-| Data Integration | ✅   | ✅ ✅  |
-| Infrastructure Monitoring | ✅ ✅ | ✅  |
-| APM | 🟡 | ✅ ✅ |
-| Log Management | ✅ ✅  | ✅  |
-| Documentation and Community Support | ✅ ✅ | ✅ ✅ |
-| Pricing | 🟡   |  ✅  |
-| UI/UX | ✅  | ✅ ✅   |
+| Features                            | Dynatrace | New Relic |
+| ----------------------------------- | --------- | --------- |
+| Getting Started                     | ✅ ✅     | ✅ ✅     |
+| Data Integration                    | ✅        | ✅ ✅     |
+| Infrastructure Monitoring           | ✅ ✅     | ✅        |
+| APM                                 | 🟡        | ✅ ✅     |
+| Log Management                      | ✅ ✅     | ✅        |
+| Documentation and Community Support | ✅ ✅     | ✅ ✅     |
+| Pricing                             | 🟡        | ✅        |
+| UI/UX                               | ✅        | ✅ ✅     |
 
-✅ ✅  - Excellent
+✅ ✅ - Excellent
 
 ✅ - Good
 
@@ -48,43 +49,64 @@ Dynatrace and New Relic are monitoring tools that provide a wide range of produc
 
 I found the onboarding process for Dynatrace straightforward. After providing my email address and basic personal information, the account setup was completed in approximately 3 minutes.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-account-setup-dynatrace.webp" alt="Account setup in Dynatrace"/>
-    <figcaption><i>Account setup in Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-account-setup-dynatrace.webp"
+    alt="Account setup in Dynatrace"
+  />
+  <figcaption>
+    <i>Account setup in Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 The onboarding process for New Relic was easy as well. After providing my email address, verifying it, setting up a password, and choosing my data region, my New Relic account was set up in under a minute.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-account-setup-new-relic.webp" alt="Account setup in New Relic"/>
-    <figcaption><i>Account setup in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-account-setup-new-relic.webp"
+    alt="Account setup in New Relic"
+  />
+  <figcaption>
+    <i>Account setup in New Relic</i>
+  </figcaption>
 </figure>
 
-
 ## Data Integration: New Relic
 
 ### Dynatrace
 
 Dynatrace supports a wide range of data sources, encompassing a total of 575 different options for automation, infrastructure observability, and more. It also allows you to build your own custom app. An app in Dynatrace refers to a tailored view or interface within the Dynatrace platform that is specifically optimized for a particular use case or set of needs. This could be focused on monitoring a particular aspect of an application's performance, security, or business analytics.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-dynatrace-data-integration.webp" alt="Data integration in Dynatrace"/>
-    <figcaption><i>Data integration in Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-dynatrace-data-integration.webp"
+    alt="Data integration in Dynatrace"
+  />
+  <figcaption>
+    <i>Data integration in Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 New Relic offers extensive data source options that allow for seamless integration of data into pre-built dashboards. It also comes with pre-configured alert policies that can be easily incorporated into your data management workflow. Additionally, New Relic is known for its user-friendly integration process and clear setup instructions, making it a straightforward choice for data integration tasks.
 
 Compared to Dynatrace, New Relic boasts a wider range of data sources, with a total of 1083 options available, providing users with greater flexibility in tailoring their monitoring and analytics solutions. I also found data integration with New Relic easier.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-data-integration.webp" alt="Data integration in New Relic"/>
-    <figcaption><i>Data integration in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-data-integration.webp"
+    alt="Data integration in New Relic"
+  />
+  <figcaption>
+    <i>Data integration in New Relic</i>
+  </figcaption>
 </figure>
 
 <NewRelicVsSigNoz />
@@ -95,30 +117,45 @@ Compared to Dynatrace, New Relic boasts a wider range of data sources, with a to
 
 Dynatrace uses DQL (Dynatrace Query Language) for querying data. DQL is used for the exploration, querying, and processing of all data stored in Grail, Dynatrace’s data warehouse. Unlike traditional SQL, which requires a predefined schema, DQL is built to handle arbitrary event data, making it particularly suitable for exploring observability data where the schema may vary or evolve.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-DQL.webp" alt="Data query using DQL"/>
-    <figcaption><i>Data query using DQL</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-DQL.webp"
+    alt="Data query using DQL"
+  />
+  <figcaption>
+    <i>Data query using DQL</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 New Relic has data explorer and [query builder](https://signoz.io/blog/query-builder-v5/) tabs. The Data Explorer tab allows users to browse their data without writing queries, while the Query Builder tab allows users to create custom queries to get more insights from their existing data.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-explorer.webp" alt="New Relic’s data explorer tab"/>
-    <figcaption><i>New Relic’s data explorer tab</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-explorer.webp"
+    alt="New Relic’s data explorer tab"
+  />
+  <figcaption>
+    <i>New Relic’s data explorer tab</i>
+  </figcaption>
 </figure>
 
-
 You have the option of querying your data using NRQL (New Relic Query Language) or PromQL. NRQL is a query language used to retrieve and analyze data from the New Relic Database (NRDB). It is similar to ANSI SQL and is designed to provide insights into applications, hosts, and business-critical activities by allowing users to create charts, set up alerts, and make API queries of New Relic data.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-query-builder.webp" alt="New Relic’s query builder tab"/>
-    <figcaption><i>New Relic’s query builder tab</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-query-builder.webp"
+    alt="New Relic’s query builder tab"
+  />
+  <figcaption>
+    <i>New Relic’s query builder tab</i>
+  </figcaption>
 </figure>
 
-
 Overall, both tools have good data querying capabilities.
 
 ## Infrastructure Monitoring: Dynatrace
@@ -127,32 +164,47 @@ Overall, both tools have good data querying capabilities.
 
 I had to install <a href = "https://docs.dynatrace.com/docs/platform/oneagent/how-one-agent-works" rel="noopener noreferrer nofollow" target="_blank" >One Agent</a> on my host machine to monitor my infrastructure. One Agent is what Dynatrace uses for conducting full-stack monitoring of your infrastructure and the services operating within it. It gave me a holistic view of my infrastructure performance, including incoming and outgoing connections, host performance, process analysis, disk usage, and more. The only drawback was not being able to set it up on macOS, as it doesn’t support it. I had to install it on a Ubuntu VM instead.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-infra-monitoring-dynatrace.webp" alt="Infrastructure monitoring on Dynatrace"/>
-    <figcaption><i>Infrastructure monitoring on Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-infra-monitoring-dynatrace.webp"
+    alt="Infrastructure monitoring on Dynatrace"
+  />
+  <figcaption>
+    <i>Infrastructure monitoring on Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 The Process Analysis section provided me with information on all the running processes on my infrastructure, along with vital stats on memory and CPU usage. This level of detail is useful for keeping tabs on my system's performance and making informed decisions about resource allocation and optimization.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-process-analysis.webp" alt="Process analysis"/>
-    <figcaption><i>Process analysis</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-process-analysis.webp"
+    alt="Process analysis"
+  />
+  <figcaption>
+    <i>Process analysis</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 New Relic facilitates the monitoring of a variety of infrastructure components through the deployment of an infrastructure agent. Upon installation on a macOS host, which is supported by New Relic, the agent automatically collects and sends data to the New Relic platform. It collects data on the infrastructure and the services running on it.
 
 While New Relic provides a solid foundation for monitoring infrastructure and services, I found that Dynatrace offered a broader array of capabilities and a deeper level of insight into my infrastructure. Dynatrace's comprehensive features provide a more detailed analysis of the system's performance.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-infra-monitoring-new-relic.webp" alt="Infrastructure monitoring on New Relic"/>
-    <figcaption><i>Infrastructure monitoring on New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-infra-monitoring-new-relic.webp"
+    alt="Infrastructure monitoring on New Relic"
+  />
+  <figcaption>
+    <i>Infrastructure monitoring on New Relic</i>
+  </figcaption>
 </figure>
 
-
 If your goal is to gain a comprehensive understanding of all activities occurring within your infrastructure, Dynatrace stands out as a robust solution.
 
 ## APM: New Relic
@@ -165,12 +217,17 @@ I had a hard time understanding the APM setup for Dynatrace because APM is not i
 
 New Relic has an APM & Services section, which is easy to locate. Monitoring an application requires adding that application as a data source and installing the agent for the application on your host machine. For example, a Python application requires a Python agent. Once your application is started with the agent, New Relic automatically collects your application data for monitoring. The process is very seamless.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-sample-app-new-relic.webp" alt="My sample Python application being monitored in New Relic APM"/>
-    <figcaption><i>My sample Python application being monitored in New Relic APM</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-sample-app-new-relic.webp"
+    alt="My sample Python application being monitored in New Relic APM"
+  />
+  <figcaption>
+    <i>My sample Python application being monitored in New Relic APM</i>
+  </figcaption>
 </figure>
 
-
 In the case of APM, a direct comparison between Dynatrace and New Relic is challenging due to the limited amount of information obtained from Dynatrace for comparison purposes. However, considering the ease of setup and simplicity of New Relic, it is the better option when it comes to APM.
 
 ## Log Management: Dynatrace
@@ -181,22 +238,32 @@ Log management in Dynatrace is powered by <a href = "https://www.dynatrace.com/p
 
 Users can define custom log ingestion rules with OneAgent and control the retention of log data by placing it into designated data retention buckets. This flexibility allows for retention periods that align with business and compliance requirements, whether for debugging or auditing purposes.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-dynatrace-log-management.webp" alt="Log management in Dynatrace"/>
-    <figcaption><i>Log management in Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-dynatrace-log-management.webp"
+    alt="Log management in Dynatrace"
+  />
+  <figcaption>
+    <i>Log management in Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 New Relic automatically ingested both my infrastructure and application logs, eliminating the need for additional configuration steps. The [Logs UI](https://signoz.io/blog/logs-ui/) offers functionalities such as log querying and real-time log streaming, which enhance visibility and troubleshooting capabilities. It also enables you to establish alerts and access log data visualizations across the entire platform, ensuring comprehensive monitoring and analysis.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-log-management.webp" alt="Log management in New Relic"/>
-    <figcaption><i>Log management in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-new-relic-log-management.webp"
+    alt="Log management in New Relic"
+  />
+  <figcaption>
+    <i>Log management in New Relic</i>
+  </figcaption>
 </figure>
 
-
 Overall, Dynatrace is a better option for log management, as it has more log management capabilities than New Relic.
 
 ## Documentation and Community Support: Both
@@ -205,22 +272,32 @@ Overall, Dynatrace is a better option for log management, as it has more log man
 
 I found the documentation good, but I struggled to understand some things and had to watch videos on their YouTube channel for better clarity. As for community support, Dynatrace has various support resources, as shown in the image below.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-support-dynatrace.webp" alt="Dynatrace support options"/>
-    <figcaption><i>Dynatrace support options</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-support-dynatrace.webp"
+    alt="Dynatrace support options"
+  />
+  <figcaption>
+    <i>Dynatrace support options</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 I found New Relic’s documentation to be good as well. As for community support, it has a support center where you can create support cases, a knowledgebase, a developer forum, a New Relic university for learning all things New Relic, and more.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-support-new-relic.webp" alt="New Relic support options"/>
-    <figcaption><i>New Relic support options</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-support-new-relic.webp"
+    alt="New Relic support options"
+  />
+  <figcaption>
+    <i>New Relic support options</i>
+  </figcaption>
 </figure>
 
-
 Overall, both tools have great community support and documentation.
 
 ## Pricing: New Relic
@@ -229,30 +306,49 @@ Overall, both tools have great community support and documentation.
 
 [Dynatrace pricing](https://signoz.io/guides/dynatrace-pricing/) model varies across each service used. It has a 15-day free trial, which gives you access to the platform’s features.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-dynatrace.webp" alt="Dynatrace pricing"/>
-    <figcaption><i>Dynatrace pricing</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-dynatrace.webp"
+    alt="Dynatrace pricing"
+  />
+  <figcaption>
+    <i>Dynatrace pricing</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
-<a href = "https://newrelic.com/pricing" rel="noopener noreferrer nofollow" target="_blank" >New Relic’s pricing</a> is usage-based. Pricing is calculated by the volume of data ingested per month and the number of users.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-new-relic.webp" alt="New Relic pricing"/>
-    <figcaption><i>New Relic pricing</i></figcaption>
+<a href="https://newrelic.com/pricing" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic’s pricing
+</a>
+is usage-based. Pricing is calculated by the volume of data ingested per month and the number of
+users.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-new-relic.webp"
+    alt="New Relic pricing"
+  />
+  <figcaption>
+    <i>New Relic pricing</i>
+  </figcaption>
 </figure>
 
-
 It has four different pricing tiers, with a free forever tier offering access to all 30+ New Relic platform capabilities and 100 GB of free data ingestion per month.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-tier.webp" alt="Pricing tiers"/>
-    <figcaption><i>Pricing tiers</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-pricing-tier.webp"
+    alt="Pricing tiers"
+  />
+  <figcaption>
+    <i>Pricing tiers</i>
+  </figcaption>
 </figure>
 
-
 New Relic can be seen as a good option based on its free forever plan, which allows new users to evaluate its capabilities without incurring immediate costs.
 
 ## UI/UX: New Relic
@@ -261,25 +357,35 @@ New Relic can be seen as a good option based on its free forever plan, which all
 
 My experience with Dynatrace's user interface was challenging, lacking clarity and intuitiveness. Navigating the platform required frequent reference to the documentation, degrading the overall user experience.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-UI-dynatrace.webp" alt="Dynatrace’s UI"/>
-    <figcaption><i>Dynatrace’s UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-UI-dynatrace.webp"
+    alt="Dynatrace’s UI"
+  />
+  <figcaption>
+    <i>Dynatrace’s UI</i>
+  </figcaption>
 </figure>
 
-
 ### New Relic
 
 Contrarily, New Relic's user interface is designed to be straightforward and accessible. It offers ready-made dashboards and alert configurations tailored to common needs. The UI is praiseworthy for its simplicity, informativeness, and ease of use. It is very beginner-friendly and improves the user experience.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/dynatrace-vs-newrelic-UI-new-relic.webp" alt="New Relic’s UI"/>
-    <figcaption><i>New Relic’s UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/dynatrace-vs-newrelic-UI-new-relic.webp"
+    alt="New Relic’s UI"
+  />
+  <figcaption>
+    <i>New Relic’s UI</i>
+  </figcaption>
 </figure>
 
-
 ## Dynatrace vs New Relic: The Final Verdict
 
-Both Dynatrace and New Relic are powerful monitoring tools, each with its own strengths and weaknesses. If you require a comprehensive and robust monitoring platform with AI-driven application performance analysis and real-time troubleshooting, Dynatrace is the preferred choice. 
+Both Dynatrace and New Relic are powerful monitoring tools, each with its own strengths and weaknesses. If you require a comprehensive and robust monitoring platform with AI-driven application performance analysis and real-time troubleshooting, Dynatrace is the preferred choice.
 
 However, it's essential to note that Dynatrace can be complex, with a steep learning curve for beginners. On the other hand, New Relic is a solid option if you prioritize user friendliness and simplicity without compromising on monitoring capabilities.
 
@@ -303,12 +409,13 @@ SigNoz provides additional features that enhance its capabilities, such as:
 
 SigNoz cloud is the easiest way to run SigNoz. [Sign up](https://signoz.io/teams/) for a free account and get 30 days of unlimited access to all features.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/new-cta-signoz.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img className="box-shadowed-image" src="/img/blog/common/new-cta-signoz.webp" alt="" />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 You can also install and self-host SigNoz yourself since it is open-source. With 16,000+ GitHub stars, <a href = "https://github.com/signoz/signoz" rel="noopener noreferrer nofollow" target="_blank" >open-source SigNoz</a> is loved by developers. Find the [instructions](https://signoz.io/docs/install/) to self-host SigNoz.
 
 ---
@@ -317,4 +424,4 @@ Further Reading:
 
 [SigNoz vs New Relic](https://signoz.io/product-comparison/signoz-vs-newrelic/)
 
-[SigNoz vs Dynatrace](https://signoz.io/product-comparison/signoz-vs-dynatrace/)
\ No newline at end of file
+[SigNoz vs Dynatrace](https://signoz.io/product-comparison/signoz-vs-dynatrace/)
diff --git a/data/comparisons/end-to-end-monitoring-tools.mdx b/data/comparisons/end-to-end-monitoring-tools.mdx
index 8b08c75b1..29e2a3dd9 100644
--- a/data/comparisons/end-to-end-monitoring-tools.mdx
+++ b/data/comparisons/end-to-end-monitoring-tools.mdx
@@ -1,16 +1,21 @@
 ---
-
 title: Top 10 End-to-End Monitoring Tools for 2025
-slug: end-to-end-monitoring-tools
 date: 2025-02-09
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover the best end-to-end monitoring tools for 2025. Learn key features, selection criteria, and implementation strategies for optimal system observability.
-keywords: [end-to-end monitoring, observability, DevOps tools, system monitoring, application performance, distributed tracing]
-
+keywords:
+  [
+    end-to-end monitoring,
+    observability,
+    DevOps tools,
+    system monitoring,
+    application performance,
+    distributed tracing,
+  ]
 ---
 
-End-to-end monitoring tools offer a comprehensive view of applications, infrastructure, and user experiences. These technologies help teams spot problems early, troubleshoot effectively, and sustain peak performance. 
+End-to-end monitoring tools offer a comprehensive view of applications, infrastructure, and user experiences. These technologies help teams spot problems early, troubleshoot effectively, and sustain peak performance.
 
 With so many tools accessible, how do you pick the appropriate one? This tutorial highlights the top end-to-end monitoring technologies for 2025, their key features, and how to properly use them.
 
@@ -24,24 +29,23 @@ End-to-end monitoring involves capturing data across every layer of your technol
 - User experience: Page load times, interaction responsiveness, and behavioural patterns.
 - Business impact: Conversion rates, revenue impact, and customer churn.
 
-
 ## Top 10 End-to-End Monitoring Tools for 2025
 
 Now that we understand the key features and requirements of end-to-end monitoring, let's examine the top [end to end monitoring tools](https://signoz.io/guides/end-to-end-monitoring-solution/) available for 2025. These solutions have been selected based on their ability to handle modern microservice architectures, cloud-native applications, and complex distributed systems.
 
 ### An Overview of Features of Top End-to-End Monitoring Tools
 
-| Feature | SigNoz | Dynatrace | Datadog | AppDynamics | Prometheus | Zabbix | Nagios | SolarWinds SAM |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| Open-Source | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ❌ |
-| Metrics, Logs, and Traces | ✅ | ✅ | ✅ | ✅ | ❌ (Metrics only) | ❌ | ❌ | ❌ |
-| Pre-Built Integrations | Limited | Extensive | Over 600 | Moderate | Limited | Moderate | Limited | 1,200+ Templates |
-| Cloud-Native | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | Primarily Windows-Based |
-| Self-Hosting | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ❌ |
-| Ideal for Large Enterprises | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ |
-| Ideal for Small Teams | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ❌ |
-| Alerting Features | Advanced | Advanced | Advanced | Advanced | Advanced | Basic | Advanced | Advanced |
-| Customizability | High | Moderate | High | Moderate | High | High | High | Moderate |
+| Feature                     | SigNoz   | Dynatrace | Datadog  | AppDynamics | Prometheus        | Zabbix   | Nagios   | SolarWinds SAM          |
+| --------------------------- | -------- | --------- | -------- | ----------- | ----------------- | -------- | -------- | ----------------------- |
+| Open-Source                 | ✅       | ❌        | ❌       | ❌          | ✅                | ✅       | ✅       | ❌                      |
+| Metrics, Logs, and Traces   | ✅       | ✅        | ✅       | ✅          | ❌ (Metrics only) | ❌       | ❌       | ❌                      |
+| Pre-Built Integrations      | Limited  | Extensive | Over 600 | Moderate    | Limited           | Moderate | Limited  | 1,200+ Templates        |
+| Cloud-Native                | ✅       | ✅        | ✅       | ✅          | ✅                | ✅       | ✅       | Primarily Windows-Based |
+| Self-Hosting                | ✅       | ❌        | ❌       | ❌          | ✅                | ✅       | ✅       | ❌                      |
+| Ideal for Large Enterprises | ✅       | ✅        | ✅       | ✅          | ❌                | ❌       | ❌       | ✅                      |
+| Ideal for Small Teams       | ✅       | ❌        | ❌       | ❌          | ✅                | ✅       | ✅       | ❌                      |
+| Alerting Features           | Advanced | Advanced  | Advanced | Advanced    | Advanced          | Basic    | Advanced | Advanced                |
+| Customizability             | High     | Moderate  | High     | Moderate    | High              | High     | High     | Moderate                |
 
 Let's look at the top ten tools in detail.
 
@@ -52,157 +56,242 @@ Let's look at the top ten tools in detail.
 <video src="/img/unified-observability/showcase.mp4" autoPlay muted loop />
 
 ### Key Features
+
     - [Unified Data](https://signoz.io/unified-observability/): It seamlessly integrates metrics, logs, and traces into a single platform for full-stack observability.
     - [OpenTelemetry Integration](https://signoz.io/why-opentelemetry/): It supports out-of-the-box integration with OpenTelemetry, allowing easy [application instrumentation](https://signoz.io/docs/instrumentation/).
     - Self-Hosted & Cloud Options: Provides self-hosted deployment for teams that want full control over their data and SigNoz Cloud for a fully managed experience with minimal maintenance.
     - Cost-Efficiency: SigNoz does not charge licensing fees, so it offers a cost-effective way for teams to manage their observability needs.
+
 ### Limitations
+
     - Self-Hosting Overhead: The self-hosted version requires more management effort as it needs to be hosted and maintained.
     - Learning Curve: While SigNoz is flexible, getting the most out of SigNoz may require initial setup time.
+
 ### Use Case
+
     - It is best for engineering teams that prioritize data control and need a cost-effective, self-hosted solution without vendor lock-in. It’s ideal for startups, mid-sized teams, and organizations that require full-stack observability with minimal overhead.
 
-<GetStartedSigNoz />  
+<GetStartedSigNoz />
 
 ## 2. Dynatrace
 
 Dynatrace provides a complete, AI-powered observability solution that includes deep integration to monitor everything from cloud infrastructure to user experience.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%201.webp" alt="Dynatrace Dasboard Example (Source: Dynatrace Docs)" caption="Dynatrace Dasboard Example (Source: Dynatrace Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%201.webp"
+  alt="Dynatrace Dasboard Example (Source: Dynatrace Docs)"
+  caption="Dynatrace Dasboard Example (Source: Dynatrace Docs)"
+/>
 
 ### Key Features
+
     - AI-Powered Root Cause Analysis: It automatically detects and diagnoses problems using AI.
     - Full-Stack Observability: It includes infrastructure measurements, application performance, and user behaviour.
     - Cloud Native: It can integrate easily with Kubernetes, containers, and microservices.
+
 ### Limitations
+
     - Cost: Its cost is high compared to open-source or self-hosted choices, especially for small teams.
     - Complexity: Its setup might be difficult for teams without prior familiarity with sophisticated monitoring systems.
+
 ### Use Case
+
     - It is suitable for big companies and complex IT infrastructures where AI-driven root cause analysis is required for rapid issue resolution and [proactive monitoring](https://signoz.io/guides/proactive-monitoring/).
 
 ## 3. Datadog
 
 A cloud-native monitoring platform that includes real-time distributed tracing, Application Performance Monitoring (APM), and over 600 integrations.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%202.webp" alt="Datadog Dashboard Example (Source: Datadog Docs)" caption="Datadog Dashboard Example (Source: Datadog Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%202.webp"
+  alt="Datadog Dashboard Example (Source: Datadog Docs)"
+  caption="Datadog Dashboard Example (Source: Datadog Docs)"
+/>
 
 ### Key Features
+
     - Real-Time APM: It can effectively monitor application performance and distributed tracing in complicated architectures.
     - Scalability: It is easily scalable for high-volume situations.
     - Pre-Built Integrations: It supports over 600 integrations which enables easy setup with the majority of key cloud platforms and services.
+
 ### Limitations
+
     - Pricing: It can be pricey at scale, especially for big data quantities.
     - Proprietary: Data is housed by Datadog, which may not be appropriate for teams who value data privacy or self-hosting.
+
 ### Use Case
+
     - It is ideal for cloud-native systems where rapid scaling and advanced tracing are required. It's also suitable for high-traffic web applications and systems with complicated microservices architectures.
 
 ## 4. AppDynamics
 
 AppDynamics offers full-stack monitoring, including powerful transaction tracing and extensive code-level diagnostics.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%203.webp" alt="AppDynamics Dashboard Example (Source: AppDynamics Docs)" caption="AppDynamics Dashboard Example (Source: AppDynamics Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%203.webp"
+  alt="AppDynamics Dashboard Example (Source: AppDynamics Docs)"
+  caption="AppDynamics Dashboard Example (Source: AppDynamics Docs)"
+/>
 
 ### Key Features
+
     - Code-Level Insights: It helps developers identify performance bottlenecks in application code and database queries.
     - Business-Context Metrics: It connects technical metrics to business results, enabling businesses to measure and optimize mission-critical transactions.
     - End-to-End Visibility: It monitors infrastructure health and application performance.
+
 ### Limitations
+
     - Enterprise-Heavy: While it is strong, the solution is best suited for large organizations and may be too much for smaller teams.
     - Cost: Higher license prices may make it harder for smaller enterprises to afford.
+
 ### Use Case
+
     - Ideal for large enterprises that require detailed application monitoring, business outcome tracking, and the capacity to troubleshoot complicated issues in production.
 
 ## 5. Prometheus + Grafana
 
 The Prometheus + Grafana stack delivers an open-source solution for metrics monitoring, alerting, and visualization of time-series data. Prometheus collects and stores metrics, while Grafana provides robust dashboards to visualize and analyze this data. Often extended with components like Loki (logs), Tempo (traces), and Mimir (scaling), this stack supports full-stack observability.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%204.webp" alt="Prometheus Dashboard Example (Source: Prometheus Docs)" caption="Prometheus Dashboard Example (Source: Prometheus Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%204.webp"
+  alt="Prometheus Dashboard Example (Source: Prometheus Docs)"
+  caption="Prometheus Dashboard Example (Source: Prometheus Docs)"
+/>
 
 ### Key Features
+
     - PromQL: Use Prometheus Query Language for advanced metric analysis.
     - Service Discovery: Native support for Kubernetes service discovery detects dynamic workloads automatically.
     - Alerting: Integrated Alertmanager provides built-in alerting to notify teams of performance issues.
     - Visualization: Grafana’s customizable dashboards turn raw metrics into actionable insights.
+
 ### Limitations
+
     - Metrics-Centric: The core stack focuses on metrics. For logs and traces, integrate with Grafana Loki and Tempo.
+
 ### Use Case
+
     - Best suited for Kubernetes and containerized environments, particularly when organizations need a scalable, open-source solution for time-series metrics.
 
 ## 6. Zabbix
 
 Zabbix is an open-source solution for monitoring cloud, on-premises, and hybrid IT systems that include built-in templates and auto-discovery capabilities.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%205.webp" alt="Zabbix Dashboard Example (Source: Zabbix Docs)" caption="Zabbix Dashboard Example (Source: Zabbix Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%205.webp"
+  alt="Zabbix Dashboard Example (Source: Zabbix Docs)"
+  caption="Zabbix Dashboard Example (Source: Zabbix Docs)"
+/>
 
 ### Key Features
+
     - Auto-Discovery: It reduces setup time by automatically detecting devices and systems to monitor.
     - Strong Infrastructure Monitoring: It is proficient in monitoring network infrastructure, servers, and hardware.
     - High Customizability: It has extensive plugin support enabling bespoke integrations and monitoring of individual system configurations.
+
 ### Limitations
+
     - UI/UX: Although functional, the user interface is less refined than in more recent programs.
     - Steeper Learning Curve: Its setup and configuration take time, particularly for teams inexperienced with the ecosystem.
+
 ### Use Case
+
     - Ideal for network-heavy environments or businesses requiring customized [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/) that supports both on-premises and hybrid deployments.
 
 ## 7. Nagios
 
 Nagios is one of the oldest and most adaptable monitoring solutions available, with a diverse plugin ecosystem.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%206.webp" alt="Nagios Platfrom (Source: Nagios Website)" caption="Nagios Platfrom (Source: Nagios Website)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%206.webp"
+  alt="Nagios Platfrom (Source: Nagios Website)"
+  caption="Nagios Platfrom (Source: Nagios Website)"
+/>
 
 ### Key Features
+
     - Extensive Plugin Ecosystem: It has custom plugins that enable teams to monitor almost any system or service.
     - Strong Alerting System: Alerts may be set up for almost any system status, with specific thresholds and criteria.
+
 ### Limitations
+
     - Outdated UI: The user interface is rudimentary and may seem cumbersome compared to more contemporary options.
     - Manual Configuration: Installing Nagios needs substantial manual configuration, which can be time-consuming.
+
 ### Use Case
+
     - Ideal for teams that want highly customizable monitoring solutions or have specific requirements that are not addressed by off-the-shelf solutions.
 
 ## 8. SolarWinds Server & Application Monitor (SAM)
 
 SolarWinds SAM includes over 1,200 pre-built templates for extensive monitoring of server health and application performance.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%207.webp" alt="SAM Dashboard Example (Source: SAM Docs)" caption="SAM Dashboard Example (Source: SAM Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%207.webp"
+  alt="SAM Dashboard Example (Source: SAM Docs)"
+  caption="SAM Dashboard Example (Source: SAM Docs)"
+/>
 
 ### Key Features
+
     - Deep Windows and Database Monitoring: It is extremely effective at [monitoring Windows](https://signoz.io/guides/windows-server-monitoring/)-based systems and databases.
     - Pre-Built Templates: It has hundreds of ready-made templates to accelerate deployment.
+
 ### Limitations
+
     - Primarily Windows-Centric: It is designed for Windows-based infrastructures, with minimal support for Linux and containerized systems.
     - License Costs: Purchasing licenses for several displays may soon add up.
+
 ### Use Case
+
     - This solution is ideal for small-to-medium-sized IT teams that need to monitor Windows environments and need something simple to set up.
 
-## 9. Honeycomb    
+## 9. Honeycomb
 
 Honeycomb is a modern observability tool that can handle large amounts of data and provides powerful querying capabilities for debugging complicated systems.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%208.webp" alt="Honeycomb Dashboard Example (Source: Honeycomb Docs)" caption="Honeycomb Dashboard Example (Source: Honeycomb Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%208.webp"
+  alt="Honeycomb Dashboard Example (Source: Honeycomb Docs)"
+  caption="Honeycomb Dashboard Example (Source: Honeycomb Docs)"
+/>
 
 ### Key Features
+
     - High-Cardinality Support: It is ideal for handling huge datasets and detailed metrics.
     - Effective Querying: It offers powerful querying capabilities for difficult troubleshooting and debugging.
+
 ### Limitations
+
     - Complicated for small Use Cases: It is ideal for complicated systems but may be overkill for small use cases.
+
 ### Use Case
+
     - It is ideally suited for modern microservices-based architectures that need deep debugging and large-scale data analysis.
 
 ## 10. New Relic
 
 New Relic offers a single platform for tracking full-stack observability, with a focus on digital experience monitoring.
 
-<Figure src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%209.webp" alt="New Relic Dashboard Example (Source: New Relic Docs)" caption="New Relic Dashboard Example (Source: New Relic Docs)" />
+<Figure
+  src="/img/comparisons/2025/02/end-to-end-monitoring-tools-image%209.webp"
+  alt="New Relic Dashboard Example (Source: New Relic Docs)"
+  caption="New Relic Dashboard Example (Source: New Relic Docs)"
+/>
 
 ### Key Features
+
     - Full-Stack Telemetry: It tracks infrastructure, application performance, and user experience.
     - AIOps: It utilizes machine learning to automate problem detection and resolution.
+
 ### Limitations
+
     - Cost: Larger teams or high-traffic apps may incur more costs.
     - Learning Curve: The platform's wide features may make it difficult for new users to understand.
+
 ### Use Case
-    - It is ideal for enterprise-level monitoring and companies that need real-time performance tracking across several apps and systems.
 
+    - It is ideal for enterprise-level monitoring and companies that need real-time performance tracking across several apps and systems.
 
 ## How to Choose the Right End-to-End Monitoring Tool?
 
@@ -246,16 +335,15 @@ When selecting the correct monitoring system, many crucial elements must be eval
 - Proof-of-Concept: Implement proof-of-concept setups for essential use cases to determine their practical applicability.
 - Team Feedback: Collect feedback from several teams (e.g., developers, operations, and management) to verify that it fulfils wide needs.
 
-
 ## Key Takeaways
 
 - End-to-end monitoring is essential for successfully managing complex, distributed systems. It delivers extensive information about application performance, user experience, infrastructure, and system health.
 - Top tools such as SigNoz, Dynatrace, and Datadog provide full observability across several system layers, with each having distinct characteristics tailored to different organizational requirements.
 - When picking a monitoring solution, consider your environment and requirements. Consider the cost, ease of use, scalability, and integration capabilities.
 - Successful implementation involves:
-    - Clear monitoring objectives.
-    - Phased rollout to ensure progressive uptake.
-    - Continuous optimization based on the insights acquired.
+  - Clear monitoring objectives.
+  - Phased rollout to ensure progressive uptake.
+  - Continuous optimization based on the insights acquired.
 - AI-driven insights, enhanced automation, and tighter connection with business metrics will shape the future of monitoring, making systems smarter and more predictable.
 
 ## FAQs
@@ -275,6 +363,7 @@ Review monitoring strategies quarterly at minimum, and after major incidents or
 ### What are the potential drawbacks of implementing end-to-end monitoring?
 
 Key challenges include:
+
 - Data overload from excessive collection
 - Complex implementation across systems
 - Performance impact on monitored systems
@@ -283,6 +372,7 @@ Key challenges include:
 ### How can we ensure our monitoring doesn't negatively impact system performance?
 
 To minimize impact:
+
 - Use sampling for high-volume data
 - Optimize instrumentation code
 - Implement asynchronous data collection
@@ -292,6 +382,7 @@ To minimize impact:
 ### How can we manage security risks when implementing monitoring tools?
 
 Key security measures:
+
 - Use encrypted communication (HTTPS/TLS)
 - Implement role-based access control
 - Enable and review audit logs
@@ -305,4 +396,4 @@ Key security measures:
 
 2. Ephemeral Services:
    - Deploy distributed tracing (OpenTelemetry/Jaeger)
-   - Centralize logs using aggregation tools before instance termination
\ No newline at end of file
+   - Centralize logs using aggregation tools before instance termination
diff --git a/data/comparisons/firebase-alternatives.mdx b/data/comparisons/firebase-alternatives.mdx
index 5af919cdf..e656f6880 100644
--- a/data/comparisons/firebase-alternatives.mdx
+++ b/data/comparisons/firebase-alternatives.mdx
@@ -1,6 +1,6 @@
 ---
 title: Top 7 Firebase Alternatives for App Development in 2025
-slug: firebase-alternatives
+
 date: 2025-01-02
 tags: [tools-comparision]
 authors: [anubhav_omar]
@@ -283,7 +283,6 @@ Comparison with Firebase
 1. Supabase: Open-source Firebase Alternative
 
    Supabase is an open-source Firebase alternative that's gaining traction. It offers:
-
    - PostgreSQL database with real-time capabilities
    - Built-in authentication and authorization
    - Storage solutions for large files
@@ -294,7 +293,6 @@ Comparison with Firebase
 2. MongoDB Realm: Scalable Solution for Mobile and Web Apps
 
    MongoDB Realm provides a robust alternative to Firebase, especially for apps requiring a flexible data model. Key features include:
-
    - Real-time sync across devices
    - Offline-first architecture
    - Built-in user authentication
@@ -305,7 +303,6 @@ Comparison with Firebase
 3. AWS Amplify: Comprehensive Backend Solution from Amazon
 
    AWS Amplify offers a set of tools and services for building scalable mobile and web applications. It provides:
-
    - GraphQL and REST APIs
    - Authentication and authorization
    - Serverless functions
@@ -316,7 +313,6 @@ Comparison with Firebase
 4. Appwrite: Self-hosted Backend Server
 
    Appwrite is a self-hosted backend server that you can run on your own infrastructure. It offers:
-
    - Database management
    - User authentication
    - Storage solutions
@@ -328,7 +324,6 @@ Comparison with Firebase
    Comparing Real-time Database Alternatives
 
    When evaluating Firebase alternatives for real-time databases, consider these factors:
-
    1. Performance:
       - Supabase: Excellent for small to medium-sized applications
       - MongoDB Realm: Scales well for large, complex datasets
@@ -355,7 +350,6 @@ Comparison with Firebase
 1. Auth0: Flexible, Feature-rich Authentication Service
 
    Auth0 is a robust authentication and authorization platform that offers:
-
    - Support for various identity providers
    - Customizable login flows
    - Multi-factor authentication
@@ -366,7 +360,6 @@ Comparison with Firebase
 2. Okta: Enterprise-grade Identity Management
 
    Okta provides a comprehensive identity management solution with:
-
    - Single sign-on (SSO) capabilities
    - Adaptive multi-factor authentication
    - API access management
@@ -377,7 +370,6 @@ Comparison with Firebase
 3. Supabase Auth: Built-in Auth for Supabase Users
 
    If you're already using Supabase for your database needs, Supabase Auth offers:
-
    - Email and password authentication
    - Social login providers
    - JWT tokens for session management
@@ -390,7 +382,6 @@ Comparison with Firebase
 1. AWS Lambda: Serverless Computing Pioneer
 
    AWS Lambda allows you to run code without provisioning or managing servers. It offers:
-
    - Support for multiple programming languages
    - Automatic scaling
    - Pay-per-execution pricing model
@@ -401,7 +392,6 @@ Comparison with Firebase
 2. Google Cloud Functions: Direct Firebase Alternative
 
    Google Cloud Functions provides a serverless execution environment that's closely related to Firebase Functions. It features:
-
    - Support for Node.js, Python, and Go
    - Automatic scaling and load balancing
    - Integration with Google Cloud services
@@ -412,7 +402,6 @@ Comparison with Firebase
 3. Azure Functions: Microsoft's Serverless Offering
 
    Azure Functions is Microsoft's answer to serverless computing, providing:
-
    - Support for multiple languages including C#, JavaScript, and Python
    - Integration with Azure and third-party services
    - Flexible scaling options
@@ -425,7 +414,6 @@ Comparison with Firebase
 1. Amazon S3: Industry-standard Object Storage
 
    Amazon S3 (Simple Storage Service) is a highly scalable object storage service. It offers:
-
    - Virtually unlimited storage capacity
    - High durability and availability
    - Fine-grained access controls
@@ -436,7 +424,6 @@ Comparison with Firebase
 2. DigitalOcean Spaces: Simple, Scalable Storage Option
 
    DigitalOcean Spaces provides S3-compatible object storage with:
-
    - Simple pricing model
    - Built-in CDN for faster content delivery
    - Easy-to-use web interface
@@ -447,7 +434,6 @@ Comparison with Firebase
 3. Cloudinary: Specialized Media Asset Management
 
    Cloudinary focuses on media asset management, offering:
-
    - Automatic image and video optimization
    - On-the-fly transformations
    - Content delivery network (CDN)
diff --git a/data/comparisons/graylog-alternatives.mdx b/data/comparisons/graylog-alternatives.mdx
index 484199471..817e13e5a 100644
--- a/data/comparisons/graylog-alternatives.mdx
+++ b/data/comparisons/graylog-alternatives.mdx
@@ -1,63 +1,77 @@
 ---
-
 title: Top 7 Graylog Alternatives for Log Management in 2025
-slug: graylog-alternatives
+
 date: 2025-01-02
 tags: [tools-comparisons]
 authors: [manjunath_irukulla]
 description: Discover the top 7 Graylog alternatives for efficient log management in 2023. Compare features, pricing, and deployment options to find the best solution for your needs.
-keywords: [graylog alternatives, log management, observability, devops tools, log analysis, open-source logging]
-
+keywords:
+  [
+    graylog alternatives,
+    log management,
+    observability,
+    devops tools,
+    log analysis,
+    open-source logging,
+  ]
 ---
 
 Log management is vital to modern IT operations, enabling teams to monitor system behaviour, troubleshoot problems, and ensure security compliance. While Graylog has been a long popular choice for many organizations, you might be seeking alternatives that better align with your specific needs.
 
-In this article, we explore the top 7 Graylog alternatives for log management in 2024, providing insights into the strengths of each solution to help you make an informed decision for your organization. 
+In this article, we explore the top 7 Graylog alternatives for log management in 2024, providing insights into the strengths of each solution to help you make an informed decision for your organization.
 
 ## Understanding Graylog and the Need for Alternatives
 
-Graylog is a popular open-source log management platform designed to collect, index, and analyze real-time log data from multiple sources. Its core features include centralized log collection, powerful search and filtering capabilities, alerting, and customisable dashboards, making it a versatile tool for monitoring and troubleshooting. With its support for both structured and unstructured data, Graylog is often chosen for IT environments that need detailed log insights.  
+Graylog is a popular open-source log management platform designed to collect, index, and analyze real-time log data from multiple sources. Its core features include centralized log collection, powerful search and filtering capabilities, alerting, and customisable dashboards, making it a versatile tool for monitoring and troubleshooting. With its support for both structured and unstructured data, Graylog is often chosen for IT environments that need detailed log insights.
 
-However, despite its flexibility and open-source nature, Graylog poses several challenges for certain users and organizations: 
+However, despite its flexibility and open-source nature, Graylog poses several challenges for certain users and organizations:
 
-- Complex Setup and Maintenance:  Graylog requires significant technical expertise to configure, deploy, and maintain particularly in larger environments. The setup often involves managing dependencies like Elasticsearch and MongoDB, which can add to the complexity.
+- Complex Setup and Maintenance: Graylog requires significant technical expertise to configure, deploy, and maintain particularly in larger environments. The setup often involves managing dependencies like Elasticsearch and MongoDB, which can add to the complexity.
 - Dependency On Specific MongoDB Versions: Graylog’s reliance on MongoDB for metadata storage means users must manage compatible MongoDB versions. Upgrading MongoDB can break compatibility, making system updates risky or cumbersome.
 - Limited Scalability For High-Volume Log Ingestion: Graylog may struggle to handle the increased load without considerable infrastructure and performance tuning for organisations with massive log volumes or those operating at enterprise scale. This can lead to delays in log processing and data retention issues.
 - Steep Learning Curve: While Graylog offers advanced features such as pipelines and stream processing, mastering these functionalities requires time and in-depth technical knowledge, which may not be feasible for teams with limited resources or expertise.
 
-Due to these limitations, many organizations explore alternatives to Graylog that can provide better ease of use, enhanced scalability, or additional features such as cloud-native integrations, real-time alerting, or simplified log analytics. 
+Due to these limitations, many organizations explore alternatives to Graylog that can provide better ease of use, enhanced scalability, or additional features such as cloud-native integrations, real-time alerting, or simplified log analytics.
 
 ## Criteria for Evaluating Log Management Solutions
 
-When selecting alternatives to Graylog, it’s essential to weigh the capabilities and limitations of each option against your organization’s specific needs. Consider the following key criteria to ensure the solution aligns with your operational goals. 
+When selecting alternatives to Graylog, it’s essential to weigh the capabilities and limitations of each option against your organization’s specific needs. Consider the following key criteria to ensure the solution aligns with your operational goals.
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-21b17e4b-0e06-4603-989e-d254093f0619.webp" alt="Evaluating Log Management Solutions" caption="Evaluating Log Management Solutions" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-21b17e4b-0e06-4603-989e-d254093f0619.webp"
+  alt="Evaluating Log Management Solutions"
+  caption="Evaluating Log Management Solutions"
+/>
 
 - Scalability and Performance: The ability to scale is crucial, especially for organizations expecting an increase in log volume as they grow.
-    - Evaluate how well the solution handles both real-time and historical log data processing under heavy loads.
-    - Consider whether the platform can scale horizontally or vertically and whether it supports clustering or distributed architectures to manage large-scale environments effectively.
+  - Evaluate how well the solution handles both real-time and historical log data processing under heavy loads.
+  - Consider whether the platform can scale horizontally or vertically and whether it supports clustering or distributed architectures to manage large-scale environments effectively.
 - Ease of Deployment: A log management solution should simplify installation, configuration, and ongoing maintenance.
-    - Cloud-based solutions often offer more streamlined deployment with minimal infrastructure management, while on-premise systems may provide more control but require greater effort in managing dependencies and updates.
-    - Choose a solution that aligns with your team’s technical expertise and resource availability.
+  - Cloud-based solutions often offer more streamlined deployment with minimal infrastructure management, while on-premise systems may provide more control but require greater effort in managing dependencies and updates.
+  - Choose a solution that aligns with your team’s technical expertise and resource availability.
 - Integration Capabilities: Seamless integration with your existing tech stack is essential for smooth Operations. Asses whether the log management platform integrates well with critical tools such as SIEM systems, cloud providers, containerized environments (Docker, Kubernetes), and third-party monitoring tools like Prometheus or Grafana.
-    - The broader the range of supported integrations, the easier it will be to centralize logs from various sources.
+  - The broader the range of supported integrations, the easier it will be to centralize logs from various sources.
 - Cost-effectiveness: Total Cost of Ownership (TCO) is a key consideration. Beyond upfront licensing fees, examine additional infrastructure, maintenance, support, and scaling expenses.
-    - Open-source tools may offer lower initial costs but often require more extensive manual management, while cloud-native or managed services might provide better long-term value with predictable pricing models.
+  - Open-source tools may offer lower initial costs but often require more extensive manual management, while cloud-native or managed services might provide better long-term value with predictable pricing models.
 - Advanced Analytics: As organizations increasingly rely on data-driven insights, the ability to leverage machine learning (ML) for log analysis becomes a differentiator.
-    - Evaluate whether the solution offers ML-powered features like anomaly detection, predictive analytics, and automated pattern-powered features like anomaly detection, predictive analysis, and pattern recognition to identify potential issues or security threats before they escalate.
+  - Evaluate whether the solution offers ML-powered features like anomaly detection, predictive analytics, and automated pattern-powered features like anomaly detection, predictive analysis, and pattern recognition to identify potential issues or security threats before they escalate.
 - Visualization Features: Effective log visualization is vital for quick diagnosis and actionable insights. Consider whether the solution offers customization that can display log data in an intuitive and meaningful way.
-    - Look for features like drag-and-drop widgets, pre-built templates, and support for custom reports,  which can help teams monitor key metrics and trends at a glance.
+  - Look for features like drag-and-drop widgets, pre-built templates, and support for custom reports, which can help teams monitor key metrics and trends at a glance.
 - Compliance Support: If your organization operates in a regulated industry, ensuring the solution can help you meet compliance requirements (e.g., GDPR, HIPPA, PCI DSS) is essential.
-    - Look for built-in security features such as role-based access control (RBAC), encryption of log data at rest and in transit, and audit logging capabilities.
-    - Solutions that provide compliance-related reports or templates can streamline audits and ensure regulatory adherence.
+  - Look for built-in security features such as role-based access control (RBAC), encryption of log data at rest and in transit, and audit logging capabilities.
+  - Solutions that provide compliance-related reports or templates can streamline audits and ensure regulatory adherence.
 
 ## Top 7 Graylog Alternatives for 2024
 
-Organizations may seek alternatives that better suit their specific needs, such as ease of use and pricing, or advanced features like real-time monitoring and alerting. This section explores the top Graylog alternatives for 2024, focusing on platforms that offer unique strengths in log management, monitoring, and analytics. Whether a small startup or a large enterprise, these tools can help you optimize your [observability stack](https://signoz.io/guides/observability-stack/). 
+Organizations may seek alternatives that better suit their specific needs, such as ease of use and pricing, or advanced features like real-time monitoring and alerting. This section explores the top Graylog alternatives for 2024, focusing on platforms that offer unique strengths in log management, monitoring, and analytics. Whether a small startup or a large enterprise, these tools can help you optimize your [observability stack](https://signoz.io/guides/observability-stack/).
 
 ### 1. SigNoz: A Comprehensive Open-Source Alternative
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-SigNoz_Logs.webp" alt="SigNoz Logs Dashboard - Source SigNoz.io" caption="SigNoz Logs Dashboard - Source SigNoz.io" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-SigNoz_Logs.webp"
+  alt="SigNoz Logs Dashboard - Source SigNoz.io"
+  caption="SigNoz Logs Dashboard - Source SigNoz.io"
+/>
 
 [SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability tool that offers robust log management capabilities. Key features include:
 
@@ -80,33 +94,51 @@ SigNoz offers both cloud and open-source versions, allowing you to choose the op
 
 ### 2. Better Stack Logs
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Better_Stack_Logs.webp" alt="Better Stack Logs Dashboard- source Better Stack Logs" caption="Better Stack Logs Dashboard- source Better Stack Logs" /> 
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Better_Stack_Logs.webp"
+  alt="Better Stack Logs Dashboard- source Better Stack Logs"
+  caption="Better Stack Logs Dashboard- source Better Stack Logs"
+/>
 
-<a href="https://betterstack.com/logs" rel="noopener noreferrer nofollow" target="_blank">Better Stack Logs</a> offers a modern, user-friendly approach to log management. It stands out with its:
+<a href="https://betterstack.com/logs" rel="noopener noreferrer nofollow" target="_blank">
+  Better Stack Logs
+</a>
+offers a modern, user-friendly approach to log management. It stands out with its:
 
 - Intuitive Interface and Quick Setup: A sleek UI allows easy navigation, making it suitable for teams without deep technical expertise.
 - Powerful Full-Text Search and Real-Time Log Tailing: These features provide quick insights into log data, enabling faster troubleshooting and debugging.
 - Customizable Dashboards and Alerting Rules: users can create tailored dashboards and set up alerting rules to get notified of specific log patterns or anomalies.
 - Competitive Pricing Model with Predictable Costs: Its straightforward pricing structure ensures cost predictability, which is significant for organizations of all sizes.
 
-Better Stack Logs excels in scenarios where ease of use and quick time-to-value are priorities. The low total cost of ownership and user-friendly interface make it especially appealing for startups and small to mid-sized businesses. 
+Better Stack Logs excels in scenarios where ease of use and quick time-to-value are priorities. The low total cost of ownership and user-friendly interface make it especially appealing for startups and small to mid-sized businesses.
 
 ### 3. Splunk
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Splunk__Logs_Dashboard.webp" alt="Splunk Logs Dashboard - source Splunk" caption="Splunk Logs Dashboard - source Splunk" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Splunk__Logs_Dashboard.webp"
+  alt="Splunk Logs Dashboard - source Splunk"
+  caption="Splunk Logs Dashboard - source Splunk"
+/>
 
-<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> is a comprehensive log management and analysis platform known for its:
+<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is a comprehensive log management and analysis platform known for its:
 
 - Robust Search and Reporting Capabilities: Splunk’s search processing language (SPL) allows users to query and analyze logs precisely.
 - Extensive Ecosystem of Apps and Integrations: Splunk has a large marketplace of apps and integrates with numerous third-party tools, enhancing its flexibility in diverse IT environments.
 - Advanced Security and Compliance Features: Features like role-based access control (RBAC) and audit logs suit organizations in highly regulated industries.
 - Machine Learning-Powered Analytics: Splunk leverages ML to provide predictive analytics and detect anomalies in log data.
 
-Splunk shines in large enterprise environments with complex IT infrastructures. Its ability to handle massive data volumes and provide deep insights makes it a powerful—albeit often expensive—choice, especially for teams requiring advanced security and analytics features. 
+Splunk shines in large enterprise environments with complex IT infrastructures. Its ability to handle massive data volumes and provide deep insights makes it a powerful—albeit often expensive—choice, especially for teams requiring advanced security and analytics features.
 
 ### 4. Logz.io
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Logz.io_Dashboard.webp" alt="Logz.io Dashboard - source Logz.io" caption="Logz.io Dashboard - source Logz.io" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Logz.io_Dashboard.webp"
+  alt="Logz.io Dashboard - source Logz.io"
+  caption="Logz.io Dashboard - source Logz.io"
+/>
 
 [Logz.io](http://logz.io/) offers a cloud-native log management solution built on the ELK (Elasticsearch, Logstash, Kibana) stack. Key features include:
 
@@ -115,73 +147,94 @@ Splunk shines in large enterprise environments with complex IT infrastructures.
 - Integration With Popular CI/CD and Monitoring Tools: [Logz.io](http://Logz.io) integrates seamlessly with tools like Jenkins, Kubernetes, and Prometheus.
 - Flexible Pricing Based on Data Volume and Retention: The pricing model allows organizations to scale based on data usage and retention needs.
 
-[Logz.io](http://logz.io/) is well-suited for organizations looking for a managed ELK solution with advanced AI capabilities. Its managed approach takes the operational burden off teams, allowing them to focus on analysis rather than infrastructure maintenance. 
+[Logz.io](http://logz.io/) is well-suited for organizations looking for a managed ELK solution with advanced AI capabilities. Its managed approach takes the operational burden off teams, allowing them to focus on analysis rather than infrastructure maintenance.
 
 ### 5. Sematext Logs
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Sematext_logs_dashboard.webp" alt="Sematext Logs Dashboard - source sematext.com" caption="Sematext Logs Dashboard - source sematext.com" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Sematext_logs_dashboard.webp"
+  alt="Sematext Logs Dashboard - source sematext.com"
+  caption="Sematext Logs Dashboard - source sematext.com"
+/>
 
-<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">Sematext</a> logs are part of a full-stack observability platform. It offers:
+<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Sematext
+</a>
+logs are part of a full-stack observability platform. It offers:
 
 - Real-Time Log Analytics and Alerting: Users can monitor logs in real-time, setting up alerts to receive notifications for specific events or thresholds.
 - Custom Dashboards and Data Visualization Options: The platform enables the creation of dashboards tailored to specific metrics or log data.
 - Flexible Deployment Options: Sematext supports cloud, on-premises, and hybrid deployments, offering flexibility based on an organization’s infrastructure.
 - Integration with Metrics, traces, and synthetic Monitoring: Sematext provides a comprehensive view of application and system health by unifying logs with other observability data.
 
-Sematext Logs is ideal for organizations seeking a [unified observability](https://signoz.io/unified-observability/) solution. Its flexible deployment options and integrated approach suit diverse infrastructure setups, from cloud-native to hybrid environments. 
+Sematext Logs is ideal for organizations seeking a [unified observability](https://signoz.io/unified-observability/) solution. Its flexible deployment options and integrated approach suit diverse infrastructure setups, from cloud-native to hybrid environments.
 
 ### 6. Datadog
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Datadog_Dashboard.webp" alt="Datadog Log Analytics Dashboard - source Datadog" caption="Datadog Log Analytics Dashboard - source Datadog" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Datadog_Dashboard.webp"
+  alt="Datadog Log Analytics Dashboard - source Datadog"
+  caption="Datadog Log Analytics Dashboard - source Datadog"
+/>
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> provides a unified platform for logs, metrics, and traces. Notable features include:
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+provides a unified platform for logs, metrics, and traces. Notable features include:
 
 - Machine Learning-Driven Log Processing and Analysis: Datadog applies machine learning algorithms to detect anomalies and uncover insights in real-time logs.
 - Extensive Integrations with Cloud Services and DevOps Tools: With over 450 integrations, Datadog seamlessly fits into existing cloud environments and DevOps workflows.
 - Customizable Alerting and Reporting: Users can set up sophisticated alerting mechanisms and generate detailed reports for system health and performance.
 - Real-time Collaboration Tools: Teams can collaborate or troubleshoot efforts in real-time, sharing insights and creating runbooks within the platform.
 
-Datadog excels in cloud-native environments and offers a comprehensive view of your entire stack. Its ability to unify logs, metrics, and traces ensures a complete observability solution, which is ideal for dynamic and large-scale systems. 
+Datadog excels in cloud-native environments and offers a comprehensive view of your entire stack. Its ability to unify logs, metrics, and traces ensures a complete observability solution, which is ideal for dynamic and large-scale systems.
 
 ### 7. LogicMonitor
 
-<Figure src="/img/comparisons/2024/11/graylog-alternatives-Logicmonitor_dashboard.webp" alt="LogicMonitor Logs Dashboard - source LogicMonitor" caption="LogicMonitor Logs Dashboard - source LogicMonitor" />
+<Figure
+  src="/img/comparisons/2024/11/graylog-alternatives-Logicmonitor_dashboard.webp"
+  alt="LogicMonitor Logs Dashboard - source LogicMonitor"
+  caption="LogicMonitor Logs Dashboard - source LogicMonitor"
+/>
 
-<a href="https://www.logicmonitor.com/" rel="noopener noreferrer nofollow" target="_blank">LogicMonitor</a> combines log intelligence with infrastructure monitoring. Key strengths include:
+<a href="https://www.logicmonitor.com/" rel="noopener noreferrer nofollow" target="_blank">
+  LogicMonitor
+</a>
+combines log intelligence with infrastructure monitoring. Key strengths include:
 
 - AIOps-Powered [Log Correlation](https://signoz.io/opentelemetry/correlating-traces-logs-metrics-nodejs/) and Analysis: By leveraging AIOps, LogicMonitor correlates logs with performance metrics, helping teams identify the root cause of issues faster.
 - Automated Log Collection and Parsing: Logs are automatically collected and parsed, reducing manual effort and ensuring timely insights.
 - Seamless Integration with Infrastructure Metrics: Logs can be correlated with infrastructure metrics for a unified view of system health.
 - Root Cause Analysis and Troubleshooting Capabilities: LogicMonitor’s ability to pinpoint the root cause of issues reduces troubleshooting time and helps teams resolve incidents faster.
 
-LogicMonitor is well-suited for organizations looking to unify their log management and infrastructure monitoring. Its AIOps capabilities help reduce alert noise, making it easier to focus on the most critical issues.  
+LogicMonitor is well-suited for organizations looking to unify their log management and infrastructure monitoring. Its AIOps capabilities help reduce alert noise, making it easier to focus on the most critical issues.
 
 ## Choosing the Right Graylog Alternative for Your Organization
 
 When selecting a log management solution, it’s essential to match the platform’s capabilities with your organization’s specific requirements. Here’s a step-by-step to ensure you make the best choice:
 
-1. Assess Your Requirements: Start by determining your organization’s key needs: 
-    - Log Volume: Calculate how much log data you generate daily and how much storage you’ll require over time.
-    - Retention Policy: Consider how long you need to keep log data for auditing, compliance, or troubleshooting purposes.
-    - Use Cases: Define your primary goals, such as performance monitoring, security auditing, or DevOps troubleshooting.
-2. Evaluate Integration Needs: A critical factor is how well the new log management solution integrates with your existing infrastructure. 
-    - Cloud and On-premises Tools: Identify the tools and services you use (e.g., AWS, Kubernetes, CI/CD pipelines, security tools).
-    - Ecosystem Compatibility: Ensure the solution integrates seamlessly with your monitoring, automation, and alerting systems.
-    - API Support: Consider a platform with robust APIs to facilitate custom integrations and workflows.
-3.  Consider Scalability: Choose a solution that can scale with your organization as you grow: 
-    - Data Handling: Ensure the solution supports both current and future log volumes, as well as data peaks during traffic surges.
-    - Architectures: Opt for platforms that provide flexible deployment options, like cloud-native, on-premises, or hybrid models.
-    - Cost Efficiency: As your organization grows, assess how costs will scale. Some platforms offer predictable pricing, while others may charge based on usage metrics like data volume or retention period.
-4. Test Drive Options: Before committing, test drive the log management solution to evaluate real-world functionality. 
-    - Free Trails: Most platforms offer trial versions. Use this opportunity to evaluate usability, performance, and feature sets.
-    - Proof of Concept: For a more in-depth evaluation, set up a proof of concept with a sample of your production logs to understand how well the solution fits your workflows.
-    - Usability: Test dashboards, search functionality, and customizability to ensure the solution meets your team’s needs.
-5.  Plan for Migration: Migrating from Graylog to a new log management solution requires a well-thought-out  approach to avoid disruptions: 
-    - Document Current Workflows: Map out how you currently manage logs, from data ingestion and processing to alerting and visualization.
-    - Data Migration: Plan how to transfer existing logs to the new platform. Consider potential data loss and compatibility during migration.
-    - Downtime Minimization: To prevent downtime or data gaps, consider a phased migration where you gradually transition log sources.
-    - Team Training: Train your team on how to use the new solution to ensure a smooth transition.
-    - Post-Migration Testing: After migration, test the system to confirm that all logs are properly ingested, analyzed, and stored.
+1. Assess Your Requirements: Start by determining your organization’s key needs:
+   - Log Volume: Calculate how much log data you generate daily and how much storage you’ll require over time.
+   - Retention Policy: Consider how long you need to keep log data for auditing, compliance, or troubleshooting purposes.
+   - Use Cases: Define your primary goals, such as performance monitoring, security auditing, or DevOps troubleshooting.
+2. Evaluate Integration Needs: A critical factor is how well the new log management solution integrates with your existing infrastructure.
+   - Cloud and On-premises Tools: Identify the tools and services you use (e.g., AWS, Kubernetes, CI/CD pipelines, security tools).
+   - Ecosystem Compatibility: Ensure the solution integrates seamlessly with your monitoring, automation, and alerting systems.
+   - API Support: Consider a platform with robust APIs to facilitate custom integrations and workflows.
+3. Consider Scalability: Choose a solution that can scale with your organization as you grow:
+   - Data Handling: Ensure the solution supports both current and future log volumes, as well as data peaks during traffic surges.
+   - Architectures: Opt for platforms that provide flexible deployment options, like cloud-native, on-premises, or hybrid models.
+   - Cost Efficiency: As your organization grows, assess how costs will scale. Some platforms offer predictable pricing, while others may charge based on usage metrics like data volume or retention period.
+4. Test Drive Options: Before committing, test drive the log management solution to evaluate real-world functionality.
+   - Free Trails: Most platforms offer trial versions. Use this opportunity to evaluate usability, performance, and feature sets.
+   - Proof of Concept: For a more in-depth evaluation, set up a proof of concept with a sample of your production logs to understand how well the solution fits your workflows.
+   - Usability: Test dashboards, search functionality, and customizability to ensure the solution meets your team’s needs.
+5. Plan for Migration: Migrating from Graylog to a new log management solution requires a well-thought-out approach to avoid disruptions:
+   - Document Current Workflows: Map out how you currently manage logs, from data ingestion and processing to alerting and visualization.
+   - Data Migration: Plan how to transfer existing logs to the new platform. Consider potential data loss and compatibility during migration.
+   - Downtime Minimization: To prevent downtime or data gaps, consider a phased migration where you gradually transition log sources.
+   - Team Training: Train your team on how to use the new solution to ensure a smooth transition.
+   - Post-Migration Testing: After migration, test the system to confirm that all logs are properly ingested, analyzed, and stored.
 
 ### Best Practices for a Successful Migration
 
@@ -220,4 +273,4 @@ When selecting a log management solution, it’s essential to match the platform
 
 - Cloud-based solutions are generally easier to set up and maintain, offering automatic updates, elastic scalability, and minimal infrastructure overhead.
 - Self-hosted solutions give you more control over data, potentially lowering costs for large volumes and enabling compliance with data sovereignty or specific security requirements.
-- Choose based on your organization’s technical capabilities, data privacy needs, and growth expectations.
\ No newline at end of file
+- Choose based on your organization’s technical capabilities, data privacy needs, and growth expectations.
diff --git a/data/comparisons/graylog-vs-loki.mdx b/data/comparisons/graylog-vs-loki.mdx
index 53c52e1ab..bf8ad2abb 100644
--- a/data/comparisons/graylog-vs-loki.mdx
+++ b/data/comparisons/graylog-vs-loki.mdx
@@ -1,6 +1,6 @@
 ---
 title: Graylog vs Loki - Choosing the Right Log Management Tool
-slug: graylog-vs-loki
+
 date: 2025-01-09
 tags: [graylog, loki, faq]
 authors: [nilesh_sinha]
@@ -344,7 +344,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://community.graylog.org/t/excessive-elasticsearch-index-size/4343" rel="noopener noreferrer nofollow" target="_blank">Excessive ElasticSearch Index Size</a>
 
   Example: A banking application collects 50,000 messages/second per node, including user login events, transaction logs, and fraud detection alerts. Graylog's Elasticsearch backend ensures 2-5 seconds query response for 1M logs, enabling auditors to perform quick searches.
-
   - Suggestion: Use Graylog for scenarios demanding rapid and complex searches, such as financial audits or security event investigations.
 
 - Loki: Typically, Loki's log ingestion is lighter and more optimized for cloud-native environments. However, since it doesn't index logs as heavily as Graylog, performing large text searches might be slower.
@@ -354,7 +353,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://community.grafana.com/t/planning-system-requirements-and-storage/57072" rel="noopener noreferrer nofollow" target="_blank">Planning system requirements and storage</a>
 
   Example: A Kubernetes cluster generates 100,000 lines/second, including pod logs labeled by namespace and service. Loki ingests these logs with lightweight Promtail agents, providing 0.5-2 seconds query response for label-based queries.
-
   - Suggestion: Opt for Loki in environments with high log volumes but less need for full-text search, like cloud-native observability or monitoring containerized services.
 
 ### 2. Resource Requirements:
@@ -366,7 +364,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://opster.com/guides/elasticsearch/capacity-planning/elasticsearch-shards-limit/" rel="noopener noreferrer nofollow" target="_blank">Understanding and Managing Elasticsearch Shards Limit</a>
 
   Example: An e-commerce platform handling 1TB/day of logs needs a cluster with 3 Elasticsearch nodes, each configured with 16 CPUs and 64GB RAM, and 1-2 Graylog servers to handle indexing and queries.
-
   - Suggestion: Allocate resources proportionally to log volume. For cost-efficiency, set index rotation policies to archive older data to cheaper storage.
 
 - Loki: More resource-efficient, especially during ingestion. Loki offloads log data to object storage (like S3), making it more memory-friendly when dealing with large log volumes, as it avoids the heavy disk I/O operations required by Elasticsearch.
@@ -376,7 +373,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ [Logs Performance Benchmark](https://signoz.io/blog/logs-performance-benchmark/)
 
   Example: A streaming service handling 1TB/day of logs uses object storage (e.g., S3) to offload disk I/O. The system runs on a smaller cluster with fewer ingester and distributor nodes, saving on compute costs.
-
   - Suggestion: Leverage object storage for large-scale [log retention](https://signoz.io/guides/log-retention/) and reduce on-premises hardware dependencies.
 
 ### 3. Scalability in High-Volume Environments:
@@ -388,7 +384,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/size-your-shards.html" rel="noopener noreferrer nofollow" target="_blank">Size your shards</a>
 
   Example: Scaling an enterprise system from 1TB/day to 5TB/day requires adding 9 Elasticsearch nodes (up from 3) to handle indexing and query loads, plus additional Graylog servers for ingestion.
-
   - Suggestion: Plan for high scaling costs and complexity. Use index optimization techniques like reducing shard count and replication factor to manage resource usage.
 
 - Loki: Designed for horizontal scalability in distributed systems, Loki is more efficient in handling massive log volumes, especially in Kubernetes or cloud-native environments. Its label-based indexing makes scaling easier and cheaper.
@@ -398,7 +393,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://grafana.com/docs/loki/latest/get-started/overview/" rel="noopener noreferrer nofollow" target="_blank">Loki overview</a>
 
   Example: A Kubernetes-based application scales from 5TB/day to 10TB/day by adding distributors and ingesters without overhauling the architecture. Loki's label-based indexing ensures efficient scaling.
-
   - Suggestion: Keep labels concise and avoid [high cardinality](https://signoz.io/blog/high-cardinality-data/) (e.g., avoid using unique request IDs as labels) to maintain query performance at scale.
 
 ### 4. Optimization Techniques:
@@ -410,7 +404,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://search-guard.com/blog/reduce-elasticsearch-search-latency-optimize-search-performance/" rel="noopener noreferrer nofollow" target="_blank">Reduce Elasticsearch Search Latency and Optimize Search Performance</a>
 
   Example: A cybersecurity system ingests 500K events/hour and uses 2 shards per index with a 7-day retention policy. Cached queries reduce response times for repeated searches.
-
   - Suggestion: Optimize shard allocation and caching for frequently queried datasets to improve performance without overloading resources.
 
 - Loki: To optimize performance, Loki recommends minimizing cardinality by properly labeling logs. Multi-tenancy support allows for better management in environments with multiple teams. Additionally, adjusting chunk sizes helps with efficient storage and retrieval of log data.
@@ -420,7 +413,6 @@ When considering performance and resource utilization, both Graylog and Loki exc
   _Source:_ <a href="https://shaorui0.github.io/2024/10/29/loki_storage_optimization/" rel="noopener noreferrer nofollow" target="_blank">Loki Storage Optimization</a>
 
   Example: A DevOps team monitors 10K services using fewer than 50 unique label combinations, such as `{app="service1", env="prod"}`. Adjusted chunk sizes minimize storage costs while retaining fast access.
-
   - Suggestion: Use meaningful but limited labels (e.g., app, environment, log level) to reduce label cardinality and enhance performance.
 
 ## Setup and Maintenance
diff --git a/data/comparisons/graylog-vs-splunk.mdx b/data/comparisons/graylog-vs-splunk.mdx
index 39aee0cca..424112c1c 100644
--- a/data/comparisons/graylog-vs-splunk.mdx
+++ b/data/comparisons/graylog-vs-splunk.mdx
@@ -1,13 +1,21 @@
 ---
-
 title: Graylog vs. Splunk - The Ultimate Log Management Showdown
-slug: graylog-vs-splunk
+
 date: 2025-03-13
-tags: [log management, graylog, splunk, signoz, observability, cloud-native]    
+tags: [log management, graylog, splunk, signoz, observability, cloud-native]
 authors: [abdulsalaam_noibi]
 description: Explore the key differences between Graylog and Splunk, two powerful log management tools, to determine the best fit for your organization.
-keywords: [graylog vs splunk, log management tools, open source logging, enterprise logging, graylog features, splunk features, signoz, cloud-native observability]
-
+keywords:
+  [
+    graylog vs splunk,
+    log management tools,
+    open source logging,
+    enterprise logging,
+    graylog features,
+    splunk features,
+    signoz,
+    cloud-native observability,
+  ]
 ---
 
 Log management is critical for monitoring modern applications, especially in cloud-native environments where microservices and containers produce high volumes of logs. As your infrastructure scales, choosing the right log management solution becomes essential for maintaining security, performance, and reliability.
@@ -15,24 +23,26 @@ Log management is critical for monitoring modern applications, especially in clo
 In this comprehensive comparison, we'll examine Graylog, Splunk, and SigNoz—three powerful log management and analysis tools—with a focus on their suitability for cloud-native applications.
 
 <KeyPointCallout title="Quick Answer">
-If you're short on time: Choose Graylog for cost-effective log management with technical expertise, Splunk for enterprise-grade features with budget flexibility, or SigNoz for unified observability (logs, metrics, and traces) in cloud-native environments.
+  If you're short on time: Choose Graylog for cost-effective log management with technical
+  expertise, Splunk for enterprise-grade features with budget flexibility, or SigNoz for unified
+  observability (logs, metrics, and traces) in cloud-native environments.
 </KeyPointCallout>
 
 ## Comparison at a Glance
 
 Here's a quick comparison table to help you understand the key differences between these tools:
 
-| Feature | Graylog | Splunk | SigNoz |
-|---------|---------|--------|--------|
-| **Core Focus** | Log management and analysis | Comprehensive machine data analytics | Full-stack observability (logs, metrics, traces) |
-| **Pricing Model** | Open-source core with paid enterprise features | Commercial with volume-based pricing | Open-source with optional cloud service |
-| **Cost (100GB/day)** | ~$20K/year (Enterprise) | $150K+/year | Free (self-hosted) or ~$9K/year (Cloud) |
-| **Technology** | Elasticsearch/OpenSearch + MongoDB | Proprietary indexing and search | ClickHouse (columnar database) |
-| **Query Language** | Lucene-based | SPL (Search Processing Language) | SQL/PromQL + UI query builder |
-| **Cloud-Native Fit** | Moderate | Legacy-to-cloud transition | Excellent (built for Kubernetes) |
-| **Deployment** | On-prem, cloud, self-managed | On-prem, cloud, hybrid | Kubernetes-native, Docker, Cloud |
-| **Scalability** | Good (with proper tuning) | Excellent (with sufficient resources) | Very good (efficient resource usage) |
-| **Learning Curve** | Moderate | Steep | Gentle |
+| Feature              | Graylog                                        | Splunk                                | SigNoz                                           |
+| -------------------- | ---------------------------------------------- | ------------------------------------- | ------------------------------------------------ |
+| **Core Focus**       | Log management and analysis                    | Comprehensive machine data analytics  | Full-stack observability (logs, metrics, traces) |
+| **Pricing Model**    | Open-source core with paid enterprise features | Commercial with volume-based pricing  | Open-source with optional cloud service          |
+| **Cost (100GB/day)** | ~$20K/year (Enterprise)                        | $150K+/year                           | Free (self-hosted) or ~$9K/year (Cloud)          |
+| **Technology**       | Elasticsearch/OpenSearch + MongoDB             | Proprietary indexing and search       | ClickHouse (columnar database)                   |
+| **Query Language**   | Lucene-based                                   | SPL (Search Processing Language)      | SQL/PromQL + UI query builder                    |
+| **Cloud-Native Fit** | Moderate                                       | Legacy-to-cloud transition            | Excellent (built for Kubernetes)                 |
+| **Deployment**       | On-prem, cloud, self-managed                   | On-prem, cloud, hybrid                | Kubernetes-native, Docker, Cloud                 |
+| **Scalability**      | Good (with proper tuning)                      | Excellent (with sufficient resources) | Very good (efficient resource usage)             |
+| **Learning Curve**   | Moderate                                       | Steep                                 | Gentle                                           |
 
 ## Core Features and Capabilities
 
@@ -40,7 +50,6 @@ Here's a quick comparison table to help you understand the key differences betwe
 
 Graylog is an open-source platform centered on [log collection and analysis](https://signoz.io/comparisons/log-analysis-tools/#graylog). It excels at gathering logs from diverse sources and making them searchable.
 
-
 <Figure
   src="/img/comparisons/2025/01/graylog-vs-loki-image.webp"
   alt="Graylog Dashboard"
@@ -62,7 +71,11 @@ The alerting system runs searches on a schedule and triggers notifications when
 
 Splunk is a commercial platform with capabilities extending beyond log management. It can ingest virtually any machine-generated data and provides powerful analytics tools.
 
-<Figure src="/img/comparisons/2025/03/appdynamics-vs-splunk-image.webp" alt="Splunk Dashboard" caption="Splunk Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/appdynamics-vs-splunk-image.webp"
+  alt="Splunk Dashboard"
+  caption="Splunk Dashboard"
+/>
 
 **Key Strengths:**
 
@@ -98,7 +111,9 @@ SigNoz provides a simple [query builder](https://signoz.io/blog/query-builder-v5
 While newer than Graylog or Splunk, SigNoz offers essential log management features (search, filters, alerts) and excels at correlating logs with traces and metrics. This makes it particularly valuable for debugging microservice architectures.
 
 <KeyPointCallout title="Technical Insight">
-SigNoz's ClickHouse backend has shown impressive performance in benchmarks—ingesting logs 2.5× faster than ELK stacks while using 50% fewer resources. This efficiency is crucial for cloud environments where resource optimization impacts costs.
+  SigNoz's ClickHouse backend has shown impressive performance in benchmarks—ingesting logs 2.5×
+  faster than ELK stacks while using 50% fewer resources. This efficiency is crucial for cloud
+  environments where resource optimization impacts costs.
 </KeyPointCallout>
 
 ## Deployment Options
@@ -184,7 +199,9 @@ For comparison, 100 GB of logs in SigNoz would cost about \$30, whereas in Splun
 This predictable cost model helps avoid the sudden budget spikes that can occur with Splunk's model when data volumes grow unexpectedly.
 
 <KeyPointCallout title="Cost Comparison">
-Processing 1 TB of logs daily could cost over \$1.5M annually with Splunk, around \$150K with Graylog Enterprise, and approximately \$90K with SigNoz Cloud (or just infrastructure costs if self-hosted).
+  Processing 1 TB of logs daily could cost over \$1.5M annually with Splunk, around \$150K with
+  Graylog Enterprise, and approximately \$90K with SigNoz Cloud (or just infrastructure costs if
+  self-hosted).
 </KeyPointCallout>
 
 ## Performance and Scalability
@@ -268,7 +285,9 @@ The UI emphasizes reducing clicks to reach relevant data. For example, you might
 New users find SigNoz easier to learn because it doesn't require a proprietary query language for basic use. The interface continues to evolve rapidly with community contributions focusing on usability improvements.
 
 <KeyPointCallout title="UX Comparison">
-Graylog offers a straightforward, no-frills experience for log analysis. Splunk provides powerful but complex tools requiring training. SigNoz delivers a modern, integrated approach that connects logs with metrics and traces for faster troubleshooting.
+  Graylog offers a straightforward, no-frills experience for log analysis. Splunk provides powerful
+  but complex tools requiring training. SigNoz delivers a modern, integrated approach that connects
+  logs with metrics and traces for faster troubleshooting.
 </KeyPointCallout>
 
 ## SigNoz vs. Graylog and Splunk for Cloud-Native Applications
@@ -280,12 +299,14 @@ In cloud-native contexts, SigNoz positions itself as a more comprehensive and mo
 The primary difference is scope—SigNoz is a full observability platform (logs, metrics, and traces) whereas Graylog focuses on log management:
 
 **Advantages of SigNoz:**
+
 - Unified telemetry eliminates the need for separate tools (Prometheus, Jaeger, etc.)
 - Built for Kubernetes with minimal setup (Helm charts)
 - More resource-efficient storage with ClickHouse
 - Native OpenTelemetry support for standardized instrumentation
 
 **Where Graylog Shines:**
+
 - Mature plugin ecosystem for custom inputs, outputs, and processing
 - More specialized [log parsing](https://signoz.io/guides/log-parsing/) and transformation capabilities
 - Better security/SIEM features in Enterprise version
@@ -298,12 +319,14 @@ For teams primarily focused on logs with separate systems for metrics/tracing, G
 SigNoz challenges Splunk on several fronts important to cloud-native users:
 
 **Advantages of SigNoz:**
+
 - Dramatically lower cost (open-source or usage-based pricing)
 - Built on open standards (OpenTelemetry) to avoid vendor lock-in
 - Unified UI for metrics, traces, and logs without multiple products
 - Lightweight deployment on Kubernetes
 
 **Where Splunk Excels:**
+
 - Battle-tested at extreme scale (multi-terabyte deployments)
 - Extensive feature set developed over 15+ years
 - Rich ecosystem of pre-built content and integrations
@@ -362,6 +385,7 @@ Yes, SigNoz is [production-ready](https://signoz.io/guides/production-readiness-
 ### How do these tools handle container logs in Kubernetes?
 
 All three can collect Kubernetes logs, but with different approaches:
+
 - **Graylog**: Typically uses Filebeat or Fluentd to collect container logs
 - **Splunk**: Offers a Kubernetes monitoring solution with dedicated forwarders
 - **SigNoz**: Native integration with [OpenTelemetry collectors](https://signoz.io/blog/opentelemetry-collector-complete-guide/) for Kubernetes
@@ -370,4 +394,4 @@ SigNoz has the most cloud-native approach, with Helm charts for deployment and b
 
 ### What's the learning curve for each platform?
 
-Graylog has a moderate learning curve with its straightforward interface and Lucene-based queries. Splunk has the steepest learning curve due to its SPL language and feature complexity. SigNoz offers the gentlest learning curve for teams familiar with modern observability tools, with an intuitive UI and standard query languages.
\ No newline at end of file
+Graylog has a moderate learning curve with its straightforward interface and Lucene-based queries. Splunk has the steepest learning curve due to its SPL language and feature complexity. SigNoz offers the gentlest learning curve for teams familiar with modern observability tools, with an intuitive UI and standard query languages.
diff --git a/data/comparisons/heroku-alternatives.mdx b/data/comparisons/heroku-alternatives.mdx
index 48d4c15fc..4417b10a5 100644
--- a/data/comparisons/heroku-alternatives.mdx
+++ b/data/comparisons/heroku-alternatives.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: 10 Best Heroku Alternatives for 2025 - Free and Paid Options
-slug: heroku-alternatives
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [simran_kumari]
 description: Discover the top 10 Heroku alternatives for 2024, including free and paid options. Find the perfect platform for your development needs in this comprehensive guide.
 keywords: [Heroku alternatives, cloud hosting, PaaS, free tier, developer platforms]
-
 ---
 
 The cloud hosting landscape has shifted dramatically, leaving developers searching for viable Heroku alternatives. Finding the right platform to host your applications can be challenging, especially with discontinuation of Heroku's free tier. This article explores the best alternatives to Heroku in 2024, highlighting their features, pricing, and ideal use cases to help you make an informed decision.
@@ -19,15 +17,15 @@ Heroku's decision to discontinue its free tier has sent shockwaves through the d
 ## Quick Guide: Top 3 Heroku Alternatives at a Glance
 
 1. Render: Best for Simplicity and Ease of Use
-    
-    Render stands out for its user-friendly interface and straightforward deployment process, making it an excellent choice for developers who prioritize simplicity.
-    
+
+   Render stands out for its user-friendly interface and straightforward deployment process, making it an excellent choice for developers who prioritize simplicity.
+
 2. Fly.io: Ideal for Global Edge Deployment
-    
-    Fly.io offers a unique advantage with its global edge deployment capabilities, allowing applications to run closer to users for reduced latency and improved performance.
-    
+
+   Fly.io offers a unique advantage with its global edge deployment capabilities, allowing applications to run closer to users for reduced latency and improved performance.
+
 3. Railway: Perfect for Rapid Development and Deployment
-Railway provides a seamless and rapid development workflow, making it ideal for teams that need to deploy quickly and iterate frequently.
+   Railway provides a seamless and rapid development workflow, making it ideal for teams that need to deploy quickly and iterate frequently.
 
 ## Criteria for Evaluating Heroku Alternatives
 
@@ -45,7 +43,11 @@ Render stands out as a user-friendly alternative to Heroku, offering a streamlin
 
 Render offers similar ease of use to Heroku, with automated deployment from Git repositories, intuitive dashboards, and seamless scaling. It provides you with various service types to choose from.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled.webp" alt="Render(Heroku’s alternative) dashboard" caption="Render(Heroku’s alternative) dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled.webp"
+  alt="Render(Heroku’s alternative) dashboard"
+  caption="Render(Heroku’s alternative) dashboard"
+/>
 
 Key Features:
 
@@ -55,9 +57,13 @@ Key Features:
 - Native support for static sites and databases
 
 Pricing:
-Render offers a free tier with limited resources. Paid plans start at $19/month, scaling based on resource usage. 
+Render offers a free tier with limited resources. Paid plans start at $19/month, scaling based on resource usage.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%201.webp" alt="Render Pricing structure: Free for hosting static websites and web services." caption="Render Pricing structure: Free for hosting static websites and web services." />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%201.webp"
+  alt="Render Pricing structure: Free for hosting static websites and web services."
+  caption="Render Pricing structure: Free for hosting static websites and web services."
+/>
 
 The pricing structure varies based on need. You can compare the pricing-based plans <a href="https://render.com/pricing#plans" rel="noopener noreferrer nofollow" target="_blank">here</a>.
 
@@ -66,11 +72,15 @@ Render excels for small to medium-sized applications, static websites, and proje
 
 ## 2. Fly.io: Global Edge Deployment Made Easy
 
-[Fly.io](http://fly.io/) takes a unique approach to deployment by running applications close to users, leveraging a global network of servers. This edge deployment strategy results in lower latency and improved performance for users worldwide. 
+[Fly.io](http://fly.io/) takes a unique approach to deployment by running applications close to users, leveraging a global network of servers. This edge deployment strategy results in lower latency and improved performance for users worldwide.
 
-It supports various popular frameworks and languages like `Django`, `Node.js` , `Python`, etc. 
+It supports various popular frameworks and languages like `Django`, `Node.js` , `Python`, etc.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%202.webp" alt="Fly.io for hosting Python, Nodejs applications for free." caption="Fly.io for hosting Python, Nodejs applications for free." /> 
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%202.webp"
+  alt="Fly.io for hosting Python, Nodejs applications for free."
+  caption="Fly.io for hosting Python, Nodejs applications for free."
+/>
 
 [Fly.io](http://Fly.io) for hosting Python, Nodejs applications for free.
 
@@ -100,7 +110,11 @@ Key Features:
 Pricing:
 When you sign up for the free Trial, you will receive a one-time grant of $5 in credits. Paid plans start at $5/month, with usage-based pricing for larger projects. They offer different pricing plans. During the trial, you can access the same features as on the Hobby plan, however, you will be limited to 500MB of RAM and shared (rather than dedicated) vCPU cores.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%203.webp" alt="Pricing plans for Railway - Heroku alternative" caption="Pricing plans for Railway - Heroku alternative" />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%203.webp"
+  alt="Pricing plans for Railway - Heroku alternative"
+  caption="Pricing plans for Railway - Heroku alternative"
+/>
 
 Ideal Projects:
 Railway is perfect for startups, small teams, and individual developers working on projects that require rapid iteration and deployment.
@@ -134,9 +148,13 @@ Key Features:
 - Built-in authentication and file storage
 
 Pricing:
-Back4app provides a free tier with limited resources. Free usage includes 250 MB of data storage and 1 GB of data transfer and 1GB of file storage. Paid plans start at $25/month, scaling based on usage and required features. 
+Back4app provides a free tier with limited resources. Free usage includes 250 MB of data storage and 1 GB of data transfer and 1GB of file storage. Paid plans start at $25/month, scaling based on usage and required features.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%204.webp" alt="Pricing plan for Back4app : alternative to Heroku for hosting full stack applications" caption="Pricing plan for Back4app : alternative to Heroku for hosting full stack applications" />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%204.webp"
+  alt="Pricing plan for Back4app : alternative to Heroku for hosting full stack applications"
+  caption="Pricing plan for Back4app : alternative to Heroku for hosting full stack applications"
+/>
 
 Ideal Scenarios:
 Choose Back4app for mobile app backends, real-time applications, and projects requiring a comprehensive set of backend services.
@@ -147,7 +165,11 @@ DigitalOcean's App Platform brings the simplicity of PaaS to its robust cloud in
 
 On signing in they give you 200$ credits to try out all the products they offer. The App platform is one of the products of DigitalOcean.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%205.webp" alt="DigitialOcean App Platform as an alternative to Heroku" caption="DigitialOcean App Platform as an alternative to Heroku" />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%205.webp"
+  alt="DigitialOcean App Platform as an alternative to Heroku"
+  caption="DigitialOcean App Platform as an alternative to Heroku"
+/>
 
 Key Features:
 
@@ -166,7 +188,11 @@ DigitalOcean App Platform is ideal for teams familiar with DigitalOcean's ecosys
 
 Platform.sh caters to larger organizations and complex applications with its robust, enterprise-focused PaaS offering. It provides advanced features for managing multi-app projects and complex infrastructures. They support a lot of frameworks, some popular ones include WordPress, Python, Node. js, PHP, Spring Boot etc.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%206.webp" alt="Platform.sh" caption="Platform.sh" /> 
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%206.webp"
+  alt="Platform.sh"
+  caption="Platform.sh"
+/>
 
 Key Features:
 
@@ -184,7 +210,11 @@ Choose Platform.sh for large-scale applications, enterprise projects, and multi-
 
 Google App Engine leverages Google's vast infrastructure to provide a highly scalable platform for application deployment. It offers seamless integration with other Google Cloud services, making it a powerful choice for complex, data-driven applications. It is part of Google's cloud computing services.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%207.webp" alt="Google App Engine Console for hosting applications for free." caption="Google App Engine Console for hosting applications for free." />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%207.webp"
+  alt="Google App Engine Console for hosting applications for free."
+  caption="Google App Engine Console for hosting applications for free."
+/>
 
 Key Features:
 
@@ -205,7 +235,11 @@ Netlify specializes in hosting static sites and serverless functions, offering a
 
 You can connect your cloud repository with Netlify and it can trigger redeployment when some changes are pushed to the repository.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%208.webp" alt="Netlify for hosting website and setting up CI/CD pipeline for deployment based on changes on cloud repositories" caption="Netlify for hosting website and setting up CI/CD pipeline for deployment based on changes on cloud repositories" /> 
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%208.webp"
+  alt="Netlify for hosting website and setting up CI/CD pipeline for deployment based on changes on cloud repositories"
+  caption="Netlify for hosting website and setting up CI/CD pipeline for deployment based on changes on cloud repositories"
+/>
 
 Key Features:
 
@@ -224,7 +258,11 @@ Choose Netlify for static websites, single-page applications, and projects lever
 
 Vercel provides a specialized platform for deploying Next.js and React applications, offering optimized performance and developer experience for these frameworks. It also contain templates for deploying application based on popular frameworks.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%209.webp" alt="Vercel templates for deploying and hosting web applications." caption="Vercel templates for deploying and hosting web applications." />
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%209.webp"
+  alt="Vercel templates for deploying and hosting web applications."
+  caption="Vercel templates for deploying and hosting web applications."
+/>
 
 Key Features:
 
@@ -249,9 +287,13 @@ When selecting a Heroku alternative, evaluate these crucial aspects:
 - Developer Experience: Assess the learning curve and available documentation.
 - Community Support: Look for active communities and third-party integrations.
 
-<Figure src="/img/comparisons/2024/08/heroku-alternatives-Untitled%2010.webp" alt="Key factors to consider while choosing Heroku alternative." caption="Key factors to consider while choosing Heroku alternative." /> 
+<Figure
+  src="/img/comparisons/2024/08/heroku-alternatives-Untitled%2010.webp"
+  alt="Key factors to consider while choosing Heroku alternative."
+  caption="Key factors to consider while choosing Heroku alternative."
+/>
 
-You may have noticed that most hosting platforms charge based on a pay-as-you-go model. To avoid incurring unexpected costs, it is essential to monitor the traffic coming to your applications. By keeping an eye on your application's usage, you can ensure that your costs remain within budget. 
+You may have noticed that most hosting platforms charge based on a pay-as-you-go model. To avoid incurring unexpected costs, it is essential to monitor the traffic coming to your applications. By keeping an eye on your application's usage, you can ensure that your costs remain within budget.
 
 ## Monitoring Your Application Across Platforms
 
@@ -280,7 +322,7 @@ With proper monitoring in place, you can confidently migrate from Heroku and mak
 
 ## Key Takeaways
 
-Although Heroku has discontinued its free tier, there are various alternatives that we can use to host our application. Some key takeaways from this article are:  
+Although Heroku has discontinued its free tier, there are various alternatives that we can use to host our application. Some key takeaways from this article are:
 
 - Heroku alternatives offer diverse options for various project needs.
 - Free tiers are still available but with different resource allocations.
diff --git a/data/comparisons/honeycomb-vs-datadog.mdx b/data/comparisons/honeycomb-vs-datadog.mdx
index f69c2b906..f2943af34 100644
--- a/data/comparisons/honeycomb-vs-datadog.mdx
+++ b/data/comparisons/honeycomb-vs-datadog.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Honeycomb vs Datadog - Choosing the Right Observability Tool
-slug: honeycomb-vs-datadog
-date: 2025-02-11 
+
+date: 2025-02-11
 tags: [observability, honeycomb, datadog]
 authors: [simran_kumari]
 description: Compare Honeycomb and Datadog for observability. Learn key features, use cases, and how to choose the best tool for your organization's needs.
-keywords: [honeycomb vs datadog, observability tools, monitoring platforms, DevOps tools, application performance monitoring, microservices monitoring]
-
+keywords:
+  [
+    honeycomb vs datadog,
+    observability tools,
+    monitoring platforms,
+    DevOps tools,
+    application performance monitoring,
+    microservices monitoring,
+  ]
 ---
 
 As software stacks grows with microservices, distributed databases, and multi-cloud setups, keeping track of what's happening gets harder. That’s where observability tools come in. Honeycomb and Datadog are two popular choices, each with its own strengths. This article compares Honeycomb and Datadog, exploring their features, philosophies, and best use cases to help you make an informed decision.
@@ -23,14 +29,16 @@ Honeycomb excels at event-driven instrumentation. Instead of just monitoring sta
 **Key Features**
 
 1. High-Dimensionality Analysis
-    - Honeycomb can analyze data with numerous unique attributes (e.g., user IDs, transaction IDs, and API endpoints). This makes it particularly useful for debugging problems that involve multiple variables.
+   - Honeycomb can analyze data with numerous unique attributes (e.g., user IDs, transaction IDs, and API endpoints). This makes it particularly useful for debugging problems that involve multiple variables.
 2. Real-Time Querying
-    - Honeycomb allows sub-second query responses, enabling interactive debugging. Engineers can explore data in real-time, trying different filters and aggregations without delays.
-        
-        <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image.webp" alt="Real-Time Querying in Honeycomb" caption="Real-Time Querying in Honeycomb" />
-        
+   - Honeycomb allows sub-second query responses, enabling interactive debugging. Engineers can explore data in real-time, trying different filters and aggregations without delays.
+     <Figure
+       src="/img/comparisons/2025/02/honeycomb-vs-datadog-image.webp"
+       alt="Real-Time Querying in Honeycomb"
+       caption="Real-Time Querying in Honeycomb"
+     />
 3. Event-Based Data Model
-    - Unlike traditional monitoring tools that focus on pre-aggregated metrics (e.g., average CPU usage), Honeycomb uses wide, structured events. Each event captures all relevant details in a single record, enabling richer analysis.
+   - Unlike traditional monitoring tools that focus on pre-aggregated metrics (e.g., average CPU usage), Honeycomb uses wide, structured events. Each event captures all relevant details in a single record, enabling richer analysis.
 
 ### Datadog
 
@@ -41,14 +49,16 @@ Datadog emphasizes integration and unification, offering a wide range of tools i
 **Key Features**
 
 1. Unified Platform
-    - Datadog brings together metrics, logs, traces, and user activity in one interface. This makes it easier for teams to correlate issues across different parts of their stack.
-        
-        <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%201.webp" alt="Unified Platform : Datadog" caption="Unified Platform : Datadog" />
-        
+   - Datadog brings together metrics, logs, traces, and user activity in one interface. This makes it easier for teams to correlate issues across different parts of their stack.
+     <Figure
+       src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%201.webp"
+       alt="Unified Platform : Datadog"
+       caption="Unified Platform : Datadog"
+     />
 2. Extensive Integrations
-    - Datadog supports hundreds of integrations with cloud providers (e.g., AWS, Azure, GCP), container platforms (e.g., Kubernetes, Docker), and third-party applications (e.g., Redis, MySQL, Elasticsearch).
+   - Datadog supports hundreds of integrations with cloud providers (e.g., AWS, Azure, GCP), container platforms (e.g., Kubernetes, Docker), and third-party applications (e.g., Redis, MySQL, Elasticsearch).
 3. Metrics-First Approach
-    - Datadog collects and processes time-series metrics at scale, making it ideal for monitoring system performance and setting up robust dashboards and alerts.
+   - Datadog collects and processes time-series metrics at scale, making it ideal for monitoring system performance and setting up robust dashboards and alerts.
 
 ## How Do Honeycomb and Datadog Differ in Their Approach?
 
@@ -56,7 +66,7 @@ Honeycomb and Datadog tackle observability from distinct angles. Honeycomb is de
 
 ### Honeycomb’s High-Cardinality, Event-Driven Analysis
 
-Honeycomb excels in monitoring large-scale systems by focusing on individual events rather than aggregated metrics, offering deep insights into system behavior. It is built to handle high-cardinality data—such as unique user IDs, session identifiers, request IDs, or build SHAs—that traditional metrics systems struggle with. 
+Honeycomb excels in monitoring large-scale systems by focusing on individual events rather than aggregated metrics, offering deep insights into system behavior. It is built to handle high-cardinality data—such as unique user IDs, session identifiers, request IDs, or build SHAs—that traditional metrics systems struggle with.
 
 Honeycomb’s ability to store and query this detailed data in real-time helps teams quickly identify and resolve performance bottlenecks, errors, or anomalies in complex environments, ensuring a more precise understanding of application behavior at scale.
 
@@ -78,11 +88,19 @@ Datadog’s strength lies in its broad coverage, acting as a single pane of glas
 
 Here’s where Honeycomb gets technical. Instead of pre-aggregating metrics, Honeycomb ingests wide, structured events. Each event is like a detailed snapshot, capturing all the attributes you might need later (e.g., `user_id`, `endpoint`, `status_code`). This data is stored in a columnar-like format, making it fast to filter and query. You get the freedom to ask ad-hoc questions without worrying about predefining metrics.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%202.webp" alt="Data Ingestion and Storage in Honeycomb" caption="Data Ingestion and Storage in Honeycomb" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%202.webp"
+  alt="Data Ingestion and Storage in Honeycomb"
+  caption="Data Ingestion and Storage in Honeycomb"
+/>
 
 Datadog’s design starts with time-series metrics. It’s great for tracking trends over time, like CPU usage or request latency. While it also supports logs and traces, its primary design pattern leans on aggregated metrics. To handle large-scale data, Datadog often uses sampling strategies—like keeping only a subset of traces to save storage and improve performance.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%203.webp" alt="Metric collection in Datadog" caption="Metric collection in Datadog" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%203.webp"
+  alt="Metric collection in Datadog"
+  caption="Metric collection in Datadog"
+/>
 
 ### Query Languages & Exploration
 
@@ -104,16 +122,16 @@ Datadog is all about providing a big-picture view. If you’re running a cloud-s
 
 Let's compare some essential features of both platforms:
 
-| Feature | Honeycomb | Datadog |
-| --- | --- | --- |
-| Core Focus | Event-driven debugging and high-cardinality data analysis | Broad observability with metrics-first, APM-centric approach |
-| Trace Analysis | Detailed, event-centric traces with filtering on unique tags like `user_id` or `X-Request-Id` | Distributed tracing integrated with metrics dashboards; search and analytics for traces |
-| Dashboards | Interactive, ad-hoc queries for live debugging | Rich, customizable dashboards with real-time visualizations and anomaly detection overlays |
-| Alerting | SLO-based alerts focused on user experience | Robust alerting engine with static thresholds, anomaly detection, and multi-channel support |
-| Anomaly Detection | Relies on user-driven analysis for transparency | AI/ML-powered anomaly detection, forecasting, and outlier alerts |
-| Data Ingestion | Wide, structured events stored for fast, high-dimensional querying | Primarily time-series data with sampling for metrics, logs, and traces |
-| Ideal Use Case | Debugging complex microservices with high-cardinality dimensions | Monitoring large, diverse infrastructures with comprehensive metrics and logs integration |
-| Strength | Iterative exploration for root cause analysis | Unified monitoring with dashboards, integrations, and AI-driven insights |
+| Feature           | Honeycomb                                                                                     | Datadog                                                                                     |
+| ----------------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Core Focus        | Event-driven debugging and high-cardinality data analysis                                     | Broad observability with metrics-first, APM-centric approach                                |
+| Trace Analysis    | Detailed, event-centric traces with filtering on unique tags like `user_id` or `X-Request-Id` | Distributed tracing integrated with metrics dashboards; search and analytics for traces     |
+| Dashboards        | Interactive, ad-hoc queries for live debugging                                                | Rich, customizable dashboards with real-time visualizations and anomaly detection overlays  |
+| Alerting          | SLO-based alerts focused on user experience                                                   | Robust alerting engine with static thresholds, anomaly detection, and multi-channel support |
+| Anomaly Detection | Relies on user-driven analysis for transparency                                               | AI/ML-powered anomaly detection, forecasting, and outlier alerts                            |
+| Data Ingestion    | Wide, structured events stored for fast, high-dimensional querying                            | Primarily time-series data with sampling for metrics, logs, and traces                      |
+| Ideal Use Case    | Debugging complex microservices with high-cardinality dimensions                              | Monitoring large, diverse infrastructures with comprehensive metrics and logs integration   |
+| Strength          | Iterative exploration for root cause analysis                                                 | Unified monitoring with dashboards, integrations, and AI-driven insights                    |
 
 ## 1. Trace Analysis
 
@@ -121,13 +139,21 @@ Let's compare some essential features of both platforms:
 
 Honeycomb offers event-centric tracing, allowing you to focus on individual traces filtered by high-cardinality dimensions like `X-Request-Id`, `user_id`, or custom tags like `build_version`. Honeycomb’s traces aren’t just about spans; they’re detailed, context-rich events. You can see everything about a request, from start to finish, and drill into whatever dimension you want without predefined groupings.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%204.webp" alt="Trace Analysis in Honeycomb" caption="Trace Analysis in Honeycomb" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%204.webp"
+  alt="Trace Analysis in Honeycomb"
+  caption="Trace Analysis in Honeycomb"
+/>
 
 ### Datadog
 
 Datadog integrates distributed tracing directly with its metrics dashboards. This means you can correlate traces with host-level metrics, like CPU usage or memory consumption. It’s a great way to get a high-level overview, but deep debugging often requires custom instrumentation.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%205.webp" alt="Datadog integrates distributed tracing" caption="Datadog integrates distributed tracing" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%205.webp"
+  alt="Datadog integrates distributed tracing"
+  caption="Datadog integrates distributed tracing"
+/>
 
 ## 2. Dashboards & Visualizations
 
@@ -135,13 +161,21 @@ Datadog integrates distributed tracing directly with its metrics dashboards. Thi
 
 Honeycomb focuses on interactive debugging through ad-hoc queries, allowing you to explore your data in real-time rather than relying on static dashboards. This is ideal for fast-paced production environments where quick investigation is essential.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%206.webp" alt="Interactive debugging in Honeycomb" caption="Interactive debugging in Honeycomb" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%206.webp"
+  alt="Interactive debugging in Honeycomb"
+  caption="Interactive debugging in Honeycomb"
+/>
 
 ### Datadog
 
 Datadog enables users to create highly customizable dashboards, including real-time graphs, anomaly detection overlays, and heatmaps. It simplifies the process of building and sharing rich visualizations, and seamlessly integrates logs, metrics, and traces in a single view. This unified approach provides a comprehensive and holistic perspective of your system’s performance.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-videoframe_3907.webp" alt="Customizable dashboards in Datadog" caption="Customizable dashboards in Datadog" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-videoframe_3907.webp"
+  alt="Customizable dashboards in Datadog"
+  caption="Customizable dashboards in Datadog"
+/>
 
 ## 3. Alerting & Notifications
 
@@ -149,13 +183,21 @@ Datadog enables users to create highly customizable dashboards, including real-t
 
 Honeycomb uses SLO-based alerts, which are tied to specific service-level objectives. This reduces [alert fatigue](https://signoz.io/blog/alert-fatigue/) by focusing on alerts that directly affect user experience.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%207.webp" alt="Honeycomb focuses on SLO-based alerts" caption="Honeycomb focuses on SLO-based alerts" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%207.webp"
+  alt="Honeycomb focuses on SLO-based alerts"
+  caption="Honeycomb focuses on SLO-based alerts"
+/>
 
 ### Datadog
 
 Datadog’s alerting engine is robust and highly customizable. You can set static thresholds, enable anomaly detection, or use multi-channel notifications to alert your team via Slack, PagerDuty, email, and more. This flexibility is useful for large teams with complex alerting requirements.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%208.webp" alt="Customizing alerts in Datadog" caption="Customizing alerts in Datadog" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%208.webp"
+  alt="Customizing alerts in Datadog"
+  caption="Customizing alerts in Datadog"
+/>
 
 ## 4. Machine Learning & Anomaly Detection
 
@@ -174,50 +216,32 @@ When evaluating observability tools, scalability and performance are critical fa
 ### 1. Data Ingestion Rates & Query Performance
 
 - Honeycomb:
-    
-    Built to handle high volumes of high-cardinality data, Honeycomb excels in ingesting wide, structured events. Its query engine delivers interactive, near-instant results, even for complex data.
-    
+  Built to handle high volumes of high-cardinality data, Honeycomb excels in ingesting wide, structured events. Its query engine delivers interactive, near-instant results, even for complex data.
 - Datadog:
-    
-    Datadog efficiently handles vast amounts of metrics via its time-series database. However, log and trace ingestion may be rate-limited depending on your pricing plan. The query performance remains strong for metrics but may slow down with massive log volumes or complex queries.
-    
+  Datadog efficiently handles vast amounts of metrics via its time-series database. However, log and trace ingestion may be rate-limited depending on your pricing plan. The query performance remains strong for metrics but may slow down with massive log volumes or complex queries.
 
 ### 2. Sampling Strategies & Data Retention
 
 - Honeycomb:
-    
-    Honeycomb does not rely on sampling for critical events, meaning it captures every event in full, providing complete visibility for debugging complex issues. However, this approach can lead to higher costs as pricing is based on event volume, especially when dealing with high-cardinality data.
-    
-    Honeycomb offers a 60-day fixed retention for all datasets, calculated from the date the events are ingested, not based on event timestamps. If your team changes plans, the data retention is maintained up to this 60-day period.
-    
+  Honeycomb does not rely on sampling for critical events, meaning it captures every event in full, providing complete visibility for debugging complex issues. However, this approach can lead to higher costs as pricing is based on event volume, especially when dealing with high-cardinality data.
+  Honeycomb offers a 60-day fixed retention for all datasets, calculated from the date the events are ingested, not based on event timestamps. If your team changes plans, the data retention is maintained up to this 60-day period.
 - Datadog:
-    
-    Datadog uses partial sampling for [distributed traces](https://signoz.io/blog/distributed-tracing/) in large systems, capturing a subset of events to manage data volume and reduce costs. While this approach works well for monitoring trends, it can hinder deep debugging since some events may be missed, especially in high-traffic environments.
-    
-    Metric retention in Datadog depends on the pricing plan, with shorter retention periods for basic plans (e.g., 15 days) and longer periods for enterprise tiers, which may limit historical data analysis in lower-tier plans.
-    
+  Datadog uses partial sampling for [distributed traces](https://signoz.io/blog/distributed-tracing/) in large systems, capturing a subset of events to manage data volume and reduce costs. While this approach works well for monitoring trends, it can hinder deep debugging since some events may be missed, especially in high-traffic environments.
+  Metric retention in Datadog depends on the pricing plan, with shorter retention periods for basic plans (e.g., 15 days) and longer periods for enterprise tiers, which may limit historical data analysis in lower-tier plans.
 
 ### 3. Multi-Region & Multi-Cloud Support
 
 - Honeycomb:
-    
-    Honeycomb operates as a SaaS platform with global ingestion endpoints, which makes it suitable for multi-cloud environments. Its lightweight architecture ensures it can scale without adding significant complexity.
-    
+  Honeycomb operates as a SaaS platform with global ingestion endpoints, which makes it suitable for multi-cloud environments. Its lightweight architecture ensures it can scale without adding significant complexity.
 - Datadog:
-    
-    Datadog shines here with its robust multi-region support and presence in data centers worldwide. It’s well-suited for hybrid cloud environments where infrastructure is spread across on-premises and multiple cloud providers.
-    
+  Datadog shines here with its robust multi-region support and presence in data centers worldwide. It’s well-suited for hybrid cloud environments where infrastructure is spread across on-premises and multiple cloud providers.
 
 ### 4. Cost-Effectiveness at Scale
 
 - Honeycomb:
-    
-    Pricing is based on event volume, which can escalate with high-cardinality data. However, the ability to quickly debug complex issues can reduce engineering time and downtime costs, offsetting the higher spend.
-    
+  Pricing is based on event volume, which can escalate with high-cardinality data. However, the ability to quickly debug complex issues can reduce engineering time and downtime costs, offsetting the higher spend.
 - Datadog:
-    
-    Datadog’s host-based pricing, combined with charges for logs, custom metrics, and advanced features, can become expensive in large environments. Volume discounts are available, but teams must carefully monitor usage to stay within budget.
-    
+  Datadog’s host-based pricing, combined with charges for logs, custom metrics, and advanced features, can become expensive in large environments. Volume discounts are available, but teams must carefully monitor usage to stay within budget.
 
 ## Integration Capabilities: Honeycomb vs Datadog
 
@@ -232,20 +256,18 @@ Both platforms offer extensive integration options, but their approaches differ:
 
 - Honeycomb: Honeycomb’s strength lies in its integration with OpenTelemetry pipelines, which allow ingestion of data from many third-party systems. It also offers integrations for developer workflows like GitHub Actions and collaboration tools like Slack. Its third-party integration ecosystem is smaller compared to Datadog.
 - Datadog: Datadog boasts over 800 built-in integrations, including databases, messaging systems, cloud providers, CI/CD tools, and security tools like Snyk and Jira, providing a comprehensive observability solution.
-    
-    <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%209.webp" alt="Datadog Integrations" caption="Datadog Integrations" />
-    
+  <Figure
+    src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%209.webp"
+    alt="Datadog Integrations"
+    caption="Datadog Integrations"
+  />
 
 ### 3. API Flexibility & Extensibility
 
 - Honeycomb:
-    
-    Honeycomb offers flexible event ingestion endpoints and GraphQL-like APIs for querying and retrieving data. This flexibility is ideal for teams that want to deeply customize their observability workflows, such as exporting data for custom dashboards or automating certain queries.
-    
+  Honeycomb offers flexible event ingestion endpoints and GraphQL-like APIs for querying and retrieving data. This flexibility is ideal for teams that want to deeply customize their observability workflows, such as exporting data for custom dashboards or automating certain queries.
 - Datadog:
-    
-    Datadog provides comprehensive REST APIs for almost every aspect of its platform, including metric ingestion, log and trace submission, dashboard management, and alert configuration. These APIs are commonly used for automating tasks or integrating Datadog with CI/CD workflows.
-    
+  Datadog provides comprehensive REST APIs for almost every aspect of its platform, including metric ingestion, log and trace submission, dashboard management, and alert configuration. These APIs are commonly used for automating tasks or integrating Datadog with CI/CD workflows.
 
 ## Collaborative Troubleshooting: How Do They Support Teams?
 
@@ -254,51 +276,41 @@ Effective observability tools should facilitate teamwork. Here's how Honeycomb a
 ### 1. Team Collaboration Features
 
 - Honeycomb:
-    
-    Honeycomb places a strong emphasis on team-based debugging, making it easy for teams to collaborate on complex issues. Key features include:
-    
-    - Shared Queries: Teams can save and share queries, allowing others to quickly dive into investigations without needing to recreate them.
-    - Boards for Storing Common Investigations: Teams can create boards to organize ongoing or common investigations, which simplifies team-wide visibility into known issues or exploration paths.
-    - Guided Query Patterns: Honeycomb’s interface allows teams to follow guided patterns for building queries, making it easier for less experienced team members to contribute to troubleshooting efforts.
+  Honeycomb places a strong emphasis on team-based debugging, making it easy for teams to collaborate on complex issues. Key features include:
+  - Shared Queries: Teams can save and share queries, allowing others to quickly dive into investigations without needing to recreate them.
+  - Boards for Storing Common Investigations: Teams can create boards to organize ongoing or common investigations, which simplifies team-wide visibility into known issues or exploration paths.
+  - Guided Query Patterns: Honeycomb’s interface allows teams to follow guided patterns for building queries, making it easier for less experienced team members to contribute to troubleshooting efforts.
 - Datadog:
-    
-    Datadog fosters collaboration by offering shared dashboards and notebook-style collaboration:
-    
-    - Dashboards: Custom dashboards with real-time data can be shared across teams, providing visibility into metrics and logs for everyone involved in an issue.
-    - Notebook Collaboration: Datadog has a notebook feature designed for writing and sharing postmortems or collaborative investigations. These notebooks can include metrics, logs, and traces, alongside commentary to support knowledge sharing.
+  Datadog fosters collaboration by offering shared dashboards and notebook-style collaboration:
+  - Dashboards: Custom dashboards with real-time data can be shared across teams, providing visibility into metrics and logs for everyone involved in an issue.
+  - Notebook Collaboration: Datadog has a notebook feature designed for writing and sharing postmortems or collaborative investigations. These notebooks can include metrics, logs, and traces, alongside commentary to support knowledge sharing.
 
 ### 2. Role-Based Access Control (RBAC)
 
 - Honeycomb:
-    
-    Honeycomb offers granular role-based access control (RBAC), allowing teams to control who can view or modify specific data. Given Honeycomb’s focus on small to medium teams, the complexity of RBAC is relatively simple. The platform allows users to set different access levels, including:
-    
-    - Read-only: Users can view the data without modifying queries.
-    - Write: Users can modify or create new queries and boards.
+  Honeycomb offers granular role-based access control (RBAC), allowing teams to control who can view or modify specific data. Given Honeycomb’s focus on small to medium teams, the complexity of RBAC is relatively simple. The platform allows users to set different access levels, including:
+  - Read-only: Users can view the data without modifying queries.
+  - Write: Users can modify or create new queries and boards.
 - Datadog:
-    
-    Datadog has a much more comprehensive RBAC system, making it suitable for larger enterprises. It supports detailed permissions, including:
-    
-    - User Access: Administrators can assign roles like read-only, editor, or admin to users.
-    - Multi-Organization Support: Datadog enables separate environments (e.g., development, production) and different organizations within the same account, which is useful for managing access in larger, complex teams.
-    
-    <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2010.webp" alt="Datadog comprehensive RBAC system" caption="Datadog comprehensive RBAC system" />
-    
+  Datadog has a much more comprehensive RBAC system, making it suitable for larger enterprises. It supports detailed permissions, including:
+  - User Access: Administrators can assign roles like read-only, editor, or admin to users.
+  - Multi-Organization Support: Datadog enables separate environments (e.g., development, production) and different organizations within the same account, which is useful for managing access in larger, complex teams.
+    <Figure
+      src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2010.webp"
+      alt="Datadog comprehensive RBAC system"
+      caption="Datadog comprehensive RBAC system"
+    />
 
 ### 3. Knowledge Sharing & Documentation
 
 - Honeycomb:
-    
-    Honeycomb emphasizes learning from each other through shared, reusable queries. Its shared queries and boards create a system of knowledge transfer and team collaboration:
-    
-    - Teams can easily save queries for future use, enabling quick access to previously identified patterns and insights.
-    - Honeycomb’s boards allow users to document ongoing investigations and solutions, providing a historical record of past issues and resolutions.
+  Honeycomb emphasizes learning from each other through shared, reusable queries. Its shared queries and boards create a system of knowledge transfer and team collaboration:
+  - Teams can easily save queries for future use, enabling quick access to previously identified patterns and insights.
+  - Honeycomb’s boards allow users to document ongoing investigations and solutions, providing a historical record of past issues and resolutions.
 - Datadog:
-    
-    Datadog supports knowledge sharing with features like tagging and annotating dashboards and monitors:
-    
-    - Tagging allows teams to mark specific data or dashboards with keywords, making it easier to locate and reference.
-    - Annotations allow users to add comments or context to monitors and dashboards, improving cross-team understanding of why certain metrics or events are important.
+  Datadog supports knowledge sharing with features like tagging and annotating dashboards and monitors:
+  - Tagging allows teams to mark specific data or dashboards with keywords, making it easier to locate and reference.
+  - Annotations allow users to add comments or context to monitors and dashboards, improving cross-team understanding of why certain metrics or events are important.
 
 ## Pricing Models: Honeycomb vs Datadog
 
@@ -308,34 +320,38 @@ Understanding the pricing structure is crucial for long-term planning:
 
 - Event-Based Pricing: Billed by the number of events ingested and retention window. Ideal for smaller teams but can get expensive at a large scale.
 - Free Tier: Limited daily event volume and short retention, suitable for testing and proof of concept.
-    
-    <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2011.webp" alt="Honeycomb pricing structure" caption="Honeycomb pricing structure" />
-    
+  <Figure
+    src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2011.webp"
+    alt="Honeycomb pricing structure"
+    caption="Honeycomb pricing structure"
+  />
 
 ### Datadog
 
 - Host-Based & Add-On Model: Base subscription is per host, with additional charges for custom metrics, logs, and traces. Pricing tiers vary by feature set (e.g., APM, security).
 - Free Tier: 14-day free trial for full feature access; limited free usage for metrics and logs.
-    
-    <Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2012.webp" alt="Datadog Pricing structure" caption="Datadog Pricing structure" />
-    
+  <Figure
+    src="/img/comparisons/2025/02/honeycomb-vs-datadog-image%2012.webp"
+    alt="Datadog Pricing structure"
+    caption="Datadog Pricing structure"
+  />
 
 ## How to Choose Between Honeycomb and Datadog
 
 Choosing between Honeycomb and Datadog depends on several factors:
 
 1. Team Size & Expertise
-    - Honeycomb: Ideal for teams with advanced engineers who need deep, event-driven debugging and high-cardinality data analysis.
-    - Datadog: Best for larger teams or enterprises that need an integrated solution with broad monitoring capabilities for infrastructure and security.
+   - Honeycomb: Ideal for teams with advanced engineers who need deep, event-driven debugging and high-cardinality data analysis.
+   - Datadog: Best for larger teams or enterprises that need an integrated solution with broad monitoring capabilities for infrastructure and security.
 2. Use Case Alignment
-    - Honeycomb: Perfect for microservices with ephemeral or dynamic environments, and for teams focused on interactive debugging workflows.
-    - Datadog: Suitable for large, multi-product organizations that need comprehensive monitoring across metrics, logs, and APM.
+   - Honeycomb: Perfect for microservices with ephemeral or dynamic environments, and for teams focused on interactive debugging workflows.
+   - Datadog: Suitable for large, multi-product organizations that need comprehensive monitoring across metrics, logs, and APM.
 3. Learning Curve & Onboarding
-    - Honeycomb: Requires familiarity with event-driven queries and advanced instrumentation, which may take longer to master.
-    - Datadog: Easier to set up for basic monitoring with quick onboarding, though advanced features may still require custom instrumentation.
+   - Honeycomb: Requires familiarity with event-driven queries and advanced instrumentation, which may take longer to master.
+   - Datadog: Easier to set up for basic monitoring with quick onboarding, though advanced features may still require custom instrumentation.
 4. Long-Term Scalability & Vendor Lock-In
-    - Consider the impact of volume-based (Honeycomb) or host-based (Datadog) pricing on your future costs as your environment grows.
-    - Evaluate if adopting open standards like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is a priority to avoid vendor lock-in and ensure flexibility for future tool-switching.
+   - Consider the impact of volume-based (Honeycomb) or host-based (Datadog) pricing on your future costs as your environment grows.
+   - Evaluate if adopting open standards like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is a priority to avoid vendor lock-in and ensure flexibility for future tool-switching.
 
 ## SigNoz: An Open-Source Alternative Worth Considering
 
@@ -343,36 +359,34 @@ While comparing [Honeycomb vs Datadog](https://signoz.io/comparisons/opentelemet
 
 [SigNoz](https://signoz.io) is an open-source observability platform that provides integrated metrics, logs, and traces in a unified interface. It is based on OpenTelemetry, which is a cloud-native, open-source standard for collecting and exporting telemetry data, making it easy to instrument microservices with minimal vendor lock-in. SigNoz is designed for teams that want full control over their [observability infrastructure](https://signoz.io/blog/observability-tools/) without relying on commercial SaaS platforms.
 
-<Figure src="/img/comparisons/2025/02/honeycomb-vs-datadog-signal-32-hostmetrics.webp" alt="Infrastructure dashboard in SigNoz" caption="Infrastructure dashboard in SigNoz" />
+<Figure
+  src="/img/comparisons/2025/02/honeycomb-vs-datadog-signal-32-hostmetrics.webp"
+  alt="Infrastructure dashboard in SigNoz"
+  caption="Infrastructure dashboard in SigNoz"
+/>
 
 ### Comparison with Honeycomb & Datadog
 
 While Honeycomb and Datadog offer powerful observability solutions, SigNoz provides notable benefits in several key areas:
 
 - Data Control:
-    - SigNoz offers a self-hosted deployment option, meaning you control where and how your observability data is stored and processed. This is a significant advantage for organizations that need to maintain strict data sovereignty and compliance requirements. Since SigNoz can be deployed on your own infrastructure or in your cloud environment, it ensures you retain full ownership of your data.
-    - Honeycomb and Datadog, on the other hand, are cloud-based platforms that manage your data for you. While they offer reliability and scalability, you are essentially trusting these third-party services with your telemetry data, which can raise concerns in regulated industries or for organizations that need to keep all data in-house.
+  - SigNoz offers a self-hosted deployment option, meaning you control where and how your observability data is stored and processed. This is a significant advantage for organizations that need to maintain strict data sovereignty and compliance requirements. Since SigNoz can be deployed on your own infrastructure or in your cloud environment, it ensures you retain full ownership of your data.
+  - Honeycomb and Datadog, on the other hand, are cloud-based platforms that manage your data for you. While they offer reliability and scalability, you are essentially trusting these third-party services with your telemetry data, which can raise concerns in regulated industries or for organizations that need to keep all data in-house.
 - Community-Driven:
-    - SigNoz is driven by the open-source community, which means that features and updates are often built based on the needs and feedback of its users. This community-driven model allows for rapid innovation and a flexible product that can evolve with changing use cases.
-    - Honeycomb and Datadog, though both are responsive to customer feedback, are commercial platforms with longer release cycles and a more controlled feature roadmap.
+  - SigNoz is driven by the open-source community, which means that features and updates are often built based on the needs and feedback of its users. This community-driven model allows for rapid innovation and a flexible product that can evolve with changing use cases.
+  - Honeycomb and Datadog, though both are responsive to customer feedback, are commercial platforms with longer release cycles and a more controlled feature roadmap.
 - Cost Savings:
-    - SigNoz allows you to avoid the per-host or per-event charges typical of cloud-based solutions like Honeycomb and Datadog. Instead, you pay only for the infrastructure you manage (e.g., your cloud or on-prem hardware), which can lead to significant cost savings, particularly at scale. SigNoz's pricing model is more predictable, with no hidden costs based on data volume or event cardinality.
-    - Honeycomb and Datadog have usage-based pricing that scales with the volume of events, metrics, or hosts being monitored. While this works well for small teams, larger organizations or those with high-cardinality data (many unique tags or identifiers) could see escalating costs as their data grows.
+  - SigNoz allows you to avoid the per-host or per-event charges typical of cloud-based solutions like Honeycomb and Datadog. Instead, you pay only for the infrastructure you manage (e.g., your cloud or on-prem hardware), which can lead to significant cost savings, particularly at scale. SigNoz's pricing model is more predictable, with no hidden costs based on data volume or event cardinality.
+  - Honeycomb and Datadog have usage-based pricing that scales with the volume of events, metrics, or hosts being monitored. While this works well for small teams, larger organizations or those with high-cardinality data (many unique tags or identifiers) could see escalating costs as their data grows.
 
 ### Why Consider SigNoz?
 
 - Customization & Compliance:
-    
-    SigNoz, being open-source and self-hosted, offers deep customization, allowing organizations to meet specific compliance needs (e.g., GDPR or data residency). In contrast, Honeycomb and Datadog provide configuration options but are more limited in data storage control, as they rely on their cloud environments.
-    
+  SigNoz, being open-source and self-hosted, offers deep customization, allowing organizations to meet specific compliance needs (e.g., GDPR or data residency). In contrast, Honeycomb and Datadog provide configuration options but are more limited in data storage control, as they rely on their cloud environments.
 - Avoiding Expensive SaaS Models:
-    
-    SigNoz is cost-effective, with charges only for infrastructure management. This makes it ideal for high-throughput systems. On the other hand, Honeycomb and Datadog can become costly due to usage-based pricing, especially with large volumes of events, hosts, or high-cardinality metrics.
-    
+  SigNoz is cost-effective, with charges only for infrastructure management. This makes it ideal for high-throughput systems. On the other hand, Honeycomb and Datadog can become costly due to usage-based pricing, especially with large volumes of events, hosts, or high-cardinality metrics.
 - Vendor Independence:
-    
-    Built on OpenTelemetry, SigNoz ensures freedom from vendor lock-in, allowing easy migration to other OpenTelemetry-compatible services. Honeycomb and Datadog are proprietary platforms, making migration harder once integrated into their ecosystems.
-    
+  Built on OpenTelemetry, SigNoz ensures freedom from vendor lock-in, allowing easy migration to other OpenTelemetry-compatible services. Honeycomb and Datadog are proprietary platforms, making migration harder once integrated into their ecosystems.
 
 Real-World Scenarios Where SigNoz Shines
 
@@ -406,4 +420,4 @@ Yes, you can use both tools together to leverage Honeycomb's deep debugging and
 
 ### What are the main differences between Honeycomb and Datadog in terms of learning curves?
 
-Honeycomb has a steeper learning curve, focusing on event-driven queries and advanced instrumentation. Datadog is easier to set up initially, with an out-of-the-box solution but requires more code-level integration for deep trace analysis.
\ No newline at end of file
+Honeycomb has a steeper learning curve, focusing on event-driven queries and advanced instrumentation. Datadog is easier to set up initially, with an out-of-the-box solution but requires more code-level integration for deep trace analysis.
diff --git a/data/comparisons/incident-management-tools.mdx b/data/comparisons/incident-management-tools.mdx
index 852de88a7..9eca87369 100644
--- a/data/comparisons/incident-management-tools.mdx
+++ b/data/comparisons/incident-management-tools.mdx
@@ -1,24 +1,31 @@
 ---
-
 title: Top 10 Incident Management Tools for IT Teams in 2025
-slug: incident-management-tools
+
 date: 2025-01-02
 tags: [Incident Management]
 authors: [manjunath_irukulla]
 description: Discover the best incident management tools for IT teams in 2024. Compare features, pricing, and use cases to find the perfect solution for your organization.
-keywords: [incident management tools, IT incident response, DevOps tools, ITSM software, alert management, on-call scheduling, incident resolution]
-
+keywords:
+  [
+    incident management tools,
+    IT incident response,
+    DevOps tools,
+    ITSM software,
+    alert management,
+    on-call scheduling,
+    incident resolution,
+  ]
 ---
 
 In today’s fast-paced digital world, incident management tools are essential for IT teams to ensure smooth and uninterrupted operations. As technology and IT ecosystems become increasingly complex, quickly identifying, responding, and resolving incidents has never been more crucial.
 
-With a wide range of tools available in 2024, how do you determine which best suits your team’s needs? This article provides a detailed overview of the top incident management solutions and offers practical advice to help you choose the right tool for your organization. 
+With a wide range of tools available in 2024, how do you determine which best suits your team’s needs? This article provides a detailed overview of the top incident management solutions and offers practical advice to help you choose the right tool for your organization.
 
 ## What is Incident Management and Why is it Crucial for IT Teams?
 
-Incident management is a structured process that IT teams use to identify, analyze, and resolve disruptions to IT services. As a critical component of IT Service Management (ITSM), it prioritizes restoring normal operations swiftly and effectively to minimize the impact on business operations. 
+Incident management is a structured process that IT teams use to identify, analyze, and resolve disruptions to IT services. As a critical component of IT Service Management (ITSM), it prioritizes restoring normal operations swiftly and effectively to minimize the impact on business operations.
 
-In today’s fast-paced digital landscape, where even brief downtimes can lead to significant revenue loss or reputational damage, incident management is no longer optional. 
+In today’s fast-paced digital landscape, where even brief downtimes can lead to significant revenue loss or reputational damage, incident management is no longer optional.
 
 ### Why Incident Management Matters
 
@@ -29,7 +36,11 @@ In today’s fast-paced digital landscape, where even brief downtimes can lead t
 
 ### Core Components of Effective Incident Management
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-Components_of_Incident_Management.webp" alt="Core Components of Effective Incident Management" caption="Core Components of Effective Incident Management" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-Components_of_Incident_Management.webp"
+  alt="Core Components of Effective Incident Management"
+  caption="Core Components of Effective Incident Management"
+/>
 
 - Incident Detection and Logging: Promptly identifying and documenting incidents to establish a clear record.
 - Classification and Prioritization: Categorizing incidents based on urgency and impact to allocate resources effectively.
@@ -42,30 +53,34 @@ By adopting a systematic approach to incident management, IT teams can transform
 
 ## Essential Features to Look for in Incident Management Tools
 
-Selecting the right incident management tool can significantly impact your IT team’s efficiency and effectiveness. When evaluating options, look for these essential features to ensure the tool aligns with your organizational needs: 
+Selecting the right incident management tool can significantly impact your IT team’s efficiency and effectiveness. When evaluating options, look for these essential features to ensure the tool aligns with your organizational needs:
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-Features_to_Look_For_in_Incident_Management.webp" alt="Essential Features to Look for in Incident Management Tools" caption="Essential Features to Look for in Incident Management Tools" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-Features_to_Look_For_in_Incident_Management.webp"
+  alt="Essential Features to Look for in Incident Management Tools"
+  caption="Essential Features to Look for in Incident Management Tools"
+/>
 
 - Real-time Alerting and Notification Systems: Effective incident response starts with timely awareness. Look for tools offering:
-    - Multi-Channel Alerts: Instant notifications via email, SMS, push notifications, and integrated chat platforms like Slack or Microsoft Teams.
-    - Customizable Alert Rules: Tailor alerts based on thresholds, service levels, or specific metrics.
-    - Intelligent Alert Grouping: Consolidate related alerts to minimize noise and avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/).
+  - Multi-Channel Alerts: Instant notifications via email, SMS, push notifications, and integrated chat platforms like Slack or Microsoft Teams.
+  - Customizable Alert Rules: Tailor alerts based on thresholds, service levels, or specific metrics.
+  - Intelligent Alert Grouping: Consolidate related alerts to minimize noise and avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/).
 - Centralized Incident Tracking and Documentation: A unified platform for incident management is critical for transparency and accountability:
-    - Unified Dashboard: Centralize incident data for a complete, real-time view.
-    - Detailed Incident Timelines and Audit Trails: Maintain comprehensive records of incident history for accountability and compliance.
-    - Knowledge-Based Integration: Provide teams quick access to solutions and troubleshooting guides for recurring issues.
+  - Unified Dashboard: Centralize incident data for a complete, real-time view.
+  - Detailed Incident Timelines and Audit Trails: Maintain comprehensive records of incident history for accountability and compliance.
+  - Knowledge-Based Integration: Provide teams quick access to solutions and troubleshooting guides for recurring issues.
 - Automated Workflow and Escalation Processes: Streamlining workflows and ensuring accountability is vital for efficient incident resolution:
-    - Configurable Routing: Automatically assign incidents based on severity, type, or team expertise.
-    - Automatic Escalation: Trigger escalations for unresolved incidents within specified timeframes.
-    - Collaboration Integration: Integrate with tools like Jira or ServiceNow to enable seamless communication and task management.
+  - Configurable Routing: Automatically assign incidents based on severity, type, or team expertise.
+  - Automatic Escalation: Trigger escalations for unresolved incidents within specified timeframes.
+  - Collaboration Integration: Integrate with tools like Jira or ServiceNow to enable seamless communication and task management.
 - Advanced Analytics and Reporting Capabilities: Data-driven insights are essential for continuous improvement.
-    - Performance Metrics: Track key indicators like mean time to detect (MTTD) and mean time to resolve (MTTR).
-    - Customizable Reporting: Generate detailed reports tailored to specific stakeholders or objectives.
-    - Proactive Insights: Identify trends and potential bottlenecks to optimize processes and prevent future incidents.
+  - Performance Metrics: Track key indicators like mean time to detect (MTTD) and mean time to resolve (MTTR).
+  - Customizable Reporting: Generate detailed reports tailored to specific stakeholders or objectives.
+  - Proactive Insights: Identify trends and potential bottlenecks to optimize processes and prevent future incidents.
 - Robust Integration Capabilities: A tool that fits seamlessly into your existing ecosystem is a must:
-    - Monitoring Tool Integration: Connect with solutions like Prometheus, Grafana, or [SigNoz](https://signoz.io/docs/introduction/) for enhanced visibility.
-    - ITSM and ChatOps Support: Streamline workflows with platforms like ServiceNow or PagerDuty and enable real-time collaboration.
-    - API Access: Facilitate custom integrations to tailor the tool to your specific operational needs.
+  - Monitoring Tool Integration: Connect with solutions like Prometheus, Grafana, or [SigNoz](https://signoz.io/docs/introduction/) for enhanced visibility.
+  - ITSM and ChatOps Support: Streamline workflows with platforms like ServiceNow or PagerDuty and enable real-time collaboration.
+  - API Access: Facilitate custom integrations to tailor the tool to your specific operational needs.
 
 ## Top 10 Incident Management Tools for 2024
 
@@ -73,9 +88,13 @@ Incident management tools are pivotal in ensuring IT service reliability and res
 
 ### 1. SigNoz
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image.webp" alt="SigNoz Dashboard - Source SigNoz.io" caption="SigNoz Dashboard - Source SigNoz.io" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image.webp"
+  alt="SigNoz Dashboard - Source SigNoz.io"
+  caption="SigNoz Dashboard - Source SigNoz.io"
+/>
 
-SigNoz takes a modern, open-source approach to observability and incident management, making it a compelling choice for organizations looking for transparency,  flexibility, and cost savings. 
+SigNoz takes a modern, open-source approach to observability and incident management, making it a compelling choice for organizations looking for transparency, flexibility, and cost savings.
 
 Key Features:
 
@@ -93,17 +112,21 @@ Cost-effectiveness:
 - Self-Hosted Option: Completely free for unlimited users, providing budget-friendly observability for startups and growing teams.
 - Cloud Offering: Competitive pricing for managed services, delivering convenience without compromising affordability.
 
-Idea Use Cases: Teams seeking transparency, flexibility, and a strong observability foundation for managing complex incidents. Organizations want a cost-effective, community-backed alternative to proprietary tools. 
+Idea Use Cases: Teams seeking transparency, flexibility, and a strong observability foundation for managing complex incidents. Organizations want a cost-effective, community-backed alternative to proprietary tools.
 
-To explore SigNoz, visit their website at [https://signoz.io](https://signoz.io) and dive into their comprehensive documentation for seamless setup and integration. 
+To explore SigNoz, visit their website at [https://signoz.io](https://signoz.io) and dive into their comprehensive documentation for seamless setup and integration.
 
-<GetStartedSigNoz/> 
+<GetStartedSigNoz />
 
 ### 2. PagerDuty
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%201.webp" alt="PagerDuty Dashboard - Source PagerDuty" caption="PagerDuty Dashboard - Source PagerDuty" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%201.webp"
+  alt="PagerDuty Dashboard - Source PagerDuty"
+  caption="PagerDuty Dashboard - Source PagerDuty"
+/>
 
-PagerDuty is a market leader in digital operations management, trusted by organizations worldwide for its powerful incident response capabilities. 
+PagerDuty is a market leader in digital operations management, trusted by organizations worldwide for its powerful incident response capabilities.
 
 Key Features:
 
@@ -111,15 +134,19 @@ Key Features:
 - On-Call Management: Flexible scheduling, rotations, and automated escalation workflows.
 - Seamless Integration: Connects with over 700 tools, including monitoring, ticketing, and communication platforms.
 
-Ideal Use Cases: Enterprises with large, distributed teams requiring sophisticated automation and real-time insights. 
+Ideal Use Cases: Enterprises with large, distributed teams requiring sophisticated automation and real-time insights.
 
 Pricing: Starts at $19/user/month for small teams, with enterprise pricing available for larger organizations.
 
 ### 3. Opsgenie
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-efc1d6f8-cf58-4a84-b22c-132f8c3a88d0.webp" alt="Opsgenie Dashboard - Source Opsgenie" caption="Opsgenie Dashboard - Source Opsgenie" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-efc1d6f8-cf58-4a84-b22c-132f8c3a88d0.webp"
+  alt="Opsgenie Dashboard - Source Opsgenie"
+  caption="Opsgenie Dashboard - Source Opsgenie"
+/>
 
-As part of the Atlassian suite, Opsgenie offers a comprehensive approach to alert management and on-call scheduling, making it a strong contender for IT teams needing structured incident response processes. 
+As part of the Atlassian suite, Opsgenie offers a comprehensive approach to alert management and on-call scheduling, making it a strong contender for IT teams needing structured incident response processes.
 
 Standout Functionalities:
 
@@ -132,15 +159,19 @@ Collaboration Features:
 - Stakeholder Notifications: Keeps relevant stakeholders informed with tailored notifications, reducing the need for manual updates.
 - Integrated Chat and Conference Bridge: Direct access to communication channels enables real-time coordination during incident resolution.
 
-Ideal Use Cases: Teams looking for tight integration with Atlassian products, such as Jira, or needing strong mobile support for on-call teams. 
+Ideal Use Cases: Teams looking for tight integration with Atlassian products, such as Jira, or needing strong mobile support for on-call teams.
 
-Pricing: Starts at $9/user/month, with advanced features available on premium plans. 
+Pricing: Starts at $9/user/month, with advanced features available on premium plans.
 
 ### 4. ServiceNow
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%202.webp" alt="ServiceNow Dashboard - Source ServiceNow" caption="ServiceNow Dashboard - Source ServiceNow" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%202.webp"
+  alt="ServiceNow Dashboard - Source ServiceNow"
+  caption="ServiceNow Dashboard - Source ServiceNow"
+/>
 
-ServiceNow is a leading IT Service Management (ITSM) platform that excels in incident management, offering a robust suite of tools for enterprise-grade IT operations. 
+ServiceNow is a leading IT Service Management (ITSM) platform that excels in incident management, offering a robust suite of tools for enterprise-grade IT operations.
 
 Enterprise-Grade Features:
 
@@ -148,19 +179,23 @@ Enterprise-Grade Features:
 - Visual Workflow Designer: Create and customize workflows with an intuitive drag-and-drop interface.
 - Advanced Analytics: Detailed reporting and dashboards provide insights into incident trends and team performance.
 - Information Technology Infrastructure Library (ITIL) Alignment: Security adheres to ITIL best practices, ensuring compliance with established IT governance frameworks. This makes it an excellent choice for enterprises operating under strict regulatory or operational standards.
-    - This alignment makes it particularly suitable for enterprises operating under stringent regulatory, operational,  or compliance standards.
-    - It empowers organizations to balance service quality, operational efficiency, and risk management, ensuring robust and reliable IT operations.
+  - This alignment makes it particularly suitable for enterprises operating under stringent regulatory, operational, or compliance standards.
+  - It empowers organizations to balance service quality, operational efficiency, and risk management, ensuring robust and reliable IT operations.
 - Customization: The platform offers unparalleled flexibility, enabling organizations to design incident management workflows tailored to their specific needs and integrate seamlessly with other enterprise systems.
 
 Ideal Use Cases: Large enterprises with complex IT infrastructures require a highly customizable, ITIL-compliant platform.
 
-Pricing: Custom pricing based on organizational needs, with solutions tailored for mid-sized to large enterprises.  
+Pricing: Custom pricing based on organizational needs, with solutions tailored for mid-sized to large enterprises.
 
 ### 5. Splunk On-Call (formerly VictorOps)
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%203.webp" alt="Splunk On Call Dashboard - Source Splunk On Call" caption="Splunk On Call Dashboard - Source Splunk On Call" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%203.webp"
+  alt="Splunk On Call Dashboard - Source Splunk On Call"
+  caption="Splunk On Call Dashboard - Source Splunk On Call"
+/>
 
-Splunk On-Call specializes in DevOps-focused incident management, combining automation with machine learning to streamline workflows and enhance operational reliability. 
+Splunk On-Call specializes in DevOps-focused incident management, combining automation with machine learning to streamline workflows and enhance operational reliability.
 
 DevOps-Centric Features:
 
@@ -173,15 +208,19 @@ Machine Learning Capabilities:
 - Anomaly Detection: Identifies irregular patterns in system behavior to proactively address potential incidents.
 - Intelligent Alert Grouping: Consolidates related alerts to minimize noise and improve focus on critical issues.
 
-Ideal Use Cases: DevOps teams seeking an integrated incident management tool that aligns with observability and CI/CD pipelines. 
+Ideal Use Cases: DevOps teams seeking an integrated incident management tool that aligns with observability and CI/CD pipelines.
 
-Pricing: Starts at $10/user/month, with scalable plans available for enterprises. 
+Pricing: Starts at $10/user/month, with scalable plans available for enterprises.
 
 ### 6. Zenduty
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%204.webp" alt="Zenduty Dashboard - Source Zenduty" caption="Zenduty Dashboard - Source Zenduty" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%204.webp"
+  alt="Zenduty Dashboard - Source Zenduty"
+  caption="Zenduty Dashboard - Source Zenduty"
+/>
 
-Zenduty provides a modern, collaborative approach to incident management, focusing on automation, streamlined communication, and cost-effectiveness. 
+Zenduty provides a modern, collaborative approach to incident management, focusing on automation, streamlined communication, and cost-effectiveness.
 
 Multi-channel Alerting:
 
@@ -194,15 +233,19 @@ Incident Response Playbooks:
 - Automated Task Assignment: Assign tasks based on predefined criteria and track their status through completion.
 - Pricing Advantage: Zenduty stands out with competitive pricing and a free tier for up to 5 users, making it an attractive choice for startups and small to medium-sized teams.
 
-Ideal Use Cases: Teams looking for an affordable, feature-rich solution that prioritizes collaboration and ease of use. 
+Ideal Use Cases: Teams looking for an affordable, feature-rich solution that prioritizes collaboration and ease of use.
 
-Pricing: Paid plans start at $9/user/month, scaling with additional features for larger teams. 
+Pricing: Paid plans start at $9/user/month, scaling with additional features for larger teams.
 
 ### 7. Jira Service Management
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%205.webp" alt="Jira Service Management Dashboard - Source Jira" caption="Jira Service Management Dashboard - Source Jira" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%205.webp"
+  alt="Jira Service Management Dashboard - Source Jira"
+  caption="Jira Service Management Dashboard - Source Jira"
+/>
 
-Jira Service Management brings incident management into the powerful Atlassian ecosystem, offering seamless integration and enhanced collaboration for IT teams. 
+Jira Service Management brings incident management into the powerful Atlassian ecosystem, offering seamless integration and enhanced collaboration for IT teams.
 
 Atlassian Integration:
 
@@ -216,13 +259,17 @@ Knowledge Base:
 
 Ideal Use Cases: Organizations already using Atlassian tools seeking a cohesive and scalable incident management solution.
 
-Pricing: Starts at $21/agent/month for standard plans, with additional tiers for premium and enterprise-level features. 
+Pricing: Starts at $21/agent/month for standard plans, with additional tiers for premium and enterprise-level features.
 
 ### 8. xMatters
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%206.webp" alt="xMatters Dashboard - Source xMatters" caption="xMatters Dashboard - Source xMatters" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%206.webp"
+  alt="xMatters Dashboard - Source xMatters"
+  caption="xMatters Dashboard - Source xMatters"
+/>
 
-xMatters is a leading incident management tool that excels in intelligent communication and workflow automation for DevOps and IT teams. 
+xMatters is a leading incident management tool that excels in intelligent communication and workflow automation for DevOps and IT teams.
 
 Workflow Automation:
 
@@ -239,16 +286,20 @@ On-call Management:
 - Flexible Scheduling: Advanced on-call management with calendar synchronization to ensure coverage.
 - Sophisticated Escalation Rules: Configurable escalation layers with multiple conditions to ensure no incident goes unresolved.
 
-Ideal Use Cases: Enterprises seeking a tool that seamlessly integrates communication, automation, and scheduling for efficient incident response. 
-Pricing: Flexible pricing options, starting with a free tier for small teams, with premium plans for more advanced features. 
+Ideal Use Cases: Enterprises seeking a tool that seamlessly integrates communication, automation, and scheduling for efficient incident response.
+Pricing: Flexible pricing options, starting with a free tier for small teams, with premium plans for more advanced features.
 
 ### 9. Freshservice
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%207.webp" alt="FreshService Dashboard - Source FreshService" caption="FreshService Dashboard - Source FreshService" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%207.webp"
+  alt="FreshService Dashboard - Source FreshService"
+  caption="FreshService Dashboard - Source FreshService"
+/>
 
 Freshservice delivers a user-friendly IT Service Management (ITSM) platform with robust incident management features, ideal for organizations that prioritize simplicity and efficiency.
 
-User Friendly Interface: 
+User Friendly Interface:
 
 - Intuitive Design: Drag-and-drop capabilities simplify ticket management, enhancing productivity for IT teams.
 - Customizable Dashboards: Tailor views and reports to monitor key performance metrics and incident trends.
@@ -263,12 +314,16 @@ AI Chatbot:
 - 24/7 Self-Service Support: Handles common queries, reducing the burden on IT teams.
 - Automated-Driven: Automatically creates, categorizes, and prioritizes tickets to streamline incident workflows.
 
-Ideal Use Cases: SMBs and enterprises seeking an ITSM tool with easy implementation and a balance of automation and usability. 
-Pricing: Starts at $19/agent/month, with advanced plans offering more customization and automation capabilities. 
+Ideal Use Cases: SMBs and enterprises seeking an ITSM tool with easy implementation and a balance of automation and usability.
+Pricing: Starts at $19/agent/month, with advanced plans offering more customization and automation capabilities.
 
 ### 10. ManageEngine ServiceDesk Plus
 
-<Figure src="/img/comparisons/2024/11/incident-management-tools-image%208.webp" alt="ManageEngine Service Plus Dashboard - Source ManageEngine" caption="ManageEngine Service Plus Dashboard - Source ManageEngine" />
+<Figure
+  src="/img/comparisons/2024/11/incident-management-tools-image%208.webp"
+  alt="ManageEngine Service Plus Dashboard - Source ManageEngine"
+  caption="ManageEngine Service Plus Dashboard - Source ManageEngine"
+/>
 
 ManageEngine ServiceDesk Plus offers a comprehensive ITSM suite that focuses on deployment flexibility, compliance, and security and caters to a wide range of organizational needs.
 
@@ -282,55 +337,55 @@ Compliance and Security:
 - ITIL and Standards Compliance: Includes built-in reports for ITIL, COBIT, and ISO 20000 to simplify adherence to industry standards.
 - Enhanced Security: Features role-based access control, robust audit trails, and encryption to safeguard sensitive data.
 
-Ideal Use Cases: Organizations seeking a customizable ITSM platform with strong compliance features and the ability to scale across different deployment models. 
+Ideal Use Cases: Organizations seeking a customizable ITSM platform with strong compliance features and the ability to scale across different deployment models.
 
-Pricing: Starts at $10/technician/month, with tailored plans for businesses of all sizes. 
+Pricing: Starts at $10/technician/month, with tailored plans for businesses of all sizes.
 
 ## How to Choose the Right Incident Management Tool for Your Team
 
-Selecting the perfect incident management tool ensures seamless workflows and faster resolution times. Here’s a detailed guide to making the right choice: 
+Selecting the perfect incident management tool ensures seamless workflows and faster resolution times. Here’s a detailed guide to making the right choice:
 
 - Assess Your Requirements:
-    - Identify Pain Points: Pinpoint areas where your current incident management process is failing short.
-    - Prioritize Features: Distinguish between must-have features (like real-time alerting) and nice-to-have functionalities (such as advanced analytics or AI-driven insights).
+  - Identify Pain Points: Pinpoint areas where your current incident management process is failing short.
+  - Prioritize Features: Distinguish between must-have features (like real-time alerting) and nice-to-have functionalities (such as advanced analytics or AI-driven insights).
 - Consider Scalability:
-    - Future-Proofing: Choose tools that can scale with your organization’s growth, whether it’s accommodating more users or handling increased incident volumes.
-    - Flexible Pricing: Opt for solutions with adaptable pricing models to ensure cost efficiency as your team expands.
+  - Future-Proofing: Choose tools that can scale with your organization’s growth, whether it’s accommodating more users or handling increased incident volumes.
+  - Flexible Pricing: Opt for solutions with adaptable pricing models to ensure cost efficiency as your team expands.
 - Integration Capabilities:
-    - Compatibility: Ensure the tool integrates smoothly with your existing ecosystem, including monitoring tools, ITSM platforms, and communication apps.
-    - API Support: Prefer tools with comprehensive APIs to enable custom integrations and automation for unique workflows.
+  - Compatibility: Ensure the tool integrates smoothly with your existing ecosystem, including monitoring tools, ITSM platforms, and communication apps.
+  - API Support: Prefer tools with comprehensive APIs to enable custom integrations and automation for unique workflows.
 - Analyze Total Cost of Ownership:
-    - Budget Beyond Subscription Fees: Evaluate upfront licensing or subscription costs and training, support, and customization expenses.
-    - Hidden Costs: Consider ongoing maintenance and upgrades that might impact your budget over time.
+  - Budget Beyond Subscription Fees: Evaluate upfront licensing or subscription costs and training, support, and customization expenses.
+  - Hidden Costs: Consider ongoing maintenance and upgrades that might impact your budget over time.
 - User Experience:
-    - Ease of Use: Test the interface for its intuitiveness, ensuring team members can adopt it without a steep learning curve.
-    - Mobile-Friendly Features: Check that the mobile app offers full functionality for on-call teams, including alert acknowledgment, escalation, and resolution.
+  - Ease of Use: Test the interface for its intuitiveness, ensuring team members can adopt it without a steep learning curve.
+  - Mobile-Friendly Features: Check that the mobile app offers full functionality for on-call teams, including alert acknowledgment, escalation, and resolution.
 - Trial and Feedback:
-    - Pilot Runs: Leverage free trials or demos to understand how the tool fits into your team’s workflow.
-    - Gather Feedback: Involve stakeholders, including on-call engineers and managers, for a holistic view of the tool’s effectiveness.
+  - Pilot Runs: Leverage free trials or demos to understand how the tool fits into your team’s workflow.
+  - Gather Feedback: Involve stakeholders, including on-call engineers and managers, for a holistic view of the tool’s effectiveness.
 
 ## Best Practices for Implementing Incident Management Tools
 
-Effectively deploying and leveraging an incident management tool goes beyond selection. These best practices can ensure seamless integration and maximum ROI: 
+Effectively deploying and leveraging an incident management tool goes beyond selection. These best practices can ensure seamless integration and maximum ROI:
 
 - Define Clear Incident Levels:
-    - Severity Tiers: Establish incident categories (e.g., P1 for critical, p4 for low priority) with well-defined criteria.
-    - Response Expectations: Assign response and resolution time targets for each severity level.
-    - Escalation Protocols: Design a clear escalation matrix to ensure unresolved issues move up the chain promptly.
+  - Severity Tiers: Establish incident categories (e.g., P1 for critical, p4 for low priority) with well-defined criteria.
+  - Response Expectations: Assign response and resolution time targets for each severity level.
+  - Escalation Protocols: Design a clear escalation matrix to ensure unresolved issues move up the chain promptly.
 - Foster a Blameless Culture:
-    - Open Communication: Promote transparency during incident reviews to uncover root causes without fear of retribution.
-    - Focus on Systemic Solutions: Address underlying issues rather than individual errors, fostering trust and collaboration.
-    - Encourage Innovation: A blameless culture inspires teams to experiment with improvements without hesitation.
+  - Open Communication: Promote transparency during incident reviews to uncover root causes without fear of retribution.
+  - Focus on Systemic Solutions: Address underlying issues rather than individual errors, fostering trust and collaboration.
+  - Encourage Innovation: A blameless culture inspires teams to experiment with improvements without hesitation.
 - Conduct Regular Training:
-    - Incident Drills: Simulate real-world scenarios to test the team’s readiness and the tool’s effectiveness.
-    - Feature Familiarization: Provide ongoing training on newly added or enhanced features in the tool.
-    - Cross-Functional Sessions: Involve stakeholders outside the IT team (e.g., customer support) to ensure everyone understands the process.
+  - Incident Drills: Simulate real-world scenarios to test the team’s readiness and the tool’s effectiveness.
+  - Feature Familiarization: Provide ongoing training on newly added or enhanced features in the tool.
+  - Cross-Functional Sessions: Involve stakeholders outside the IT team (e.g., customer support) to ensure everyone understands the process.
 - Continuously Improve:
-    - Data-Driven Insights: Regularly analyze incident trends and resolution metrics to identify bottlenecks and inefficiencies.
-    - Feedback Loops: Solicit input from end-users and responders to refine workflows and tool configurations.
-    - Process Optimization: Update incident management practices based on post-mortem learnings and evolving team needs.
+  - Data-Driven Insights: Regularly analyze incident trends and resolution metrics to identify bottlenecks and inefficiencies.
+  - Feedback Loops: Solicit input from end-users and responders to refine workflows and tool configurations.
+  - Process Optimization: Update incident management practices based on post-mortem learnings and evolving team needs.
 
-By embedding these practices into your implementation strategy, your incident management tool becomes a linchpin for operational excellence, enabling faster resolutions, improved collaboration, and proactive service improvements. 
+By embedding these practices into your implementation strategy, your incident management tool becomes a linchpin for operational excellence, enabling faster resolutions, improved collaboration, and proactive service improvements.
 
 ## FAQs
 
@@ -341,7 +396,7 @@ By embedding these practices into your implementation strategy, your incident ma
 
 ### How can incident management tools improve MTTR (Mean Time to Resolution)?
 
-Incident management tools help reduce MTTR by: 
+Incident management tools help reduce MTTR by:
 
 - Automating Alert Assignments: Automatically routing alerts to the right personnel or team based on predefined rules.
 - Contextual Diagnosis: Providing rich context such as logs, metrics, and recent changes to aid in swift troubleshooting.
@@ -351,22 +406,22 @@ Incident management tools help reduce MTTR by:
 
 ### Are open-source incident management tools as effective as commercial solutions?
 
-Open-source tools, such as SigNoz, can be highly effective when: 
+Open-source tools, such as SigNoz, can be highly effective when:
 
 - Customization: Teams need tailored solutions that align closely with specific workflows.
 - Budget Constraints: They offer cost savings compared to proprietary tools.
 - Community Support: They benefit from active communities for troubleshooting and improvements.
 
-However, they may require: 
+However, they may require:
 
 - Technical Expertise: Advanced skills for setup, configuration, and maintenance.
 - Support Planning: Limited or slower support compared to commercial vendors.
 
-Choosing between open-source and commercial tools depends on your organization’s resources and specific needs. 
+Choosing between open-source and commercial tools depends on your organization’s resources and specific needs.
 
 ### How do incident management tools integrate with monitoring and observability platforms?
 
-Integration mechanisms typically include: 
+Integration mechanisms typically include:
 
 - APIs: Facilitating real-time data exchange and incident creation from monitoring tools.
 - Pre-Built Connectors: Simplified integration with platforms like Prometheus, Nagios, or Datadog.
@@ -374,21 +429,21 @@ Integration mechanisms typically include:
 - Bi-Directional Sync: Allowing updates between for enriched incident context and resolution tracking.
 - Unified Dashboards: Combining observability data with incident timelines for comprehensive insights.
 
-These integrations bridge the gap between detection and resolution, enabling quicker action. 
+These integrations bridge the gap between detection and resolution, enabling quicker action.
 
 ### What are the main differences between incident management and incident response tools?
 
 - Scope:
-    - Incident Management: Covers the entire lifecycle from detection, triage, and resolution to post-mortem analysis.
-    - Incident Response: Focuses on the immediate actions of an active incident, especially in critical scenarios like security breaches.
+  - Incident Management: Covers the entire lifecycle from detection, triage, and resolution to post-mortem analysis.
+  - Incident Response: Focuses on the immediate actions of an active incident, especially in critical scenarios like security breaches.
 - Features:
-    - Incident Management: Includes knowledge bases, reporting, and trend analysis for IT service improvement.
-    - Incident Response: Prioritizes real-time collaboration, investigation, and rapid containment.
+  - Incident Management: Includes knowledge bases, reporting, and trend analysis for IT service improvement.
+  - Incident Response: Prioritizes real-time collaboration, investigation, and rapid containment.
 - Use Cases:
-    - Incident Management: Broad IT service management and SLA adherence.
-    - Incident Response: Specialized for handling critical crises, often in security or operations.
+  - Incident Management: Broad IT service management and SLA adherence.
+  - Incident Response: Specialized for handling critical crises, often in security or operations.
 - Integration:
-    - Incident Management: Link with ITSM, observability, and communication platforms.
-    - Incident Response: Often integrates deeply with security and forensic analysis tools.
+  - Incident Management: Link with ITSM, observability, and communication platforms.
+  - Incident Response: Often integrates deeply with security and forensic analysis tools.
 
-Modern tools often merge these functionalities, providing a unified approach to managing and responding to incidents.
\ No newline at end of file
+Modern tools often merge these functionalities, providing a unified approach to managing and responding to incidents.
diff --git a/data/comparisons/infrastructure-monitoring-tools.mdx b/data/comparisons/infrastructure-monitoring-tools.mdx
index b6b77d485..5af0099c6 100644
--- a/data/comparisons/infrastructure-monitoring-tools.mdx
+++ b/data/comparisons/infrastructure-monitoring-tools.mdx
@@ -1,11 +1,20 @@
 ---
-title: "15 Best Infrastructure Monitoring Tools in 2025"
-slug: "infrastructure-monitoring-tools"
-date: "2025-09-04"
+title: '15 Best Infrastructure Monitoring Tools in 2025'
+
+date: '2025-09-04'
 tags: [monitoring, infrastructure]
-authors: ["sarafadeen-ibrahim"]
-description: "Compare the top infrastructure monitoring tools with real pricing breakdowns, implementation complexity ratings, and honest assessments based on actual user experiences."
-keywords: [best infrastructure monitoring tools, infrastructure monitoring tools comparison, open source monitoring tools, cloud monitoring solutions, datadog alternatives, prometheus monitoring, devops monitoring platforms]
+authors: ['sarafadeen-ibrahim']
+description: 'Compare the top infrastructure monitoring tools with real pricing breakdowns, implementation complexity ratings, and honest assessments based on actual user experiences.'
+keywords:
+  [
+    best infrastructure monitoring tools,
+    infrastructure monitoring tools comparison,
+    open source monitoring tools,
+    cloud monitoring solutions,
+    datadog alternatives,
+    prometheus monitoring,
+    devops monitoring platforms,
+  ]
 ---
 
 If you're reading this, you're probably drowning in monitoring tool options while your infrastructure grows more complex by the day. Maybe you're tired of Datadog's surprise bills, or perhaps Nagios finally feels too dated for your Kubernetes clusters. Whatever brought you here, let's talk directly about what these tools actually do, what they really cost, and which one works best for your team's specific needs.
@@ -14,23 +23,27 @@ If you're reading this, you're probably drowning in monitoring tool options whil
 
 Before diving into detailed reviews, here's what you need to know in 30 seconds:
 
-| Tool                     | Best For                                                      | Real Monthly Cost                              | Setup Complexity*      | Infrastructure Coverage            |
-| ------------------------ | ------------------------------------------------------------- | ---------------------------------------------- | ---------------------- | ---------------------------------- |
-| **Datadog**              | Well-funded startups/enterprises                              | \$15-30/host + extras                           | Medium (2-3 weeks)     | Full-stack                         |
-| **SigNoz**               | Teams wanting OTel-native observability or deployment freedom | Free OSS or transparent cloud pricing          | Medium (2-3 weeks)     | Full-stack APM, metrics, and logs  |
-| **New Relic**            | Application-centric orgs                                      | ~\$0.40/GB + \$49-99/user                        | Medium (2-3 weeks)     | Full-stack                         |
-| **Prometheus + Grafana** | Technical teams with k8s                                      | Free OSS or Grafana Cloud (usage-based pricing)| High (4-6 weeks)       | Flexible/custom                    |
-| **Dynatrace**            | Large enterprises                                             | \$29/month (infra) or \$58/month (full-stack)    | Low (1-2 weeks)        | Full-stack with AI                 |
-| **Zabbix**               | Traditional IT environments                                   | Free + time investment                         | Very High (6-8 weeks)  | Network, server, cloud             |
-| **Nagios**               | Legacy environments                                           | Free + massive time cost                       | Very High (8-12 weeks) | Network, server                    |
-
-*Setup complexity estimates based on typical enterprise deployments, including agent installation, dashboard configuration, alert setup, and team training. These timelines are derived from user-reported experiences in production environments, vendor documentation, and implementation guides. **Important**: Actual implementation times vary significantly based on environment complexity, infrastructure size, team expertise, and specific requirements. Simple deployments may be faster, while complex multi-cloud environments typically take longer.*
+| Tool                     | Best For                                                      | Real Monthly Cost                               | Setup Complexity\*     | Infrastructure Coverage           |
+| ------------------------ | ------------------------------------------------------------- | ----------------------------------------------- | ---------------------- | --------------------------------- |
+| **Datadog**              | Well-funded startups/enterprises                              | \$15-30/host + extras                           | Medium (2-3 weeks)     | Full-stack                        |
+| **SigNoz**               | Teams wanting OTel-native observability or deployment freedom | Free OSS or transparent cloud pricing           | Medium (2-3 weeks)     | Full-stack APM, metrics, and logs |
+| **New Relic**            | Application-centric orgs                                      | ~\$0.40/GB + \$49-99/user                       | Medium (2-3 weeks)     | Full-stack                        |
+| **Prometheus + Grafana** | Technical teams with k8s                                      | Free OSS or Grafana Cloud (usage-based pricing) | High (4-6 weeks)       | Flexible/custom                   |
+| **Dynatrace**            | Large enterprises                                             | \$29/month (infra) or \$58/month (full-stack)   | Low (1-2 weeks)        | Full-stack with AI                |
+| **Zabbix**               | Traditional IT environments                                   | Free + time investment                          | Very High (6-8 weeks)  | Network, server, cloud            |
+| **Nagios**               | Legacy environments                                           | Free + massive time cost                        | Very High (8-12 weeks) | Network, server                   |
 
+_Setup complexity estimates based on typical enterprise deployments, including agent installation, dashboard configuration, alert setup, and team training. These timelines are derived from user-reported experiences in production environments, vendor documentation, and implementation guides. **Important**: Actual implementation times vary significantly based on environment complexity, infrastructure size, team expertise, and specific requirements. Simple deployments may be faster, while complex multi-cloud environments typically take longer._
 
 ## The Core Tools: Detailed Analysis
 
 ### Datadog
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-datadog.png" alt="Datadog Infrastructure Monitoring Dashboard" caption="Datadog Infrastructure Monitoring Dashboard (Credits: Datadog)" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-datadog.png"
+  alt="Datadog Infrastructure Monitoring Dashboard"
+  caption="Datadog Infrastructure Monitoring Dashboard (Credits: Datadog)"
+/>
 
 **Infrastructure Coverage**: Full-stack (network, server, application, containers, logs, cloud)
 
@@ -40,13 +53,15 @@ Setting up Datadog typically takes 2-3 weeks to reach production readiness. Whil
 The true cost at scale starts at \$15 per host per month for Pro (\$23 for Enterprise), but that's just the beginning. According to [Datadog's 2025 pricing](/blog/datadog-pricing/), you get 100 custom metrics per host included, then pay \$1 per 100 additional custom metrics. The high-watermark billing system means you're charged based on your peak usage (99th percentile), not average usage. Organizations with 100 hosts commonly pay \$50,000+ monthly when factoring in custom metrics, logs, and APM charges.
 
 **Strengths**:
+
 - Unified platform eliminates tool sprawl
-- Excellent Kubernetes and cloud-native support  
+- Excellent Kubernetes and cloud-native support
 - Strong APM with distributed tracing
 - 900+ integrations out of the box
 - Intuitive UI that non-technical stakeholders can use
 
 **Weaknesses**:
+
 - Complex pricing with surprise bills (high-watermark billing catches many off guard)
 - Tag explosion can increase costs by 10x overnight
 - Vendor lock-in concerns are real, migration is painful
@@ -58,7 +73,12 @@ The true cost at scale starts at \$15 per host per month for Pro (\$23 for Enter
 **Avoid If**: Budget predictability is crucial or you're cost-conscious at scale
 
 ### New Relic
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-new-relic.png" alt="New Relic Infrastructure Monitoring Dashboard" caption="New Relic Infrastructure Monitoring Dashboard (Credits: New Relic)" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-new-relic.png"
+  alt="New Relic Infrastructure Monitoring Dashboard"
+  caption="New Relic Infrastructure Monitoring Dashboard (Credits: New Relic)"
+/>
 
 **Infrastructure Coverage**: Full-stack with strong APM focus, expanding infrastructure capabilities
 
@@ -66,6 +86,7 @@ The true cost at scale starts at \$15 per host per month for Pro (\$23 for Enter
 New Relic uses a dual pricing model: data ingestion at \$0.40/GB (after 100GB free) plus seat-based pricing (\$49 for Core users, Full Platform users vary by edition - Standard at \$99, Pro at \$349). This combination can make costs less predictable than pure consumption models. Setup complexity is similar to Datadog, taking 2-3 weeks for production deployment. The platform excels at application monitoring but infrastructure features feel secondary.
 
 **Strengths**:
+
 - Superior APM capabilities with code-level insights
 - More predictable pricing model than competitors
 - AI-powered insights (AIOps) actually useful
@@ -73,6 +94,7 @@ New Relic uses a dual pricing model: data ingestion at \$0.40/GB (after 100GB fr
 - Excellent for microservices architectures
 
 **Weaknesses**:
+
 - [Infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/) less mature than APM
 - Limited on-premise deployment options
 - Dual pricing model (data + seats) can complicate cost planning
@@ -84,7 +106,12 @@ New Relic uses a dual pricing model: data ingestion at \$0.40/GB (after 100GB fr
 **Avoid If**: Primary focus is network/infrastructure rather than applications
 
 ### Prometheus + Grafana Stack
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-prometheus-grafana.png" alt="Prometheus and Grafana Monitoring Stack" caption="Prometheus and Grafana Monitoring Stack (Credits: Grafana)" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-prometheus-grafana.png"
+  alt="Prometheus and Grafana Monitoring Stack"
+  caption="Prometheus and Grafana Monitoring Stack (Credits: Grafana)"
+/>
 
 **Infrastructure Coverage**: Flexible (depends on exporters - typically server, containers, custom metrics)
 
@@ -92,11 +119,13 @@ New Relic uses a dual pricing model: data ingestion at \$0.40/GB (after 100GB fr
 The "free" in free and open source is misleading. While the software costs nothing, expect 4-6 weeks for production readiness based on teams deploying the kube-prometheus-stack. You'll need expertise in PromQL, understanding of time-series databases, and knowledge of Kubernetes. For those wanting managed services, Grafana Cloud uses usage-based pricing (not per-user) and includes the full LGTM stack (Loki, Grafana, Tempo, Mimir).
 
 **Deployment Options**:
+
 - **Self-hosted**: Completely free but requires significant expertise and operational costs.
 - **Grafana Cloud**: Managed [LGTM stack](https://signoz.io/docs/migration/migrate-from-grafana-to-signoz/) with usage-based pricing
 - **Kube-prometheus-stack**: Pre-configured Helm chart reduces setup time
 
 **Strengths**:
+
 - Industry standard for Kubernetes monitoring
 - Completely free for self-hosted deployments
 - Highly customizable and extensible
@@ -106,6 +135,7 @@ The "free" in free and open source is misleading. While the software costs nothi
 - Grafana provides best-in-class visualization for any data source
 
 **Weaknesses**:
+
 - Steep learning curve (PromQL is powerful but complex)
 - Storage and cardinality challenges at scale
 - No built-in long-term storage (need Thanos or Cortex)
@@ -116,9 +146,13 @@ The "free" in free and open source is misleading. While the software costs nothi
 
 **Avoid If**: Limited DevOps expertise or need turnkey solution without managed services
 
-
 ### Dynatrace
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-dynatrace.png" alt="Dynatrace Infrastructure Monitoring Platform" caption="Dynatrace Infrastructure Monitoring Platform (Credits: Dynatrace)" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-dynatrace.png"
+  alt="Dynatrace Infrastructure Monitoring Platform"
+  caption="Dynatrace Infrastructure Monitoring Platform (Credits: Dynatrace)"
+/>
 
 **Infrastructure Coverage**: Full-stack with AI-driven insights across all layers
 
@@ -126,6 +160,7 @@ The "free" in free and open source is misleading. While the software costs nothi
 Dynatrace's OneAgent provides the easiest deployment experience, with automatic discovery and dependency mapping working out of the box. Most teams are operational within 1-2 weeks. Pricing in 2025 is \$0.04/hour for infrastructure monitoring only (any size host, approximately \$29/month), while full-stack monitoring costs \$0.08/hour (approximately \$58/month for an 8GB host). The AI capabilities (Davis AI) genuinely reduce alert noise and provide useful root cause analysis.
 
 **Strengths**:
+
 - Best-in-class AI/ML capabilities for anomaly detection
 - Automatic discovery eliminates manual configuration
 - Code-level visibility without code changes
@@ -133,6 +168,7 @@ Dynatrace's OneAgent provides the easiest deployment experience, with automatic
 - Minimal ongoing maintenance required
 
 **Weaknesses**:
+
 - Expensive at scale (100 hosts = ~\$35k/year for infrastructure monitoring, ~\$70k for full-stack)
 - Can be overwhelming with feature complexity
 - Less flexibility than open-source alternatives
@@ -142,9 +178,13 @@ Dynatrace's OneAgent provides the easiest deployment experience, with automatic
 
 **Avoid If**: Small teams, tight budgets, or simple infrastructure
 
-
 ### Zabbix
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-zabbix.png" alt="Zabbix Network Monitoring Interface" caption="Zabbix Network Monitoring Interface (Credits: Zabbix)" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-zabbix.png"
+  alt="Zabbix Network Monitoring Interface"
+  caption="Zabbix Network Monitoring Interface (Credits: Zabbix)"
+/>
 
 **Infrastructure Coverage**: Network, server, cloud, applications (with templates)
 
@@ -152,6 +192,7 @@ Dynatrace's OneAgent provides the easiest deployment experience, with automatic
 Zabbix requires serious commitment. Plan for 6-8 weeks before your team is proficient. The configuration is extensive, requiring understanding of templates, triggers, and the Zabbix proxy architecture. While completely free, the time investment is substantial. We've seen teams spend months perfecting their Zabbix setup.
 
 **Strengths**:
+
 - Completely free and open source
 - Scales to 100,000+ monitored devices
 - Extremely flexible and customizable
@@ -160,6 +201,7 @@ Zabbix requires serious commitment. Plan for 6-8 weeks before your team is profi
 - Predictable resource usage
 
 **Weaknesses**:
+
 - User interface feels dated (though improving)
 - Complex configuration with steep learning curve
 - Limited modern cloud integrations
@@ -170,11 +212,13 @@ Zabbix requires serious commitment. Plan for 6-8 weeks before your team is profi
 
 **Avoid If**: Need modern UI, quick deployment, or lack dedicated monitoring staff
 
-
-
 ### Nagios
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-nagios.png" alt="Nagios Core Monitoring Interface" caption="Nagios Core Monitoring Interface (Credits: Nagios)" />
 
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-nagios.png"
+  alt="Nagios Core Monitoring Interface"
+  caption="Nagios Core Monitoring Interface (Credits: Nagios)"
+/>
 
 **Infrastructure Coverage**: Network and server monitoring (traditional infrastructure)
 
@@ -182,6 +226,7 @@ Zabbix requires serious commitment. Plan for 6-8 weeks before your team is profi
 Nagios is monitoring's equivalent of COBOL, still running critical infrastructure but showing its age. Expect 8-12 weeks before your team is productive. Configuration is entirely through text files, the UI hasn't meaningfully changed since 2009, and scaling for dynamic environments is painful. Yet it's rock-solid reliable.
 
 **Strengths**:
+
 - Battle-tested with 20+ years of development
 - Massive plugin ecosystem (thousands available)
 - Complete control over every aspect
@@ -189,6 +234,7 @@ Nagios is monitoring's equivalent of COBOL, still running critical infrastructur
 - Extremely stable and predictable
 
 **Weaknesses**:
+
 - Interface is painfully dated
 - Configuration via text files only
 - Lacks modern features (no distributed tracing, poor container support)
@@ -199,9 +245,13 @@ Nagios is monitoring's equivalent of COBOL, still running critical infrastructur
 
 **Avoid If**: Cloud-native infrastructure, containerized environments, or modern DevOps practices
 
-
 ### SigNoz
-<Figure src="/images/comparisons/09/best-infrastructure-monitoring-tools-signoz.png" alt="SigNoz Open Source Observability Platform" caption="SigNoz Open Source Observability Platform" />
+
+<Figure
+  src="/images/comparisons/09/best-infrastructure-monitoring-tools-signoz.png"
+  alt="SigNoz Open Source Observability Platform"
+  caption="SigNoz Open Source Observability Platform"
+/>
 
 **Infrastructure Coverage**: Full-stack observability with APM, metrics, logs, and traces
 
@@ -209,6 +259,7 @@ Nagios is monitoring's equivalent of COBOL, still running critical infrastructur
 SigNoz offers an open-source alternative to commercial monitoring platforms, built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) standards. Setup typically takes 2-3 weeks, comparable to other modern platforms. The ClickHouse backend provides efficient query performance at scale. Both cloud and self-hosted deployment options are available.
 
 **Strengths**:
+
 - Open-source with commercial support options available
 - Built on OpenTelemetry standards
 - Single platform for metrics, traces, and logs
@@ -217,6 +268,7 @@ SigNoz offers an open-source alternative to commercial monitoring platforms, bui
 - Infrastructure monitoring with host metrics, Kubernetes support, and cloud integrations
 
 **Weaknesses**:
+
 - Smaller community compared to Prometheus/Grafana
 - Fewer third-party integrations than Datadog (but growing)
 - Documentation improving but not as extensive as mature tools
@@ -236,34 +288,40 @@ Those who have the expertise to manage SigNoz themselves or just want to start w
 ## Secondary Tools Worth Considering
 
 ### PRTG Network Monitor
+
 **Best For**: Windows-centric environments and SMBs  
 **Reality Check**: Excellent user experience with sensor-based licensing (average 5-10 sensors per device). Pricing ranges from free (100 sensors) to $17,899 (10,000 sensors). Great for SMBs monitoring \<500 devices. Setup is refreshingly simple compared to open-source alternatives, with most teams operational within days.
 
 ### SolarWinds
+
 **Best For**: Enterprise network monitoring  
 **Reality Check**: Comprehensive network monitoring capabilities but recent security breaches have damaged trust. Expensive and complex. Consider alternatives unless you specifically need their network performance monitoring strengths.
 
 ### AppDynamics
+
 **Best For**: Deep application performance monitoring  
 **Reality Check**: Acquired by Cisco, strong APM capabilities similar to New Relic. Complex pricing model and steep learning curve. Best suited for Java/.NET enterprise applications. Integration with Cisco ecosystem is a plus for existing Cisco customers.
 
 ### Splunk
+
 **Best For**: Log analysis and security operations  
 **Reality Check**: The gold standard for log analysis but eye-wateringly expensive at scale. Costs can exceed \$100k/year for modest deployments. Excellent for security operations and compliance-heavy industries. Consider only if logs are your primary concern.
 
 ### Site24x7
+
 **Best For**: All-in-one SaaS monitoring for SMBs  
 **Reality Check**: Good value for small businesses needing basic monitoring across websites, servers, and applications. Starts at \$9/month for basic monitoring, scales to \$35/month for infrastructure monitoring. Limited depth compared to specialized tools but covers the basics well for smaller teams.
 
 ### Checkmk
+
 **Best For**: Modern alternative to Nagios  
 **Reality Check**: Builds on Nagios core but adds modern UI and easier configuration. Raw edition is free, enterprise edition provides support. Good migration path from Nagios. German engineering shows in reliability and efficiency.
 
 ### Elastic Stack (ELK)
+
 **Best For**: Log management and analysis  
 **Reality Check**: Powerful but complex. Requires significant expertise to run at scale. Resource-hungry, especially Elasticsearch. Free to start but operational costs add up quickly. Elastic Cloud reduces complexity but isn't cheap.
 
-
 ## Making Your Final Decision
 
 **Start with your constraints**, not features. Budget, team expertise, and existing tool investments will eliminate 80% of options immediately. A perfect tool you can't afford or operate is worse than a basic tool that works.
@@ -276,7 +334,6 @@ Those who have the expertise to manage SigNoz themselves or just want to start w
 
 The best monitoring tool is the one your team will actually use. Complex platforms with amazing capabilities sit unused while simple tools that solve real problems get adopted immediately. Start with your most painful monitoring gap, solve it well, then expand coverage incrementally.
 
-
 Hope we answered all your questions regarding infrastructure monitoring tools. If you have more questions, feel free to use the SigNoz AI chatbot, or join our [slack community](https://signoz.io/slack/).
 
-You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
\ No newline at end of file
+You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
diff --git a/data/comparisons/jaeger-alternatives.mdx b/data/comparisons/jaeger-alternatives.mdx
index c9e7a01cf..73fcac389 100644
--- a/data/comparisons/jaeger-alternatives.mdx
+++ b/data/comparisons/jaeger-alternatives.mdx
@@ -1,25 +1,25 @@
 ---
 title: Top 6 Jaeger Alternatives in 2025 [Open-Source Included]
-slug: jaeger-alternatives
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Looking for distributed tracing solutions? Here are top 6 Jaeger alternatives - 1.SigNoz(open-source) 2.Honeycomb 3.Tempo by Grafana 4.Datadog...
 image: /img/blog/2024/02/jaeger-alternatives-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [Jaeger,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [Jaeger, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Jaeger is an open-source distributed tracing backend that has been on the market for a while. It was developed by Uber Technologies in 2015 and contributed to the Cloud Native Computing Foundation (CNCF). It is designed to monitor and troubleshoot complex distributed systems by providing insights into the flow of requests and responses across microservice architectures.
-
 
+Jaeger is an open-source distributed tracing backend that has been on the market for a while. It was developed by Uber Technologies in 2015 and contributed to the Cloud Native Computing Foundation (CNCF). It is designed to monitor and troubleshoot complex distributed systems by providing insights into the flow of requests and responses across microservice architectures.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-cover.webp" alt="Jaeger Alternatives cover image"/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-cover.webp"
+    alt="Jaeger Alternatives cover image"
+  />
 </figure>
 
-
 Distributed tracing is critical for cloud-native microservices-based applications. Before we look into Jaeger alternatives, let’s have a brief overview of distributed tracing.
 
 ## What is Distributed Tracing?
@@ -34,9 +34,9 @@ Distributed tracing is useful in identifying bottlenecks, latency issues, and er
 
 Jaeger is a powerful tool for distributed tracing, but it has its downsides, which may necessitate considering an alternative tool. Jaeger’s UI is limited, and you might need more capabilities for analyzing your trace data.
 
-Another notable limitation is its narrow focus on distributed tracing. In today's complex software ecosystems, troubleshooting and resolving issues require more than just tracing requests across microservices. 
+Another notable limitation is its narrow focus on distributed tracing. In today's complex software ecosystems, troubleshooting and resolving issues require more than just tracing requests across microservices.
 
-You need access to rich metrics that offer insights into system performance, resource utilization, and application behavior. Jaeger lacks observability features such as metrics collection, logging, and profiling. This means you may need to use additional tools alongside Jaeger to gather comprehensive observability data. Using multiple tools for monitoring is not easy and often requires more engineering bandwidth. 
+You need access to rich metrics that offer insights into system performance, resource utilization, and application behavior. Jaeger lacks observability features such as metrics collection, logging, and profiling. This means you may need to use additional tools alongside Jaeger to gather comprehensive observability data. Using multiple tools for monitoring is not easy and often requires more engineering bandwidth.
 
 Another limitation worth considering is the maintenance required for the databases supported by Jaeger. Currently, Jaeger supports Cassandra and Elasticsearch as its backends, but these databases require ongoing maintenance and may not scale as easily as other options. This can be a concern for teams that are looking for a more scalable and easier-to-maintain solution for their distributed tracing needs.
 
@@ -51,30 +51,39 @@ Here are the top 6 Jaeger alternatives to consider adopting in 2024:
 - [New Relic](#new-relic)
 - [Aspecto](#aspecto)
 
-
 ## SigNoz
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/signoz_flamegraphs.webp" alt="Traces represented as Flamegraphs and Gantt charts in SigNoz dashbaord"/>
-    <figcaption><i>Traces represented as Flamegraphs and Gantt charts in SigNoz dashbaord</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/common/signoz_flamegraphs.webp"
+    alt="Traces represented as Flamegraphs and Gantt charts in SigNoz dashbaord"
+  />
+  <figcaption>
+    <i>Traces represented as Flamegraphs and Gantt charts in SigNoz dashbaord</i>
+  </figcaption>
 </figure>
 
-
 [SigNoz](https://signoz.io/) is a robust alternative to Jaeger, offering a full-stack, open-source solution that provides a unified view of logs, metrics, and traces. By consolidating these signals into a single pane of glass, SigNoz enables engineering teams to gain deeper insights into application performance and troubleshoot issues more effectively.
 
 SigNoz also provides advanced features for tracing data. You can run aggregates on trace data and filter it across your application-specific attributes to troubleshoot performance issues.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/traces_custom_aggregates.webp" alt="Run aggregates on trace data"/>
-    <figcaption><i>Run aggregates on trace data</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/common/traces_custom_aggregates.webp"
+    alt="Run aggregates on trace data"
+  />
+  <figcaption>
+    <i>Run aggregates on trace data</i>
+  </figcaption>
 </figure>
 
-
 SigNoz is built to support OpenTelemetry natively. OpenTelemetry is <a href = "https://www.cncf.io/projects/opentelemetry" rel="noopener noreferrer nofollow" target="_blank" >backed</a> by Cloud Native Computing Foundation and is the second most active project after Kubernetes in the CNCF landscape. OpenTelemetry is the future of cloud-native [application instrumentation](https://signoz.io/docs/instrumentation/). Jaeger also shifted from Jaeger clients to OpenTelemetry SDKs for generating trace data.
 
 ### Key features
 
-Apart from distributed tracing, SigNoz also provides: 
+Apart from distributed tracing, SigNoz also provides:
 
 - APM: Monitor application metrics like p99 latency, error rates for your services, external API calls, and individual endpoints.
 - Metrics and Dashboards: Monitor any metrics important to you and create dashboards around any use case like external calls, API endpoints, JVM metrics.
@@ -85,13 +94,22 @@ Apart from distributed tracing, SigNoz also provides:
 
 ## Honeycomb
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-honeycomb.webp" alt="Honeycomb observability dashboard"/>
-    <figcaption><i>Honeycomb observability dashboard (Source: Honeycomb’s website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-honeycomb.webp"
+    alt="Honeycomb observability dashboard"
+  />
+  <figcaption>
+    <i>Honeycomb observability dashboard (Source: Honeycomb’s website)</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.honeycomb.io" rel="noopener noreferrer nofollow" target="_blank" >Honeycomb</a> is a full-stack, cloud-based observability tool that provides users with real-time insights into their complex systems and supports events, logs, and traces.
+<a href="https://www.honeycomb.io" rel="noopener noreferrer nofollow" target="_blank">
+  Honeycomb
+</a>
+ is a full-stack, cloud-based observability tool that provides users with real-time insights into
+their complex systems and supports events, logs, and traces.
 
 Honeycomb's tracing feature connects events to show the sequence of operations within a system clearly. It can also simulate user activity within the system, allowing it to detect patterns, correlations, or anomalies that may not be evident when analyzing individual events separately.
 
@@ -106,13 +124,26 @@ Honeycomb can also identify traces associated with poor user experiences in syst
 
 ## Tempo by Grafana (open-source)
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-tempo.webp" alt="Tracing dashboard"/>
-    <figcaption><i>Tracing dashboard (Source: Grafana Tempo docs)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-tempo.webp"
+    alt="Tracing dashboard"
+  />
+  <figcaption>
+    <i>Tracing dashboard (Source: Grafana Tempo docs)</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://grafana.com/oss/tempo" rel="noopener noreferrer nofollow" target="_blank" >Grafana Tempo</a> is an open-source distributed tracing backend specifically designed for storing and retrieving trace data efficiently. Its high scalability allows it to handle large volumes, reducing operational complexities and costs. This is attributed to its object storage backend, which enables long-term trace storage and positions it as a good alternative to Jaeger. Tempo utilizes TraceQL, a custom query language designed specifically for analyzing traces. With TraceQL, specific spans can be easily selected for analysis.
+<a href="https://grafana.com/oss/tempo" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana Tempo
+</a>
+is an open-source distributed tracing backend specifically designed for storing and retrieving trace
+data efficiently. Its high scalability allows it to handle large volumes, reducing operational
+complexities and costs. This is attributed to its object storage backend, which enables long-term
+trace storage and positions it as a good alternative to Jaeger. Tempo utilizes TraceQL, a custom
+query language designed specifically for analyzing traces. With TraceQL, specific spans can be
+easily selected for analysis.
 
 In addition, Tempo integrates seamlessly with Grafana, Mimir, Prometheus, and Loki, providing comprehensive observability and monitoring capabilities.
 
@@ -122,13 +153,24 @@ In addition, Tempo integrates seamlessly with Grafana, Mimir, Prometheus, and Lo
 
 ## Datadog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-datadog.webp" alt="Distributed tracing flame graphs"/>
-    <figcaption><i>Distributed tracing flame graphs (Source: Datadog)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-datadog.webp"
+    alt="Distributed tracing flame graphs"
+  />
+  <figcaption>
+    <i>Distributed tracing flame graphs (Source: Datadog)</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.datadog.com" rel="noopener noreferrer nofollow" target="_blank" >Datadog</a> is a leading observability platform that provides comprehensive monitoring and analytics solutions for modern cloud-scale applications. It allows you to pinpoint issues by seamlessly correlating traces with a variety of data sources, such as logs, infrastructure metrics, database queries, network calls, and frontend telemetry, all in one unified view.
+<a href="https://www.datadog.com" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+is a leading observability platform that provides comprehensive monitoring and analytics solutions
+for modern cloud-scale applications. It allows you to pinpoint issues by seamlessly correlating
+traces with a variety of data sources, such as logs, infrastructure metrics, database queries,
+network calls, and frontend telemetry, all in one unified view.
 
 Datadog's distributed tracing tool is particularly powerful, enabling real-time searches and analyses of traces that are error-prone, have high latency, or are valuable. It also includes a feature for creating tag-based retention filters, which help manage traces by retaining only the most important ones based on tail-based criteria.
 
@@ -142,12 +184,17 @@ Datadog's distributed tracing tool is particularly powerful, enabling real-time
 
 ## New Relic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-new-relic.webp" alt="Distributed tracing"/>
-    <figcaption><i>Distributed tracing</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-new-relic.webp"
+    alt="Distributed tracing"
+  />
+  <figcaption>
+    <i>Distributed tracing</i>
+  </figcaption>
 </figure>
 
-
 New Relic is an all-in-one platform designed to help you monitor your applications and services in real-time. It focuses on four key types of data: metrics, events, logs, and traces, which are referred to as "MELT.” With New Relic, you can track requests across your distributed system using its distributed tracing feature. It offers a user-friendly interface dedicated to understanding and analyzing your traces.
 
 New Relic also offers support for trace sampling, a feature designed to reduce the volume of spans generated. This capability is valuable for the reduction of data storage and ingestion costs, as well as for focusing on relevant traces while filtering out unnecessary noise.
@@ -163,14 +210,26 @@ New Relic also offers support for trace sampling, a feature designed to reduce t
 
 ## Aspecto
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/jaeger-alternatives-aspecto.webp" alt="Trace analysis"/>
-    <figcaption><i>Trace analysis (Source: Aspecto website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/jaeger-alternatives-aspecto.webp"
+    alt="Trace analysis"
+  />
+  <figcaption>
+    <i>Trace analysis (Source: Aspecto website)</i>
+  </figcaption>
 </figure>
 
-
-
-<a href = "https://www.aspecto.io" rel="noopener noreferrer nofollow" target="_blank" >Aspecto</a> is an observability platform powered by OpenTelemetry that simplifies the process of troubleshooting and debugging distributed applications. It stands out as a flexible and feature-rich alternative to Jaeger, offering a unified interface that requires no code changes, making it easy for developers to visualize and troubleshoot transactions within their distributed services.  With its secondary dimension grouping functionality, Aspecto allows you to delve deeper into your tracing data, facilitating the identification of key system issues.
+<a href="https://www.aspecto.io" rel="noopener noreferrer nofollow" target="_blank">
+  Aspecto
+</a>
+is an observability platform powered by OpenTelemetry that simplifies the process of troubleshooting
+and debugging distributed applications. It stands out as a flexible and feature-rich alternative to
+Jaeger, offering a unified interface that requires no code changes, making it easy for developers to
+visualize and troubleshoot transactions within their distributed services. With its secondary
+dimension grouping functionality, Aspecto allows you to delve deeper into your tracing data,
+facilitating the identification of key system issues.
 
 Aspecto has a built-in sampling feature that efficiently reduces telemetry costs at scale, while its comprehensive logs and traces visualization ensures complete system visibility and streamlined troubleshooting.
 
@@ -203,4 +262,4 @@ In this case, SigNoz stands out as a robust option. It is open-source with a Saa
 
 [Distributed Tracing with OpenTelemetry - Part II](https://signoz.io/blog/opentelemetry-distributed-tracing-part-2/)
 
-[Top 13 Distributed Tracing Tools](https://signoz.io/blog/distributed-tracing-tools/)
\ No newline at end of file
+[Top 13 Distributed Tracing Tools](https://signoz.io/blog/distributed-tracing-tools/)
diff --git a/data/comparisons/kibana-alternatives.mdx b/data/comparisons/kibana-alternatives.mdx
index c16e346b1..0b0edd3fd 100644
--- a/data/comparisons/kibana-alternatives.mdx
+++ b/data/comparisons/kibana-alternatives.mdx
@@ -1,40 +1,40 @@
 ---
 title: Latest Top 9 Kibana Alternatives [2025 Comprehensive Guide]
-slug: kibana-alternatives
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [gargi]
 description: Here are top 9 Kibana alternatives that you can use for data visualization - 1.SigNoz(open-source) 2.Grafana 3.Datadog 4.Knowi 5.Dynatrace...
 image: /img/blog/2024/03/kibana-alternatives-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [kibana-alternatives,kibana,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [kibana-alternatives, kibana, opentelemetry, open-source, monitoring-tools, signoz]
 ---
+
 Kibana is one of the most popular data visualization platforms with its built-in anomaly detection, custom visualization options, or relational analysis. An integral part of the ELK stack, it helps you query and present your data on dashboards in the form of graphs and charts.
 
 But one of the major drawbacks of Kibana is that it can only work with Elasticsearch as the data source. As a result, scaling Kibana independently can be a challenge for organizations. Additionally, its poor support for metrics might lead users to seek alternative solutions.
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 That’s why I’ve rounded up the top [Kibana alternatives](https://signoz.io/comparisons/kibana-alternatives/#5-dynatrace) you can use to identify issues, derive insights, and increase data observability. This list includes open-source solutions, SaaS offerings as well as self-hosted platforms.
 
 ## The Top Kibana Alternatives
 
 ### 1. SigNoz
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/signoz_list_of_traces_hc.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img className="box-shadowed-image" src="/img/blog/common/signoz_list_of_traces_hc.webp" alt="" />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
-
 Source: [SigNoz](https://signoz.io/docs/userguide/manage-dashboards/)
 
 [SigNoz](https://signoz.io/) is a popular full-stack open-source APM tool with powerful features like root cause analysis, live tailing, anomaly detection, detailed trace filtering, and scalable stream processing architecture. Built natively to support OpenTelemetry, SigNoz lets you visualize all three types of signals. Not to mention, it can ingest, process and analyze data at any scale.
@@ -45,131 +45,167 @@ You can also build customized dashboards visualizing data from a number of data
 
 Additionally, you can take advantage of SigNoz’s service maps to see all the components of an app. Installation is straightforward with just three steps. Even, [OpenTelemetry visualization](https://signoz.io/blog/opentelemetry-visualization/) becomes effortless with auto-instrumentation for languages like Java, Python, Ruby, Rust, and others.
 
-**Pros:** 
+**Pros:**
 
 1. Superfast log analytics with columnar ClickHouse-based storage.
 2. Out-of-the-box flamegraphs and Gantt charts to identify the exact issue.
 3. Great value for money with feature-rich custom dashboards and a responsive team.
-4. Extremely user-friendly with thorough documentation, clean UI, and easy installation. 
+4. Extremely user-friendly with thorough documentation, clean UI, and easy installation.
 
-**Cons:** 
+**Cons:**
 
 1. Live support might be unavailable, but it's made up by its 4000-member active Slack community.
 2. More visualization options needed, however, they’re constantly updating.
 
 ### 2. Grafana
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-grafana.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-grafana.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://grafana.com/grafana" rel="noopener noreferrer nofollow" target="_blank" >Grafana</a>
 
-<a href = "https://grafana.com" rel="noopener noreferrer nofollow" target="_blank" >Grafana</a> is an open-source observability platform with powerful data visualization, analytics, and monitoring capabilities. It lets you query time-series database data, visualize it in charts, graphs, tables, heatmaps, draw insights, create and share dashboards, track metrics and send alerts.
+<a href="https://grafana.com" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a>
+is an open-source observability platform with powerful data visualization, analytics, and monitoring
+capabilities. It lets you query time-series database data, visualize it in charts, graphs, tables,
+heatmaps, draw insights, create and share dashboards, track metrics and send alerts.
 
-Grafana has a pluggable data source model and comes with support for popular time series databases like Graphite or Prometheus, and for cloud monitoring services like Amazon or Azure. You can take data from wherever and unify it in a ‘single-pane-of-glass’ view. 
+Grafana has a pluggable data source model and comes with support for popular time series databases like Graphite or Prometheus, and for cloud monitoring services like Amazon or Azure. You can take data from wherever and unify it in a ‘single-pane-of-glass’ view.
 
 You’ll find configuration tools, adequate documentation, and a query editor for each data source Grafana supports. Moreover, this Kibana alternative has advanced querying and transformation capabilities coupled with panel customization for proper visualization of data. While it has a forever free plan, it also offers a premium suite of tools within its Enterprise plan.
 
-**Pros:** 
+**Pros:**
 
 1. Support for 30+ data sources with no need for ingesting data to a backend store.
 2. Advanced metrics support with a wide-range of plugins and community support.
 3. Pre-defined templates and vast customization opportunities for fast searches.
 
-**Cons:** 
+**Cons:**
 
 1. The initial installation process can be a steep learning curve for production environments.
-2. Sometimes too slow to load, especially when your templating variable values haven’t loaded. 
-3. Making reports with Grafana isn’t straightforward. 
+2. Sometimes too slow to load, especially when your templating variable values haven’t loaded.
+3. Making reports with Grafana isn’t straightforward.
 
 ### 3. Datadog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-datadog.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-datadog.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.datadoghq.com/product/platform/dashboards/#visualizations" rel="noopener noreferrer nofollow" target="_blank" >Datadog</a>
 
-<a href = "https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank" >Datadog</a> is a cloud-based Kibana alternative that’s known for unifying metrics, logs, and events from 450+ technologies. Besides enabling full-stack visibility, Datadog offers template and auto-generated dashboards which require no coding. 
+<a href="https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+is a cloud-based Kibana alternative that’s known for unifying metrics, logs, and events from 450+
+technologies. Besides enabling full-stack visibility, Datadog offers template and auto-generated
+dashboards which require no coding.
 
-Earlier, it had two types of dashboards: screenboards which gave you pixel-level control, and timeboards to help you troubleshoot at a particular moment. 
+Earlier, it had two types of dashboards: screenboards which gave you pixel-level control, and timeboards to help you troubleshoot at a particular moment.
 
-Now, Datadog’s interactive out-of-the-box dashboards have a seamless editing experience with shortcuts, a responsive grid layout, and bulk action support on widget groups. So, now you can visualize and correlate system-wide telemetry data on any screen, and add complexity. 
+Now, Datadog’s interactive out-of-the-box dashboards have a seamless editing experience with shortcuts, a responsive grid layout, and bulk action support on widget groups. So, now you can visualize and correlate system-wide telemetry data on any screen, and add complexity.
 
 In fact, you can create custom dashboards with the API, build new views, use formulas and functions to best represent your data. Use Datadog’s geomap graphs, heatmaps, stacked graphs, or toplists to graph any data or compare metrics over months, and share with teammates and relevant stakeholders for easier overview.
 
-**Pros:** 
+**Pros:**
 
-1. The interactive dashboards are easy to customize and can be autogenerated with API. 
+1. The interactive dashboards are easy to customize and can be autogenerated with API.
 2. Seamless integration with strong support for various tools and services.
 3. Responsive customer support to navigate issues with a big picture view.
 
-**Cons:** 
+**Cons:**
 
-1. Set up and configuration can be a steep learning curve, especially for beginners. 
-2. Datadog’s plans can be costly, especially if you have a high volume of data. 
-3. It doesn’t support advanced mathematical or graphing operations. 
+1. Set up and configuration can be a steep learning curve, especially for beginners.
+2. Datadog’s plans can be costly, especially if you have a high volume of data.
+3. It doesn’t support advanced mathematical or graphing operations.
 
 ### 4. Knowi
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-knowi.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-knowi.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.knowi.com/docs/visualizations.html" rel="noopener noreferrer nofollow" target="_blank" >Knowi</a>
 
 With 40+ visualization options, <a href = "https://www.knowi.com" rel="noopener noreferrer nofollow" target="_blank" >Knowi</a> is a business intelligence tool for data visualization, analytics, and reporting. An ideal Kibana alternative, it supports native integration to virtually any data source.
 
 You can also enjoy seamless third-party data source integration with Apache Cassandra, BigQuery, MongoDB, MySQL, PostgreSQL, Oracle, Couchbase, and many others. Moreover, in doing so, it eliminates the need for data transformation processes or custom coding or ETL and accelerates ElasticSearch analytics projects.
 
-You can create blended data sources from NoSQL data stores, or relational and Cloud APIs sources, and visualize the outcomes instantly. Not only that, you can create dynamic and embeddable analytics with NLP or ML to meet data visualization needs for businesses of any size. 
+You can create blended data sources from NoSQL data stores, or relational and Cloud APIs sources, and visualize the outcomes instantly. Not only that, you can create dynamic and embeddable analytics with NLP or ML to meet data visualization needs for businesses of any size.
 
 Creating queries with its drag-and-drop query generator is straightforward. Best for both on-premise or cloud-hosted needs, Knowi allows developers to monitor market trends or generate visualizations of query results or test use cases in a unified platform.
 
-**Pros:** 
+**Pros:**
 
 1. Works with unstructured data and makes managing datasets easy.
-2. Availability of a good selection of visualizations like data grid, geo, or image heatmaps, etc. 
-3. Extremely responsive support, adept in covering documentation gaps. 
+2. Availability of a good selection of visualizations like data grid, geo, or image heatmaps, etc.
+3. Extremely responsive support, adept in covering documentation gaps.
 
-**Cons:** 
+**Cons:**
 
-1. Documentation isn’t the most thorough. 
+1. Documentation isn’t the most thorough.
 2. Certain UX flows are confusing, like the Dashboard > Widget delete.
-3. Lack of widget filtering options or to save favorites. 
+3. Lack of widget filtering options or to save favorites.
 
 ### 5. Dynatrace
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-dynatrace.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-dynatrace.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://docs.dynatrace.com/docs/observe-and-explore/dashboards-new" rel="noopener noreferrer nofollow" target="_blank" >Dynatrace</a>
 
-<a href = "https://www.dynatrace.com" rel="noopener noreferrer nofollow" target="_blank" >Dynatrace</a> is an all-in-one AI-powered data monitoring platform that uses advanced ML techniques and algorithms to detect and analyze performance issues. While most developers use Dynatrace for its performance monitoring capabilities of microservices, containers, and serverless applications, its data visualization and reporting features are compelling!
+<a href="https://www.dynatrace.com" rel="noopener noreferrer nofollow" target="_blank">
+  Dynatrace
+</a>
+is an all-in-one AI-powered data monitoring platform that uses advanced ML techniques and algorithms
+to detect and analyze performance issues. While most developers use Dynatrace for its performance
+monitoring capabilities of microservices, containers, and serverless applications, its data
+visualization and reporting features are compelling!
 
-You can create customized dashboards, visualize complex data sets in real-time using charts, graphs, heatmaps. In fact, you can also generate detailed reports by customizing report templates, or opting for automated report generation. 
+You can create customized dashboards, visualize complex data sets in real-time using charts, graphs, heatmaps. In fact, you can also generate detailed reports by customizing report templates, or opting for automated report generation.
 
-You can add variables to filter tiles and make your dashboards more dynamic, and set up baselining in dashboards to identify anomalies faster. Or, annotate your visualizations with markdown-formatted text. 
+You can add variables to filter tiles and make your dashboards more dynamic, and set up baselining in dashboards to identify anomalies faster. Or, annotate your visualizations with markdown-formatted text.
 
-As a Kibana alternative, it allows you to create dashboards faster with predefined data and code snippets. You can also explore custom dashboards in Dynatrace Hub. You can even query and visualize data stored using Dynatrace Query Language (DQL) or write code to fetch external data. Dynatrace allows seamless integration to collaboration tools like Slack or Teams, reporting tools for streamlining incident management processes. 
+As a Kibana alternative, it allows you to create dashboards faster with predefined data and code snippets. You can also explore custom dashboards in Dynatrace Hub. You can even query and visualize data stored using Dynatrace Query Language (DQL) or write code to fetch external data. Dynatrace allows seamless integration to collaboration tools like Slack or Teams, reporting tools for streamlining incident management processes.
 
-**Pros:** 
+**Pros:**
 
 1. Supports easy integration with 650+ supported technologies.
 2. Documentation on the platform is extensive, with responsive support.
 3. Feature-rich dashboards, with smartscape allowing a full picture of the production environment.
 
-**Cons:** 
+**Cons:**
 
 1. High resource utilization and infrastructure dependencies can impact overall performance.
 2. Steep learning curve for beginners when it comes to implementation or customization.
@@ -177,59 +213,75 @@ As a Kibana alternative, it allows you to create dashboards faster with predefin
 
 ### 6. New Relic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-new-relic.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-new-relic.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://newrelic.com/platform/dashboards" rel="noopener noreferrer nofollow" target="_blank" >New Relic</a>
 
-<a href = "https://newrelic.com/platform" rel="noopener noreferrer nofollow" target="_blank" >New Relic</a> is an all-in-one observability platform that allows you to monitor your entire stack. 750+ integrations in this Kibana alternative like Java, MySQL, Node.js can help you tear down team, data, and tool silos. In fact, it offers multiple visualization options. You can query data using dashboards from anywhere in your stack to find precise and in-depth insights.
+<a href="https://newrelic.com/platform" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a>
+is an all-in-one observability platform that allows you to monitor your entire stack. 750+
+integrations in this Kibana alternative like Java, MySQL, Node.js can help you tear down team, data,
+and tool silos. In fact, it offers multiple visualization options. You can query data using
+dashboards from anywhere in your stack to find precise and in-depth insights.
 
-Moreover, consider New Relic to correlate all your telemetry data, use pre-built template options to build dynamic dashboards, and customize your view with filters and queries. 
+Moreover, consider New Relic to correlate all your telemetry data, use pre-built template options to build dynamic dashboards, and customize your view with filters and queries.
 
-When it comes to dashboards, you can create or configure them via NerdGraph API. You can also leverage automation, or create templates using variables. Chat directly in the dashboard UI to make collaboration effective, export them easily for quick shares, and keep everyone in the loop. 
+When it comes to dashboards, you can create or configure them via NerdGraph API. You can also leverage automation, or create templates using variables. Chat directly in the dashboard UI to make collaboration effective, export them easily for quick shares, and keep everyone in the loop.
 
-As everything’s connected, you can borrow a visualization from anywhere else in the platform like Logs or Lookout to your own dashboard. In addition to promising easier workflows, New Relic charts have precise querying messages to help you troubleshoot faster. Not only that, you can duplicate dashboards or widgets easily, 
+As everything’s connected, you can borrow a visualization from anywhere else in the platform like Logs or Lookout to your own dashboard. In addition to promising easier workflows, New Relic charts have precise querying messages to help you troubleshoot faster. Not only that, you can duplicate dashboards or widgets easily,
 
-**Pros:** 
+**Pros:**
 
 1. Querying and visualizing data is lightning fast with the dashboard widget query.
 2. Easy-to-use tools like brush and zoom, chart scrubber makes visualization effective.
 3. Variables functionality makes migrating dashboards from other platforms hassle-free.
 
-**Cons:** 
+**Cons:**
 
 1. Limited visualization options when it comes to Kibana or other Kibana alternatives.
-2. Pricing is expensive, especially for high volume of data. 
+2. Pricing is expensive, especially for high volume of data.
 3. Lack of intuitive UI, detailed documentation, or prompt support.
 
 ### 7. Sematext
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-sematext.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-sematext.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://sematext.com/experience" rel="noopener noreferrer nofollow" target="_blank" >Sematext</a>
 
 With its focus primarily on log management, <a href = "https://sematext.com" rel="noopener noreferrer nofollow" target="_blank" >Sematext</a>, the all-in-one monitoring tool, offers pre-built dashboards for effortless data visualization. It’s easy to use and shows a unified real-time view of logs, events, and metrics to track performance and reduce bottlenecks.
 
-Sematext has a chart-builder you can use to visualize events as time-series charts, heatbars, or tables. Once created, they are added to your dashboard as components and will give you in-depth insights into trends. You can also use optional filters and groupings to configure them further. In fact, you can create as many dashboards as you need for easy correlation and troubleshooting. 
+Sematext has a chart-builder you can use to visualize events as time-series charts, heatbars, or tables. Once created, they are added to your dashboard as components and will give you in-depth insights into trends. You can also use optional filters and groupings to configure them further. In fact, you can create as many dashboards as you need for easy correlation and troubleshooting.
 
-Sematext also offers 100 different integrations, with each having its own set of pre-built dashboards, reports, and alerting mechanisms. Turn on scheduled reports to automatically receive performance updates on key metrics, save time, or share information faster. 
+Sematext also offers 100 different integrations, with each having its own set of pre-built dashboards, reports, and alerting mechanisms. Turn on scheduled reports to automatically receive performance updates on key metrics, save time, or share information faster.
 
-You can also use saved views on dashboards to save your filters and groups for faster access. This Kibana alternative has additional useful features like the split screen to help you correlate and compare two different reports or dashboards. 
+You can also use saved views on dashboards to save your filters and groups for faster access. This Kibana alternative has additional useful features like the split screen to help you correlate and compare two different reports or dashboards.
 
-**Pros:** 
+**Pros:**
 
 1. Affordable pricing, easy-to-use default dashboards, and note-worthy data ingestion.
 2. Super quick and responsive live customer service.
-3. The Web UI is user-friendly, supporting effortless implementation. 
+3. The Web UI is user-friendly, supporting effortless implementation.
 
-**Cons:** 
+**Cons:**
 
 1. Documentation for older agents is missing.
 2. Limited visualization options, in comparison to other Kibana alternatives.
@@ -237,59 +289,80 @@ You can also use saved views on dashboards to save your filters and groups for f
 
 ### 8. Splunk
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-splunk.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-splunk.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.splunk.com/en_us/blog/platform/dashboard-studio-dashboard-customization-made-easy.html" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a>
 
-<a href = "https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a> is an enterprise-class observability and security platform that allows end-to-end view across your entire stack. Whether it’s hybrid, on premise, or the edge, you’ll prevent costly downtime by never missing issues with automated workflows, proactive monitoring, and clear visualization. 
+<a href="https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is an enterprise-class observability and security platform that allows end-to-end view across your
+entire stack. Whether it’s hybrid, on premise, or the edge, you’ll prevent costly downtime by never
+missing issues with automated workflows, proactive monitoring, and clear visualization.
 
-It has a browser-like interface that indexes and correlates real-time data, whether time-series, or categorical. And then visualizes it, sends alerts and reports. Splunk’s visualization options include tables, line charts, Choropleth maps, and single value visualizations. 
+It has a browser-like interface that indexes and correlates real-time data, whether time-series, or categorical. And then visualizes it, sends alerts and reports. Splunk’s visualization options include tables, line charts, Choropleth maps, and single value visualizations.
 
-You can then add these visualizations to dashboards that use JSON source code or simple XML source code. 
+You can then add these visualizations to dashboards that use JSON source code or simple XML source code.
 
-If you would rather not use code to edit dashboards or customize visualizations, opt for Splunk’s advanced visual editor. For your unique cases, you can also create customized visualizations using the API from Splunkbase. 
+If you would rather not use code to edit dashboards or customize visualizations, opt for Splunk’s advanced visual editor. For your unique cases, you can also create customized visualizations using the API from Splunkbase.
 
-**Pros:** 
+**Pros:**
 
 1. Great documentation with example test-cases, detailed guides, and a strong community.
-2. This Kibana alternative work with any form of data, even unstructured data. 
-3. Splunk’s library of preconfigured modules help you get fast insights. 
+2. This Kibana alternative work with any form of data, even unstructured data.
+3. Splunk’s library of preconfigured modules help you get fast insights.
 
-**Cons:** 
+**Cons:**
 
 1. High pricing, especially for large volumes of data.
 2. Its data ingestion features aren’t the best, with missing fields or irrelevant content.
-3. Optimizing for speed can be difficult if you’re new to Splunk. 
+3. Optimizing for speed can be difficult if you’re new to Splunk.
 
 ### 9. Graylog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-alternatives-graylog.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-alternatives-graylog.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://graylog.org/products/source-available" rel="noopener noreferrer nofollow" target="_blank" >Graylog</a>
 
-<a href = "https://graylog.org" rel="noopener noreferrer nofollow" target="_blank" >Graylog</a> is an enterprise-level SIEM tool that can help you search and visualize terabytes of data, get notified with alerts, and create or automate reports. In fact, it has a wide variety of widgets like statistical values, stacked charts, quick value results, or search value counts to help you visualize data from logs. 
+<a href="https://graylog.org" rel="noopener noreferrer nofollow" target="_blank">
+  Graylog
+</a>
+is an enterprise-level SIEM tool that can help you search and visualize terabytes of data, get
+notified with alerts, and create or automate reports. In fact, it has a wide variety of widgets like
+statistical values, stacked charts, quick value results, or search value counts to help you
+visualize data from logs.
 
 You can export searches to empty dashboards, but you need Grafana to visualize data effectively with Graylog. As its primary focus is on log management, it offers limited visualization capabilities. You can still use histograms, scatter plots, or custom dashboards for basic visualizations. It’s great for [centralized logging](https://signoz.io/blog/centralized-logging/) and has native alerting facilities, unlike Kibana.
 
 Plus, Graylog’s visualization capabilities are driven by advanced data aggregation, which allows you to combine and aggregate different types of data in a single chart for a pivot-like experience. You can build pre-defined searches to optimize business efficiencies, reduce downtime, and quickly pull up saved searches to identify and troubleshoot issues faster.
 
-**Pros:** 
+**Pros:**
 
-1. Data ingestion capabilities are top-tier. 
-2. Powerful search options for troubleshooting. 
+1. Data ingestion capabilities are top-tier.
+2. Powerful search options for troubleshooting.
 3. Flexible configuration to meet enterprise needs or infrastructure requirements.
 
-**Cons:** 
+**Cons:**
 
-1. Limited visualization capabilities and is rather Grafana-dependent. 
+1. Limited visualization capabilities and is rather Grafana-dependent.
 2. Unaffordable pricing with a lack of pre-built dashboards or templates.
 3. Writing extractors or content packs can be a time- and effort-intensive task.
 
@@ -314,4 +387,4 @@ Here are some points you should consider before choosing the right Kibana altern
 
 **[Top 14 ELK alternatives [open source included]](https://signoz.io/blog/elk-alternatives/)**
 
-**[Kibana vs Grafana: A Scenario-Based Decision Guide](https://signoz.io/blog/kibana-vs-grafana/)**
\ No newline at end of file
+**[Kibana vs Grafana: A Scenario-Based Decision Guide](https://signoz.io/blog/kibana-vs-grafana/)**
diff --git a/data/comparisons/kibana-vs-splunk.mdx b/data/comparisons/kibana-vs-splunk.mdx
index 884db121a..9a33fad5f 100644
--- a/data/comparisons/kibana-vs-splunk.mdx
+++ b/data/comparisons/kibana-vs-splunk.mdx
@@ -1,54 +1,49 @@
 ---
 title: Kibana vs Splunk - Choose between the Two Leading Log Management Tools
-slug: kibana-vs-splunk
+
 date: 2024-03-26
 tags: [tools-comparison]
 authors: [ehis]
 description: Kibana and Splunk are both monitoring tools used primarily for log monitoring. Splunk is a platform for searching, monitoring, and analyzing machine-generated big data, including logs, events, and metrics. On the other hand, Kibana is...
 image: /img/blog/2024/03/kibana-vs-splunk-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [kibana-vs-splunk,splunk,kibana,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [kibana-vs-splunk, splunk, kibana, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
-Splunk and Kibana are highly regarded for their data analysis and visualization capabilities.  Splunk is a platform for searching, monitoring, and analyzing machine-generated big data, including logs, events, and metrics. Kibana, on the other hand, is an open-source data visualization dashboard for Elasticsearch.
-
+Splunk and Kibana are highly regarded for their data analysis and visualization capabilities. Splunk is a platform for searching, monitoring, and analyzing machine-generated big data, including logs, events, and metrics. Kibana, on the other hand, is an open-source data visualization dashboard for Elasticsearch.
 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-vs-splunk-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-vs-splunk-cover.webp" alt="" />
 </figure>
 
-
 This article aims to compare and contrast two of the industry’s most prominent data visualization tools, Splunk and Kibana. By examining their features, functionalities, and use cases, we provide readers with comprehensive insights to make informed decisions about which tool best suits their data visualization needs.
 
 ## Kibana vs Splunk: At a glance
 
 Here’s a quick overview of the differences between Kibana and Splunk.
 
-|  |                               Kibana |                                        Splunk |
-| --- | --- | --- |
-|            Type | Open source software | Proprietary, closed-source, and commercial software |
-|  Search capabilities | Simplified query language | It uses (S.P.L) (Splunk Processing Language) |
-| Data Ingestion  | Relies on Elasticsearch for data indexing and collection | Ingests and indexes various data types from different sources. |
-| Pricing and Cost | Open-source, cost-effective | More expensive |
-| Target Audience     | Data analysts, developers, business users | Widely used in IT operations, security, and analytics |
-| Data visualization | Advanced | Limited |
-| Scalability and Performance | Scalable, but relies on Elasticsearch cluster performance | Highly scalable |
-| Alerting and Monitoring | Limited | YES |
-| Log Management and Analytics | Limited | YES |
-| Real-time Data Monitoring | Limited | YES |
-| Ease of Use | User-friendly, accessible | It can be complex, may require training |
-| Customization and Extensibility | customization options may be more limited compared to Splunk | It supports a wide range of apps and plugins. |
-| Compliance and Security | It inherits security features from Elasticsearch but may need extra setup for advanced security. | It provides strong compliance and security features, such as role-based access control, data encryption, and audit logging. |
-| Deployment Options | Deployed with Elasticsearch, which can be on-premises or in the cloud and also offers managed Elasticsearch services | Deployed  as a stand-alone and offers on-premises and cloud deployment. |
+|                                 | Kibana                                                                                                               | Splunk                                                                                                                      |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| Type                            | Open source software                                                                                                 | Proprietary, closed-source, and commercial software                                                                         |
+| Search capabilities             | Simplified query language                                                                                            | It uses (S.P.L) (Splunk Processing Language)                                                                                |
+| Data Ingestion                  | Relies on Elasticsearch for data indexing and collection                                                             | Ingests and indexes various data types from different sources.                                                              |
+| Pricing and Cost                | Open-source, cost-effective                                                                                          | More expensive                                                                                                              |
+| Target Audience                 | Data analysts, developers, business users                                                                            | Widely used in IT operations, security, and analytics                                                                       |
+| Data visualization              | Advanced                                                                                                             | Limited                                                                                                                     |
+| Scalability and Performance     | Scalable, but relies on Elasticsearch cluster performance                                                            | Highly scalable                                                                                                             |
+| Alerting and Monitoring         | Limited                                                                                                              | YES                                                                                                                         |
+| Log Management and Analytics    | Limited                                                                                                              | YES                                                                                                                         |
+| Real-time Data Monitoring       | Limited                                                                                                              | YES                                                                                                                         |
+| Ease of Use                     | User-friendly, accessible                                                                                            | It can be complex, may require training                                                                                     |
+| Customization and Extensibility | customization options may be more limited compared to Splunk                                                         | It supports a wide range of apps and plugins.                                                                               |
+| Compliance and Security         | It inherits security features from Elasticsearch but may need extra setup for advanced security.                     | It provides strong compliance and security features, such as role-based access control, data encryption, and audit logging. |
+| Deployment Options              | Deployed with Elasticsearch, which can be on-premises or in the cloud and also offers managed Elasticsearch services | Deployed as a stand-alone and offers on-premises and cloud deployment.                                                      |
 
 Before we start deep dive into key differences of Kibana and Splunk, let’s have a brief overview of both platforms.
 
 ## Overview of Splunk and Kibana
 
-Splunk and Kibana are highly regarded for their data analysis and visualization capabilities.  Splunk is a platform for searching, monitoring, and analyzing machine-generated big data, including logs, events, and metrics. It provides real-time insights into operational data through a user-friendly interface, allowing users to quickly identify and troubleshoot issues, track performance, and gain valuable insights from their data.
+Splunk and Kibana are highly regarded for their data analysis and visualization capabilities. Splunk is a platform for searching, monitoring, and analyzing machine-generated big data, including logs, events, and metrics. It provides real-time insights into operational data through a user-friendly interface, allowing users to quickly identify and troubleshoot issues, track performance, and gain valuable insights from their data.
 
 Kibana, on the other hand, is an open-source data visualization dashboard for Elasticsearch. It provides users with a variety of visualization options, including charts, graphs, maps, and tables, to help them understand and explore their data. Kibana is commonly used alongside Elasticsearch to create interactive visualizations and dashboards for monitoring, analyzing, and exploring large datasets.
 
@@ -59,20 +54,23 @@ Kibana, on the other hand, is an open-source data visualization dashboard for El
 1. **Real-time Data Monitoring:** Splunk offers powerful real-time data monitoring capabilities, allowing users to monitor data streams as they are generated. This enables immediate insights into system performance, user behavior, and other critical metrics, empowering users to make informed decisions quickly.
 2. **Log Management and Analytics:** Splunk's log management and analytics capabilities are renowned for their comprehensiveness. Splunk allows users to efficiently manage and analyze logs from various sources, providing valuable insights into system performance, security, and other aspects of IT infrastructure. Its powerful search and visualization features make it a popular choice for organizations looking to make sense of their log data.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-vs-splunk-log-observer.webp" alt="Log Observer in Splunk"/>
-    <figcaption><i>Log Observer in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-vs-splunk-log-observer.webp"
+    alt="Log Observer in Splunk"
+  />
+  <figcaption>
+    <i>Log Observer in Splunk</i>
+  </figcaption>
 </figure>
 
-
-
 1. **Target Audience:** Splunk's target audience primarily consists of IT operations professionals, security experts, and business analytics specialists. These professionals leverage Splunk's capabilities to monitor and troubleshoot IT systems, enhance security posture, and derive valuable business insights from data analysis.
-   
 2. **Data Ingestion:** Splunk is renowned for its ability to ingest and index a wide range of data types, including log files, metrics, and events. It can collect data from diverse sources such as servers, applications, and network devices. This flexibility allows Splunk to handle the complex data needs of organizations, making it a powerful tool for data analysis and monitoring.
 
 3. **Search Processing Language (SPL):** Splunk utilizes its proprietary SPL (Search Processing Language) to enable users to query and analyze data effectively. SPL empowers users to conduct intricate searches and analyses on their log data, providing unparalleled flexibility and control over data exploration and extraction. This unique capability sets Splunk apart as a robust and powerful tool for data analytics and visualization.
 
-4. **Alerting and Monitoring:**  Splunk provides robust alerting and monitoring features, enabling users to set up alerts based on predefined conditions and monitor their log data in real time. This capability allows users to proactively detect and respond to issues, ensuring the smooth operation of their IT infrastructure. Splunk's alerting and monitoring capabilities are highly configurable, allowing users to tailor them to their specific needs and requirements.
+4. **Alerting and Monitoring:** Splunk provides robust alerting and monitoring features, enabling users to set up alerts based on predefined conditions and monitor their log data in real time. This capability allows users to proactively detect and respond to issues, ensuring the smooth operation of their IT infrastructure. Splunk's alerting and monitoring capabilities are highly configurable, allowing users to tailor them to their specific needs and requirements.
 
 5. **Scalability:** Splunk is engineered to scale efficiently, making it well-suited for organizations with substantial log management requirements. It can handle large volumes of data, ensuring organizations can effectively manage and analyze their data as it grows. This scalability is a key feature of Splunk, enabling organizations to maintain high performance and reliability even as their data needs expand.
 
@@ -80,12 +78,17 @@ Kibana, on the other hand, is an open-source data visualization dashboard for El
 
 Kibana is part of the ELK stack, which stands for Elasticsearch, Logstash, and Kibana. The ELK stack is a collection of three open-source tools that are commonly used together for log management and analytics.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/kibana-vs-splunk-dashboard.webp" alt="Kibana Dashboard"/>
-    <figcaption><i>Kibana Dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/kibana-vs-splunk-dashboard.webp"
+    alt="Kibana Dashboard"
+  />
+  <figcaption>
+    <i>Kibana Dashboard</i>
+  </figcaption>
 </figure>
 
-
 **Kibana's core functionalities encompass the following:**
 
 1. **Data Visualization and Dashboard Creation:** In Kibana, users have the ability to create dynamic and interactive dashboards that visualize Elasticsearch queries. These dashboards can then be shared with others, enabling collaborative data analysis and decision-making. Kibana's intuitive interface and powerful visualization options make it a valuable tool for exploring and presenting data from Elasticsearch.
@@ -98,7 +101,7 @@ Kibana is part of the ELK stack, which stands for Elasticsearch, Logstash, and K
 
 ### Functionality and Features:
 
-Splunk offers a comprehensive suite of features, including advanced log management, security information and event management (SIEM), and real-time data monitoring. It excels in providing a wide range of functionalities for managing and analyzing machine-generated data. 
+Splunk offers a comprehensive suite of features, including advanced log management, security information and event management (SIEM), and real-time data monitoring. It excels in providing a wide range of functionalities for managing and analyzing machine-generated data.
 
 In contrast, Kibana is renowned for its powerful visualization capabilities, especially when integrated with Elasticsearch. While it may not offer the same breadth of features as Splunk, Kibana's strength lies in its ability to create interactive dashboards and visualizations for in-depth data analysis. When used alongside Elasticsearch, Kibana provides a robust platform for exploring and visualizing large datasets, making it ideal for data analysts and developers seeking to derive meaningful insights from their data.
 
@@ -110,21 +113,21 @@ On the other hand, Kibana's scalability is closely tied to the performance of th
 
 ### Visualization and Reporting:
 
-Splunk and Kibana both offer robust visualization features but with different emphases. Splunk's primary focus is on log management and analysis, so while it provides some visualization capabilities, they may not be as advanced or customizable as Kibana's. 
+Splunk and Kibana both offer robust visualization features but with different emphases. Splunk's primary focus is on log management and analysis, so while it provides some visualization capabilities, they may not be as advanced or customizable as Kibana's.
 
 However, Splunk's visualizations can still provide valuable insights into data. On the other hand, Kibana is renowned for its powerful visualization capabilities, offering a wide range of options such as bar charts, line charts, pie charts, and maps. Kibana's visualizations are highly customizable, allowing users to create interactive dashboards and reports that cater to their specific needs. Splunk and Kibana offer strong visualization features, Splunk's visualizations are more geared towards providing insights into log data, while Kibana's visualizations are highly customizable and suitable for creating interactive dashboards and reports for a wide range of data analysis purposes.
 
 ### Data Collection and Indexing:
 
-Splunk provides a comprehensive out-of-the-box solution for data collection and indexing, making it easy for users to ingest and index various types of data sources. Splunk's robust data collection capabilities include support for log files, metrics, events, and other forms of machine-generated data, allowing users to quickly start collecting and analyzing data without extensive configuration. 
+Splunk provides a comprehensive out-of-the-box solution for data collection and indexing, making it easy for users to ingest and index various types of data sources. Splunk's robust data collection capabilities include support for log files, metrics, events, and other forms of machine-generated data, allowing users to quickly start collecting and analyzing data without extensive configuration.
 
 In contrast, Kibana relies on Elasticsearch for data indexing and collection. While Elasticsearch provides powerful indexing capabilities, setting up and configuring Elasticsearch for data collection may require additional effort and expertise compared to Splunk's out-of-the-box solution. Additionally, users may need to configure Elasticsearch to ingest and index data from different sources, which can add complexity to the setup process. Overall, Splunk's comprehensive data collection and indexing capabilities provide users with a streamlined experience for collecting and analyzing data, while Kibana's dependence on Elasticsearch for data indexing and collection may require additional configuration and setup effort.
 
 ### Visualization and Reporting:
 
-While both Splunk and Kibana offer strong visualization features, they differ in their focus and customization options. 
+While both Splunk and Kibana offer strong visualization features, they differ in their focus and customization options.
 
-Splunk's primary emphasis is on log management and analysis, so its visualization capabilities, while valuable, may not be as advanced or customizable as Kibana's. Splunk's visualizations can still provide valuable insights into data, particularly for log data analysis. 
+Splunk's primary emphasis is on log management and analysis, so its visualization capabilities, while valuable, may not be as advanced or customizable as Kibana's. Splunk's visualizations can still provide valuable insights into data, particularly for log data analysis.
 
 In contrast, Kibana is renowned for its powerful and highly customizable visualization capabilities. It offers a wide range of visualization options, including bar charts, line charts, pie charts, and maps, allowing users to create interactive dashboards and reports tailored to their specific needs. Kibana's visualizations enable users to explore and analyze data in depth, making it a preferred choice for data analysts and developers seeking advanced visualization capabilities. In summary, while Splunk's visualizations are effective for log management and analysis, Kibana's visualizations are highly customizable and suitable for creating interactive dashboards and reports for a wide range of data analysis purposes.
 
@@ -136,7 +139,7 @@ On the other hand, Splunk, while powerful, can be more complex and may require m
 
 ### Use Cases and Industry Adoption:
 
-Splunk is widely adopted in sectors requiring robust IT operations and security monitoring, such as cybersecurity, network monitoring, and IT troubleshooting. Its comprehensive features for log management, real-time monitoring, and security information and event management (SIEM) make it a popular choice among organizations with demanding operational and security needs. 
+Splunk is widely adopted in sectors requiring robust IT operations and security monitoring, such as cybersecurity, network monitoring, and IT troubleshooting. Its comprehensive features for log management, real-time monitoring, and security information and event management (SIEM) make it a popular choice among organizations with demanding operational and security needs.
 
 In contrast, Kibana's strong visualization capabilities make it preferred in scenarios where interactive data exploration and visualization are key, such as data analytics, business intelligence, and performance monitoring. Its ability to create interactive dashboards and visualizations makes it well-suited for users seeking to derive insights and trends from their data. Overall, while Splunk is favored for its extensive IT and security monitoring capabilities, Kibana's focus on visualization and data exploration makes it a preferred choice for users seeking to visualize and analyze data in a more interactive and intuitive manner.
 
@@ -156,7 +159,7 @@ Kibana:
 
 ### Alerting and Monitoring :
 
-**Splunk:** 
+**Splunk:**
 
 - Splunk provides robust alerting and monitoring capabilities.
 - Users can set up alerts based on predefined conditions and monitor data in real-time.
@@ -178,7 +181,7 @@ When deciding between Splunk and Kibana, it's essential to consider your specifi
 2. Splunk is the preferred choice for environments needing robust log management, security monitoring, and real-time data analysis capabilities. Use Splunk if you need a comprehensive platform for ingesting, analyzing, and visualizing diverse types of data and logs. Splunk is known for its advanced search and filter capabilities, making it easy to search and analyze data from various sources. It is suitable for businesses facing complex data analysis needs, especially large enterprises dealing with extensive log volumes and requiring robust security and alert management features. However, note that Splunk's extensive features come with substantial maintenance costs and licensing expenses based on indexed data volume.
 3. Kibana shines in projects that emphasize data visualization, especially when Elasticsearch is already part of the technology stack. Choose Kibana if you prioritize data visualization and exploration, especially when used alongside Elasticsearch. Kibana excels in visualizing and exploring data, offering a powerful solution for organizations focused on data visualization and exploration. It is particularly beneficial for projects that emphasize data visualization and are already using Elasticsearch. However, Kibana's alerting capabilities are more limited compared to Splunk, and it may require additional configurations or plugins for advanced security features.
 
-While both Splunk and Kibana excel in data visualization and analysis, their suitability depends on the organization's specific needs, budget, and existing infrastructure. Splunk is unmatched in its comprehensive data analysis capabilities, making it ideal for complex enterprise environments where robust features are paramount. 
+While both Splunk and Kibana excel in data visualization and analysis, their suitability depends on the organization's specific needs, budget, and existing infrastructure. Splunk is unmatched in its comprehensive data analysis capabilities, making it ideal for complex enterprise environments where robust features are paramount.
 
 On the other hand, Kibana shines in visualizing and exploring data, particularly when paired with Elasticsearch, offering a powerful solution for organizations focused on data visualization and exploration.
 
@@ -198,4 +201,4 @@ Compared to Splunk, SigNoz can be much more cost-effective. Splunk is mainly sui
 
 **[Elasticsearch vs Splunk - Top Pick for Log Analysis](https://signoz.io/blog/elasticsearch-vs-splunk/)**
 
-**[Grafana vs Splunk - Key Features and Differences](https://signoz.io/blog/grafana-vs-splunk/)**
\ No newline at end of file
+**[Grafana vs Splunk - Key Features and Differences](https://signoz.io/blog/grafana-vs-splunk/)**
diff --git a/data/comparisons/kubernetes-alternatives.mdx b/data/comparisons/kubernetes-alternatives.mdx
index ab0561d0c..e9ad2f0f2 100644
--- a/data/comparisons/kubernetes-alternatives.mdx
+++ b/data/comparisons/kubernetes-alternatives.mdx
@@ -1,20 +1,25 @@
 ---
-
 title: Top 8 Kubernetes Alternatives - Should You Switch in 2025?
-slug: kubernetes-alternatives
+
 date: 2025-01-02
 tags: [kubernetes, tools-comparisions]
 authors: [aayush_sharma]
 description: Explore the top 8 Kubernetes alternatives for 2024. Learn about serverless options, open-source solutions, and how to choose the right platform for your needs.
-keywords: [kubernetes alternatives, container orchestration, serverless computing, cloud-native platforms, DevOps tools]
-
+keywords:
+  [
+    kubernetes alternatives,
+    container orchestration,
+    serverless computing,
+    cloud-native platforms,
+    DevOps tools,
+  ]
 ---
 
 Kubernetes has completely transformed how we manage container orchestration, making application deployment, scaling, and management much easier. However, Kubernetes isn’t a one-size-fits-all solution. Different needs and environments in the vast field of software development require different approaches. This is where we require Kubernetes Alternatives. This article explores the top 8 Kubernetes alternatives in 2024, helping you decide if it's time to make a switch.
 
 ## What is Kubernetes?
 
-Kubernetes, also known as k8s or “kube,” is an open-source containerization platform. It was by developed by Google and available as open-source software in 2014.  Kubernetes allows applications to be run on physical servers, public or private cloud storage platforms, and hybrid combinations according to your business needs. It also automates the deployment, scaling and management of containered platform which allows team to use their time and energy more efficiently.
+Kubernetes, also known as k8s or “kube,” is an open-source containerization platform. It was by developed by Google and available as open-source software in 2014. Kubernetes allows applications to be run on physical servers, public or private cloud storage platforms, and hybrid combinations according to your business needs. It also automates the deployment, scaling and management of containered platform which allows team to use their time and energy more efficiently.
 
 Due to its open-source nature and extensive documentation, Kubernetes has become one of the leaders in containerization platforms. However, the system has a significant learning curve and can be confusing to set up and navigate, leading some to seek an alternative to this complicated platform. The
 
@@ -34,7 +39,12 @@ These challenges require the search for Kubernetes alternatives that offer simpl
 
 ### 1. AWS EKS
 
-<a href="https://aws.amazon.com/eks/" rel="noopener noreferrer nofollow" target="_blank">Amazon EKS</a> is Amazon Web Services (AWS) fully managed Kubernetes service. It automates key tasks such as patching, node provisioning, and updates. EKS is deeply integrated with AWS services like Elastic Load Balancing, IAM, and Amazon VPC, making it a robust choice for AWS-centric organizations.
+<a href="https://aws.amazon.com/eks/" rel="noopener noreferrer nofollow" target="_blank">
+  Amazon EKS
+</a>
+is Amazon Web Services (AWS) fully managed Kubernetes service. It automates key tasks such as
+patching, node provisioning, and updates. EKS is deeply integrated with AWS services like Elastic
+Load Balancing, IAM, and Amazon VPC, making it a robust choice for AWS-centric organizations.
 
 It stands out for its:
 
@@ -47,7 +57,15 @@ Although EKS is good choice for businesses who are into AWS ecosystem and also l
 
 ### 2. Azure Container Instances (ACI)
 
-<a href="https://azure.microsoft.com/en-us/products/container-instances" rel="noopener noreferrer nofollow" target="_blank">Microsoft's Azure Container Instances</a> provides a serverless container runtime without the complexity of orchestration. Its advantages include:
+<a
+  href="https://azure.microsoft.com/en-us/products/container-instances"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Microsoft's Azure Container Instances
+</a>
+provides a serverless container runtime without the complexity of orchestration. Its advantages
+include:
 
 - Rapid container startup times
 - Per-second billing
@@ -65,7 +83,11 @@ Performance metrics show ACI excels in quick-start scenarios but may not be as c
 
 ### 3. Google Cloud Run
 
-<a href="https://cloud.google.com/run" rel="noopener noreferrer nofollow" target="_blank">Google Cloud Run</a> takes serverless to the next level by allowing you to run stateless containers that automatically scale based on incoming requests. Its standout features are:
+<a href="https://cloud.google.com/run" rel="noopener noreferrer nofollow" target="_blank">
+  Google Cloud Run
+</a>
+takes serverless to the next level by allowing you to run stateless containers that automatically
+scale based on incoming requests. Its standout features are:
 
 - HTTP-driven auto-scaling
 - Support for any programming language or binary
@@ -83,7 +105,14 @@ While Cloud Run offers incredible simplicity, it's limited to HTTP(S) workloads
 
 ### 4. Docker Swarm
 
-<a href="https://docs.docker.com/engine/swarm/" rel="noopener noreferrer nofollow" target="_blank">Docker Swarm</a> is a container orchestration platform that helps you manage and run groups of containers, which are  portable versions of your application that can run anywhere. If you're using Docker to create and run these containers, Docker Swarm makes it easy to group them together and manage them as a team. Docker Swarm is also easy to use which makes it good alternative for teams to seeking a more accessible solution.
+<a href="https://docs.docker.com/engine/swarm/" rel="noopener noreferrer nofollow" target="_blank">
+  Docker Swarm
+</a>
+is a container orchestration platform that helps you manage and run groups of containers, which are
+portable versions of your application that can run anywhere. If you're using Docker to create and
+run these containers, Docker Swarm makes it easy to group them together and manage them as a team.
+Docker Swarm is also easy to use which makes it good alternative for teams to seeking a more
+accessible solution.
 
 It stands out for its:
 
@@ -97,8 +126,12 @@ However, if your app is very large or complex and you require advance scaling fe
 
 ### 5. Apache Mesos
 
-<a href="https://mesos.apache.org/" rel="noopener noreferrer nofollow" target="_blank">Apache Mesos</a> is a flexible and powerful platform that can manage both containers and non-containerized applications. It’s particularly useful for large-scale deployments where you need to handle complex workloads across a variety of environments.
-It stands out for its:
+<a href="https://mesos.apache.org/" rel="noopener noreferrer nofollow" target="_blank">
+  Apache Mesos
+</a>
+is a flexible and powerful platform that can manage both containers and non-containerized
+applications. It’s particularly useful for large-scale deployments where you need to handle complex
+workloads across a variety of environments. It stands out for its:
 
 1. Apache Mesos is good for large enterprises or complex projects that need to manage a mix of different types of workloads, not just containers.
 2. It allows you to run containerized and non-containerized applications side by side which gives you more flexibility in managing your resources.
@@ -108,7 +141,12 @@ However, Apache Mesos can be more complex to set up and manage compared to Kuber
 
 ### 6. Nomad by HashiCorp
 
-<a href="https://www.nomadproject.io/" rel="noopener noreferrer nofollow" target="_blank">Nomad by HashiCorp</a> not only helps to  manage containerized application but helps in managing batch  applications with a single and simple interface. It’s known for being lightweight and easy to integrate with other tools in the HashiCorp ecosystem.
+<a href="https://www.nomadproject.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Nomad by HashiCorp
+</a>
+not only helps to manage containerized application but helps in managing batch applications with a
+single and simple interface. It’s known for being lightweight and easy to integrate with other tools
+in the HashiCorp ecosystem.
 
 1. Nomad is a great choice for small to medium-sized businesses or teams that need a flexible solution to manage a variety of workloads, not just containers.
 2. It’s lightweight and easy to set up which makes it ideal for teams that want to avoid the complexity of more heavyweight orchestrators like Kubernetes.
@@ -118,8 +156,16 @@ However, Nomad might not offer as many native features for container orchestrati
 
 ### 7. OpenShift (Red Hat)
 
-<a href="https://www.redhat.com/en/technologies/cloud-computing/openshift" rel="noopener noreferrer nofollow" target="_blank">OpenShift by Red Hat</a> is a Kubernetes-based platform that comes with extra features which is meant for enterprise use. It is designed to help you build, deploy, and manage applications across hybrid cloud environments..
-It stands out for its:
+<a
+  href="https://www.redhat.com/en/technologies/cloud-computing/openshift"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  OpenShift by Red Hat
+</a>
+is a Kubernetes-based platform that comes with extra features which is meant for enterprise use. It
+is designed to help you build, deploy, and manage applications across hybrid cloud environments.. It
+stands out for its:
 
 1. OpenShift is ideal for enterprise businesses or teams that need security, various tools, and also support.
 2. It also integrates seamlessly with Red Hat products, which makes it a good choice for organizations already using Red Hat technologies.
@@ -129,7 +175,11 @@ While OpenShift provides many powerful features but it can be more expensive and
 
 ### 8. Rancher
 
-<a href="https://www.rancher.com/" rel="noopener noreferrer nofollow" target="_blank">Rancher</a> is a user-friendly platform that simplifies Kubernetes management which makes it easier to run Kubernetes clusters across different environments, whether on-premises or in the cloud.
+<a href="https://www.rancher.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Rancher
+</a>
+is a user-friendly platform that simplifies Kubernetes management which makes it easier to run
+Kubernetes clusters across different environments, whether on-premises or in the cloud.
 
 1. Rancher is perfect for small to medium-sized businesses or teams who wants to manage multiple Kubernetes clusters easily.
 2. It offers an strong multi-cluster management capabilities and also easier to deploy and manage Kubernetes across various environments.
@@ -218,4 +268,4 @@ Yes, migration is possible but requires careful planning:
 - Containerized applications are generally portable between platforms.
 - You may need to adjust deployment configurations and service definitions.
 - Some Kubernetes-specific features might not have direct equivalents in other platforms.
-- A phased migration approach is often recommended to minimize disruption.
\ No newline at end of file
+- A phased migration approach is often recommended to minimize disruption.
diff --git a/data/comparisons/lightstep-alternatives.mdx b/data/comparisons/lightstep-alternatives.mdx
index 0cf761d60..1e8a229dc 100644
--- a/data/comparisons/lightstep-alternatives.mdx
+++ b/data/comparisons/lightstep-alternatives.mdx
@@ -1,16 +1,22 @@
 ---
-title: "Top 9 Lightstep (ServiceNow) Alternatives in 2025 (And How to Migrate)"
-slug: "lightstep-alternatives"
-date: "2025-10-01"
+title: 'Top 9 Lightstep (ServiceNow) Alternatives in 2025 (And How to Migrate)'
+date: '2025-10-01'
 tags: [observability, opentelemetry]
-authors: ["yuvraj"]
+authors: ['yuvraj']
 description: "With Lightstep's end-of-life notice, find the best alternatives for a smooth migration. Explore open-source and OTel-native options like SigNoz."
-keywords: [lightstep alternative, servicenow cloud observability, lightstep end of life, opentelemetry, signoz]
+keywords:
+  [
+    lightstep alternative,
+    servicenow cloud observability,
+    lightstep end of life,
+    opentelemetry,
+    signoz,
+  ]
 ---
 
 ServiceNow recently announced the [end-of-life (EOL) for Lightstep](https://docs.lightstep.com/changelog/eol-notice#heres-what-you-need-to-know), now known as Cloud Observability. Support will officially end on **March 1, 2026**, or at the end of your contract, and ServiceNow has confirmed there will be no direct replacement or migration path.
 
-This news can be disruptive for engineering teams who rely on Lightstep for critical observability. The announcement highlights a significant risk in relying on proprietary, closed-source tools for essential infrastructure. 
+This news can be disruptive for engineering teams who rely on Lightstep for critical observability. The announcement highlights a significant risk in relying on proprietary, closed-source tools for essential infrastructure.
 
 At SigNoz we believe critical infra shouldn’t hinge on a vendor’s roadmap. Observability is too critical a piece to leave to such risks. With open source, you always have an escape hatch.
 
@@ -20,9 +26,9 @@ If you're now searching for a stable, future-proof alternative to Lightstep, you
 
 Lightstep was a powerful observability platform, highly regarded as an early leader in distributed tracing. Many engineering teams chose it for its:
 
-* **Strong OpenTelemetry Support:** Lightstep was an early and significant contributor to OpenTelemetry (OTel), building its platform to provide first-class OpenTelemetry support. This meant users could instrument their applications with open standards, avoiding agent lock-in.
-* **Unified Observability:** It provided unified dashboards to visualize logs, metrics, and traces in one place, which helped teams correlate different telemetry signals during an investigation.
-* **Advanced Tracing Features:** It offered features like service diagrams, root cause analysis, and "Change Intelligence" to correlate performance deviations with deployments.
+- **Strong OpenTelemetry Support:** Lightstep was an early and significant contributor to OpenTelemetry (OTel), building its platform to provide first-class OpenTelemetry support. This meant users could instrument their applications with open standards, avoiding agent lock-in.
+- **Unified Observability:** It provided unified dashboards to visualize logs, metrics, and traces in one place, which helped teams correlate different telemetry signals during an investigation.
+- **Advanced Tracing Features:** It offered features like service diagrams, root cause analysis, and "Change Intelligence" to correlate performance deviations with deployments.
 
 A good Lightstep alternative should ideally match or exceed these capabilities, providing a unified view of telemetry while being built on open standards.
 
@@ -40,18 +46,17 @@ Here are the top alternatives to Lightstep, evaluated based on their support for
   caption="SigNoz dashboard"
 />
 
-
 **Key Features & Strengths:**
 
-* **Truly Unified Observability:** SigNoz uses a single backend (Columnar database) for logs, metrics, and traces, so you can pivot from a trace to related logs without switching tools.
-* **OpenTelemetry-Native:** SigNoz is built from the ground up to support OpenTelemetry. There are no proprietary agents, and it fully supports OTel semantic conventions, ensuring a smooth migration from Lightstep.
-* **Cost-Effective and Transparent Pricing:** The open-source version is free to self-host. SigNoz Cloud offers a simple, usage-based pricing model without per-user or per-host fees, which is often more predictable and affordable than competitors.
-* **Powerful Querying and Analytics:** You can run advanced analytics on your telemetry data, such as finding the p99 latency for all services with a specific tag.
-* **Control Over Your Data:** With both cloud and self-hosted options, you can choose where your data resides, which is crucial for compliance and privacy.
+- **Truly Unified Observability:** SigNoz uses a single backend (Columnar database) for logs, metrics, and traces, so you can pivot from a trace to related logs without switching tools.
+- **OpenTelemetry-Native:** SigNoz is built from the ground up to support OpenTelemetry. There are no proprietary agents, and it fully supports OTel semantic conventions, ensuring a smooth migration from Lightstep.
+- **Cost-Effective and Transparent Pricing:** The open-source version is free to self-host. SigNoz Cloud offers a simple, usage-based pricing model without per-user or per-host fees, which is often more predictable and affordable than competitors.
+- **Powerful Querying and Analytics:** You can run advanced analytics on your telemetry data, such as finding the p99 latency for all services with a specific tag.
+- **Control Over Your Data:** With both cloud and self-hosted options, you can choose where your data resides, which is crucial for compliance and privacy.
 
 **Considerations & Trade-offs:**
 
-* Compared to Datadog, its ecosystem of pre-built integrations is still growing. However, its OTel-native nature means it can ingest data from any system that supports OTLP.
+- Compared to Datadog, its ecosystem of pre-built integrations is still growing. However, its OTel-native nature means it can ingest data from any system that supports OTLP.
 
 **Verdict:**
 
@@ -69,14 +74,14 @@ Datadog is a market-leading, all-in-one SaaS observability platform that covers
 
 **Key Features & Strengths:**
 
-* **Comprehensive Feature Set:** Datadog offers an incredibly broad range of features consolidated into a single platform, reducing tool sprawl.
-* **Extensive Integrations:** It has hundreds of integrations that make setup easy for a wide variety of technologies.
-* **Polished UI:** The dashboards are highly customizable and the platform includes AI-powered features like Watchdog for anomaly detection.
+- **Comprehensive Feature Set:** Datadog offers an incredibly broad range of features consolidated into a single platform, reducing tool sprawl.
+- **Extensive Integrations:** It has hundreds of integrations that make setup easy for a wide variety of technologies.
+- **Polished UI:** The dashboards are highly customizable and the platform includes AI-powered features like Watchdog for anomaly detection.
 
 **Considerations & Trade-offs:**
 
-* **High and Unpredictable Cost:** Datadog's multi-vector pricing (per-host, per-GB, per-user, custom metrics) is notoriously complex and often leads to bill shock. OpenTelemetry metrics can be charged as expensive "custom metrics."
-* **Vendor Lock-in:** The platform heavily relies on its proprietary agent, which can make it difficult and costly to migrate away from.
+- **High and Unpredictable Cost:** Datadog's multi-vector pricing (per-host, per-GB, per-user, custom metrics) is notoriously complex and often leads to bill shock. OpenTelemetry metrics can be charged as expensive "custom metrics."
+- **Vendor Lock-in:** The platform heavily relies on its proprietary agent, which can make it difficult and costly to migrate away from.
 
 For a detailed breakdown of Datadog's pricing complexities and hidden costs, check out this comprehensive guide: [Datadog Pricing Main Caveats Explained](https://signoz.io/blog/datadog-pricing/).
 
@@ -96,14 +101,14 @@ New Relic is an observability pioneer that has evolved into a full-stack platfor
 
 **Key Features & Strengths:**
 
-* **Strong APM Capabilities:** New Relic provides deep, code-level insights and powerful transaction tracing.
-* **Generous Free Tier:** Its free tier (100 GB of data ingest per month) provides an easy entry point for small teams.
-* **OpenTelemetry Support:** New Relic offers excellent support for OpenTelemetry, allowing you to send data via OTLP without using their proprietary agents. However, it's important to understand that the platform is **OTel-compatible, not OTel-native**. It ingests and translates OpenTelemetry data into its [internal proprietary format.](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-best-practices-metrics/)
+- **Strong APM Capabilities:** New Relic provides deep, code-level insights and powerful transaction tracing.
+- **Generous Free Tier:** Its free tier (100 GB of data ingest per month) provides an easy entry point for small teams.
+- **OpenTelemetry Support:** New Relic offers excellent support for OpenTelemetry, allowing you to send data via OTLP without using their proprietary agents. However, it's important to understand that the platform is **OTel-compatible, not OTel-native**. It ingests and translates OpenTelemetry data into its [internal proprietary format.](https://docs.newrelic.com/docs/opentelemetry/best-practices/opentelemetry-best-practices-metrics/)
 
 **Considerations & Trade-offs:**
 
-* **Cost at Scale:** Despite a simplified model, costs can escalate significantly with high data volumes or a large number of users.
-* **UI Complexity:** The user interface can be cluttered and has a steep learning curve for new users.
+- **Cost at Scale:** Despite a simplified model, costs can escalate significantly with high data volumes or a large number of users.
+- **UI Complexity:** The user interface can be cluttered and has a steep learning curve for new users.
 
 **The verdict:**
 
@@ -121,13 +126,13 @@ Honeycomb is a SaaS platform designed for analyzing high-cardinality, high-dimen
 
 **Key Features & Strengths:**
 
-* **Excellent for High-Cardinality Data:** Honeycomb excels at letting you slice and dice data by any attribute, which is invaluable for debugging novel production issues.
-* **Developer-Centric Workflow:** Features like "BubbleUp" automatically highlight outlier attributes, speeding up root cause analysis.
-* **OpenTelemetry-Native:** It's a strong proponent of OTel and offers simple, event-based pricing.
+- **Excellent for High-Cardinality Data:** Honeycomb excels at letting you slice and dice data by any attribute, which is invaluable for debugging novel production issues.
+- **Developer-Centric Workflow:** Features like "BubbleUp" automatically highlight outlier attributes, speeding up root cause analysis.
+- **OpenTelemetry-Native:** It's a strong proponent of OTel and offers simple, event-based pricing.
 
 **Considerations & Trade-offs:**
 
-* **Not a Full-Stack Solution:** Honeycomb is hyper-focused on tracing and events. Its capabilities for traditional infrastructure monitoring and unstructured log management are less mature. You will likely need other tools to get a complete picture.
+- **Not a Full-Stack Solution:** Honeycomb is hyper-focused on tracing and events. Its capabilities for traditional infrastructure monitoring and unstructured log management are less mature. You will likely need other tools to get a complete picture.
 
 **The verdict:**
 
@@ -145,14 +150,14 @@ The Grafana stack is a popular open-source, composable observability solution co
 
 **Key Features & Strengths:**
 
-* **Best-in-Class Visualization:** Grafana provides beautiful, highly customizable dashboards that can pull data from countless sources.
-* **Open and Composable:** Being fully open-source, it offers maximum flexibility and no vendor lock-in. It's a cornerstone of the CNCF ecosystem.
-* **Strong Community:** It has a vibrant open-source community and is the de-facto standard for visualizing Prometheus metrics.
+- **Best-in-Class Visualization:** Grafana provides beautiful, highly customizable dashboards that can pull data from countless sources.
+- **Open and Composable:** Being fully open-source, it offers maximum flexibility and no vendor lock-in. It's a cornerstone of the CNCF ecosystem.
+- **Strong Community:** It has a vibrant open-source community and is the de-facto standard for visualizing Prometheus metrics.
 
 **Considerations & Trade-offs:**
 
-* **Operational Complexity:** The biggest challenge is managing four separate, distributed systems (Loki, Grafana, Tempo, Mimir). This requires significant operational expertise and can be resource-intensive.
-* **Siloed Data:** While Grafana can visualize data from different sources, the backends are separate. This makes it harder to perform deep correlations between logs, metrics, and traces compared to a unified system like SigNoz.
+- **Operational Complexity:** The biggest challenge is managing four separate, distributed systems (Loki, Grafana, Tempo, Mimir). This requires significant operational expertise and can be resource-intensive.
+- **Siloed Data:** While Grafana can visualize data from different sources, the backends are separate. This makes it harder to perform deep correlations between logs, metrics, and traces compared to a unified system like SigNoz.
 
 **The verdict:**
 
@@ -170,12 +175,12 @@ Jaeger is a graduated CNCF open-source project and a well-known standard for end
 
 **Key Features & Strengths:**
 
-* **Powerful Open-Source Tracing:** Jaeger is a robust, scalable, and free solution dedicated to distributed tracing. It provides rich visualization tools for trace timelines and service dependency graphs.
-* **CNCF Standard:** As a CNCF project, it's tightly aligned with the cloud-native ecosystem and OpenTelemetry.
+- **Powerful Open-Source Tracing:** Jaeger is a robust, scalable, and free solution dedicated to distributed tracing. It provides rich visualization tools for trace timelines and service dependency graphs.
+- **CNCF Standard:** As a CNCF project, it's tightly aligned with the cloud-native ecosystem and OpenTelemetry.
 
 **Considerations & Trade-offs:**
 
-* **Tracing Only:** Jaeger's main limitation is its exclusive focus on tracing. It does not handle logs or metrics. To get full observability, you must integrate and manage it with other tools like Prometheus for metrics and an ELK stack for logs.
+- **Tracing Only:** Jaeger's main limitation is its exclusive focus on tracing. It does not handle logs or metrics. To get full observability, you must integrate and manage it with other tools like Prometheus for metrics and an ELK stack for logs.
 
 **The verdict:**
 
@@ -197,7 +202,7 @@ Elastic Observability is a unified solution built on the well-known Elastic Stac
 - **Unified Experience:** It provides a single, unified experience for logs, metrics, and traces within the Kibana interface, allowing for seamless correlation between different signals.
 - **Open-Core Foundation:** The solution is built on an open-source foundation, which provides a low-friction entry point and avoids immediate vendor lock-in. It is often seen as a more cost-effective alternative to Splunk, particularly for self-hosted deployments.
 
-****Considerations & Trade-offs:****
+\***\*Considerations & Trade-offs:\*\***
 
 - **Operational Complexity:** The primary trade-off is the complexity of managing a large-scale Elasticsearch cluster, which requires significant expertise in tuning and scaling.
 - **Cloud Costs:** While Elastic Cloud removes the operational burden of self-hosting, its costs can be confusing and unexpectedly high for large workloads.
@@ -282,7 +287,7 @@ exporters:
   otlp/lightstep:
     endpoint: ingest.lightstep.com:443
     headers:
-      "lightstep-access-token": "${LIGHTSTEP_ACCESS_TOKEN}"
+      'lightstep-access-token': '${LIGHTSTEP_ACCESS_TOKEN}'
 
 service:
   pipelines:
@@ -290,7 +295,7 @@ service:
       receivers: [otlp]
       processors: [batch]
       exporters: [otlp/lightstep]
-````
+```
 
 **After (SigNoz Config):**
 
@@ -301,9 +306,9 @@ exporters:
   otlp/signoz:
     # Replace <REGION> with your SigNoz cloud region
     # ex: us, in, eu
-    endpoint: "ingest.<REGION>.signoz.cloud:443"
+    endpoint: 'ingest.<REGION>.signoz.cloud:443'
     headers:
-      "signoz-ingestion-key": "${SIGNOZ_INGESTION_KEY}"
+      'signoz-ingestion-key': '${SIGNOZ_INGESTION_KEY}'
 
 service:
   pipelines:
@@ -331,7 +336,7 @@ Also note that historical data cannot be migrated from Lightstep to SigNoz. You
 
 ## Other Ways to Get Started with SigNoz
 
-You can choose between various deployment options in SigNoz apart from SigNoz cloud (shown above). 
+You can choose between various deployment options in SigNoz apart from SigNoz cloud (shown above).
 
 Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
diff --git a/data/comparisons/log-aggregation-tools.mdx b/data/comparisons/log-aggregation-tools.mdx
index 8d477b055..03dd928fb 100644
--- a/data/comparisons/log-aggregation-tools.mdx
+++ b/data/comparisons/log-aggregation-tools.mdx
@@ -1,25 +1,25 @@
 ---
 title: Top 9 Log Aggregation Tools [2025 Comprehensive Guide]
-slug: log-aggregation-tools
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [mary]
 description: Log aggregation is essential in software systems. Numerous components generate logs in a distributed software system. Log aggregation tools centralize log data from various sources, enabling efficient monitoring, troubleshooting, and analysis...
 image: /img/blog/2024/03/log-aggregation-tools-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [log-aggregation-tools,logs,opentelemetry,open-source,monitoring-tools,signoz]
-
+keywords: [log-aggregation-tools, logs, opentelemetry, open-source, monitoring-tools, signoz]
 ---
+
 Log aggregation is essential in software systems. In a distributed software system, there are numerous components that generate logs. Log aggregation tools centralize data from various sources, enabling efficient monitoring, troubleshooting, and analysis. This centralized approach makes monitoring, analysis, and troubleshooting much easier
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-cover.webp"
+    alt=""
+  />
 </figure>
 
-
-In this article, we will discuss [log aggregation tools](https://signoz.io/comparisons/log-aggregation-tools/#common-features-of-log-aggregation-tools),  how they work, the benefits they offer, the top log aggregation tools currently in use, and how to choose the right log aggregator for your applications.
+In this article, we will discuss [log aggregation tools](https://signoz.io/comparisons/log-aggregation-tools/#common-features-of-log-aggregation-tools), how they work, the benefits they offer, the top log aggregation tools currently in use, and how to choose the right log aggregator for your applications.
 
 ## What is Log Aggregation?
 
@@ -27,7 +27,7 @@ Log aggregation is the process of collecting log data generated by various syste
 
 ## Log Aggregation in Log Management
 
-Log management is a broader process that involves collecting, storing, processing, analyzing, monitoring, reporting, and disposing of log data to provide actionable insights for supporting troubleshooting, performance enhancement, or security monitoring. In the log management process,  log aggregation is a critical part that comes first, after which other parts such as analysis, monitoring, and reporting can then be done. 
+Log management is a broader process that involves collecting, storing, processing, analyzing, monitoring, reporting, and disposing of log data to provide actionable insights for supporting troubleshooting, performance enhancement, or security monitoring. In the log management process, log aggregation is a critical part that comes first, after which other parts such as analysis, monitoring, and reporting can then be done.
 
 ## What are Log Aggregation Tools
 
@@ -37,21 +37,26 @@ Log aggregation tools are software applications designed to collect, consolidate
 
 Log aggregation tools work following these series of steps:
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-process.webp" alt="How Log Aggregation Tools Work"/>
-    <figcaption><i>How Log Aggregation Tools Work</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-process.webp"
+    alt="How Log Aggregation Tools Work"
+  />
+  <figcaption>
+    <i>How Log Aggregation Tools Work</i>
+  </figcaption>
 </figure>
 
-
 - **Collection of Logs:** Log aggregation starts with the collection of log data from various sources that have been previously identified. This can be done through different methods; through a standard logging protocol known as Syslog, streaming protocols like SNMP, Netflow, or IPFIX from network devices, real-time sources through an agent, or directly from network devices or systems via API or network protocol integration. Some log aggregation tools also utilize a combination of these methods.
 
 - **Parsing:** After logs have been collected, the next step is to parse the log data to derive meaningful insights. The parsing process involves extracting key pieces of information from each logged event and organizing them into a common format. Since logs originating from diverse sources may have varying formats, parsing ensures that all extracted data follow a standardized format. During parsing, logs are also filtered to eliminate irrelevant entries or flag anomalies that may indicate security threats.
 
 - **Processing:** After the log data has been parsed, it is then processed. The processing may involve:
-    - Augmenting log data with additional context to provide more meaningful insights during analysis. This can include adding information such as hostnames, IP addresses, geographical locations, user identities, or any other relevant contextual data. This process is called enrichment.
-    - Masking sensitive data with placeholder values or pseudonyms to ensure compliance with privacy regulations and protect sensitive data.
-    - Correlating relationships and dependencies between different log events or across multiple log sources.
-    - Quality assurance checks to ensure accuracy, completeness, and consistency. This may involve validation against predefined rules or patterns to identify any anomalies, or errors in the log data.
+  - Augmenting log data with additional context to provide more meaningful insights during analysis. This can include adding information such as hostnames, IP addresses, geographical locations, user identities, or any other relevant contextual data. This process is called enrichment.
+  - Masking sensitive data with placeholder values or pseudonyms to ensure compliance with privacy regulations and protect sensitive data.
+  - Correlating relationships and dependencies between different log events or across multiple log sources.
+  - Quality assurance checks to ensure accuracy, completeness, and consistency. This may involve validation against predefined rules or patterns to identify any anomalies, or errors in the log data.
 
 **Storage:**
 
@@ -80,7 +85,7 @@ Let’s look at some of the features of log aggregation tools. The following are
 Now, let’s look at the benefits of log aggregation tools;
 
 - **Centralized Log Management:** One major benefit of log aggregation tools is that they provide a central platform for managing logs from various sources.
-- **Real-time Monitoring:**  Using log aggregation tools also helps provide real-time visibility into system and application events.
+- **Real-time Monitoring:** Using log aggregation tools also helps provide real-time visibility into system and application events.
 - **Easy debugging and troubleshooting:** By providing a comprehensive view of events, log aggregation tools enable easier troubleshooting and debugging.
 - **Trend identification** : Trends and patterns can be easily identified, and can be helpful in detecting anomalies, and optimizing system performance.
 - **Cost Saving:** By centralizing log management and analysis, log aggregation tools reduce the time and resources required for managing logs separately.
@@ -91,7 +96,9 @@ Let’s look at the top log aggregation tools that are currently in use. In this
 
 ### SigNoz
 
-<a href = "https://signoz.io" rel="noopener noreferrer nofollow" target="_blank" >SigNoz Website</a>
+<a href="https://signoz.io" rel="noopener noreferrer nofollow" target="_blank">
+  SigNoz Website
+</a>
 
 SigNoz is an open-source observability platform that provides logs, traces, and metrics in a single application. It is an open-source alternative to platforms like DataDog and NewRelic.
 
@@ -99,12 +106,17 @@ SigNoz natively supports [OpenTelemetry](https://signoz.io/blog/what-is-opentele
 
 SigNoz is available as open-source software and a cloud offering. Signing up for [SigNoz Cloud](https://signoz.io/teams/) is the easiest way to get started with SigNoz. You can also self-host SigNoz; instructions to self-host can be found [here](https://signoz.io/docs/install/).
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/signoz_live_logs.webp" alt="SigNoz Logs Dashboard"/>
-    <figcaption><i>SigNoz Logs Dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/common/signoz_live_logs.webp"
+    alt="SigNoz Logs Dashboard"
+  />
+  <figcaption>
+    <i>SigNoz Logs Dashboard</i>
+  </figcaption>
 </figure>
 
-
 **Features of SigNoz**
 
 - SigNoz provides metrics, traces, and logs under a single pane of glass.
@@ -126,16 +138,23 @@ SigNoz is available as open-source software and a cloud offering. Signing up for
 
 ### Sumo Logic
 
-<a href = "https://www.sumologic.com" rel="noopener noreferrer nofollow" target="_blank" >Sumo Logic Website</a>
-
-Sumo Logic is a platform that provides cloud monitoring, log management, and real-time insights for web and SaaS based apps. Sumo Logic provides exceptional log aggregation and [log parsing](https://signoz.io/guides/log-parsing/) functionality. It can collect logs from almost any system with timestamps and format and bring them together to support an end-to-end log management process. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-sumologic.webp" alt="Sumo Logic Logs Dashboard"/>
-    <figcaption><i>Sumo Logic Logs Dashboard (Source: Sumo Logic)</i></figcaption>
+<a href="https://www.sumologic.com" rel="noopener noreferrer nofollow" target="_blank">
+  Sumo Logic Website
+</a>
+
+Sumo Logic is a platform that provides cloud monitoring, log management, and real-time insights for web and SaaS based apps. Sumo Logic provides exceptional log aggregation and [log parsing](https://signoz.io/guides/log-parsing/) functionality. It can collect logs from almost any system with timestamps and format and bring them together to support an end-to-end log management process.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-sumologic.webp"
+    alt="Sumo Logic Logs Dashboard"
+  />
+  <figcaption>
+    <i>Sumo Logic Logs Dashboard (Source: Sumo Logic)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Powerful search and AI-powered analytics capabilities that can help reduce troubleshooting times.
@@ -157,16 +176,23 @@ Sumo Logic is a platform that provides cloud monitoring, log management, and re
 
 ### Logtail
 
-<a href = "https://betterstack.com" rel="noopener noreferrer nofollow" target="_blank" >BetterStack Website</a>
-
-Logtail(now known as BetterStack) is an observability tool with a log aggregation feature that collect logs across various stacks with SQL-compatible [structured logging](https://signoz.io/blog/structured-logs/) in real time. With Logtail you can  examine, organize, and store  logs in a structured format ,search them and create custom reports using SQL. You can then save the reports as a dashboard, giving you and your team an overview of your entire stack.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-logtail.webp" alt="Logtail Logs Dashboard"/>
-    <figcaption><i>Logtail Logs Dashboard (Source: BetterStack)</i></figcaption>
+<a href="https://betterstack.com" rel="noopener noreferrer nofollow" target="_blank">
+  BetterStack Website
+</a>
+
+Logtail(now known as BetterStack) is an observability tool with a log aggregation feature that collect logs across various stacks with SQL-compatible [structured logging](https://signoz.io/blog/structured-logs/) in real time. With Logtail you can examine, organize, and store logs in a structured format ,search them and create custom reports using SQL. You can then save the reports as a dashboard, giving you and your team an overview of your entire stack.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-logtail.webp"
+    alt="Logtail Logs Dashboard"
+  />
+  <figcaption>
+    <i>Logtail Logs Dashboard (Source: BetterStack)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - SQL-compatible structured log management.
@@ -182,16 +208,23 @@ Logtail(now known as BetterStack) is an observability tool with a log aggregatio
 
 ### Fluentd
 
-<a href = "https://www.fluentd.org" rel="noopener noreferrer nofollow" target="_blank" >Fluentd Website</a>
+<a href="https://www.fluentd.org" rel="noopener noreferrer nofollow" target="_blank">
+  Fluentd Website
+</a>
 
 Fluentd is an open-source data collector that enables the unification of data collection and consumption so as to enhance the understanding and usage of data. Fluentd is capable of collecting, parsing, transforming, analyzing, and storing various types of data. It prioritizes structuring data as JSON, and this allows it to effectively integrate all aspects of log data processing, including collection, filtering, buffering, and distribution, across various sources and destinations. It also provides a wide array of plugins to collect data from different sources and store it in different destinations.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-fluentd.webp" alt="Flentd Logs Dashboard"/>
-    <figcaption><i>Flentd Logs Dashboard (Source: Fluentd)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-fluentd.webp"
+    alt="Flentd Logs Dashboard"
+  />
+  <figcaption>
+    <i>Flentd Logs Dashboard (Source: Fluentd)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Unified logging with JSON.
@@ -212,17 +245,24 @@ Fluentd is an open-source data collector that enables the unification of data co
 
 ### LogStash
 
-<a href = "https://www.elastic.co/logstash" rel="noopener noreferrer nofollow" target="_blank" >LogStash Website</a>
+<a href="https://www.elastic.co/logstash" rel="noopener noreferrer nofollow" target="_blank">
+  LogStash Website
+</a>
 
 Logstash is part of the ELK(Elasticsearch, Logstash, Kibana) Stack, a widely used log analysis platform. It is an open-source data collection engine whose primary function involves aggregating data from various origins, processing it, and transmitting it along the pipeline, typically for direct indexing in Elasticsearch.
 Logstash can extract data from nearly any data source using its input plugins, apply diverse data transformations and enhancements through filter plugins, and dispatch the processed data to numerous destinations via output plugins.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-logstach.webp" alt="Logstash Visualization"/>
-    <figcaption><i>Logstash Visualization (Source: ElasticSearch)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-logstach.webp"
+    alt="Logstash Visualization"
+  />
+  <figcaption>
+    <i>Logstash Visualization (Source: ElasticSearch)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Open source.
@@ -241,16 +281,23 @@ Logstash can extract data from nearly any data source using its input plugins, a
 
 ### Splunk
 
-<a href = "https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank" >Splunk Website</a>
-
-Splunk is a comprehensive log analysis platform that collects, indexes, and analyzes massive volumes of machine-generated data from various sources, including messaging systems, databases, network devices, and more. With it’s Search Processing Language(SPL), Splunk makes it easy to search and analyze large amounts of data in real-time, and it also provides pre-built visualizations for creating  informative dashboards. Also, Splunk is does not only provide log analytics features, but also extend to application management, compliance, and security.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-splunk.webp" alt="Splunk Log View"/>
-    <figcaption><i>Splunk Log View (Source: Splunk)</i></figcaption>
+<a href="https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk Website
+</a>
+
+Splunk is a comprehensive log analysis platform that collects, indexes, and analyzes massive volumes of machine-generated data from various sources, including messaging systems, databases, network devices, and more. With it’s Search Processing Language(SPL), Splunk makes it easy to search and analyze large amounts of data in real-time, and it also provides pre-built visualizations for creating informative dashboards. Also, Splunk is does not only provide log analytics features, but also extend to application management, compliance, and security.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-splunk.webp"
+    alt="Splunk Log View"
+  />
+  <figcaption>
+    <i>Splunk Log View (Source: Splunk)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Splunk provides a dashboard and data visualization.
@@ -274,18 +321,25 @@ Splunk is a comprehensive log analysis platform that collects, indexes, and anal
 
 ### Datadog
 
-<a href = "https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank" >Datadog Website</a>
+<a href="https://www.datadoghq.com" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog Website
+</a>
 
 Datadog is a cloud-based monitoring and analytics platform that provides real-time insights into complex IT environments. It helps organizations of all sizes to monitor their infrastructure, applications, logs, and other data sources in a unified manner, enabling them to identify and resolve issues before they impact their customers quickly.
 
 At its core, Datadog collects data from various sources, including servers, databases, cloud services, containers, and other applications. It then uses it to create customizable dashboards, alerts, and reports that provide a comprehensive view of the entire infrastructure.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-datadog.webp" alt="Datadog Log Management Dashboard"/>
-    <figcaption><i>Datadog Log Management Dashboard (Source: Datadog)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-datadog.webp"
+    alt="Datadog Log Management Dashboard"
+  />
+  <figcaption>
+    <i>Datadog Log Management Dashboard (Source: Datadog)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Rapid troubleshooting and analytics with no querying language.
@@ -308,16 +362,23 @@ At its core, Datadog collects data from various sources, including servers, data
 
 ### New Relic
 
-<a href = "https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank" >New Relic Website</a>
+<a href="https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic Website
+</a>
 
 New Relic is a cloud-based network monitoring and observability platform for full-stack monitoring. New Relic offers a fast, scalable log management platform to collect and connect your logs with the rest of your telemetry and infrastructure data in a single place. This log management solution provides deeper visibility into application and infrastructure performance data (events, errors, traces, and more) to reduce mean time to resolution (MTTR) and quickly troubleshoot production incidents.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-newrelic.webp" alt="New Relic Logs Dashboard"/>
-    <figcaption><i>New Relic Logs Dashboard (Source: New Relic)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-newrelic.webp"
+    alt="New Relic Logs Dashboard"
+  />
+  <figcaption>
+    <i>New Relic Logs Dashboard (Source: New Relic)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - New Relic leverages the power of a central telemetry data platform.
@@ -338,19 +399,25 @@ New Relic is a cloud-based network monitoring and observability platform for fu
 
 ### SolarWinds Papertrail
 
-<a href = "https://www.papertrail.com" rel="noopener noreferrer nofollow" target="_blank" >Papertrail Website</a>
+<a href="https://www.papertrail.com" rel="noopener noreferrer nofollow" target="_blank">
+  Papertrail Website
+</a>
 
-SolarWinds Papertrail provides cloud-based log management solution that seamlessly aggregates logs from applications, servers, network devices, services, platforms, and much more. The live tail capability in Papertrail allows you to tail logs in real time, with pause, search, infinite scroll, and selectable log elements. 
+SolarWinds Papertrail provides cloud-based log management solution that seamlessly aggregates logs from applications, servers, network devices, services, platforms, and much more. The live tail capability in Papertrail allows you to tail logs in real time, with pause, search, infinite scroll, and selectable log elements.
 
 Papertrail can be used with a wide variety of log types, including Syslog, text log files, Apache, MySQL, Ruby on Rails, Windows events, Tomcat, Heroku apps, routers, firewalls, and many more.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/log-aggregation-tools-solarwinds.webp" alt="Papertrail Dashboard"/>
-    <figcaption><i>Papertrail Dashboard (Source: Papertrail)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/log-aggregation-tools-solarwinds.webp"
+    alt="Papertrail Dashboard"
+  />
+  <figcaption>
+    <i>Papertrail Dashboard (Source: Papertrail)</i>
+  </figcaption>
 </figure>
 
-
-
 **Features**
 
 - Built-in search functionality that utilizes query syntax methodology to filter data across multiple sources.
@@ -370,7 +437,7 @@ Papertrail can be used with a wide variety of log types, including Syslog, text
 
 ## Choosing the right Log Aggregation tool
 
-The first thing to consider when choosing a log aggregation tool is your need; consider the qualities and features of the log aggregation tool; does it align with your use case? does it meet the needs of your applications? can it handle the volume of logs generated by your systems? does it support the types of logs generated by your systems? is it compatible with your existing infrastructure? Also, check if the tool's storage capabilities, security, and encryption features,  as well as data retention policies, meet your requirements.
+The first thing to consider when choosing a log aggregation tool is your need; consider the qualities and features of the log aggregation tool; does it align with your use case? does it meet the needs of your applications? can it handle the volume of logs generated by your systems? does it support the types of logs generated by your systems? is it compatible with your existing infrastructure? Also, check if the tool's storage capabilities, security, and encryption features, as well as data retention policies, meet your requirements.
 
 Another factor you should consider is the pricing, log aggregation tools come with varying pricing models. Therefore, evaluating whether the tool fits your budget constraints is essential.
 
@@ -382,7 +449,6 @@ Log aggregation tools are crucial in efficiently managing log data and providing
 
 An open-source tool like [SigNoz](https://signoz.io/) is a good option to consider when deciding on log aggregation tools for your systems. SigNoz seamlessly integrates with OpenTelemetry and can aggregate logs from various sources. It also visualizes Traces, Metrics, and Logs in a single application, making it easy to manage, monitor, and analyze log data. Additionally, when using SigNoz, you can easily get support from its documentation and amazing open-source community.
 
-
 ## Getting Started with SigNoz
 
 <GetStartedSigNoz />
@@ -395,4 +461,4 @@ An open-source tool like [SigNoz](https://signoz.io/) is a good option to consid
 
 **[Log Monitoring 101 Detailed Guide [Included 10 Tips]](https://signoz.io/blog/log-monitoring/)**
 
-**[Top 11 Loki alternatives](https://signoz.io/blog/loki-alternatives/)**
\ No newline at end of file
+**[Top 11 Loki alternatives](https://signoz.io/blog/loki-alternatives/)**
diff --git a/data/comparisons/log-analysis-tools.mdx b/data/comparisons/log-analysis-tools.mdx
index ec661ca0f..f8483c8a8 100644
--- a/data/comparisons/log-analysis-tools.mdx
+++ b/data/comparisons/log-analysis-tools.mdx
@@ -1,151 +1,155 @@
 ---
-
 title: Top 10 Log Analysis Tools that You Must Consider [2025 Guide]
-slug: log-analysis-tools
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Discover the top 10 log analysis tools for IT professionals in 2024. Learn about essential features, selection criteria, and best practices for implementation.
 image: /img/blog/2024/04/log-analysis-tools-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [log-analysis-tools,logs,opentelemetry,open-source,monitoring-tools,signoz]
-
+keywords: [log-analysis-tools, logs, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
 <head>
   <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Top 10 Log Analysis Tools that You Must Consider [2024 Guide]",
-  "alternativeHeadline": "Discover the best log analysis tools for IT professionals in 2024",
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-09-30T00:00:00Z",
-  "dateModified": "2024-09-30T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/comparisons/log-analysis-tools/"
-  },
-  "description": "Discover the top 10 log analysis tools for IT professionals in 2024. Learn about essential features, selection criteria, and best practices for implementation.",
-  "keywords": "log-analysis-tools, logs, opentelemetry, open-source, monitoring-tools, signoz",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Log Analysis",
-      "description": "The process of examining and interpreting log data to gain insights into system behavior and performance"
-    },
-    {
-      "@type": "Thing",
-      "name": "IT Monitoring",
-      "description": "The practice of overseeing and managing IT systems to ensure optimal performance and security"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Log Analysis Tool"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Splunk",
-      "applicationCategory": "Log Analysis Tool"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Graylog",
-      "applicationCategory": "Log Analysis Tool"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What are log analysis tools and why are they important?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Log analysis tools are software applications designed to collect, process, and analyze log data generated by various IT systems and applications. They are important because they help IT professionals improve security, troubleshoot issues faster, monitor performance, and manage compliance by providing critical insights into system behavior and events."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the essential features of effective log analysis tools?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Essential features of effective log analysis tools include real-time log ingestion and processing, advanced search and filtering capabilities, visualization and dashboarding, alerting and notification systems, machine learning and AI-powered anomaly detection, scalability, integration capabilities, and compliance and security features."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I choose the right log analysis tool for my organization?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To choose the right log analysis tool, consider factors such as data collection and ingestion capabilities, cost, scalability, integration with existing IT infrastructure, ease of use, visualization options, and whether an open-source or proprietary solution better aligns with your organization's needs and budget. It's also important to evaluate the tool's ability to meet your specific use cases and compliance requirements."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Get Started with SigNoz for Log Analysis",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install SigNoz",
-        "text": "Choose between self-hosted or cloud options and follow the documentation for your chosen deployment method."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Log Sources",
-        "text": "Set up log collectors for your applications and systems, and configure log parsing and structuring rules."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create Custom Dashboards",
-        "text": "Design dashboards tailored to your specific use cases and utilize SigNoz's visualization tools for effective data representation."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Set Up Alerts",
-        "text": "Define alerting rules based on log patterns or thresholds and configure notification channels (e.g., email, Slack)."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Explore Advanced Features",
-        "text": "Leverage SigNoz's machine learning capabilities for anomaly detection and integrate with other observability data (metrics, traces) for comprehensive analysis."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Top 10 Log Analysis Tools that You Must Consider [2024 Guide]',
+        alternativeHeadline: 'Discover the best log analysis tools for IT professionals in 2024',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-09-30T00:00:00Z',
+        dateModified: '2024-09-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/comparisons/log-analysis-tools/',
+        },
+        description:
+          'Discover the top 10 log analysis tools for IT professionals in 2024. Learn about essential features, selection criteria, and best practices for implementation.',
+        keywords: 'log-analysis-tools, logs, opentelemetry, open-source, monitoring-tools, signoz',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Log Analysis',
+            description:
+              'The process of examining and interpreting log data to gain insights into system behavior and performance',
+          },
+          {
+            '@type': 'Thing',
+            name: 'IT Monitoring',
+            description:
+              'The practice of overseeing and managing IT systems to ensure optimal performance and security',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Log Analysis Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Splunk',
+            applicationCategory: 'Log Analysis Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Graylog',
+            applicationCategory: 'Log Analysis Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are log analysis tools and why are they important?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Log analysis tools are software applications designed to collect, process, and analyze log data generated by various IT systems and applications. They are important because they help IT professionals improve security, troubleshoot issues faster, monitor performance, and manage compliance by providing critical insights into system behavior and events.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the essential features of effective log analysis tools?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Essential features of effective log analysis tools include real-time log ingestion and processing, advanced search and filtering capabilities, visualization and dashboarding, alerting and notification systems, machine learning and AI-powered anomaly detection, scalability, integration capabilities, and compliance and security features.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I choose the right log analysis tool for my organization?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "To choose the right log analysis tool, consider factors such as data collection and ingestion capabilities, cost, scalability, integration with existing IT infrastructure, ease of use, visualization options, and whether an open-source or proprietary solution better aligns with your organization's needs and budget. It's also important to evaluate the tool's ability to meet your specific use cases and compliance requirements.",
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Get Started with SigNoz for Log Analysis',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install SigNoz',
+              text: 'Choose between self-hosted or cloud options and follow the documentation for your chosen deployment method.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Log Sources',
+              text: 'Set up log collectors for your applications and systems, and configure log parsing and structuring rules.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create Custom Dashboards',
+              text: "Design dashboards tailored to your specific use cases and utilize SigNoz's visualization tools for effective data representation.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Alerts',
+              text: 'Define alerting rules based on log patterns or thresholds and configure notification channels (e.g., email, Slack).',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Explore Advanced Features',
+              text: "Leverage SigNoz's machine learning capabilities for anomaly detection and integrate with other observability data (metrics, traces) for comprehensive analysis.",
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
 Logs are essential for diagnosing downtimes, identifying security breaches, and troubleshooting errors. As systems and applications are in operation, they tend to produce a vast array of log files depending on the complexity of the system, the number of applications running, and the configurations in place. In the event of an application or system error, manually gathering and reviewing these logs for troubleshooting purposes can be time-consuming.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-cover.webp"
+    alt=""
+  />
 </figure>
 
 Adopting a log analysis tool is highly recommended to streamline this process and remove the manual burden. Log analysis tools automate the process of collecting, parsing, and analyzing log data, making troubleshooting more efficient and less time-consuming. They are software applications that collect, parse, and analyze log data to help developers monitor, debug, and optimize their applications.
@@ -212,25 +216,43 @@ SigNoz uses OpenTelemetry for instrumenting applications. OpenTelemetry, backed
 
 After sending logs to SigNoz, you can use an intuitive [query builder](https://signoz.io/blog/query-builder-v5/) to filter and search through your logs. You can build charts, save views for quick access, and set up alerts.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-logs-query-builder.webp" alt="An intuitive logs query builder to search and filter through logs"/>
-<figcaption><i>An intuitive logs query builder to search and filter through logs</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-logs-query-builder.webp"
+    alt="An intuitive logs query builder to search and filter through logs"
+  />
+  <figcaption>
+    <i>An intuitive logs query builder to search and filter through logs</i>
+  </figcaption>
 </figure>
 
 [Save views](https://signoz.io/docs/product-features/saved-view/) for quick access later.
 
 You can view your logs in detailed view with attributes, in `json` format and context tab that shows logs before and after the selected log from the same source.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-log-detailed-view.webp" alt="Log detailed view for a selected log line in SigNoz"/>
-<figcaption><i>Log detailed view for a selected log line in SigNoz</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-log-detailed-view.webp"
+    alt="Log detailed view for a selected log line in SigNoz"
+  />
+  <figcaption>
+    <i>Log detailed view for a selected log line in SigNoz</i>
+  </figcaption>
 </figure>
 
 You can also view logs in real time with live tail logging.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-tail-logging.webp" alt="Live Tail Logging in SigNoz"/>
-<figcaption><i>Live Tail Logging in SigNoz</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-tail-logging.webp"
+    alt="Live Tail Logging in SigNoz"
+  />
+  <figcaption>
+    <i>Live Tail Logging in SigNoz</i>
+  </figcaption>
 </figure>
 
 With Logs Pipelines, you can transform logs to suit your querying and aggregation needs before they get stored in the database, thus saving a lot of cost.
@@ -243,9 +265,15 @@ Splunk is a software platform that specializes in the collection, analysis, and
 
 Splunk ingests data from various sources, including logs, network traffic, and other machine-generated data. This data is then indexed and stored in a searchable format. Users can query this data using Splunk's proprietary search language, SPL (Search Processing Language), to find specific events, patterns, or anomalies within the data.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-splunk.webp" alt="Log Observer in Splunk"/>
-<figcaption><i>Log Observer in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-splunk.webp"
+    alt="Log Observer in Splunk"
+  />
+  <figcaption>
+    <i>Log Observer in Splunk</i>
+  </figcaption>
 </figure>
 
 Some key features of Splunk are:
@@ -263,9 +291,15 @@ Graylog ingests log data from various sources, including servers, applications,
 
 Graylog supports a wide range of data formats, including syslog, log4j, and many others, making it versatile for analyzing different types of log data.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-graylog.webp" alt="Graylog Log Analysis"/>
-<figcaption><i>Graylog Log Analysis</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-graylog.webp"
+    alt="Graylog Log Analysis"
+  />
+  <figcaption>
+    <i>Graylog Log Analysis</i>
+  </figcaption>
 </figure>
 
 Some key features of Graylog are:
@@ -282,9 +316,15 @@ Some key features of Graylog are:
 
 SumoLogic is a leading cloud-native SaaS log analytics platform. It centrally collects and analyzes log data in real-time, enabling organizations to proactively troubleshoot and resolve issues before they can impact the health and performance of their applications and systems.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-sumologic.webp" alt="Log analysis in Sumo Logic"/>
-<figcaption><i>Log analysis in Sumo Logic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-sumologic.webp"
+    alt="Log analysis in Sumo Logic"
+  />
+  <figcaption>
+    <i>Log analysis in Sumo Logic</i>
+  </figcaption>
 </figure>
 
 Some key features of Sumo Logic are:
@@ -300,9 +340,15 @@ Elasticsearch is a powerful log analysis tool that is part of the <a href = "ht
 
 Elasticsearch works hand in hand with Logstash and Kibana for log analysis. Logstash is primarily responsible for collecting, parsing, and processing logs from a variety of sources. Once processed, these logs are then sent to Elasticsearch for analysis. Kibana, on the other hand, is utilized for visualizing the ingested log data, allowing users to filter and search through the data more effectively.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-elasticsearch.webp" alt="Log parsing in log pipelines"/>
-<figcaption><i>Log parsing in log pipelines</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-elasticsearch.webp"
+    alt="Log parsing in log pipelines"
+  />
+  <figcaption>
+    <i>Log parsing in log pipelines</i>
+  </figcaption>
 </figure>
 
 Some key features of Elasticsearch are:
@@ -318,9 +364,15 @@ Datadog is a comprehensive monitoring and analytics platform that excels as a lo
 
 Datadog transforms unstructured streams of raw log data into centralized, structured datasets. It automatically applies tags to logs after ingestion and lets you analyze large volumes of log data and perform complex investigations without having to learn a complex query language.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-datadog.webp" alt="Searching through ingested log data without a query language"/>
-<figcaption><i>Searching through ingested log data without a query language</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-datadog.webp"
+    alt="Searching through ingested log data without a query language"
+  />
+  <figcaption>
+    <i>Searching through ingested log data without a query language</i>
+  </figcaption>
 </figure>
 
 Some key features of Datadog are;
@@ -332,11 +384,27 @@ Some key features of Datadog are;
 
 ## Logwatch
 
-<a href = "https://ubuntu.com/server/docs/logwatch" rel="noopener noreferrer nofollow" target="_blank" >Logwatch</a> is an open-source log analysis tool designed to automatically parse and analyze log files from various services and applications running on Linux or Unix-based systems. It presents a summary of the log data, including system activity, security events, and potential issues in a detailed, easy-to-read format, making it simple to identify and troubleshoot problems.
-
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-logwatch.webp" alt="Logwatch log analyzer"/>
-<figcaption><i>Logwatch log analyzer</i></figcaption>
+<a
+  href="https://ubuntu.com/server/docs/logwatch"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Logwatch
+</a>
+ is an open-source log analysis tool designed to automatically parse and analyze log files from
+various services and applications running on Linux or Unix-based systems. It presents a summary of
+the log data, including system activity, security events, and potential issues in a detailed,
+easy-to-read format, making it simple to identify and troubleshoot problems.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-logwatch.webp"
+    alt="Logwatch log analyzer"
+  />
+  <figcaption>
+    <i>Logwatch log analyzer</i>
+  </figcaption>
 </figure>
 
 Some key features of Logwatch:
@@ -353,9 +421,15 @@ LogicMonitor is a cloud-based [infrastructure monitoring](https://signoz.io/guid
 
 As logs are being ingested into the platform, Logic Monitor parses the information contained within log lines, making it readily available for searching and data analysis. This methodology allows for a more efficient and accurate analysis of log data.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-logic-monitor.webp" alt="Visualization of ingested logs"/>
-<figcaption><i>Visualization of ingested logs</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-logic-monitor.webp"
+    alt="Visualization of ingested logs"
+  />
+  <figcaption>
+    <i>Visualization of ingested logs</i>
+  </figcaption>
 </figure>
 
 Some key features of Logic Monitor are;
@@ -369,9 +443,15 @@ Some key features of Logic Monitor are;
 
 Sematext is a comprehensive log management platform that extends the capabilities of the Elastic Stack. This allows it to ingest logs from a wide variety of sources, such as log shippers, logging libraries, and more. Sematext provides robust searching, filtering, and tagging functionalities for efficient log analysis and anomaly detection.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-sematext.webp" alt="Log analysis UI in Sematext"/>
-<figcaption><i>Log analysis UI in Sematext</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-sematext.webp"
+    alt="Log analysis UI in Sematext"
+  />
+  <figcaption>
+    <i>Log analysis UI in Sematext</i>
+  </figcaption>
 </figure>
 
 Some key features of Sematext are;
@@ -387,9 +467,15 @@ SolarWinds provides a wide range of products designed to help organizations mana
 
 SolarWinds Log Analyzer provides a powerful keyword search engine that allows users to search through logs without the need for any query language. Additionally, it comes with predefined filters that enable users to quickly identify logs based on criteria such as severity level and IP address, streamlining the process of troubleshooting and monitoring. As logs are ingested, it automatically assigns a severity indicator to each log entry, helping users to quickly identify and prioritize performance issues.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/04/log-analysis-tools-solarwind.webp" alt="Log analysis in SolarWind’s log viewer"/>
-<figcaption><i>Log analysis in SolarWind’s log viewer</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/log-analysis-tools-solarwind.webp"
+    alt="Log analysis in SolarWind’s log viewer"
+  />
+  <figcaption>
+    <i>Log analysis in SolarWind’s log viewer</i>
+  </figcaption>
 </figure>
 
 Some key features of SolarWinds are;
@@ -420,20 +506,20 @@ Selecting the appropriate log analysis tool involves evaluating several key fact
 SigNoz offers a powerful, open-source solution for log analysis that combines ease of use with advanced features. Here's how to get started:
 
 1. **Install SigNoz**:
-    - Choose between self-hosted or cloud options
-    - Follow the documentation for your chosen deployment method
+   - Choose between self-hosted or cloud options
+   - Follow the documentation for your chosen deployment method
 2. **Configure Log Sources**:
-    - Set up log collectors for your applications and systems
-    - Configure [log parsing](https://signoz.io/guides/log-parsing/) and structuring rules
+   - Set up log collectors for your applications and systems
+   - Configure [log parsing](https://signoz.io/guides/log-parsing/) and structuring rules
 3. **Create Custom Dashboards**:
-    - Design dashboards tailored to your specific use cases
-    - Utilize SigNoz's visualization tools for effective data representation
+   - Design dashboards tailored to your specific use cases
+   - Utilize SigNoz's visualization tools for effective data representation
 4. **Set Up Alerts**:
-    - Define alerting rules based on log patterns or thresholds
-    - Configure notification channels (e.g., email, Slack)
+   - Define alerting rules based on log patterns or thresholds
+   - Configure notification channels (e.g., email, Slack)
 5. **Explore Advanced Features**:
-    - Leverage SigNoz's machine learning capabilities for anomaly detection
-    - Integrate with other observability data (metrics, traces) for comprehensive analysis
+   - Leverage SigNoz's machine learning capabilities for anomaly detection
+   - Integrate with other observability data (metrics, traces) for comprehensive analysis
 
 <GetStartedSigNoz />
 
@@ -444,23 +530,23 @@ By following these steps, you can quickly set up a robust log analysis solution
 To maximize the value of your chosen [log analysis tool](https://signoz.io/comparisons/log-analysis-tools/#solarwinds), follow these best practices:
 
 1. **Define Clear Goals and Use Cases**:
-    - Identify specific objectives for your log analysis implementation
-    - Prioritize use cases based on business impact
+   - Identify specific objectives for your log analysis implementation
+   - Prioritize use cases based on business impact
 2. **Establish a Centralized Log Collection and Retention Strategy**:
-    - Implement a consistent log collection method across all systems
-    - Define [log retention](https://signoz.io/guides/log-retention/) policies based on compliance requirements and operational needs
+   - Implement a consistent log collection method across all systems
+   - Define [log retention](https://signoz.io/guides/log-retention/) policies based on compliance requirements and operational needs
 3. **Implement Proper Log Security and Access Controls**:
-    - Encrypt log data in transit and at rest
-    - Implement role-based access control for log data
+   - Encrypt log data in transit and at rest
+   - Implement role-based access control for log data
 4. **Train Your Team on Effective Log Analysis Techniques**:
-    - Provide training on the chosen tool and log analysis best practices
-    - Encourage knowledge sharing among team members
+   - Provide training on the chosen tool and log analysis best practices
+   - Encourage knowledge sharing among team members
 5. **Regularly Review and Optimize Your Log Analysis Processes**:
-    - Periodically assess the effectiveness of your log analysis implementation
-    - Continuously refine alerting rules and dashboards based on evolving needs
+   - Periodically assess the effectiveness of your log analysis implementation
+   - Continuously refine alerting rules and dashboards based on evolving needs
 6. **Integrate Log Analysis with Other IT Processes**:
-    - Incorporate log analysis into incident response procedures
-    - Use log insights to inform capacity planning and performance optimization
+   - Incorporate log analysis into incident response procedures
+   - Use log insights to inform capacity planning and performance optimization
 
 By following these best practices, you can ensure that your log analysis implementation delivers maximum value to your organization.
 
@@ -509,4 +595,4 @@ By carefully considering these factors, you can select and implement a log analy
 
 **Further Reading:**
 
-[7 Open-Source Log Management Tools that you may consider in 2024](https://signoz.io/blog/open-source-log-management/)
\ No newline at end of file
+[7 Open-Source Log Management Tools that you may consider in 2024](https://signoz.io/blog/open-source-log-management/)
diff --git a/data/comparisons/logicmonitor-competitors.mdx b/data/comparisons/logicmonitor-competitors.mdx
index 4f3002f40..208df958e 100644
--- a/data/comparisons/logicmonitor-competitors.mdx
+++ b/data/comparisons/logicmonitor-competitors.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top LogicMonitor Alternatives in 2025
-slug: logicmonitor-competitors
 date: 2025-03-13
 tags: [Network Monitoring, IT Monitoring, Observability, SRE]
 authors: [manjunath_irukulla]
 description: Explore the top LogicMonitor competitors and alternatives for network monitoring, IT infrastructure monitoring, and observability in 2025.
-keywords: [logicmonitor competitors, logicmonitor alternatives, network monitoring tools, IT monitoring software, observability platforms]
-
+keywords:
+  [
+    logicmonitor competitors,
+    logicmonitor alternatives,
+    network monitoring tools,
+    IT monitoring software,
+    observability platforms,
+  ]
 ---
 
 LogicMonitor is a popular IT monitoring platform that offers comprehensive infrastructure visibility. However, no single monitoring solution works best for everyone. Your specific needs, budget, and technical requirements might make other options more suitable for your business.
@@ -15,36 +19,48 @@ LogicMonitor is a popular IT monitoring platform that offers comprehensive infra
 This guide compares the top [LogicMonitor alternatives](https://signoz.io/comparisons/logicmonitor-competitors/#splunk) for 2025, helping you choose the right monitoring tool for your needs.
 
 <KeyPointCallout title="Quick Answer">
-For developers and SREs: SigNoz and Prometheus+Grafana are top open-source alternatives with full observability capabilities. For enterprises, Datadog offers 750+ integrations and unified monitoring, while Dynatrace provides AI-powered automation. New Relic's usage-based pricing (with 100GB free) works well for growing teams, and specialized tools like Splunk excel at log analytics and security monitoring.
+  For developers and SREs: SigNoz and Prometheus+Grafana are top open-source alternatives with full
+  observability capabilities. For enterprises, Datadog offers 750+ integrations and unified
+  monitoring, while Dynatrace provides AI-powered automation. New Relic's usage-based pricing (with
+  100GB free) works well for growing teams, and specialized tools like Splunk excel at log analytics
+  and security monitoring.
 </KeyPointCallout>
 
 ## Why People Look for LogicMonitor Alternatives
 
 LogicMonitor is a cloud-based IT infrastructure monitoring and analytics platform that provides businesses with real-time insights into the health and performance of their IT systems. It offers comprehensive monitoring across hybrid environments, including on-premises infrastructure, cloud services, and applications, all through an agentless, automated platform.
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-LogicMonitor_Dashboard.webp" alt="LogicMonitor Dashboard" caption="LogicMonitor Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-LogicMonitor_Dashboard.webp"
+  alt="LogicMonitor Dashboard"
+  caption="LogicMonitor Dashboard"
+/>
 
 While LogicMonitor is a comprehensive IT infrastructure monitoring solution, some organizations seek alternatives due to specific limitations or requirements:
 
 **Cost Issues:**
+
 - High enterprise licensing fees, especially as you grow
 - Fixed pricing instead of pay-per-use options
 - Hidden costs for add-ons and premium features
 - Lack of pricing transparency (often requiring sales contact with no free trial)
 
 **Technical Limitations:**
+
 - Struggles with very large or complex environments
 - Difficult integration with hybrid cloud setups
 - Missing advanced features available in other tools
 - Limited support for modern cloud-native applications and Kubernetes
 
 **User Experience Problems:**
+
 - Complex interface for new users
 - Steep learning curve without proper training
 - Incomplete documentation for troubleshooting
 - Dashboards that aren't as customizable as some alternatives
 
 **Business Concerns:**
+
 - Slow support response for critical issues
 - Limited availability in some regions
 - Incomplete compliance with industry standards like HIPAA and GDPR
@@ -56,31 +72,35 @@ Let's examine each alternative to help you find the best monitoring solution for
 ### SigNoz
 
 <div className="overflow-hidden rounded-xl shadow-2xl">
-    <video autoPlay muted loop className="lg:w-[120%]">
+  <video autoPlay muted loop className="lg:w-[120%]">
     <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
     Your browser does not support the video tag.
-    </video>
+  </video>
 </div>
 
 [SigNoz](https://signoz.io/) is an open-source observability platform built on OpenTelemetry. It combines logs, metrics, and traces in a single dashboard. Unlike paid tools, you can host it yourself, saving money while keeping complete control of your data.
 
 **Key Benefits:**
+
 - **Free Open-Source Option:** Get enterprise features like [distributed tracing](https://signoz.io/blog/distributed-tracing/) without the high cost
 - **Easy Integration:** Works natively with OpenTelemetry for simple setup
 - **Flexible Deployment:** Run in the cloud or on your own servers
 - **No Per-Host Fees:** Usage-based pricing model is more predictable for containerized environments
 
 **Performance:**
+
 - Uses ClickHouse database for fast data storage and retrieval
 - Monitors system and application performance in real-time
 - Provides unified UI for metrics, traces, and logs with advanced filtering
 - Supports real-time application performance insights with root-cause analysis
 
 **Limitations:**
+
 - Requires some knowledge of OpenTelemetry
 - Setup and maintenance effort needed if self-hosting
 
 **Pricing:**
+
 - Free self-hosted community edition
 - Cloud SaaS from ~\$49/month (usage-based)
 - Logs \$0.30/GB, metrics \$0.10 per 1M samples (15-30 day retention)
@@ -89,17 +109,23 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### Datadog
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-Datadog_Dashboard.webp" alt="Datadog Monitoring Dashboard" caption="Datadog Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-Datadog_Dashboard.webp"
+  alt="Datadog Monitoring Dashboard"
+  caption="Datadog Monitoring Dashboard"
+/>
 
 [Datadog](https://www.datadoghq.com/) is a cloud-based platform that monitors infrastructure, analyzes security, and manages logs. With over 750 integrations and AI-powered anomaly detection, it's popular for complex environments.
 
 **Key Benefits:**
+
 - **Complete Monitoring:** Watches cloud, on-premises, and hybrid environments
 - **AI Insights:** Uses machine learning to reduce false alarms
 - **Highly Scalable:** Handles large cloud environments with ease
 - **Unified Platform:** Combines metrics, traces, logs, and security in one solution
 
 **Performance:**
+
 - Provides security monitoring with threat detection
 - Tracks compliance with regulations
 - Offers polished dashboards for quick insights
@@ -107,12 +133,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Strong support for Kubernetes and cloud-native applications
 
 **Limitations:**
+
 - Costs increase quickly as you add data and integrations
 - Per-host pricing can be expensive for microservices
 - Complex pricing model can lead to unexpected charges
 - Data is hosted in vendor's cloud, which may not meet strict governance requirements
 
 **Pricing:**
+
 - Free tier (up to 5 hosts)
 - Pro ~\$15/host/month (annual) for core features
 - Enterprise ~\$23/host with advanced AI and 15-month retention
@@ -122,17 +150,23 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### New Relic
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-new-relic-kpi-dashboard-geckoboard.webp" alt="New Relic Server Monitoring Dashboard" caption="New Relic Server Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-new-relic-kpi-dashboard-geckoboard.webp"
+  alt="New Relic Server Monitoring Dashboard"
+  caption="New Relic Server Monitoring Dashboard"
+/>
 
 [New Relic](https://newrelic.com/) specializes in application performance monitoring (APM), providing insights into code execution, user experience, and system health. Used by over 15 million developers, it helps identify performance bottlenecks.
 
 **Key Benefits:**
+
 - **Deep Application Insight:** Tracks performance from backend to frontend
 - **Real-Time Data:** Shows performance issues as they happen
 - **Works Everywhere:** Integrates with many technologies and environments
 - **Developer-Friendly:** Offers intuitive visualizations and custom queries (NRQL)
 
 **Performance:**
+
 - Uses AI to detect unusual patterns automatically
 - Alerts teams to problems before customers notice
 - Auto-instruments many languages with minimal configuration
@@ -140,12 +174,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Supports [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) data ingestion
 
 **Limitations:**
+
 - Pricing increases with usage, especially for large companies
 - Learning curve for full-stack monitoring features
 - Per-user fees can make it expensive for large teams
 - Interface can feel busy given the breadth of features
 
 **Pricing:**
+
 - Free tier (100 GB/month, 1 user)
 - Usage-based at \$0.30 per GB of data beyond free limit
 - Additional costs for user licenses
@@ -154,17 +190,23 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### Dynatrace
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-k8s-workload-overview-dashboard.webp" alt="Dynatrace Kubernetes Workload Monitor Dashboard" caption="Dynatrace Kubernetes Workload Monitor Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-k8s-workload-overview-dashboard.webp"
+  alt="Dynatrace Kubernetes Workload Monitor Dashboard"
+  caption="Dynatrace Kubernetes Workload Monitor Dashboard"
+/>
 
 [Dynatrace](https://www.dynatrace.com/) is an advanced APM solution that uses AI to monitor applications, infrastructure, and user experience. It helps enterprises ensure optimal performance through automated root cause analysis.
 
 **Key Benefits:**
+
 - **AI-Powered Analysis:** Automatically finds the root cause of problems with Davis AI
 - **End-to-End Visibility:** Monitors everything from user experience to backend systems
 - **Automatic Mapping:** Shows how all your applications connect to each other (Smartscape)
 - **Built for Cloud:** Works well with modern cloud environments including Kubernetes and serverless
 
 **Performance:**
+
 - Reduces time to detect and fix problems through AI analysis
 - Handles complex enterprise environments
 - PurePath provides end-to-end code-level tracing for every transaction
@@ -172,12 +214,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Excels in cloud-native environments
 
 **Limitations:**
+
 - Requires training to use advanced features
 - Premium pricing not ideal for smaller organizations
 - Can feel heavyweight with numerous features
 - Less flexible for ad-hoc open-source integrations
 
 **Pricing:**
+
 - Usage-based pricing (pay-as-you-go): ~\$0.08 per hour per 8GiB host for full-stack monitoring
 - Custom pricing for enterprise
 - Overall higher cost tier but includes advanced automation
@@ -186,29 +230,37 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### Zabbix
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-Zabbix_Dashboard.webp" alt="Zabbix Monitoring Dashboard" caption="Zabbix Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-Zabbix_Dashboard.webp"
+  alt="Zabbix Monitoring Dashboard"
+  caption="Zabbix Monitoring Dashboard"
+/>
 
 [Zabbix](https://www.zabbix.com/) is an open-source tool for monitoring IT infrastructure, including servers, applications, and networks. It offers over 400 built-in templates for monitoring different systems.
 
 **Key Benefits:**
+
 - **Free to Use:** No licensing fees makes it budget-friendly
 - **Comprehensive Coverage:** Monitors networks, servers, applications, and cloud
 - **Highly Customizable:** Adapts to your specific monitoring needs
 - **Flexible Deployment:** Can be installed on-premises or in the cloud
 
 **Performance:**
+
 - Stores long-term data for trend analysis
 - Automates actions based on triggers you define
 - Supports distributed monitoring with proxies
 - Handles basic server, network, and service monitoring efficiently
 
 **Limitations:**
+
 - Requires significant setup for complex environments
 - Steeper learning curve than some alternatives
 - Focuses on infrastructure and basic application checks
 - Limited APM capabilities compared to specialized tools
 
 **Pricing:**
+
 - Free open-source (costs only for hardware and maintenance)
 - Commercial support available separately
 
@@ -216,23 +268,30 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### PRTG Network Monitor
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-PRTG_Network_Monitoring.webp" alt="PRTG Server Monitoring Dashboard" caption="PRTG Server Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-PRTG_Network_Monitoring.webp"
+  alt="PRTG Server Monitoring Dashboard"
+  caption="PRTG Server Monitoring Dashboard"
+/>
 
 [PRTG Network Monitor](https://www.paessler.com/prtg) is a comprehensive solution for network, IT infrastructure, and service monitoring. It shows real-time network health to help you detect and fix issues before they affect operations.
 
 **Key Benefits:**
+
 - **All-in-One Solution:** Monitors network devices, servers, and virtual environments
 - **Custom Alerts:** Notifies you based on thresholds you set
 - **Easy to Use:** Features simple setup and user-friendly interface
 - **Unified View:** Provides a single dashboard for all monitored components
 
 **Performance:**
+
 - Provides real-time visibility into network health
 - Detects issues before they impact operations
 - Offers detailed migration guides from other tools
 - Includes sensors for various technologies and protocols
 
 **Limitations:**
+
 - May need extra configuration for advanced use
 - Can be resource-intensive when monitoring many devices
 - Less focused on application-level monitoring
@@ -242,11 +301,16 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### Splunk
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-Splunk__Logs_Dashboard.webp" alt="Splunk Website Monitoring Dashboard" caption="Splunk Website Monitoring Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-Splunk__Logs_Dashboard.webp"
+  alt="Splunk Website Monitoring Dashboard"
+  caption="Splunk Website Monitoring Dashboard"
+/>
 
 [Splunk](https://www.splunk.com/) is a leading platform for analyzing machine data and managing security events. Organizations use it for log management, security monitoring, and compliance.
 
 **Key Benefits:**
+
 - **Powerful Log Analysis:** Processes huge amounts of data quickly with SPL query language
 - **Advanced Security:** Detects threats 50% faster with machine learning
 - **Handles High Volume:** Scales to enterprise-level data needs
@@ -254,6 +318,7 @@ Let's examine each alternative to help you find the best monitoring solution for
 - **Dual Purpose:** Serves both IT operations and security teams
 
 **Performance:**
+
 - Uses Splunk Processing Language (SPL) for deep log analysis
 - Processes massive amounts of data efficiently
 - AI-driven IT Service Intelligence (ITSI) predicts and detects incidents
@@ -261,12 +326,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Includes incident response integration with war-room collaboration
 
 **Limitations:**
+
 - Expensive, starting around \$2,000/month for just 5GB/day
 - Needs robust infrastructure for large deployments
 - Steep learning curve for mastering SPL
 - Separate UIs for core Splunk and newer components
 
 **Pricing:**
+
 - Modular pricing: Infrastructure Monitoring ~\$15 per host/month
 - APM ~\$55 per host
 - Real User Monitoring ~\$14 per 10k sessions
@@ -276,11 +343,16 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### AppDynamics
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-database-dashboard_hardware-metrics.webp" alt="AppDynamics Database Dashboard" caption="AppDynamics Database Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-database-dashboard_hardware-metrics.webp"
+  alt="AppDynamics Database Dashboard"
+  caption="AppDynamics Database Dashboard"
+/>
 
 [AppDynamics](https://www.splunk.com/en_us/appdynamics-joins-splunk.html?301=appdynamics), now owned by Cisco, provides visibility into application performance, infrastructure health, and business impact. It helps organizations monitor complex systems and improve user experiences.
 
 **Key Benefits:**
+
 - **Business Impact Focus:** Links application performance to business outcomes
 - **Complete Stack Visibility:** Monitors frontend, backend, and database layers
 - **AI-Powered Analysis:** Finds and fixes issues 30% faster
@@ -288,6 +360,7 @@ Let's examine each alternative to help you find the best monitoring solution for
 - **Collaboration Tools:** Features "virtual war room" for incident response
 
 **Performance:**
+
 - Tracks user interactions and application responsiveness
 - Correlates technical issues with business metrics
 - Instruments at the code level, tracing transactions across distributed services
@@ -295,12 +368,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Includes security vulnerability detection in runtime
 
 **Limitations:**
+
 - Requires dedicated resources for setup and management
 - Premium pricing not suitable for smaller businesses
 - Complex to implement fully in large environments
 - Less modern interface compared to newer tools
 
 **Pricing:**
+
 - Enterprise pricing (custom quotes)
 - Infrastructure monitoring starts around \$6 per CPU core/month
 - Full APM for large deployments is costly
@@ -309,17 +384,23 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### IBM Instana
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-instana-dashboard.webp" alt="IBM Instana Dashboard" caption="IBM Instana Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-instana-dashboard.webp"
+  alt="IBM Instana Dashboard"
+  caption="IBM Instana Dashboard"
+/>
 
 [Instana](https://www.ibm.com/products/instana) is an automated application performance monitoring tool designed for modern cloud-native applications. It provides real-time observability with minimal configuration.
 
 **Key Benefits:**
+
 - **Automatic Discovery:** Instantly maps all services and dependencies
 - **Zero Configuration:** Deploys agents that auto-instrument applications
 - **Real-Time Monitoring:** Provides metrics at 1-second intervals
 - **AI-Assisted Analysis:** Identifies root causes across cascading failures
 
 **Performance:**
+
 - Continuously detects new components or changes
 - Provides high-granularity metrics with low latency
 - Leverages AI for performance analysis
@@ -327,12 +408,14 @@ Let's examine each alternative to help you find the best monitoring solution for
 - Includes end-user monitoring for web and mobile
 
 **Limitations:**
+
 - Learning curve for its automated approach
 - High starting costs not suitable for small environments
 - Enterprise-heavy sales and support model
 - Overwhelming amount of data and events initially
 
 **Pricing:**
+
 - Tiered plans: Essentials around \$207/month
 - Advanced ~\$775/month for full-stack, AI features
 - Pricing per host (MVS unit) with packages
@@ -341,42 +424,52 @@ Let's examine each alternative to help you find the best monitoring solution for
 
 ### Elastic Observability
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-elastic-dashboard.webp" alt="Elastic Observability Dashboard" caption="Elastic Observability Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-elastic-dashboard.webp"
+  alt="Elastic Observability Dashboard"
+  caption="Elastic Observability Dashboard"
+/>
 
 [Elastic Observability](https://www.elastic.co/observability) builds on the popular ELK stack (Elasticsearch, Logstash, Kibana) to provide a complete monitoring solution. It handles logs, metrics, and traces on a proven search analytics engine.
 
 **Key Benefits:**
+
 - **Open-Source Foundation:** Much of the stack is open-source or source-available
 - **Powerful Search:** Industry-leading search capabilities for logs and metrics
 - **Flexible Deployment:** Self-host or use Elastic Cloud managed service
 - **Universal Profiling:** Deep performance insights across your stack
 
 **Performance:**
+
 - Handles logs, infrastructure metrics, [APM traces](https://signoz.io/blog/apm-vs-distributed-tracing/) on one platform
 - Supports OpenTelemetry and 350+ prebuilt integrations
 - Provides powerful log search with Kibana's Discover
 - Offers deep visibility with Lucene query syntax
 
 **Limitations:**
+
 - Complex to tune and configure when self-hosting
 - Requires significant resources for high ingest rates
 - Some advanced features only in paid tiers
 - Multiple Kibana apps may feel less unified than competitors
 
 **Pricing:**
+
 - Open-source self-managed (free basic license)
 - Elastic Cloud managed service starts ~\$95/month (Standard)
 - Higher tiers from ~\$125+ for enterprise features
 
 **Best For:** Organizations that need powerful log analytics and search capabilities, especially those already using Elasticsearch
 
-
-
 ## How to Choose the Right Monitoring Tool
 
 Selecting the right tool is crucial for your system's performance. Consider these key factors:
 
-<Figure src="/img/comparisons/2025/03/logicmonitor-competitors-2df84e10-7051-439c-9fee-dfcc5cb6a8cf.webp" alt="Factors to consider when selecting an IT monitoring tool" caption="Factors to consider when selecting an IT monitoring tool" />
+<Figure
+  src="/img/comparisons/2025/03/logicmonitor-competitors-2df84e10-7051-439c-9fee-dfcc5cb6a8cf.webp"
+  alt="Factors to consider when selecting an IT monitoring tool"
+  caption="Factors to consider when selecting an IT monitoring tool"
+/>
 
 - **Budget:** Set a realistic budget that balances cost with needed features. Sometimes paying more upfront saves money later by preventing downtime.
 
@@ -392,7 +485,6 @@ Selecting the right tool is crucial for your system's performance. Consider thes
 
 - **Community Support:** Tools with active communities provide valuable resources for troubleshooting and optimization.
 
-
 ## Getting Started with SigNoz
 
 If you need an open-source, affordable, full-stack observability platform, SigNoz offers a great alternative to expensive tools like LogicMonitor. It provides enterprise-grade features built specifically for developers and engineering teams.
@@ -410,15 +502,18 @@ If you need an open-source, affordable, full-stack observability platform, SigNo
 ## Final Recommendations
 
 **For Developer-Centric Teams and Startups:**
+
 - SigNoz or Prometheus+Grafana for budget-conscious teams
 - New Relic's free tier (100GB/month) for small applications
 
 **For SRE Teams in Mid-to-Large Organizations:**
+
 - Datadog or New Relic for balance of features and usability
 - Dynatrace for complex, dynamic environments with automation needs
 - Hybrid approach: open-source metrics with specialized APM tool
 
 **For Enterprises with Strict Compliance Requirements:**
+
 - Self-hosted Elastic Observability or SigNoz for data control
 - Splunk for combined IT operations and security monitoring
 - AppDynamics for business-transaction focused monitoring
@@ -467,6 +562,7 @@ Use this formula to assess the return on investment:
 ROI = (Cost savings from reduced downtime + Efficiency gains) ÷ (Tool cost + Migration effort)
 
 **Example calculation:**
+
 - \$5,000 monthly loss from downtime × 50% reduction = \$2,500 monthly savings
 - 8 hours saved monthly × \$50/hour = \$400 monthly efficiency gain
 - Total monthly savings: \$2,900
@@ -480,4 +576,4 @@ This means for every dollar spent on the monitoring tool, your business saves \$
 
 ### How do open-source and commercial tools compare for large environments?
 
-Open-source tools like Prometheus+Grafana or SigNoz can scale to large environments but require more engineering effort to maintain. They offer cost savings but need expertise to configure and optimize. Commercial tools like Datadog, Dynatrace, and New Relic provide more automation and out-of-the-box functionality but at higher costs. For very large deployments, the total cost of ownership might be similar when accounting for infrastructure and personnel costs.
\ No newline at end of file
+Open-source tools like Prometheus+Grafana or SigNoz can scale to large environments but require more engineering effort to maintain. They offer cost savings but need expertise to configure and optimize. Commercial tools like Datadog, Dynatrace, and New Relic provide more automation and out-of-the-box functionality but at higher costs. For very large deployments, the total cost of ownership might be similar when accounting for infrastructure and personnel costs.
diff --git a/data/comparisons/logstash-alternatives.mdx b/data/comparisons/logstash-alternatives.mdx
index d0af4896d..261ab0e95 100644
--- a/data/comparisons/logstash-alternatives.mdx
+++ b/data/comparisons/logstash-alternatives.mdx
@@ -1,30 +1,29 @@
 ---
 title: Top 11 Logstash Alternatives [2025 Guide]
-slug: logstash-alternatives
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [mary]
 description: Logstash is an open-source log processing pipeline that ingests data from multiple sources, then transforms and sends it to various destinations. Despite its flexibility, Logstash might not always be the best fit for your specific requirements...
 image: /img/blog/2024/05/logstash-alternatives-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [logstash-alternatives,logstash,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [logstash-alternatives, logstash, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Logstash is an open-source log processing pipeline that ingests data from multiple sources, then transforms and sends it to various destinations. Despite its flexibility, Logstash might not always be the best fit for your specific requirements. In this article, we will look at the top alternatives to Logstash that you may want to consider for your application needs.
-
 
+Logstash is an open-source log processing pipeline that ingests data from multiple sources, then transforms and sends it to various destinations. Despite its flexibility, Logstash might not always be the best fit for your specific requirements. In this article, we will look at the top alternatives to Logstash that you may want to consider for your application needs.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 But before that, let us have a brief overview of Logstash.
 
 ## What is Logstash?
 
-Logstash is a core part of the ELK (Elasticsearch, Logstash, and Kibana) Stack, an open-source log management tool and data analytics tool. Logstash, as the log collection engine, collects and unifies data from several sources before sending it to other destinations, usually Elasticsearch, though it can also send data to other destinations for further processing and analysis. 
+Logstash is a core part of the ELK (Elasticsearch, Logstash, and Kibana) Stack, an open-source log management tool and data analytics tool. Logstash, as the log collection engine, collects and unifies data from several sources before sending it to other destinations, usually Elasticsearch, though it can also send data to other destinations for further processing and analysis.
 
 One major advantage of Logstash is its ability to aggregate data from various sources and the flexibility it provides with a large number of plugins. Logstash can retrieve data from virtually any data origin by using its input plugins, execute various data modification functions through filter plugins, and then transmit the processed data to multiple destinations via output plugins. Despite these benefits, Logstash has certain drawbacks, which we will look at in the section below.
 
@@ -45,12 +44,17 @@ SigNoz is an open-source observability platform for monitoring applications that
 
 SigNoz provides an easy way to get started through the SigNoz Cloud, with which you don’t need to install or manage the infrastructure. It also provides the option of self-hosting on macOS or Linux computers.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-signoz.webp" alt="SigNoz Logs Dashboard (Source: SigNoz Website)"/>
-    <figcaption><i>SigNoz Logs Dashboard (Source: SigNoz Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-signoz.webp"
+    alt="SigNoz Logs Dashboard (Source: SigNoz Website)"
+  />
+  <figcaption>
+    <i>SigNoz Logs Dashboard (Source: SigNoz Website)</i>
+  </figcaption>
 </figure>
 
-
 One of the features that makes SigNoz a great alternative to Logstash is that it lets you collect, analyze, and visualize Traces, Metrics, and logs all in a single application.
 
 **Other features:**
@@ -73,12 +77,17 @@ Graylog is a comprehensive open-source platform that provides a [centralized log
 
 [Graylog](https://signoz.io/comparisons/graylog-vs-splunk/) provides the easy option of utilizing it through the Graylog Cloud and allows users to self-host and manage Graylog on Linux distributions (Ubuntu, Debian, RHEL/CentOS, SUSE, or Docker).
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-graylog.webp" alt="Graylog Dashboard (Source: Graylog Website)"/>
-    <figcaption><i>Graylog Dashboard (Source: Graylog Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-graylog.webp"
+    alt="Graylog Dashboard (Source: Graylog Website)"
+  />
+  <figcaption>
+    <i>Graylog Dashboard (Source: Graylog Website)</i>
+  </figcaption>
 </figure>
 
-
 **Features of Graylog**
 
 - Graylog enables fast querying of logs.
@@ -102,14 +111,19 @@ Beats is a family of open-source lightweight shippers in the Elastic Stack ecosy
 - **Auditbeat:** for audit data, and
 - **Heartbeat:** for uptime monitoring.
 
-Beats are highly lightweight with few dependencies, making them easy to install on servers, containers, or deployed as functions. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-beats.webp" alt="Beats  Visualization in Kibana (Source: Elastic Search)"/>
-    <figcaption><i>Beats  Visualization in Kibana (Source: Elastic Search)</i></figcaption>
+Beats are highly lightweight with few dependencies, making them easy to install on servers, containers, or deployed as functions.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-beats.webp"
+    alt="Beats  Visualization in Kibana (Source: Elastic Search)"
+  />
+  <figcaption>
+    <i>Beats Visualization in Kibana (Source: Elastic Search)</i>
+  </figcaption>
 </figure>
 
-
 **Features of Beats**
 
 - Lightweight nature.
@@ -123,17 +137,21 @@ Beats can be downloaded and self-hosted for free. It can also be consumed as a c
 
 ## Splunk
 
-Splunk is a comprehensive platform that provides security and observability features. Splunk Enterprise, one of Splunk's solutions, is software that enables the collection, indexing, search, analysis, and visualization of data from various sources, including websites, applications, sensors, databases, network devices, and more. With Splunk Enterprise, you can search and analyze large amounts of data in real time, and it provides pre-built visualizations to help you quickly create informative dashboards. 
+Splunk is a comprehensive platform that provides security and observability features. Splunk Enterprise, one of Splunk's solutions, is software that enables the collection, indexing, search, analysis, and visualization of data from various sources, including websites, applications, sensors, databases, network devices, and more. With Splunk Enterprise, you can search and analyze large amounts of data in real time, and it provides pre-built visualizations to help you quickly create informative dashboards.
 
 Users typically access Splunk Enterprise via a web browser using Splunk Web. Alternatively, you can administer your Splunk Enterprise deployment using the command-line interface.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-splunk.webp" alt="Splunk Logs Dashboard (Source: Splunk Website)"/>
-    <figcaption><i>Splunk Logs Dashboard (Source: Splunk Website)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-splunk.webp"
+    alt="Splunk Logs Dashboard (Source: Splunk Website)"
+  />
+  <figcaption>
+    <i>Splunk Logs Dashboard (Source: Splunk Website)</i>
+  </figcaption>
 </figure>
 
-
-
 **Features**
 
 - Its user-friendly graphical interface allows users to easily create custom dashboards for organizing and sharing data, as well as integrate it into other applications.
@@ -147,14 +165,19 @@ Splunk provides a flexible way of paying based on how much data you bring in or
 
 ## Atatus
 
-Atatus is a comprehensive observability platform that provides full-stack application monitoring.  Atatus simplifies log monitoring monitors as it can aggregate logs from various sources, process all your logs, generate metrics,  and visualize log data all from one central place, enabling easy analysis and troubleshooting. Data is monitored and collected by Atatus through agents, which can be installed on either the host or the application. Atatus supports many agents and works on major frameworks, programming languages, Linux distributions, and MacOS. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-atatus.webp" alt="Atatus Dashboard (Source: Atatus)"/>
-    <figcaption><i>Atatus Dashboard (Source: Atatus)</i></figcaption>
+Atatus is a comprehensive observability platform that provides full-stack application monitoring. Atatus simplifies log monitoring monitors as it can aggregate logs from various sources, process all your logs, generate metrics, and visualize log data all from one central place, enabling easy analysis and troubleshooting. Data is monitored and collected by Atatus through agents, which can be installed on either the host or the application. Atatus supports many agents and works on major frameworks, programming languages, Linux distributions, and MacOS.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-atatus.webp"
+    alt="Atatus Dashboard (Source: Atatus)"
+  />
+  <figcaption>
+    <i>Atatus Dashboard (Source: Atatus)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Atatus is capable of collecting data logs, traces, and metrics from a wide range of sources, including log files, servers, applications, networks, and security devices.
@@ -172,12 +195,17 @@ Rsyslog is an open-source, lightweight **log** processing system based on the
 
 Rsyslog is a popular shipper with Linux distributions as it mostly comes preinstalled with its dependencies.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-rsyslog.webp" alt="Rsyslog  Logs Visualization (Source: Elastic Search)"/>
-    <figcaption><i>Rsyslog  Logs Visualization (Source: Elastic Search)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-rsyslog.webp"
+    alt="Rsyslog  Logs Visualization (Source: Elastic Search)"
+  />
+  <figcaption>
+    <i>Rsyslog Logs Visualization (Source: Elastic Search)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Direct support for various databases, including MySQL, Postgres Firebird, Interbase, MS SQL, SQLite, Oracle, and more, via libdbi, enhances flexibility and compatibility.
@@ -187,18 +215,23 @@ Rsyslog is a popular shipper with Linux distributions as it mostly comes preinst
 
 **Pricing**
 
-Rsyslog is open-source and can be downloaded freely. 
+Rsyslog is open-source and can be downloaded freely.
 
 ## Syslog-ng
 
 Syslog-ng is an open-source log management solution that allows you to collect, parse, classify, rewrite, and correlate logs from across your infrastructure and store or route them to other destinations. While it is built on syslog, it has features that go beyond the fundamental syslog functionality and can be customized with plugins to fit any use case.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-syslog.webp" alt="Syslog  Logs Visualization (Source: BMC)"/>
-    <figcaption><i>Syslog  Logs Visualization (Source: BMC)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-syslog.webp"
+    alt="Syslog  Logs Visualization (Source: BMC)"
+  />
+  <figcaption>
+    <i>Syslog Logs Visualization (Source: BMC)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Syslog-ng simplifies log storage by supporting a variety of databases such as SQL (MySQL, PostgreSQL, Oracle), MongoDB, and Redis, giving you more options for storing log messages.
@@ -212,15 +245,19 @@ Syslog-ng is open-source and can be downloaded freely. Its premium edition has v
 
 ## Fluentd
 
-Fluentd is an open-source data collector capable of collecting, parsing, transforming, analyzing, and storing various types of data. It prioritizes structuring data as JSON,  which enables it to successfully combine all parts of log data processing, including collecting, filtering, buffering, and distribution across multiple sources and destinations. It also provides a vast range of plugins for gathering data from various sources and storing it in multiple destinations.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-fluentd.webp" alt="Fluentd  Logs Dashboard (Source: Fluentd)"/>
-    <figcaption><i>Fluentd  Logs Dashboard (Source: Fluentd)</i></figcaption>
+Fluentd is an open-source data collector capable of collecting, parsing, transforming, analyzing, and storing various types of data. It prioritizes structuring data as JSON, which enables it to successfully combine all parts of log data processing, including collecting, filtering, buffering, and distribution across multiple sources and destinations. It also provides a vast range of plugins for gathering data from various sources and storing it in multiple destinations.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-fluentd.webp"
+    alt="Fluentd  Logs Dashboard (Source: Fluentd)"
+  />
+  <figcaption>
+    <i>Fluentd Logs Dashboard (Source: Fluentd)</i>
+  </figcaption>
 </figure>
 
-
-
 **Features**
 
 - Fluentd structures data as JSON to unify processing log data across multiple sources and destinations, and this makes data processing easier.
@@ -234,16 +271,21 @@ Fluentd is fully free and fully open-source.
 
 ## New Relic
 
-New Relic is a cloud-based monitoring and observability software solution that offers a fast, scalable log management platform to collect and connect your logs with the rest of your infrastructure data in a single place. This log management solution provides deeper visibility into both application and infrastructure performance data, including events, errors, traces, and more. 
+New Relic is a cloud-based monitoring and observability software solution that offers a fast, scalable log management platform to collect and connect your logs with the rest of your infrastructure data in a single place. This log management solution provides deeper visibility into both application and infrastructure performance data, including events, errors, traces, and more.
 
 New Relic gathers data using agents and provides four major types of agents: APM agents: For server-side applications, Browser agents: For browser applications, Infrastructure agents: For hosts and on-host integrations, Mobile agents: For mobile applications.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-newrelic.webp" alt="New Relic  Logs Dashboard (Source: New Relic)"/>
-    <figcaption><i>New Relic  Logs Dashboard (Source: New Relic)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-newrelic.webp"
+    alt="New Relic  Logs Dashboard (Source: New Relic)"
+  />
+  <figcaption>
+    <i>New Relic Logs Dashboard (Source: New Relic)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - New Relic includes pre-defined alerts, but you can also create your own. It allows you to receive alerts through tools like PagerDuty, ServiceNow, Jira, Slack, and more
@@ -255,16 +297,21 @@ New Relic gathers data using agents and provides four major types of agents: APM
 
 New Relic offers a free plan which is limited to 100GB of data ingest per month. The paid plans, which have more features and higher limits, are priced at \$49/user for core users. Then \$99/per user, \$349/user, and \$549/per for standard, pro, and enterprise options for full-platform users
 
-## Datadog 
+## Datadog
 
-Datadog is a cloud-based monitoring and analytics software solution that provides real-time insights into  IT infrastructures. It monitors infrastructures, applications, logs, and other data sources in a unified manner, collects data from these sources, and then uses it to create customizable dashboards, alerts, and reports that provide a comprehensive view of the entire infrastructure. It collects events and metrics from hosts with the Datadog agent, which can be local hosts (Windows, MacOS), containerized environments (Docker, Kubernetes), or on-premises data centers. It can also be installed and configured using configuration management tools (Chef, Puppet, and Ansible).
+Datadog is a cloud-based monitoring and analytics software solution that provides real-time insights into IT infrastructures. It monitors infrastructures, applications, logs, and other data sources in a unified manner, collects data from these sources, and then uses it to create customizable dashboards, alerts, and reports that provide a comprehensive view of the entire infrastructure. It collects events and metrics from hosts with the Datadog agent, which can be local hosts (Windows, MacOS), containerized environments (Docker, Kubernetes), or on-premises data centers. It can also be installed and configured using configuration management tools (Chef, Puppet, and Ansible).
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-datadog.webp" alt="Datadog Logs Dashboard (Source: Datadog)"/>
-    <figcaption><i>Datadog Logs Dashboard (Source: Datadog)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-datadog.webp"
+    alt="Datadog Logs Dashboard (Source: Datadog)"
+  />
+  <figcaption>
+    <i>Datadog Logs Dashboard (Source: Datadog)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Datadog enables rapid troubleshooting and analytics with no querying language.
@@ -280,12 +327,17 @@ Datadog offers a free plan with limited features, a pro plan starting at \$15 pe
 
 Memzo is a cloud-based log management and analysis platform that provides a telemetry pipeline for ingesting data from multiple sources, parsing it, and seamlessly routing it to various destinations. It also enables the analysis, easy search, filtering, and visualization of log data. Memzo can incorporate data from existing log analysis environments or entirely new data streams, making it easy to aggregate log data with its support for a broad range of ingestion options such as the logging agent, the CLI, the client-side logger, integrations with other logging platforms, code libraries, and REST API.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/05/logstash-alternatives-memzo.webp" alt="Memzo Dashboard (Source: Memzo)"/>
-    <figcaption><i>Memzo Dashboard (Source: Memzo)</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/05/logstash-alternatives-memzo.webp"
+    alt="Memzo Dashboard (Source: Memzo)"
+  />
+  <figcaption>
+    <i>Memzo Dashboard (Source: Memzo)</i>
+  </figcaption>
 </figure>
 
-
 **Features**
 
 - Memzo automatically parses logs as it ingests them. It also provides the option of [parsing logs](https://signoz.io/guides/log-parsing/) using custom templates and allows you to analyze logs using its advanced search features.
@@ -302,11 +354,11 @@ For Log Analysis, there are two pricing options in addition to a free, limited p
 
 # Factors to Consider When Choosing Between Logstash Alternatives
 
-When considering alternatives to Logstash, several factors should guide your decision-making process. First and foremost, consider your specific needs and requirements. Ensure that the features offered by a particular alternative or tool can cater to your application's needs. Resource utilization and performance are also important factors to consider, especially when handling large data volumes. 
+When considering alternatives to Logstash, several factors should guide your decision-making process. First and foremost, consider your specific needs and requirements. Ensure that the features offered by a particular alternative or tool can cater to your application's needs. Resource utilization and performance are also important factors to consider, especially when handling large data volumes.
 
 Moreover, factor in scalability, ensuring the solution can grow with your needs, and consider the availability of robust technical and community support. Also, consider the ease of use and configuration. Lastly, ensure that the cost and pricing align with your budget.
 
-Now that we have reached the end of the article, you should be able to decide on an option among the top alternatives we have explored. If you're looking for a complete tool that can meet all of your requirements and needs, SigNoz is an excellent choice. 
+Now that we have reached the end of the article, you should be able to decide on an option among the top alternatives we have explored. If you're looking for a complete tool that can meet all of your requirements and needs, SigNoz is an excellent choice.
 
 ## Getting started with SigNoz
 
diff --git a/data/comparisons/network-security-monitoring-tools.mdx b/data/comparisons/network-security-monitoring-tools.mdx
index 65f8206a2..46d3c3ded 100644
--- a/data/comparisons/network-security-monitoring-tools.mdx
+++ b/data/comparisons/network-security-monitoring-tools.mdx
@@ -1,69 +1,71 @@
 ---
-
 title: Top 10 Network Security Monitoring Tools for 2025
-slug: network-security-monitoring-tools
 date: 2025-01-02
 tags: [tools-comparisons]
 authors: [manjunath_irukulla]
 description: Discover the best network security monitoring tools for 2024. Learn about essential features, implementation strategies, and future trends in NSM.
-keywords: [network security monitoring, NSM tools, cybersecurity, threat detection, network analysis]
-
+keywords:
+  [network security monitoring, NSM tools, cybersecurity, threat detection, network analysis]
 ---
 
 In today’s fast-paced digital world, securing your organization’s network against cyber threats is critical. Network Security Monitoring (NSM) tools are essential for achieving this, offering real-time insights into network traffic and detecting potential threats to uphold a strong security posture.
 
-As cyber threats grow, selecting the right NSM solution becomes more crucial. This guide provides an in-depth look at the top 10 NSM tools for 2024, detailing their features and how they can strengthen your organization’s defenses. 
+As cyber threats grow, selecting the right NSM solution becomes more crucial. This guide provides an in-depth look at the top 10 NSM tools for 2024, detailing their features and how they can strengthen your organization’s defenses.
 
 ## What is Network Security Monitoring?
 
-Network security monitoring (NSM) is a critical process that involves the continuous examination of network traffic and system activities to identify, analyze, and respond to security threats in real time. Unlike traditional network monitoring, which primarily focuses on ensuring the performance and availability of network services, NSM is deeply rooted in a security-centric approach. 
+Network security monitoring (NSM) is a critical process that involves the continuous examination of network traffic and system activities to identify, analyze, and respond to security threats in real time. Unlike traditional network monitoring, which primarily focuses on ensuring the performance and availability of network services, NSM is deeply rooted in a security-centric approach.
 
-Its primary goal is to detect and mitigate malicious activities, unauthorized access, and vulnerabilities within the network infrastructure before they can cause significant harm. 
+Its primary goal is to detect and mitigate malicious activities, unauthorized access, and vulnerabilities within the network infrastructure before they can cause significant harm.
 
 Key components of effective network security monitoring include:
 
-<Figure src="/img/comparisons/2024/09/network-security-monitoring-tools-napkin-selection_(3)_(1).webp" alt="Key components of effective network security monitoring tools" caption="Key components of effective network security monitoring tools" />
+<Figure
+  src="/img/comparisons/2024/09/network-security-monitoring-tools-napkin-selection_(3)_(1).webp"
+  alt="Key components of effective network security monitoring tools"
+  caption="Key components of effective network security monitoring tools"
+/>
 
 Key components of effective network security monitoring tools
 
-1. Real-time traffic analysis: This involves the ongoing examination of network packets and data flows as they traverse the network. By monitoring traffic in real-time, NSM tools can identify suspicious activities, such as unusual communication patterns or data transfers, indicating a potential security threat.  
-2. Log management: Effective NSM relies heavily on the collection, storage, and analysis of logs generated by network devices, servers, and applications. These logs provide crucial insights into network activities, allowing security teams to trace incidents, identify compromised systems, and correlate events across the network. 
-3. Intrusion detection: NSM tools are equipped with mechanisms to detect unauthorized access attempts, policy violations, and other indicators of a security breach. Advanced systems can not only identify these threats but also automatically respond to mitigate them, such as blocking malicious traffic or isolating affected systems. 
-4. Anomaly detection: This involves the identification of deviations from normal network behavior. By establishing a baseline of typical network activity, NSM tools can spot anomalies that may suggest the presence of new or unknown threats, such as zero-day attacks or advanced persistent threats (APTs). 
+1. Real-time traffic analysis: This involves the ongoing examination of network packets and data flows as they traverse the network. By monitoring traffic in real-time, NSM tools can identify suspicious activities, such as unusual communication patterns or data transfers, indicating a potential security threat.
+2. Log management: Effective NSM relies heavily on the collection, storage, and analysis of logs generated by network devices, servers, and applications. These logs provide crucial insights into network activities, allowing security teams to trace incidents, identify compromised systems, and correlate events across the network.
+3. Intrusion detection: NSM tools are equipped with mechanisms to detect unauthorized access attempts, policy violations, and other indicators of a security breach. Advanced systems can not only identify these threats but also automatically respond to mitigate them, such as blocking malicious traffic or isolating affected systems.
+4. Anomaly detection: This involves the identification of deviations from normal network behavior. By establishing a baseline of typical network activity, NSM tools can spot anomalies that may suggest the presence of new or unknown threats, such as zero-day attacks or advanced persistent threats (APTs).
 
-Traditional network monitoring is primarily concerned with ensuring that network resources are performing optimally and are available when needed. It focuses on metrics like uptime, bandwidth utilization, and latency. However, NSM elevates the focus to include the detection and management of security threats. It’s not just about whether the network is functioning; it’s about ensuring that the network is secure, resilient to attacks, and able to support rapid responses and recovery when incidents occur. 
+Traditional network monitoring is primarily concerned with ensuring that network resources are performing optimally and are available when needed. It focuses on metrics like uptime, bandwidth utilization, and latency. However, NSM elevates the focus to include the detection and management of security threats. It’s not just about whether the network is functioning; it’s about ensuring that the network is secure, resilient to attacks, and able to support rapid responses and recovery when incidents occur.
 
-In short, while traditional monitoring asks, “Is the network running smoothly?” NSM asks, “Is the network secure from threats?” This shift in focus is crucial in today’s threat landscape, where cyber attacks are increasingly sophisticated and can quickly exploit any vulnerabilities in a network. 
+In short, while traditional monitoring asks, “Is the network running smoothly?” NSM asks, “Is the network secure from threats?” This shift in focus is crucial in today’s threat landscape, where cyber attacks are increasingly sophisticated and can quickly exploit any vulnerabilities in a network.
 
 ## Why Network Security Monitoring is Crucial in 2024
 
 The importance of network security monitoring has never been greater. Here's why NSM is critical for organizations in 2024:
 
-1. Evolving threat landscape: The cyber threat landscape is constantly changing, with attackers developing new techniques and exploiting advanced technologies to bypass traditional security measures. From zero-day vulnerabilities to sophisticated ransomware campaigns, the range of potential threats is expanding. 
-    - Network security monitoring enables organizations to stay ahead of these evolving dangers by continuously analyzing network activity, identifying anomalies, and responding to threats in real-time. This proactive approach is essential for defending against both known and emerging cyber threats.
-2. Increasing network complexity: With rapid adoption of cloud computing, the Internet of Things (IoT), and remote work, networks have become more complex and dispersed. The distributed nature makes it challenging to maintain visibility and control over all network components. 
-    - NSM provides comprehensive visibility across these diverse environments, ensuring that all parts of the network, whether on-premises, cloud-based, or hybrid, are monitored for security threats. By centralized security monitoring, NSM helps organizations manage the complexity and ensure that no part of the network is left unprotected.
-3. Regulatory compliance: As data protection regulations become more stringent, organizations must demonstrate that they are taking appropriate measures to safeguard sensitive information. Network security monitoring plays a key role in achieving compliance by continuously monitoring and documenting security practices. 
-    - NSM tools provide detailed logs and reports that can be used to demonstrate compliance with regulations such as GDPR, HIPAA, and CCPA. By ensuring that all security activities are tracked and recorded, NSM helps organizations avoid costly fines and legal repercussions.
-4. Cost implications: The financial repercussions of a security breach can be catastrophic, affecting both the bottom line and the organization’s reputation. In 2024, the average cost of a data breach continues to rise, making prevention more crucial than ever. 
-    - NSM helps organizations avoid these devastating incidents by providing early detection and intervention capabilities. By identifying and addressing threats before they can cause significant harm, NSM minimizes the potential financial and operational damage associated with security breaches.
+1. Evolving threat landscape: The cyber threat landscape is constantly changing, with attackers developing new techniques and exploiting advanced technologies to bypass traditional security measures. From zero-day vulnerabilities to sophisticated ransomware campaigns, the range of potential threats is expanding.
+   - Network security monitoring enables organizations to stay ahead of these evolving dangers by continuously analyzing network activity, identifying anomalies, and responding to threats in real-time. This proactive approach is essential for defending against both known and emerging cyber threats.
+2. Increasing network complexity: With rapid adoption of cloud computing, the Internet of Things (IoT), and remote work, networks have become more complex and dispersed. The distributed nature makes it challenging to maintain visibility and control over all network components.
+   - NSM provides comprehensive visibility across these diverse environments, ensuring that all parts of the network, whether on-premises, cloud-based, or hybrid, are monitored for security threats. By centralized security monitoring, NSM helps organizations manage the complexity and ensure that no part of the network is left unprotected.
+3. Regulatory compliance: As data protection regulations become more stringent, organizations must demonstrate that they are taking appropriate measures to safeguard sensitive information. Network security monitoring plays a key role in achieving compliance by continuously monitoring and documenting security practices.
+   - NSM tools provide detailed logs and reports that can be used to demonstrate compliance with regulations such as GDPR, HIPAA, and CCPA. By ensuring that all security activities are tracked and recorded, NSM helps organizations avoid costly fines and legal repercussions.
+4. Cost implications: The financial repercussions of a security breach can be catastrophic, affecting both the bottom line and the organization’s reputation. In 2024, the average cost of a data breach continues to rise, making prevention more crucial than ever.
+   - NSM helps organizations avoid these devastating incidents by providing early detection and intervention capabilities. By identifying and addressing threats before they can cause significant harm, NSM minimizes the potential financial and operational damage associated with security breaches.
 5. Rapid incident response: In today’s fast-paced digital world, time is of the essence when responding to security incidents. The longer a threat goes undetected, the more damage it can inflict. NSM tools are designed to facilitate rapid incident response by providing real-time -threat detection, detailed analysis, and automated response mechanisms.
-    - This enables security teams to act quickly, reducing the impact of an attack and restoring normal operations faster. In an era where downtime can translate into substantial financial losses, the ability to respond swiftly is a significant advantage.
+   - This enables security teams to act quickly, reducing the impact of an attack and restoring normal operations faster. In an era where downtime can translate into substantial financial losses, the ability to respond swiftly is a significant advantage.
 
 ## Essential Features of Network Security Monitoring Tools
 
 When evaluating NSM tools, look for these key features:
 
-1. Real-time threat detection: continuously monitors network traffic to identify and alert on security threats as they happen, enabling rapid response to potential breaches. 
-    - Why it’s important: The speed at which you detect and respond to threats can be the difference between a minor incident and a catastrophic breach. Real-time detection ensures that your posture remains proactive, rather than reactive.
-2. Log management and analysis: collects, stores, and analyzes log data from various sources, providing insights into user activity and supporting forensic investigations and compliance. 
-    - Why it’s important: Comprehensive log management is crucial for understanding the full scope of network activity and maintaining and auditing the trail. It also plays a key role in meeting regulatory compliance standards, such as GDPR and HIPAA, which require detailed records of security practices.
-3. Network traffic analysis: inspects data packets and flow patterns to detect anomalies, helping to identify unauthorized access, data leaks, and other malicious activities. 
-    - Why it’s important: Thorough network traffic analysis provides a clear picture of what is happening within your network, helping to detect and mitigate threats that might otherwise go unnoticed. It’s particularly valuable in environments where network traffic is complex or distributed across multiple locations.
+1. Real-time threat detection: continuously monitors network traffic to identify and alert on security threats as they happen, enabling rapid response to potential breaches.
+   - Why it’s important: The speed at which you detect and respond to threats can be the difference between a minor incident and a catastrophic breach. Real-time detection ensures that your posture remains proactive, rather than reactive.
+2. Log management and analysis: collects, stores, and analyzes log data from various sources, providing insights into user activity and supporting forensic investigations and compliance.
+   - Why it’s important: Comprehensive log management is crucial for understanding the full scope of network activity and maintaining and auditing the trail. It also plays a key role in meeting regulatory compliance standards, such as GDPR and HIPAA, which require detailed records of security practices.
+3. Network traffic analysis: inspects data packets and flow patterns to detect anomalies, helping to identify unauthorized access, data leaks, and other malicious activities.
+   - Why it’s important: Thorough network traffic analysis provides a clear picture of what is happening within your network, helping to detect and mitigate threats that might otherwise go unnoticed. It’s particularly valuable in environments where network traffic is complex or distributed across multiple locations.
 4. Automated incident response: executes predefined actions automatically when a threat is detected, reducing response time and minimizing the impact of security incidents.
-    - Why it’s important: Automation in incident response helps ensure that threats are addressed quickly and effectively, even when security teams are not immediately available. It also reduces the risk of human error during critical moments, helping to maintain a strong security posture.
-5. Scalability: Ensures that the NSM tool can grow with your network, maintaining performance and security effectiveness as data volumes and network complexity increase. 
-    - Why it’s important: In today’s dynamic business environment, network demands can change rapidly. An NSM tool that scales seamlessly ensures continuous protection without the need for frequent upgrades or replacements, making it a cost-effective and future-proof solution.
+   - Why it’s important: Automation in incident response helps ensure that threats are addressed quickly and effectively, even when security teams are not immediately available. It also reduces the risk of human error during critical moments, helping to maintain a strong security posture.
+5. Scalability: Ensures that the NSM tool can grow with your network, maintaining performance and security effectiveness as data volumes and network complexity increase.
+   - Why it’s important: In today’s dynamic business environment, network demands can change rapidly. An NSM tool that scales seamlessly ensures continuous protection without the need for frequent upgrades or replacements, making it a cost-effective and future-proof solution.
 
 ### Advanced Capabilities to Look For
 
@@ -76,47 +78,55 @@ When evaluating modern NSM tools, look for these advanced features:
 
 ## Top 10 Network Security Monitoring Tools for 2024
 
-Choosing the right network security monitoring tool is a critical decision for any organization looking to protect its infrastructure from evolving cyber threats. This comparison of the top 10 network security monitoring tools for 2024 provides insights into each tool’s capabilities across various key areas. 
+Choosing the right network security monitoring tool is a critical decision for any organization looking to protect its infrastructure from evolving cyber threats. This comparison of the top 10 network security monitoring tools for 2024 provides insights into each tool’s capabilities across various key areas.
 
-<Figure src="/img/comparisons/2024/09/network-security-monitoring-tools-NSM.webp" alt="Top 10 Network Security Monitoring Tools" caption="Top 10 Network Security Monitoring Tools" /> 
+<Figure
+  src="/img/comparisons/2024/09/network-security-monitoring-tools-NSM.webp"
+  alt="Top 10 Network Security Monitoring Tools"
+  caption="Top 10 Network Security Monitoring Tools"
+/>
 
 ### Feature Comparison of Leading Network Security Monitoring Tools in 2024:
 
-| Tool | Real-Time Threat Detection | Log Management & Analysis | Network Traffic Analysis | Automated Incident Response | Scalability | Machine Learning & AI | Threat Intelligence  Integration | Customizable Dashboards | Cloud & Hybrid Monitoring |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| AlgoSec | Yes | Yes | Limited | Yes | High | No | Yes | Moderate | Yes |
-| SolarWinds SEM | Yes | Yes | Moderate | Yes | High | Limited | Yes | Moderate | Yes |
-| Nagios | No | Limited | Yes | No | High | No | No | Yes | Limited |
-| Splunk | Yes | Yes | Yes | Yes | High | Yes | Yes | Yes | Yes |
-| Security Onion | Yes | Yes | Yes | Limited | Moderate | No | Limited | Yes | Limited |
-| ELK Stack | Limited | Yes | Yes | No | High | Yes | Yes | Yes | Yes |
-| Wireshark | No | No | Yes | No | Low  | No | No | Limited | No |
-| OSSEC | Yes | Yes | Limited | Yes | Moderate | No | No | Limited  | No |
-| Suricata | Yes | Limited | Yes | No | High | Limited | No | Moderate | Limited |
-| Zeek | Yes | Yes | Yes | No | High | Yes | Yes | Yes | Limited |
-
-Moderate - The tool provides that feature, but it might not be as advanced or comprehensive as other tools that fully excel in that area. 
+| Tool           | Real-Time Threat Detection | Log Management & Analysis | Network Traffic Analysis | Automated Incident Response | Scalability | Machine Learning & AI | Threat Intelligence Integration | Customizable Dashboards | Cloud & Hybrid Monitoring |
+| -------------- | -------------------------- | ------------------------- | ------------------------ | --------------------------- | ----------- | --------------------- | ------------------------------- | ----------------------- | ------------------------- |
+| AlgoSec        | Yes                        | Yes                       | Limited                  | Yes                         | High        | No                    | Yes                             | Moderate                | Yes                       |
+| SolarWinds SEM | Yes                        | Yes                       | Moderate                 | Yes                         | High        | Limited               | Yes                             | Moderate                | Yes                       |
+| Nagios         | No                         | Limited                   | Yes                      | No                          | High        | No                    | No                              | Yes                     | Limited                   |
+| Splunk         | Yes                        | Yes                       | Yes                      | Yes                         | High        | Yes                   | Yes                             | Yes                     | Yes                       |
+| Security Onion | Yes                        | Yes                       | Yes                      | Limited                     | Moderate    | No                    | Limited                         | Yes                     | Limited                   |
+| ELK Stack      | Limited                    | Yes                       | Yes                      | No                          | High        | Yes                   | Yes                             | Yes                     | Yes                       |
+| Wireshark      | No                         | No                        | Yes                      | No                          | Low         | No                    | No                              | Limited                 | No                        |
+| OSSEC          | Yes                        | Yes                       | Limited                  | Yes                         | Moderate    | No                    | No                              | Limited                 | No                        |
+| Suricata       | Yes                        | Limited                   | Yes                      | No                          | High        | Limited               | No                              | Moderate                | Limited                   |
+| Zeek           | Yes                        | Yes                       | Yes                      | No                          | High        | Yes                   | Yes                             | Yes                     | Limited                   |
+
+Moderate - The tool provides that feature, but it might not be as advanced or comprehensive as other tools that fully excel in that area.
 
 Limited - The tool offers only basic or minimal support for the feature. It might have some capabilities in this area, but they are not robust enough to be relied upon for comprehensive needs.
 
 ### Use Cases and Deployment Options for Top Network Security Monitoring Tools:
 
-| Tool | Best Use Case | Deployment Options | Ease of Use | Cost | Integration Capabilities | Support & Community |
-| --- | --- | --- | --- | --- | --- | --- |
-| AlgoSec | complex network security policy management | On-premises, Cloud, Hybrid | Moderate | High | Strong | High |
-| SolarWinds SEM | SIEM with automated incident response | On-premises, Cloud, Hybrid | Easy | High | Extensive | High |
-| Nagios | Customizable monitoring for infrastructure | On-premises, Cloud (with plugins) | Difficult  | Low (Open-source) | Extensive (with plugins) | High (Community-driven) |
-| Splunk | Large-scale log analysis and threat hunting | On-premises, Cloud, Hybrid | Moderate | High | Extensive | High |
-| Security Onion | Cost-effective NSM for small to medium orgs | On-premises | Moderate | Low (Open-source) | Limited | Moderate |
-| ELK Stack | Scalable log analysis and visualization | On-premises, Cloud, Hybrid | Moderate | Low (Open-source) | Strong | High |
-| Wireshark | Deep packet inspection and forensic analysis | On-premises | Difficult | Low (Open-source) | Limited | High |
-| OSSEC | Host-based intrusion detection | On-premises, Cloud (with modifications) | Moderate | Low (Open-source) | Limited | Moderate |
-| Suricata | High-performance IDS/IPS | On-premises | Moderate | Low (Open-source) | Limited | High |
-| Zeek | Highly customizable network analysis | On-premises | Difficult | Low (Open-source) | Strong | High |
+| Tool           | Best Use Case                                | Deployment Options                      | Ease of Use | Cost              | Integration Capabilities | Support & Community     |
+| -------------- | -------------------------------------------- | --------------------------------------- | ----------- | ----------------- | ------------------------ | ----------------------- |
+| AlgoSec        | complex network security policy management   | On-premises, Cloud, Hybrid              | Moderate    | High              | Strong                   | High                    |
+| SolarWinds SEM | SIEM with automated incident response        | On-premises, Cloud, Hybrid              | Easy        | High              | Extensive                | High                    |
+| Nagios         | Customizable monitoring for infrastructure   | On-premises, Cloud (with plugins)       | Difficult   | Low (Open-source) | Extensive (with plugins) | High (Community-driven) |
+| Splunk         | Large-scale log analysis and threat hunting  | On-premises, Cloud, Hybrid              | Moderate    | High              | Extensive                | High                    |
+| Security Onion | Cost-effective NSM for small to medium orgs  | On-premises                             | Moderate    | Low (Open-source) | Limited                  | Moderate                |
+| ELK Stack      | Scalable log analysis and visualization      | On-premises, Cloud, Hybrid              | Moderate    | Low (Open-source) | Strong                   | High                    |
+| Wireshark      | Deep packet inspection and forensic analysis | On-premises                             | Difficult   | Low (Open-source) | Limited                  | High                    |
+| OSSEC          | Host-based intrusion detection               | On-premises, Cloud (with modifications) | Moderate    | Low (Open-source) | Limited                  | Moderate                |
+| Suricata       | High-performance IDS/IPS                     | On-premises                             | Moderate    | Low (Open-source) | Limited                  | High                    |
+| Zeek           | Highly customizable network analysis         | On-premises                             | Difficult   | Low (Open-source) | Strong                   | High                    |
 
 ### 1. AlgoSec
 
-<a href="https://www.algosec.com/" rel="noopener noreferrer nofollow" target="_blank">AlgoSec</a> offers a comprehensive network security policy management solution that includes robust monitoring capabilities.
+<a href="https://www.algosec.com/" rel="noopener noreferrer nofollow" target="_blank">
+  AlgoSec
+</a>
+offers a comprehensive network security policy management solution that includes robust monitoring
+capabilities.
 
 Key features:
 
@@ -134,13 +144,20 @@ Cons:
 - Complex Setup: Initial setup and configuration can be challenging, particularly for organizations with less experience in managing complex network infrastructures.
 - Limited NSM Focus: While excellent for firewall and policy management, AlgoSec may require additional tools for comprehensive network security monitoring.
 
-Insight: 
+Insight:
 
 - Users from cybersecurity forums often highlight AlgoSec’s ability to reduce the complexity and time involved in audits, making it a preferred choice for large enterprises with stringent compliance needs.
 
 ### 2. SolarWinds Security Event Manager (SEM)
 
-<a href="https://www.solarwinds.com/security-event-manager" rel="noopener noreferrer nofollow" target="_blank">SolarWinds Security Event Manager (SEM)</a> is a powerful Security Information and Event Manager SIEM solution with strong NSM capabilities.
+<a
+  href="https://www.solarwinds.com/security-event-manager"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  SolarWinds Security Event Manager (SEM)
+</a>
+is a powerful Security Information and Event Manager SIEM solution with strong NSM capabilities.
 
 Key Functions:
 
@@ -153,18 +170,21 @@ Pros:
 - User-Friendly Interface: The intuitive dashboard and customizable views make SEM accessible to IT teams without specialized security expertise.
 - Scalability: SEM can be deployed in both on-premises and cloud environments, scaling easily from small businesses to large enterprises.
 
-Cons: 
+Cons:
 
 - Cost Considerations: The intuitive dashboard and customizable views make SEM accessible to IT teams without specialized security expertise.
 - Limited Customization: Although the interface is user-friendly, some users report that the customization options are somewhat limited compared to more advanced SIEM solutions.
 
-Insight: 
+Insight:
 
 - Discussions on platforms like Reddit often praise SEM for its ease of use and quick deployment, making it a popular choice for organizations needing an out-of-the-box solution.
 
 ### 3. Nagios
 
-<a href="https://www.nagios.org/" rel="noopener noreferrer nofollow" target="_blank">Nagios</a> is an open-source monitoring system that can be extended for network security monitoring.
+<a href="https://www.nagios.org/" rel="noopener noreferrer nofollow" target="_blank">
+  Nagios
+</a>
+is an open-source monitoring system that can be extended for network security monitoring.
 
 Key Features:
 
@@ -182,13 +202,17 @@ Cons:
 - Steep Learning Curve: Nagios requires significant expertise to configure and manage, especially when implementing advanced monitoring features.
 - Manual Configuration: The initial setup and ongoing maintenance can be time-consuming, as many plugins and features require manual configuration.
 
-Insight: 
+Insight:
 
 - Open-source enthusiasts frequently mention, Nagios as a go-to tool for those who need a customizable and cost-effective monitoring solution, though they caution that it requires a strong technical background to use effectively.
 
 ### 4. Splunk
 
-<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> is a powerful data analytics platform widely used for security information and event management (SIEM).
+<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is a powerful data analytics platform widely used for security information and event management
+(SIEM).
 
 Key strengths:
 
@@ -196,94 +220,109 @@ Key strengths:
 - Machine Learning-Powered Threat Detection: Leveraging machine learning, Splunk can identify anomalous patterns in data, predicting potential threats before they materialize.
 - Extensive Integration Capabilities: Splunk integrates with a wide range of third-party tools and platforms, enhancing its functionality within a larger security ecosystem.
 
-Pros: 
+Pros:
 
 - Scalability: Splunk is capable of handling vast amounts of data, making it ideal for large enterprises with high-volume environments.
 - Advanced Analytics: The platform’s powerful analytics engine enables in-depth threat hunting and forensic analysis, which are critical for identifying sophisticated attacks.
 
-Cost: 
+Cost:
 
 - High Cost: Splunk’s licensing model can be expensive, particularly for organizations that need to process large data volumes or deploy it across multiple locations.
 - Complexity: Due to its vast capabilities, Splunk has a steep learning curve and may require specialized training to fully utilize its features.
 
-Insight: 
+Insight:
 
 - In professional circles, Splunk is often highlighted for its powerful analytics and scalability, making it a top choice for large enterprises, though smaller organizations may find it prohibitive.
 
 ### 5. Security Onion
 
-<a href="https://securityonionsolutions.com/" rel="noopener noreferrer nofollow" target="_blank">Security Onion</a> is a free, open-source Linux distribution for intrusion detection, network security monitoring, and log management.
+<a href="https://securityonionsolutions.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Security Onion
+</a>
+is a free, open-source Linux distribution for intrusion detection, network security monitoring, and
+log management.
 
-Key Features: 
+Key Features:
 
 - Integrated ID/IPS Tools: Security Onion includes tools like Suricata and Zeek for comprehensive intrusion detection and prevention.
 - [Centralized Log Management](https://signoz.io/blog/centralized-logging/): The platform integrates Elasticsearch, Logstash, and Kibana (ELK) Elasticsearch, Logstash, and Kibana (ELK stack) to collect, analyze, and visualize log data.
 
-Pros: 
+Pros:
 
 - Comprehensive Feature Set: Security Onion provides a full suite of security tools, making it an all-in-one solution for network security monitoring.
 - Cost-Effective: Being open-source, Security Onion is a cost-effective choice for organizations with limited budgets but strong security needs.
 
-Cons: 
+Cons:
 
 - Resource-Intensive: Running multiple integrated tools can be resource-heavy, requiring significant hardware and careful management to maintain performance.
 - Complex Setup: Although comprehensive, the setup process can be complex, particularly for organizations that lack experience with open-source security tools.
 
-Insight: 
+Insight:
 
 - Security Onion is often recommended in community discussions as a powerful, budget-friendly option for those who are comfortable with open-source solutions and need a comprehensive suite of security tools.
 
 ### 6. ELK Stack (Elasticsearch, Logstash, Kibana)
 
-<a href="https://www.elastic.co/elastic-stack/" rel="noopener noreferrer nofollow" target="_blank">ELK</a> Stack is a popular open-source solution for log analysis and visualization.
+<a href="https://www.elastic.co/elastic-stack/" rel="noopener noreferrer nofollow" target="_blank">
+  ELK
+</a>
+Stack is a popular open-source solution for log analysis and visualization.
 
-Key Features: 
+Key Features:
 
 - Centralized Log Collection: Logstash ingests logs from various sources, while Elasticsearch indexes and stores the data, providing a [centralized log management solution](https://signoz.io/blog/centralized-logging/#best-practices-for-centralized-logging).
 - Full-Text-Search and Analysis: Elasticsearch enables full-text search across logs, allowing for quick and effective analysis of security events.
 - Customizable Dashboard: Kibana offers powerful visualization tools that allow users to create custom dashboards to monitor network security metrics in real-time.
 
-Pros: 
+Pros:
 
 - Flexibility: The ELK Stack is customizable, making it suitable for a wide range of security monitoring use cases, from simple log analysis to complex threat hunting.
 - Scalability: It can scale horizontally, handling large volumes of data, which is essential for enterprises with extensive logging requirements.
 
-Cons: 
+Cons:
 
 - Complex Setup and Management: Configuring and maintaining the ELK Stack can be complex, requiring significant expertise in both setup and ongoing management.
 - Performance Overhead: Large-scale deployments can lead to performance issues, especially if not properly optimized.
 
-Insight: 
+Insight:
 
 - The ELK Stack is frequently discussed in cyber security forums, where users appreciate its flexibility its flexibility and powerful analytics capabilities, though they caution about the need for proper tuning and maintenance to avoid performance bottlenecks.
 
 ### 7. Wireshark
 
-<a href="https://www.wireshark.org/" rel="noopener noreferrer nofollow" target="_blank">Wireshark</a> is a powerful, open-source network protocol analyzer used for deep packet inspection and troubleshooting.
+<a href="https://www.wireshark.org/" rel="noopener noreferrer nofollow" target="_blank">
+  Wireshark
+</a>
+is a powerful, open-source network protocol analyzer used for deep packet inspection and
+troubleshooting.
 
-Key Features: 
+Key Features:
 
 - Deep Packet Inspection: Wireshark captures and analyzes network packets in real time, providing detailed insights into network traffic at the protocol level.
 - Protocol-Level Investigation: The tool supports the analysis of hundreds of protocols, making it a go-to tool for diagnosing network issues and investigating security incidents.
 - Forensic Analysis: Wireshark’s ability to capture and store packet data makes it invaluable for forensic investigations following a security breach.
 
-Pros: 
+Pros:
 
 - Unmatched Visibility: Wireshark provides deep visibility into network traffic, allowing users to troubleshoot issues and investigate suspicious activities at a granular level.
 - Wide Protocol Support: The tool’s extensive protocol support makes it a versatile choice for analyzing various types of network’s traffic.
 
-Cons: 
+Cons:
 
 - High Learning Curve: Effective use of Wireshark requires significant networking knowledge, making it less accessible for beginners.
 - Manual Process: Wireshark is primarily a manual tool, meaning it’s not suitable for real-time monitoring of large networks where automated analysis is required.
 
-Insight: 
+Insight:
 
 - Wireshark is highly regarded in networking communities for its depth of analysis, though users emphasize the importance of a solid understanding of networking concepts to use it effectively.
 
 ### 8. OSSEC
 
-<a href="https://www.ossec.net/" rel="noopener noreferrer nofollow" target="_blank">OSSEC</a> (Open Source HIDS Security) is a host-based intrusion detection system with log analysis and integrity checking capabilities.
+<a href="https://www.ossec.net/" rel="noopener noreferrer nofollow" target="_blank">
+  OSSEC
+</a>
+(Open Source HIDS Security) is a host-based intrusion detection system with log analysis and
+integrity checking capabilities.
 
 Key features:
 
@@ -291,23 +330,27 @@ Key features:
 - Log Analysis and Alerting: The tool analyzes logs from various sources, providing alerts based on predefined security rules.
 - Rootkit Detection: OSSEC can detect rootkits and other malicious software, providing an additional layer of security for endpoint protection.
 
-Pros: 
+Pros:
 
 - Lightweight and Efficient: OSSEC’s agent-based architecture allows for efficient monitoring of endpoints without significant resource overhead.
-- Strong Community Support: As an open-source tool,  OSSEC benefits from a large community of users and developers who contribute to its ongoing development and support.
+- Strong Community Support: As an open-source tool, OSSEC benefits from a large community of users and developers who contribute to its ongoing development and support.
 
-Cons: 
+Cons:
 
 - Limited Networking Monitoring: OSSECC focuses primary on host-based intrusion detection, meaning it needs to be complemented with network monitoring tools for comprehensive coverage.
 - Complex Rule Management: While powerful, OSSEC’s rule management can be complex, requiring careful tuning to avoid false positives and ensure effective monitoring.
 
-Insight: 
+Insight:
 
 - In discussions among security professionals, OSSEC is often recommended for its effectiveness in monitoring endpoints, though its noted that it works best when integrated with other network monitoring tools.
 
 ### 9. Suricata
 
-<a href="https://suricata.io/" rel="noopener noreferrer nofollow" target="_blank">Suricata</a> is an open-source intrusion detection system (IDS) and intrusion prevention system (IPS) with network security monitoring capabilities.
+<a href="https://suricata.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Suricata
+</a>
+is an open-source intrusion detection system (IDS) and intrusion prevention system (IPS) with
+network security monitoring capabilities.
 
 Key-Features:
 
@@ -315,36 +358,39 @@ Key-Features:
 - Protocol Identification: The tool can identify and analyze a wide range of network protocols, providing detailed insights into traffic patterns and potential threats.
 - Real-Time Threat Detection: Suricata detects threats in real-time, enabling prompt responses to potential security incidents.
 
-Pros: 
+Pros:
 
 - High Performance: Suricata’s ability to handle large volumes of traffic efficiently makes it a top choice for high-speed networks and large enterprises.
 - Open-Source Flexibility: As an open-source tool, Suricata can be customized and extended to meet specific security monitoring needs.
 
-Cons: 
+Cons:
 
 - Complex Configuration: Setting up and tuning Suricata can be complex, particularly in environment with diverse and high-volume traffic.
 - Resource Intensive: The tool’s high performance comes at the cost of significant resource usage, which can be challenging for smaller networks.
 
-Insight: 
+Insight:
 
 - Suricata is frequently mentioned in technical forums as a preferred IDS/IPS for environments that require high throughput and detailed protocol analysis, though users caution about its resource demands.
 
 ### 10. Zeek (formerly Bro)
 
-<a href="https://zeek.org/" rel="noopener noreferrer nofollow" target="_blank">Zeek</a> is a powerful network analysis framework used for security monitoring, traffic analysis, and more.
+<a href="https://zeek.org/" rel="noopener noreferrer nofollow" target="_blank">
+  Zeek
+</a>
+is a powerful network analysis framework used for security monitoring, traffic analysis, and more.
 
-Key Features: 
+Key Features:
 
 - Detailed Protocol Analysis: Zeek excels at analyzing network protocols, providing deep insights into network behavior and potential security threats.
 - Custom Scripting Language: The tool’s scripting language allows users to create custom detection rules and workflows, enabling tailored monitoring solutions.
 - Network Monitoring and Forensics: Zeek not only monitors network traffic but also records it for later analysis, making it useful for both real-time detection and forensic investigations.
 
-Pros: 
+Pros:
 
 - High Customizability: Zeek’s scripting language offers unparalleled flexibility, allowing users to tailor the tool to specific network environments and security needs.
 - Strong Forensic Capabilities: The ability to log and analyze network traffic makes Zeek invaluable for post incident investigations.
 
-Cons: 
+Cons:
 
 - Steep Learning Curve: Zeek’s power and flexibility come with a steep learning curve, requiring significant expertise to fully leverage its capabilities.
 - Limited Out-of-the-Box Functionality: While highly customizable, Zeek offers limited functionality without significant configuration, making it less accessible for users seeking an out-of-the-box solution.
@@ -355,61 +401,60 @@ Insight:
 
 ## Implementing Network Security Monitoring with SigNoz
 
-While traditional NSM tools offer valuable capabilities, SigNoz stands out by providing a robust solution that enhances and complements these features. Setting up SigNoz in your environment can significantly improve the effectiveness of your network security monitoring strategy. If you’re ready to get started, follow the [SigNoz Setup Guide](https://signoz.io/docs/install/) for detailed instructions. 
+While traditional NSM tools offer valuable capabilities, SigNoz stands out by providing a robust solution that enhances and complements these features. Setting up SigNoz in your environment can significantly improve the effectiveness of your network security monitoring strategy. If you’re ready to get started, follow the [SigNoz Setup Guide](https://signoz.io/docs/install/) for detailed instructions.
 
-Key Features of SigNoz for NSM: 
+Key Features of SigNoz for NSM:
 
 - [Distributed Tracing](https://signoz.io/blog/distributed-tracing/): analyzes transactions in detail for a comprehensive view of network and application interactions.
 - Real-Time Metrics and Log Correlations: Integrates metrics and logs for synchronized insights and faster detection.
 - Anomaly Detection and Alerting: Identifies unusual patterns and generates alerts for timely response.
 - Custom Dashboard Creation: Offers tailored dashboards for specific security insights and visualizations.
 
-How SigNoz Enhances Your NSM Strategy: 
+How SigNoz Enhances Your NSM Strategy:
 
-1. End-to-End Visibility: Provides a complete view of both application and network interactions, improving overall security monitoring. 
-2. Rapid Incident Investigation: Facilitates quick investigation with correlated logs and transaction traces, reducing response time. 
-3. Customizable Alerts: Allows for the creation of specific alerts for security events and anomalies, ensuring timely and relevant notifications. 
+1. End-to-End Visibility: Provides a complete view of both application and network interactions, improving overall security monitoring.
+2. Rapid Incident Investigation: Facilitates quick investigation with correlated logs and transaction traces, reducing response time.
+3. Customizable Alerts: Allows for the creation of specific alerts for security events and anomalies, ensuring timely and relevant notifications.
 
 <GetStartedSigNoz />
 
 ## Best Practices for Effective Network Security Monitoring
 
-To maximize the effectiveness of your NSM tools, follow these best practices 
-
+To maximize the effectiveness of your NSM tools, follow these best practices
 
 Best Practices for effective network security monitoring tool
 
-1. Establish a baseline: define the normal network activity patterns to quickly identify and address any anomalies. 
-2. Implement a layered approach: Utilize a combination of tools and strategies for a comprehensive security monitoring system. 
-3. Regular updates and maintenance: Keep your NSM tools and rulesets up to date to stay ahead of emerging threats. 
-4. Employee training: Equip your team with the skills to use NSM tools effectively and interpret their data accurately. 
-5. Continuous improvement: Continuously assess and enhance your monitoring processes to adapt to new threats and refine your security posture. 
+1. Establish a baseline: define the normal network activity patterns to quickly identify and address any anomalies.
+2. Implement a layered approach: Utilize a combination of tools and strategies for a comprehensive security monitoring system.
+3. Regular updates and maintenance: Keep your NSM tools and rulesets up to date to stay ahead of emerging threats.
+4. Employee training: Equip your team with the skills to use NSM tools effectively and interpret their data accurately.
+5. Continuous improvement: Continuously assess and enhance your monitoring processes to adapt to new threats and refine your security posture.
 
 ## Challenges in Network Security Monitoring
 
-Despite its numerous advantages, Network Security Monitoring (NSM) presents several challenges that can impact security teams and their effectiveness: 
+Despite its numerous advantages, Network Security Monitoring (NSM) presents several challenges that can impact security teams and their effectiveness:
 
-1. [Alert fatigue](https://signoz.io/blog/alert-fatigue/): Security teams can become overwhelmed by the sheer volume of alerts generated by NSM tools. This high alert volume can lead to “alert fatigue,"  where important threats may be missed or ignored amidst a flood of less critical notifications. 
-    - Solution: To mitigate alert fatigue, it’s crucial to implement proper alert tuning and prioritization. This involves configuring your NSM tools to filter out false positives and prioritize alerts based on severity, ensuring that the security team focuses on the most critical threats.
-2. Keeping pace with threats: The cyber threat landscape is constantly evolving, with new attack vectors and techniques emerging regularly. This rapid pace of change can make it challenging for NSM tools to stay updated with the latest threats and detection methods. 
-    - Solution: Regular updates to threat detection rules, signatures, and algorithms are essential. Security teams should also integrate threat intelligence feeds and collaborate with industry peers to stay informed about new threats and vulnerabilities.
-3. Performance Impact: Comprehensive network monitoring can be resource-intensive, potentially affecting network performance. The added overhead of analyzing traffic and logs may slow down network operations or impact the user experience. 
-    - Solution: Balance the need for detailed monitoring with network performance requirements. implement efficient data collection and analysis methods, and ensure that NSM tools are configured to minimize their impact on overall network performance.
-4. Privacy concerns: Network monitoring often involves the collection and analysis of sensitive data, raising privacy concerns. Ensuring that monitoring practices comply with data protection regulations is essential to avoid legal and ethical issues. 
-    - Solution: Implement privacy-conscious monitoring practices by anonymizing or aggregating data where possible. Ensure that your NSM practices align with data protection regulations such as GDPR, or CCPA and maintain transparency with users about data collection and usage.
+1. [Alert fatigue](https://signoz.io/blog/alert-fatigue/): Security teams can become overwhelmed by the sheer volume of alerts generated by NSM tools. This high alert volume can lead to “alert fatigue," where important threats may be missed or ignored amidst a flood of less critical notifications.
+   - Solution: To mitigate alert fatigue, it’s crucial to implement proper alert tuning and prioritization. This involves configuring your NSM tools to filter out false positives and prioritize alerts based on severity, ensuring that the security team focuses on the most critical threats.
+2. Keeping pace with threats: The cyber threat landscape is constantly evolving, with new attack vectors and techniques emerging regularly. This rapid pace of change can make it challenging for NSM tools to stay updated with the latest threats and detection methods.
+   - Solution: Regular updates to threat detection rules, signatures, and algorithms are essential. Security teams should also integrate threat intelligence feeds and collaborate with industry peers to stay informed about new threats and vulnerabilities.
+3. Performance Impact: Comprehensive network monitoring can be resource-intensive, potentially affecting network performance. The added overhead of analyzing traffic and logs may slow down network operations or impact the user experience.
+   - Solution: Balance the need for detailed monitoring with network performance requirements. implement efficient data collection and analysis methods, and ensure that NSM tools are configured to minimize their impact on overall network performance.
+4. Privacy concerns: Network monitoring often involves the collection and analysis of sensitive data, raising privacy concerns. Ensuring that monitoring practices comply with data protection regulations is essential to avoid legal and ethical issues.
+   - Solution: Implement privacy-conscious monitoring practices by anonymizing or aggregating data where possible. Ensure that your NSM practices align with data protection regulations such as GDPR, or CCPA and maintain transparency with users about data collection and usage.
 
 ## Future Trends in Network Security Monitoring
 
 As technology evolves, so do NSM tools and practices. Keep an eye on these emerging trends:
 
-1. AI-Driven Threat Detection: Machine learning algorithms are becoming integral to NSM tools, enabling more sophisticated detection of complex and emerging attack patterns. AI algorithms can analyze vast amounts of data, identify subtle anomalies, and predict potential threats with greater accuracy. 
-    - It can help to improve the identification of sophisticated attacks that traditional methods might miss, allowing for more proactive threat management.
-2. Integration with SOAR: Security Orchestration, Automation, and Response (SOAR) platforms will increasingly integrate with NSM tools for faster incident response. SOAR platforms automate repetitive tasks, coordinate responses, and provide a centralized view of security operations. 
-    - This integration will enable faster, more efficient incident response =, reduce manual intervention, and enhance overall security posture by automating complex workflows and improving coordination between tools.
-3. Cloud-native monitoring: As more organizations adopt cloud services, NSM tools will evolve to provide better visibility and monitoring capabilities in cloud-native and hybrid cloud setups. This includes monitoring cloud infrastructure, services, and applications with tools designed specifically for cloud environments. 
-    - Improved cloud-monitoring will help organizations maintain security across diverse cloud environments, address cloud-specific threats, and ensure consistent security practices regardless of where their data and applications reside.
+1. AI-Driven Threat Detection: Machine learning algorithms are becoming integral to NSM tools, enabling more sophisticated detection of complex and emerging attack patterns. AI algorithms can analyze vast amounts of data, identify subtle anomalies, and predict potential threats with greater accuracy.
+   - It can help to improve the identification of sophisticated attacks that traditional methods might miss, allowing for more proactive threat management.
+2. Integration with SOAR: Security Orchestration, Automation, and Response (SOAR) platforms will increasingly integrate with NSM tools for faster incident response. SOAR platforms automate repetitive tasks, coordinate responses, and provide a centralized view of security operations.
+   - This integration will enable faster, more efficient incident response =, reduce manual intervention, and enhance overall security posture by automating complex workflows and improving coordination between tools.
+3. Cloud-native monitoring: As more organizations adopt cloud services, NSM tools will evolve to provide better visibility and monitoring capabilities in cloud-native and hybrid cloud setups. This includes monitoring cloud infrastructure, services, and applications with tools designed specifically for cloud environments.
+   - Improved cloud-monitoring will help organizations maintain security across diverse cloud environments, address cloud-specific threats, and ensure consistent security practices regardless of where their data and applications reside.
 4. Zero Trust implementation: The Zero Trust security model, which assumes that threats can be internal or external and requires continuous verification of every access request, is gaining traction. NSM tools will support Zero Trust by providing continuous monitoring, real-time verification, and detailed visibility into network and user activities.
-    - NSM tools will be crucial in enforcing Zero Trust principles by delivering real-time insights and alerts on network traffic and access patterns, helping to validate user and device identities, and ensuring that only authorized access is granted.
+   - NSM tools will be crucial in enforcing Zero Trust principles by delivering real-time insights and alerts on network traffic and access patterns, helping to validate user and device identities, and ensuring that only authorized access is granted.
 
 ## Key Takeaways
 
@@ -423,22 +468,22 @@ As technology evolves, so do NSM tools and practices. Keep an eye on these emerg
 
 ### What is the difference between network monitoring and network security monitoring?
 
-Network monitoring focuses on the performance and availability of network resources. In contrast, network security monitoring focuses on identifying and analyzing security threats and anomalies within the network to protect against potential breaches. 
+Network monitoring focuses on the performance and availability of network resources. In contrast, network security monitoring focuses on identifying and analyzing security threats and anomalies within the network to protect against potential breaches.
 
 ### How often should network security monitoring tools be updated?
 
-NSM tools should be updated regularly, to incorporate the latest updates and patches, ensuring they can detect new threats and vulnerabilities. Additionally, rulesets and threat intelligence feeds should be refreshed daily or more often to stay current with emerging threats. 
+NSM tools should be updated regularly, to incorporate the latest updates and patches, ensuring they can detect new threats and vulnerabilities. Additionally, rulesets and threat intelligence feeds should be refreshed daily or more often to stay current with emerging threats.
 
 ### Can network security monitoring tools prevent all cyber attacks?
 
-While NSM tools are essential  for detecting and responding to security threats, they cannot prevent all cyberattacks. They should be part of a broader security strategy that should include preventive measures, employee training, and comprehensive incident response planning.
+While NSM tools are essential for detecting and responding to security threats, they cannot prevent all cyberattacks. They should be part of a broader security strategy that should include preventive measures, employee training, and comprehensive incident response planning.
 
 ### What skills are needed to effectively use network security monitoring tools?
 
-To effectively use NSM tools, one needs a blend of skills, including: 
+To effectively use NSM tools, one needs a blend of skills, including:
 
 - Network architecture and protocol understanding
 - Knowledge of common cyber threats and attack vectors
 - Data analysis and interpretation skills
 - Familiarity with scripting and automation tools
-- Understanding of relevant compliance and regulatory requirements
\ No newline at end of file
+- Understanding of relevant compliance and regulatory requirements
diff --git a/data/comparisons/new-relic-vs-appdynamics.mdx b/data/comparisons/new-relic-vs-appdynamics.mdx
index 4822abaf4..756c06918 100644
--- a/data/comparisons/new-relic-vs-appdynamics.mdx
+++ b/data/comparisons/new-relic-vs-appdynamics.mdx
@@ -1,43 +1,51 @@
 ---
 title: New Relic vs AppDynamics - In-Depth Comparison Guide [2025]
-slug: new-relic-vs-appdynamics
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Both New Relic and AppDynamics are observability and monitoring tools that provide insights into the performance and health of applications, infrastructure, and services. One thing to note is that New Relic is better suited for small to mid-sized businesses while AppDynamics is well-suited for large enterprises...
 image: /img/blog/2024/03/new-relic-vs-appdynamics-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [newrelic-vs-appdynamics,new-relic,appdynamics,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [
+    newrelic-vs-appdynamics,
+    new-relic,
+    appdynamics,
+    opentelemetry,
+    open-source,
+    monitoring-tools,
+    signoz,
+  ]
 ---
-Both New Relic and AppDynamics are observability and monitoring tools that provide insights into the performance and health of applications, infrastructure, and services. 
-
-New Relic is a cloud-based observability platform that provides real-time analytics, [distributed tracing](https://signoz.io/blog/distributed-tracing/), and application performance monitoring (APM) capabilities. AppDynamics, on the other hand, is a full-stack application performance management (APM) solution that offers deep insights into application performance, user experience, and business performance.
 
+Both New Relic and AppDynamics are observability and monitoring tools that provide insights into the performance and health of applications, infrastructure, and services.
 
+New Relic is a cloud-based observability platform that provides real-time analytics, [distributed tracing](https://signoz.io/blog/distributed-tracing/), and application performance monitoring (APM) capabilities. AppDynamics, on the other hand, is a full-stack application performance management (APM) solution that offers deep insights into application performance, user experience, and business performance.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-appdynamics-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-appdynamics-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 One thing to note between both tools is that New Relic is better suited for small to medium-sized businesses while AppDynamics is well-suited for large enterprises.
 
 ## New Relic vs AppDynamics: At a glance
 
-| Features | New Relic | AppDynamics |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Log management | ✅ | ✅ |
-| Application Security | 🟡  | ✅  |
-| Infrastructure Monitoring | ✅ | ✅  |
-| Network Monitoring | ✅ | ✅  |
-| Real-User Monitoring | 🟡  | ✅ |
-| Synthetic Monitoring | 🟡  | ✅ |
-| Open-Telemetry Support | ✅ | ✅ |
-| SLA Monitoring | ✅ | 🟡 |
-| Free Forever Plan | ✅ | ❌ |
+| Features                  | New Relic | AppDynamics |
+| ------------------------- | --------- | ----------- |
+| APM                       | ✅        | ✅          |
+| Log management            | ✅        | ✅          |
+| Application Security      | 🟡        | ✅          |
+| Infrastructure Monitoring | ✅        | ✅          |
+| Network Monitoring        | ✅        | ✅          |
+| Real-User Monitoring      | 🟡        | ✅          |
+| Synthetic Monitoring      | 🟡        | ✅          |
+| Open-Telemetry Support    | ✅        | ✅          |
+| SLA Monitoring            | ✅        | 🟡          |
+| Free Forever Plan         | ✅        | ❌          |
 
 ✅ - Available
 
@@ -47,78 +55,65 @@ One thing to note between both tools is that New Relic is better suited for smal
 
 ### What is New Relic?
 
-New Relic is a cloud-based full-stack observability platform that provides real-time insights into the performance and behavior of systems. It offers a comprehensive suite of tools for monitoring, alerting, and troubleshooting, aiming to eliminate silos for data, tools, and teams. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-appdynamics-nr.webp" alt="New Relic APM dashboard"/>
-    <figcaption><i>New Relic APM dashboard</i></figcaption>
+New Relic is a cloud-based full-stack observability platform that provides real-time insights into the performance and behavior of systems. It offers a comprehensive suite of tools for monitoring, alerting, and troubleshooting, aiming to eliminate silos for data, tools, and teams.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-appdynamics-nr.webp"
+    alt="New Relic APM dashboard"
+  />
+  <figcaption>
+    <i>New Relic APM dashboard</i>
+  </figcaption>
 </figure>
 
-
 ### Key features of New Relic
 
 - **Application Performance Monitoring (APM)** <br/>
-    
-    New Relic provides robust APM capabilities, offering real-time insights into application performance and user experience. It enables teams to quickly identify and resolve performance issues.
-    
+  New Relic provides robust APM capabilities, offering real-time insights into application performance and user experience. It enables teams to quickly identify and resolve performance issues.
 - **Real User Monitoring (RUM)**<br/>
-    
-    New Relic's RUM feature captures detailed insights into user interactions, providing real-time analytics for understanding and optimizing the user experience.
-    
+  New Relic's RUM feature captures detailed insights into user interactions, providing real-time analytics for understanding and optimizing the user experience.
 - **Dashboards and Visualizations**<br/>
-    
-    New Relic has an intuitive UI and comes with pre-configured monitoring dashboards. It also allows for the creation of custom dashboards to monitor important metrics. Additionally, it offers a range of visualization options for understanding and analyzing application data efficiently.
-    
+  New Relic has an intuitive UI and comes with pre-configured monitoring dashboards. It also allows for the creation of custom dashboards to monitor important metrics. Additionally, it offers a range of visualization options for understanding and analyzing application data efficiently.
 - **Incident Alerting**<br/>
-    
-    New Relic’s incident alerting feature quickly notifies teams about performance anomalies, allowing for immediate resolution.
-    
+  New Relic’s incident alerting feature quickly notifies teams about performance anomalies, allowing for immediate resolution.
 
 ### What is AppDynamics?
 
 AppDynamics is a comprehensive full-stack observability and monitoring platform used by organizations to ensure the optimal performance and reliability of their software applications. It provides a wide range of tools for performance management and IT Operations analytics, offering visibility across all infrastructure components, including networks, servers, and containers. It also supports application performance monitoring, database monitoring, SAP monitoring, and end-user monitoring, enabling businesses to identify performance bottlenecks, monitor production environments, and understand user experiences with their products. AppDynamics is optimized for production environments to ensure minimal performance overhead.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-appdynamics-ad.webp" alt="Appdynamics observability platform for full visibility of application performance"/>
-    <figcaption><i>Appdynamics observability platform for full visibility of application performance</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-appdynamics-ad.webp"
+    alt="Appdynamics observability platform for full visibility of application performance"
+  />
+  <figcaption>
+    <i>Appdynamics observability platform for full visibility of application performance</i>
+  </figcaption>
 </figure>
 
-
 ### Key Features of AppDynamics
 
 - **End-User Monitoring**<br/>
-    
-    AppDynamics end-user monitoring feature offers visibility into how users interact with applications from various devices, browsers, and locations for optimizing application performance accordingly.
-    
+  AppDynamics end-user monitoring feature offers visibility into how users interact with applications from various devices, browsers, and locations for optimizing application performance accordingly.
 - **Dashboards and Visualizations**<br/>
-    
-    AppDynamics also allows for the creation of custom dashboards, but it allows for more customization and 
-    
+  AppDynamics also allows for the creation of custom dashboards, but it allows for more customization and
 - **Application Performance Monitoring**<br/>
-    
-    AppDynamics enables real-time monitoring of both business and application performance. It includes an auto-discovery feature that automatically identifies and displays the status of connected devices and applications. This feature uses color-coding to visually indicate the health status of each component, allowing for quick identification of any faults or issues.
-    
+  AppDynamics enables real-time monitoring of both business and application performance. It includes an auto-discovery feature that automatically identifies and displays the status of connected devices and applications. This feature uses color-coding to visually indicate the health status of each component, allowing for quick identification of any faults or issues.
 - **Synthetic monitoring**<br/>
-    
-    AppDynamics' Synthetic Monitoring feature is designed to actively test applications by simulating user behavior, thereby establishing baselines and measuring performance in a controlled environment.
-    
+  AppDynamics' Synthetic Monitoring feature is designed to actively test applications by simulating user behavior, thereby establishing baselines and measuring performance in a controlled environment.
 
 ## New Relic vs AppDynamics: Key Differences
 
 - **Application Security**<br/>
-    
-    New Relic offers features focused on application security such as real-time threat detection, application security monitoring, and compliance reporting. On the other hand, AppDynamics provides robust application security features including runtime application self-protection (RASP), code-level security insights, and advanced anomaly detection to identify and mitigate security threats in real-time.
-    
+  New Relic offers features focused on application security such as real-time threat detection, application security monitoring, and compliance reporting. On the other hand, AppDynamics provides robust application security features including runtime application self-protection (RASP), code-level security insights, and advanced anomaly detection to identify and mitigate security threats in real-time.
 - **Pricing**<br/>
-    
-    New Relic utilizes a user-based pricing model where the cost is determined by the number of users or licenses purchased. This is quite expensive but is generally considered more affordable in contrast to AppDynamics. New Relic provides a free forever plan with 100 GB of free data ingest per month for users looking to test the platform.
-    
-    AppDynamics uses an <a href = "https://www.appdynamics.com/pricing#~cisco-appdynamics" rel="noopener noreferrer nofollow" target="_blank" >SKU pricing model</a> which is based on licensed units per CPU Core, with different packages available to cater to various needs, including [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/), Premium, and Enterprise packages. The pricing can immediately get expensive considering the cost of monitoring a large number of CPU Cores. AppDynamics doesn’t provide a free forever plan like New Relic but it offers a free 15-day trial period for users to explore the platform before committing to a purchase.
-    
+  New Relic utilizes a user-based pricing model where the cost is determined by the number of users or licenses purchased. This is quite expensive but is generally considered more affordable in contrast to AppDynamics. New Relic provides a free forever plan with 100 GB of free data ingest per month for users looking to test the platform.
+  AppDynamics uses an <a href = "https://www.appdynamics.com/pricing#~cisco-appdynamics" rel="noopener noreferrer nofollow" target="_blank" >SKU pricing model</a> which is based on licensed units per CPU Core, with different packages available to cater to various needs, including [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/), Premium, and Enterprise packages. The pricing can immediately get expensive considering the cost of monitoring a large number of CPU Cores. AppDynamics doesn’t provide a free forever plan like New Relic but it offers a free 15-day trial period for users to explore the platform before committing to a purchase.
 - **Synthetic monitoring**<br/>
-    
-    AppDynamics does synthetic monitoring better than New Relic this is because New Relic collects data from real users only while AppDynamics collects data from both real users and synthetic users. This dual data collection method enhances the accuracy and reliability of performance insights, identifying and addressing potential issues before they impact end users.
-    
+  AppDynamics does synthetic monitoring better than New Relic this is because New Relic collects data from real users only while AppDynamics collects data from both real users and synthetic users. This dual data collection method enhances the accuracy and reliability of performance insights, identifying and addressing potential issues before they impact end users.
 
 ## New Relic vs AppDynamics: Final Verdict
 
@@ -131,7 +126,7 @@ If you are wondering when to choose New Relic over AppDynamics or vice versa, we
 
 ## SigNoz: A New Relic and AppDynamics alternative
 
-[SigNoz](https://signoz.io/) is a good alternative to consider when looking for a New Relic and [AppDynamics alternative](https://signoz.io/comparisons/appdynamics-competitors/). It is an open-source, full-stack APM tool designed to cater to the needs of businesses looking for a flexible, cost-effective, and vendor-agnostic solution for application performance monitoring. 
+[SigNoz](https://signoz.io/) is a good alternative to consider when looking for a New Relic and [AppDynamics alternative](https://signoz.io/comparisons/appdynamics-competitors/). It is an open-source, full-stack APM tool designed to cater to the needs of businesses looking for a flexible, cost-effective, and vendor-agnostic solution for application performance monitoring.
 
 Here are some things you can do with SigNoz:
 
diff --git a/data/comparisons/new-relic-vs-grafana.mdx b/data/comparisons/new-relic-vs-grafana.mdx
index be3be1cd1..cee9f2416 100644
--- a/data/comparisons/new-relic-vs-grafana.mdx
+++ b/data/comparisons/new-relic-vs-grafana.mdx
@@ -1,48 +1,49 @@
 ---
 title: New Relic vs Grafana - In-depth Comparison [2025]
-slug: new-relic-vs-grafana
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: We have compared New Relic and Grafana by sending data from a sample application to both platforms and comparing our experience. Check out New Relic vs Grafana across key aspects like APM, log management, infrastructure monitoring, application security...
 image: /img/blog/2024/03/new-relic-vs-grafana-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [newrelic-vs-grafana,newrelic,grafana,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [newrelic-vs-grafana, newrelic, grafana, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-New Relic and Grafana are popular monitoring and observability tools that provide a wide range of products with similar features. In this post, I have compared New Relic and Grafana on important features like APM, log management, infrastructure monitoring, application security, etc.
-
 
+New Relic and Grafana are popular monitoring and observability tools that provide a wide range of products with similar features. In this post, I have compared New Relic and Grafana on important features like APM, log management, infrastructure monitoring, application security, etc.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 <Admonition type="info">
-💡 I instrumented a sample application and sent data to New Relic and Grafana to evaluate my experience. Some takeaways are subjective and based on personal preference.
+  💡 I instrumented a sample application and sent data to New Relic and Grafana to evaluate my
+  experience. Some takeaways are subjective and based on personal preference.
 </Admonition>
 
 ## New Relic vs Grafana: Overview
 
-New Relic and Grafana are both powerful tools designed for monitoring and observability, but they serve different purposes and offer unique features. Grafana is primarily known for its data visualization capabilities, allowing users to create interactive dashboards that provide insights into their data. When integrated with the <a href = "https://grafana.com/about/grafana-stack" rel="noopener noreferrer nofollow" target="_blank" >Grafana stack</a>, which includes additional components like Loki for logging, it becomes a comprehensive observability and monitoring solution. 
+New Relic and Grafana are both powerful tools designed for monitoring and observability, but they serve different purposes and offer unique features. Grafana is primarily known for its data visualization capabilities, allowing users to create interactive dashboards that provide insights into their data. When integrated with the <a href = "https://grafana.com/about/grafana-stack" rel="noopener noreferrer nofollow" target="_blank" >Grafana stack</a>, which includes additional components like Loki for logging, it becomes a comprehensive observability and monitoring solution.
 
 New Relic, on the other hand, is an all-in-one [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/) solution. It integrates a wide range of features directly within its platform.
 
 Here’s a quick overview of the overall platform features and functionality of New Relic and Grafana.
 
-| Features | Grafana | New Relic |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Log management | 🟡  | ✅  |
-| Infrastructure monitoring | 🟡  | ✅  |
-| Visualization | ✅  | ✅  |
-| Real user monitoring | ✅ | ✅ |
-| OpenTelemetry support | ✅ | ✅ |
-| Incident response and management | 🟡  | ✅ |
-| Application security | ❌ | ✅ |
-| Free Tier | ✅  | ✅  |
+| Features                         | Grafana | New Relic |
+| -------------------------------- | ------- | --------- |
+| APM                              | ✅      | ✅        |
+| Log management                   | 🟡      | ✅        |
+| Infrastructure monitoring        | 🟡      | ✅        |
+| Visualization                    | ✅      | ✅        |
+| Real user monitoring             | ✅      | ✅        |
+| OpenTelemetry support            | ✅      | ✅        |
+| Incident response and management | 🟡      | ✅        |
+| Application security             | ❌      | ✅        |
+| Free Tier                        | ✅      | ✅        |
 
 ✅ - Available
 
@@ -56,34 +57,48 @@ To evaluate the APM feature in Grafana and New Relic, I sent data from a sample
 
 Grafana Cloud uses its Application Observability solution to observe and monitor the performance of applications. This solution allows for the detection of anomalies in applications and root cause analysis. It helped me identify request failures in my application.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-app-observability.webp" alt="Application observability in Grafana"/>
-    <figcaption><i>Application observability in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-app-observability.webp"
+    alt="Application observability in Grafana"
+  />
+  <figcaption>
+    <i>Application observability in Grafana</i>
+  </figcaption>
 </figure>
 
-
-
 New Relic’s APM feature provided me with real-time monitoring of my application’s telemetry data, including metrics, logs, events, and transactions, through a combination of pre-built and custom dashboards. On the [Distributed Tracing](https://signoz.io/distributed-tracing/) page, I was able to filter traces by Trace Groups, Root entry span, Root entity, and Errors. This allowed me to focus more on specific traces with failures and latency issues.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-apm-nr.webp" alt="APM in New Relic"/>
-    <figcaption><i>APM in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-apm-nr.webp"
+    alt="APM in New Relic"
+  />
+  <figcaption>
+    <i>APM in New Relic</i>
+  </figcaption>
 </figure>
 
-
 With New Relic, you can visualize inter-service relationships and dependencies within an application using service maps, end-to-end visibility of requests using flamegraphs, generate SLA reports, manage vulnerabilities, and more. New Relic provided me with a lot of information on my application’s performance.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-flamegraph-visualization.webp" alt="Flamegraph visualization"/>
-    <figcaption><i>Flamegraph visualization</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-flamegraph-visualization.webp"
+    alt="Flamegraph visualization"
+  />
+  <figcaption>
+    <i>Flamegraph visualization</i>
+  </figcaption>
 </figure>
 
-
-Both tools have good APM capabilities. If you require deep insights into your application and its performance, New Relic is a better choice. 
+Both tools have good APM capabilities. If you require deep insights into your application and its performance, New Relic is a better choice.
 
 ## Log Management: Grafana for cost effectiveness, New Relic for better log insights
 
-Grafana uses Loki from the Grafana stack for log management. Loki is a log aggregation tool designed to store and query logs from all your applications and infrastructure. 
+Grafana uses Loki from the Grafana stack for log management. Loki is a log aggregation tool designed to store and query logs from all your applications and infrastructure.
 
 Loki indexes only the metadata (labels) of logs, compresses them into chunks and then stores them in object storage like S3 buckets. The compressed chunks, smaller index, and use of low-cost object storage, makes Loki less expensive to use.
 
@@ -93,20 +108,30 @@ Other features of Loki:
 - Ingests logs without requiring any formatting requirements.
 - You can build metrics and generate alerts from your log lines
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-loki.webp" alt="Loki visualization through Grafana"/>
-    <figcaption><i>Loki visualization through Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-loki.webp"
+    alt="Loki visualization through Grafana"
+  />
+  <figcaption>
+    <i>Loki visualization through Grafana</i>
+  </figcaption>
 </figure>
 
-
 Log management in New Relic didn’t require any setup at all, my application and system logs were automatically collected by the New Relic agent. I could immediately visualize and query them in the logs tab. Log query in New Relic is done using Lucene, an open-source search library, and the New Relic Query Language (NRQL). They both allow for instant query and analysis of log data.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-log-nr.webp" alt="Log management in New Relic"/>
-    <figcaption><i>Log management in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-log-nr.webp"
+    alt="Log management in New Relic"
+  />
+  <figcaption>
+    <i>Log management in New Relic</i>
+  </figcaption>
 </figure>
 
-
 Other New Relic log management features include:
 
 - Root cause analysis for troubleshooting
@@ -120,12 +145,17 @@ If your focus is log aggregation, scalability, and cost-effectiveness, Grafana L
 
 Grafana Cloud allows for infrastructure monitoring of AWS, Kubernetes, and Grafana integrations such as Linux machines, databases, applications, and more. It provides a managed Grafana instance, integration with various data sources, powerful visualization tools, and alerting capabilities. This allowed me to focus on monitoring my infrastructure without the complexities of managing the underlying infrastructure. I was also able to create customized dashboards to monitor specific metrics from my infrastructure.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-kubernetes.webp" alt="Kubernetes monitoring in Grafana"/>
-    <figcaption><i>Kubernetes monitoring in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-kubernetes.webp"
+    alt="Kubernetes monitoring in Grafana"
+  />
+  <figcaption>
+    <i>Kubernetes monitoring in Grafana</i>
+  </figcaption>
 </figure>
 
-
 In New Relic, you can monitor different infrastructure types by deploying the infrastructure agent. The agent automatically collected and sent data from my host infrastructure and services running on it to the New Relic platform. It provided out-of-the-box dashboard for me to visualize my infrastructure data.
 
 With New Relic infrastructure monitoring, you can:
@@ -135,12 +165,17 @@ With New Relic infrastructure monitoring, you can:
 - Manage alert settings directly from the relevant infrastructure chart.
 - You can also see log messages related to your errors and traces directly in your app's or host's UI.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-infra-monitoring.webp" alt="Infrastructure monitoring in New Relic"/>
-    <figcaption><i>Infrastructure monitoring in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-infra-monitoring.webp"
+    alt="Infrastructure monitoring in New Relic"
+  />
+  <figcaption>
+    <i>Infrastructure monitoring in New Relic</i>
+  </figcaption>
 </figure>
 
-
 When choosing between Grafana and New Relic for infrastructure monitoring, consider the costs. Both tools can be expensive but the cost can be less depending on what you want to monitor.
 
 <GrafanaVsSigNoz />
@@ -165,20 +200,30 @@ Some of the features IRM provides include:
 - Identification of actionable insights on incidents across services, teams, or geos.
 - Query of incident data
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-incident-query.webp" alt="Incident query"/>
-    <figcaption><i>Incident query</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-incident-query.webp"
+    alt="Incident query"
+  />
+  <figcaption>
+    <i>Incident query</i>
+  </figcaption>
 </figure>
 
-
-New Relic provides an <a href = "https://newrelic.com/platform/applied-intelligence" rel="noopener noreferrer nofollow" target="_blank" >AIOps and Applied Intelligence</a> tool for incident management. This feature integrates machine learning and advanced logic to minimize the impact of redundant alerts, allowing for a swift focus on alerts that indicate genuine issues. It can also correlate related incidents for quicker identification and resolution. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-correlation-of-incidents.webp" alt="Correlation of related incidents"/>
-    <figcaption><i>Correlation of related incidents</i></figcaption>
+New Relic provides an <a href = "https://newrelic.com/platform/applied-intelligence" rel="noopener noreferrer nofollow" target="_blank" >AIOps and Applied Intelligence</a> tool for incident management. This feature integrates machine learning and advanced logic to minimize the impact of redundant alerts, allowing for a swift focus on alerts that indicate genuine issues. It can also correlate related incidents for quicker identification and resolution.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-correlation-of-incidents.webp"
+    alt="Correlation of related incidents"
+  />
+  <figcaption>
+    <i>Correlation of related incidents</i>
+  </figcaption>
 </figure>
 
-
 The platform supports real-time collaboration among teams through contextual notifications, ensuring that all relevant parties are informed and can contribute effectively. It provided me with detailed and in-depth information on root causes and the response history. This comes in handy for post-incident reports, providing valuable insights for future incident management strategies.
 
 For better incident management using advanced technologies, providing more features and allowing collaboration with team mates for faster incident resolution, choose New Relic.
@@ -187,29 +232,39 @@ For better incident management using advanced technologies, providing more featu
 
 Grafana does not exactly have an inbuilt product or feature for application security but it does allow for integration with open-source tools like <a href = "https://github.com/mergestat/mergestat" rel="noopener noreferrer nofollow" target="_blank" >MergeStat</a> and OSV-Scanner for scanning vulnerabilities in environments. You can also configure security hardening for additional security, to prevent vulnerabilities from being exploited by an attacker.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-osv.webp" alt="OSV scan dashboard"/>
-    <figcaption><i>OSV scan dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-osv.webp"
+    alt="OSV scan dashboard"
+  />
+  <figcaption>
+    <i>OSV scan dashboard</i>
+  </figcaption>
 </figure>
 
-
-Application security in New Relic is carried out using the <a href = "https://docs.newrelic.com/docs/iast/introduction" rel="noopener noreferrer nofollow" target="_blank" >Interactive Application Security Testing</a> (IAST) feature. IAST provided 360 visibility into the risks and vulnerabilities in my application. The built-in guardrails within IAST were instrumental in mitigating these security risks. 
+Application security in New Relic is carried out using the <a href = "https://docs.newrelic.com/docs/iast/introduction" rel="noopener noreferrer nofollow" target="_blank" >Interactive Application Security Testing</a> (IAST) feature. IAST provided 360 visibility into the risks and vulnerabilities in my application. The built-in guardrails within IAST were instrumental in mitigating these security risks.
 
 IAST can be incorporated into development processes as it allows for the identification and resolution of security issues without the need for separate, time-consuming security testing phases. This approach streamlines the development workflow, ensuring that security considerations are integrated seamlessly into the development lifecycle.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/new-relic-vs-grafana-app-security.webp" alt="Application security in New Relic"/>
-    <figcaption><i>Application security in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/new-relic-vs-grafana-app-security.webp"
+    alt="Application security in New Relic"
+  />
+  <figcaption>
+    <i>Application security in New Relic</i>
+  </figcaption>
 </figure>
 
-
 If you require a platform with in-built application security feature, New Relic is the clear choice. If you have an existing security solution you want to integrate with your monitoring platform, then choose Grafana.
 
 ## Pricing: Grafana
 
 Grafana being an open-source platform is free to use. Additionally, it offers both a cloud version and an enterprise version to cater to a wide range of user needs. The Grafana Cloud edition provides a free forever plan, and the enterprise version with a 14-day free trial.
 
-New Relic’s pricing is based on two things: the amount of data ingested and user Seats. It also provides a free forever plan with 100GB of free data ingest each month. Post the 100GB, you need to pay \$0.3/GB or \$0.5/GB ingested based on your plan. 
+New Relic’s pricing is based on two things: the amount of data ingested and user Seats. It also provides a free forever plan with 100GB of free data ingest each month. Post the 100GB, you need to pay \$0.3/GB or \$0.5/GB ingested based on your plan.
 
 New Relic’s user seats can get [expensive](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/#no-user-based-pricing-collaborate-seamlessly-with-signoz) as it allows only 5 full platform users in its standard plan, and the cost of full platform users can be up to \$549/user per month for enterprise plans.
 
@@ -236,7 +291,7 @@ Here are a few reasons why you can consider SigNoz as an alternative to Grafana
 
 - **SigNoz is open-source:** SigNoz is open-source, and unlike Grafana it has a single backend to manage logs , metrics, and traces. Grafana’s open-source version requires installation of the entire Grafana stack to be able to monitor your application and infrastructure. New Relic doesn’t have an open source version. SigNoz also has a cloud based version with free usage at start.
 - **All in one platform:** SigNoz being full stack provides visibility into your logs, metrics and traces in a single pane of glass. There is no need for any other “stack” or integration with other tools for monitoring your application and infrastructure data.
-- **Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/):**  SigNoz is an OpenTelemetry native tool. OpenTelemetry is the emerging standard for collecting and managing telemetry data. Being built with OpenTelemetry from scratch, SigNoz frees you from vendor lock-in, allowing you to use any backend of your choice.
+- **Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/):** SigNoz is an OpenTelemetry native tool. OpenTelemetry is the emerging standard for collecting and managing telemetry data. Being built with OpenTelemetry from scratch, SigNoz frees you from vendor lock-in, allowing you to use any backend of your choice.
 - **Flexible log management:** SigNoz’s log management solution provides a lot of flexibility. You can transform data with our logs pipeline, you get out of the box UI for log management, an advanced logs [query builder](https://signoz.io/blog/query-builder-v5/), correlation of logs with other telemetry signals for troubleshooting and more.
 
 ## Getting Started with SigNoz
diff --git a/data/comparisons/newrelic-vs-prometheus.mdx b/data/comparisons/newrelic-vs-prometheus.mdx
index 1d4d31df1..1e3e6dadb 100644
--- a/data/comparisons/newrelic-vs-prometheus.mdx
+++ b/data/comparisons/newrelic-vs-prometheus.mdx
@@ -1,36 +1,43 @@
 ---
 title: New Relic vs Prometheus - Detailed Comparison for 2025
-slug: newrelic-vs-prometheus
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: New Relic and Prometheus are both monitoring tools. But while New Relic is a comprehensive application monitoring platform that offers a wide range of features, including Application Performance Monitoring (APM), log monitoring, infrastructure monitoring, and real-user monitoring, Prometheus is focused only on metrics monitoring...
 image: /img/blog/2024/02/newrelic-vs-prometheus-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [newrelic-vs-prometheus,prometheus,newrelic,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [
+    newrelic-vs-prometheus,
+    prometheus,
+    newrelic,
+    opentelemetry,
+    open-source,
+    monitoring-tools,
+    signoz,
+  ]
 ---
+
 New Relic and Prometheus are popularly used tools for monitoring applications and systems. New Relic excels in providing comprehensive application monitoring solutions, while Prometheus specializes in metric collection.
 
 In this post, I have compared New Relic and Prometheus on important features like data collection, visualization capabilities, APM, data storage, etc.
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/new-relic-vs-prometheus-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/new-relic-vs-prometheus-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 **Testing environment**
 
-
 <Admonition type="tip">
-💡 I configured two sample applications: one in Python and the other in PHP, alongside a MySQL database. I sent their data to both New Relic and Prometheus for evaluation. Some takeaways are subjective and based on personal preference.
+  💡 I configured two sample applications: one in Python and the other in PHP, alongside a MySQL
+  database. I sent their data to both New Relic and Prometheus for evaluation. Some takeaways are
+  subjective and based on personal preference.
 </Admonition>
 
-
-
 ## New Relic vs Prometheus: An Overview
 
 New Relic is a versatile monitoring tool that offers a wide range of features, including Application Performance Monitoring (APM), log monitoring, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), and real-user monitoring. In contrast, Prometheus focuses on monitoring time-series data.
@@ -39,8 +46,6 @@ Prometheus is open-source and free to use, while New Relic is a paid tool, which
 
 To use New Relic, you simply need to sign up, create an account, and follow the onboarding steps to get started. As Prometheus is open-source, it requires self-installation and management. However, managed services for Prometheus are available from many cloud vendors, including [AWS](https://aws.amazon.com/prometheus/).
 
-
-
 ## Getting Started: New Relic
 
 ### New Relic
@@ -61,22 +66,32 @@ New Relic provides a total of 1083 data sources for data collection without the
 
 New Relic also provides the flexibility to collect custom data in cases where New Relic does not automatically support a given data source. This could include custom trace data, custom infrastructure data, and custom attributes and events.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-data-collection-nr.webp" alt="Data collection in New Relic"/>
-    <figcaption><i>Data collection in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-data-collection-nr.webp"
+    alt="Data collection in New Relic"
+  />
+  <figcaption>
+    <i>Data collection in New Relic</i>
+  </figcaption>
 </figure>
 
-
 ### Prometheus
 
 Prometheus also supports data collection from different data sources. It collects data through a pull-based model, where it actively scrapes metrics from configured targets at regular intervals. These targets can be servers, applications, or services that expose metrics in a format that Prometheus can understand, typically over HTTP. It uses a configuration file to define the targets it should scrape, including the URL, the scrape interval, and any specific metrics to collect. From the below image, you can see I was able to scrape metrics from several target endpoints.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-http-metrics.webp" alt="Prometheus scraping metrics from HTTP endpoints"/>
-    <figcaption><i>Prometheus scraping metrics from HTTP endpoints</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-http-metrics.webp"
+    alt="Prometheus scraping metrics from HTTP endpoints"
+  />
+  <figcaption>
+    <i>Prometheus scraping metrics from HTTP endpoints</i>
+  </figcaption>
 </figure>
 
-
 Both tools have impressive data collection capabilities, but New Relic stands out for the broader range of data it can accept.
 
 <NewRelicVsSigNoz />
@@ -87,42 +102,57 @@ Both tools have impressive data collection capabilities, but New Relic stands ou
 
 New Relic has impressive visualization capabilities. It provides pre-built dashboards for easy understanding and analysis of data, ensuring that you can quickly identify trends and insights. After the New Relic agent collected and sent my application data to New Relic, I could visualize and monitor my application without needing to create a dashboard.
 
-Users also have the flexibility to create and customize dashboards from scratch or by using custom queries to monitor the exact application metrics needed. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-dashboard-nr.webp" alt="Dashboard creation in New Relic"/>
-    <figcaption><i>Dashboard creation in New Relic</i></figcaption>
+Users also have the flexibility to create and customize dashboards from scratch or by using custom queries to monitor the exact application metrics needed.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-dashboard-nr.webp"
+    alt="Dashboard creation in New Relic"
+  />
+  <figcaption>
+    <i>Dashboard creation in New Relic</i>
+  </figcaption>
 </figure>
 
-
 For users who may require more customization options beyond what the standard charts and dashboards can offer, New Relic allows the development of New Relic Apps or the customization of existing apps from the <a href = "https://opensource.newrelic.com/nerdpacks" rel="noopener noreferrer nofollow" target="_blank" >App catalog</a>.
 
 ### Prometheus
 
 Prometheus, on the other hand, has limited visualization capabilities. It has a very basic built-in expression browser for visualizing metrics, but this doesn’t provide much information about your metrics data. Prometheus provides only table and graph visualization options. I couldn't make sense of my application metrics using them, so I had to send my application data to Grafana for visualization, which required setting up Grafana separately.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-graph.webp" alt="Graph visualization in Prometheus"/>
-    <figcaption><i>Graph visualization in Prometheus</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-graph.webp"
+    alt="Graph visualization in Prometheus"
+  />
+  <figcaption>
+    <i>Graph visualization in Prometheus</i>
+  </figcaption>
 </figure>
 
-
 New Relic clearly provides advanced visualization capabilities as opposed to Prometheus.
 
 ## APM (Application Performance Monitoring): New Relic
 
 ### New Relic
 
-New Relic's APM feature offers extensive monitoring capabilities for all your applications and microservices. It provides real-time monitoring of [application telemetry](https://signoz.io/comparisons/opentelemetry-vs-application-insights/) data, including metrics, logs, events, and transactions, through a combination of pre-built and custom dashboards. 
+New Relic's APM feature offers extensive monitoring capabilities for all your applications and microservices. It provides real-time monitoring of [application telemetry](https://signoz.io/comparisons/opentelemetry-vs-application-insights/) data, including metrics, logs, events, and transactions, through a combination of pre-built and custom dashboards.
 
 Additionally, it extends its functionality with features like service maps, offering visualization of inter-service relationships and dependencies within an application, SLA reports, vulnerability management, and much more. New Relic’s APM feature is comprehensive, and I was particularly impressed by the depth of information it provided about my application.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-apm-nr.webp" alt="APM in New Relic"/>
-    <figcaption><i>APM in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-apm-nr.webp"
+    alt="APM in New Relic"
+  />
+  <figcaption>
+    <i>APM in New Relic</i>
+  </figcaption>
 </figure>
 
-
 ### Prometheus
 
 Prometheus currently lacks APM functionality as it is focused on the collection of metrics data only.
@@ -151,22 +181,32 @@ New Relic uses the New Relic Query Language (NRQL) for data queries. NRQL allows
 
 Additionally, NRQL integrates with New Relic's APIs, such as <a href = "https://docs.newrelic.com/docs/apis/graphql-api/tutorials/nerdgraph-graphiql-nrql-tutorial" rel="noopener noreferrer nofollow" target="_blank" >NerdGraph</a>, for more complex data retrieval needs. It can be used to create simple queries, such as fetching rows of data in a raw tabular form to give insight into individual events and run powerful calculations on the data before it's presented to you, such as crafting funnels based on how end users are using your site or application.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-nrql.webp" alt="Data query in New Relic using NRQL"/>
-    <figcaption><i>Data query in New Relic using NRQL</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-nrql.webp"
+    alt="Data query in New Relic using NRQL"
+  />
+  <figcaption>
+    <i>Data query in New Relic using NRQL</i>
+  </figcaption>
 </figure>
 
-
 ### Prometheus
 
-Prometheus provides a powerful and flexible querying language known as PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) for querying and analyzing time-series data. PromQL allows users to perform a wide range of operations, including filtering, aggregation, and mathematical transformations, on the collected metrics data. Users can write expressive queries to extract valuable insights and monitor system performance effectively. With support for functions like rate, sum, and histogram_quantile, PromQL enables advanced analysis and visualization of metrics data. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-promql.webp" alt="Query in Prometheus using PromQL"/>
-    <figcaption><i>Query in Prometheus using PromQL</i></figcaption>
+Prometheus provides a powerful and flexible querying language known as PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) for querying and analyzing time-series data. PromQL allows users to perform a wide range of operations, including filtering, aggregation, and mathematical transformations, on the collected metrics data. Users can write expressive queries to extract valuable insights and monitor system performance effectively. With support for functions like rate, sum, and histogram_quantile, PromQL enables advanced analysis and visualization of metrics data.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-promql.webp"
+    alt="Query in Prometheus using PromQL"
+  />
+  <figcaption>
+    <i>Query in Prometheus using PromQL</i>
+  </figcaption>
 </figure>
 
-
 Both tools have good data query capabilities.
 
 ## Alerting: New Relic
@@ -177,22 +217,32 @@ New Relic's alerting feature, in collaboration with its AI capabilities, provide
 
 The alerting system is equipped with extensive capabilities, including the configuration of signals for evaluation at specific thresholds, root cause analysis, alert organization through tagging, the identification of anomalies, and the routing of issues to systems via notifications. The AI feature enhances the alerting system by enriching issue notifications with additional New Relic data, providing deeper insights into each alert. It correlates incoming incidents to identify patterns and suppresses noise, ensuring that you receive notifications only when necessary.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-alert-nr.webp" alt="Alerting in New Relic"/>
-    <figcaption><i>Alerting in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-alert-nr.webp"
+    alt="Alerting in New Relic"
+  />
+  <figcaption>
+    <i>Alerting in New Relic</i>
+  </figcaption>
 </figure>
 
-
 ### Prometheus
 
 In contrast, Prometheus lacks a built-in mechanism for explicitly configuring alert rules. Instead, alerting is handled by a component known as Alertmanager. Alertmanager handles alerts, including silence, inhibition, aggregation, and notification transmission. It can be set up to send alerts through a variety of channels, including email, on-call notification systems, and chat platforms, through the definition of alert rules. Once the conditions in the alert rules are met, Prometheus creates the alert instances and sends them to Alertmanager.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-alertmanager.webp" alt="Received alert from Prometheus in Alertmanager"/>
-    <figcaption><i>Received alert from Prometheus in Alertmanager</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-alertmanager.webp"
+    alt="Received alert from Prometheus in Alertmanager"
+  />
+  <figcaption>
+    <i>Received alert from Prometheus in Alertmanager</i>
+  </figcaption>
 </figure>
 
-
 The integration of AI with New Relic's Alerting feature enhances its alerting capabilities, making it a superior alerting option.
 
 ## UI/UX: New Relic
@@ -201,44 +251,68 @@ The integration of AI with New Relic's Alerting feature enhances its alerting ca
 
 New Relic's user interface is designed to be straightforward and accessible, making it very beginner-friendly. As a new user, I find it incredibly easy to navigate. The UI provides all the necessary information, with minimal need to refer to the documentation for navigation, significantly enhancing the user experience.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-ui-nr.webp" alt="New Relic’s UI"/>
-    <figcaption><i>New Relic’s UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-ui-nr.webp"
+    alt="New Relic’s UI"
+  />
+  <figcaption>
+    <i>New Relic’s UI</i>
+  </figcaption>
 </figure>
 
-
 ### Prometheus
 
 Prometheus provides a basic web interface, primarily focused on querying and visualizing time series data. The UI is functional but relatively minimalistic, with options for executing PromQL queries, viewing graphs, and exploring metrics. The user experience in Prometheus is straightforward and efficient.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-ui-prom.webp" alt="Prometheus UI"/>
-    <figcaption><i>Prometheus UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-ui-prom.webp"
+    alt="Prometheus UI"
+  />
+  <figcaption>
+    <i>Prometheus UI</i>
+  </figcaption>
 </figure>
 
-
 Overall, New Relic has a better user experience and user interface.
 
 ## Pricing: Prometheus
 
 ### New Relic
 
-<a href = "https://newrelic.com/pricing" rel="noopener noreferrer nofollow" target="_blank" >New Relic’s pricing</a> is usage-based. Pricing is calculated by the volume of data ingested per month and the number of users.
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-pricing-nr.webp" alt="New Relic pricing"/>
-    <figcaption><i>New Relic pricing</i></figcaption>
+<a href="https://newrelic.com/pricing" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic’s pricing
+</a>
+is usage-based. Pricing is calculated by the volume of data ingested per month and the number of
+users.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-pricing-nr.webp"
+    alt="New Relic pricing"
+  />
+  <figcaption>
+    <i>New Relic pricing</i>
+  </figcaption>
 </figure>
 
-
 It has 4 different pricing tiers, with a free forever tier offering access to all 30+ New Relic platform capabilities and 100 GB of free data ingestion per month.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/02/newrelic-vs-prometheus-pricing-nr-2.webp" alt="Pricing tiers"/>
-    <figcaption><i>Pricing tiers</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/newrelic-vs-prometheus-pricing-nr-2.webp"
+    alt="Pricing tiers"
+  />
+  <figcaption>
+    <i>Pricing tiers</i>
+  </figcaption>
 </figure>
 
-
 New Relic can be seen as a good option based on its free forever plan, which allows new users to evaluate its capabilities without incurring immediate costs.
 
 ### Prometheus
@@ -281,16 +355,13 @@ While New Relic and Prometheus are valuable monitoring solutions, they are not w
 Here are a few reasons why you should choose SigNoz over New Relic and Prometheus:
 
 - **Open-Source**<br></br>
-    [SigNoz](https://signoz.io/docs/introduction/) offers both an open-source and cloud version, providing users with flexibility based on their specific requirements. Users can choose between the versions depending on their use case: opt for the self-hosted (open-source) version for complete control over environment management, or choose the cloud version for hassle-free management without the need for self-hosting.
-    
+  [SigNoz](https://signoz.io/docs/introduction/) offers both an open-source and cloud version, providing users with flexibility based on their specific requirements. Users can choose between the versions depending on their use case: opt for the self-hosted (open-source) version for complete control over environment management, or choose the cloud version for hassle-free management without the need for self-hosting.
 - **[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) support**<br></br>
-    SigNoz is designed to natively support OpenTelemetry, a CNCF project rapidly gaining popularity and emerging as the standard for observability. It generates and manages telemetry data (logs, metrics, and traces) which are vital for achieving comprehensive application [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/). OpenTelemetry also frees you from vendor lock-in, enabling users to export data to any backend of choice. 
-    
+  SigNoz is designed to natively support OpenTelemetry, a CNCF project rapidly gaining popularity and emerging as the standard for observability. It generates and manages telemetry data (logs, metrics, and traces) which are vital for achieving comprehensive application [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/). OpenTelemetry also frees you from vendor lock-in, enabling users to export data to any backend of choice.
 - **Transparent Pricing**<br></br>
-    Unlike New Relic's usage-based model, which charges based on the number of users, SigNoz Cloud allows you to invite an unlimited number of team members without additional charges for user seats. SigNoz offers transparent and predictable pricing, where you are billed solely based on the volume of data you send, preventing unexpected costs.
-    
-    The open-source version is also completely free to use and can save costs for new users looking to try out SigNoz.
-    
+  Unlike New Relic's usage-based model, which charges based on the number of users, SigNoz Cloud allows you to invite an unlimited number of team members without additional charges for user seats. SigNoz offers transparent and predictable pricing, where you are billed solely based on the volume of data you send, preventing unexpected costs.
+  The open-source version is also completely free to use and can save costs for new users looking to try out SigNoz.
+
 ## Getting Started with SigNoz
 
 <GetStartedSigNoz />
@@ -301,4 +372,4 @@ Here are a few reasons why you should choose SigNoz over New Relic and Prometheu
 
 [SigNoz - Open-source alternative to New Relic](https://signoz.io/blog/open-source-newrelic-alternative/)
 
-[Open Source Single Pane of Glass Monitoring | SigNoz](https://signoz.io/blog/single-pane-of-glass-monitoring/)
\ No newline at end of file
+[Open Source Single Pane of Glass Monitoring | SigNoz](https://signoz.io/blog/single-pane-of-glass-monitoring/)
diff --git a/data/comparisons/newrelic-vs-sentry.mdx b/data/comparisons/newrelic-vs-sentry.mdx
index 33955e138..e331419e7 100644
--- a/data/comparisons/newrelic-vs-sentry.mdx
+++ b/data/comparisons/newrelic-vs-sentry.mdx
@@ -1,30 +1,30 @@
 ---
 title: New Relic vs Sentry - In-depth Comparison Guide [2025]
-slug: newrelic-vs-sentry
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: New Relic is tailored towards application performance and full stack observability of systems while Sentry specializes in identifying and reporting application errors...
 image: /img/blog/2024/04/newrelic-vs-sentry-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [newrelic-vs-sentry,newrelic,sentry,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [newrelic-vs-sentry, newrelic, sentry, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
 New Relic and Sentry are monitoring tools but with different use cases. New Relic is tailored towards application performance and full stack observability of systems while Sentry specializes in identifying and reporting application errors.
 
 In this post, I have compared New Relic and Sentry on important features like APM, error monitoring, pricing, etc.
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 <Admonition type="info">
-💡 I instrumented a sample Python Application and sent data to both New Relic and Sentry to evaluate my experience. Some takeaways are subjective and based on personal preference.
+  💡 I instrumented a sample Python Application and sent data to both New Relic and Sentry to
+  evaluate my experience. Some takeaways are subjective and based on personal preference.
 </Admonition>
 
 ## New Relic vs Sentry: At a glance
@@ -35,23 +35,23 @@ Sentry, on the other hand, is an application and error monitoring platform that
 
 Here’s a quick overview of the overall platform features and functionality of New Relic and Sentry.
 
-| Features | New Relic | Sentry |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Infrastructure Monitoring | ✅ | ❌ |
-| Session Replay | ✅ | ✅ |
-| Profiling | ❌ | ✅ |
-| Open-Source version | ❌ | ✅ |
-| Application Security | ✅ | ❌ |
-| Log management | ✅ | 🟡 |
-| Alerting | ✅ | ✅ |
-| OpenTelemetry Support | 🟡 | 🟡 |
-| Error Monitoring | ✅ | ✅  |
-| Incident Management | ✅ | ❌ |
-| Cloud SIEM | ❌ | ❌ |
-| Real User Monitoring | ✅ | ❌ |
-| Cron Monitoring | 🟡 | ✅  |
-| Free trial | ✅ (Free forever) | 🟡 (14-days) |
+| Features                  | New Relic         | Sentry       |
+| ------------------------- | ----------------- | ------------ |
+| APM                       | ✅                | ✅           |
+| Infrastructure Monitoring | ✅                | ❌           |
+| Session Replay            | ✅                | ✅           |
+| Profiling                 | ❌                | ✅           |
+| Open-Source version       | ❌                | ✅           |
+| Application Security      | ✅                | ❌           |
+| Log management            | ✅                | 🟡           |
+| Alerting                  | ✅                | ✅           |
+| OpenTelemetry Support     | 🟡                | 🟡           |
+| Error Monitoring          | ✅                | ✅           |
+| Incident Management       | ✅                | ❌           |
+| Cloud SIEM                | ❌                | ❌           |
+| Real User Monitoring      | ✅                | ❌           |
+| Cron Monitoring           | 🟡                | ✅           |
+| Free trial                | ✅ (Free forever) | 🟡 (14-days) |
 
 ✅ - Available
 
@@ -67,62 +67,88 @@ New Relic provides an “Errors Inbox” feature that detects and triages errors
 
 I was able to view errors from my application directly in the Errors Inbox UI. This came out of the box and did not require any additional configuration besides my APM and [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/) setup.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-error-box-nr.webp" alt="Errors Inbox in New Relic"/>
-    <figcaption><i>Errors Inbox in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-error-box-nr.webp"
+    alt="Errors Inbox in New Relic"
+  />
+  <figcaption>
+    <i>Errors Inbox in New Relic</i>
+  </figcaption>
 </figure>
 
-
 The Errors Inbox is closely integrated with New Relic’s APM. It leverages data from APM to pinpoint errors specific to individual applications. In the Triage tab, errors are categorized based on the count, error rate, and groups, and under the Group errors tab, you can filter different attributes and group errors to help narrow down what you are looking for.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-error-integration-nr.webp" alt="Errors Inbox integration with New Relic’s APM"/>
-    <figcaption><i>Errors Inbox integration with New Relic’s APM</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-error-integration-nr.webp"
+    alt="Errors Inbox integration with New Relic’s APM"
+  />
+  <figcaption>
+    <i>Errors Inbox integration with New Relic’s APM</i>
+  </figcaption>
 </figure>
 
-
-
 The Error Groups provide comprehensive insights into error details such as timestamp, host, users impacted, associated URL, logs, error messages, and more. I found the details to be incredibly useful and helpful in troubleshooting my application.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-error-insights-nr.webp" alt="Insights into error details with New Relic’s APM"/>
-    <figcaption><i>Insights into error details</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-error-insights-nr.webp"
+    alt="Insights into error details with New Relic’s APM"
+  />
+  <figcaption>
+    <i>Insights into error details</i>
+  </figcaption>
 </figure>
 
-
-
 ### Sentry
 
-Error monitoring in Sentry requires integrating Sentry with your application. This involves installing the SDK for that application and configuring Sentry’s SDK as well. It was a straightforward and seamless process for me. This allows Sentry to automatically capture errors and exceptions that occur within my application. These errors are displayed in the Issues UI in real-time. 
+Error monitoring in Sentry requires integrating Sentry with your application. This involves installing the SDK for that application and configuring Sentry’s SDK as well. It was a straightforward and seamless process for me. This allows Sentry to automatically capture errors and exceptions that occur within my application. These errors are displayed in the Issues UI in real-time.
 
 The Issues UI provides information on error types, their frequency, and the environments in which they occur. It allows for filtering and searching based on various criteria such as error level, release version, and timestamp.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-list-of-issues-sentry.webp" alt="List of issues/errors coming from my application in Sentry"/>
-    <figcaption><i>List of issues/errors coming from my application</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-list-of-issues-sentry.webp"
+    alt="List of issues/errors coming from my application in Sentry"
+  />
+  <figcaption>
+    <i>List of issues/errors coming from my application</i>
+  </figcaption>
 </figure>
 
-
-
 Inspecting these issues provided me with more information about the source it generated from, the error message, as well as the impact it has on my users.
 
 Additionally, you can correlate these issues with the relevant traces to gain a deeper understanding of the underlying causes and potential performance bottlenecks.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-connection-error-sentry.webp" alt="Detailed Sentry insights into the “ConnectionError” issue"/>
-    <figcaption><i>Detailed insights into the “ConnectionError” issue</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-connection-error-sentry.webp"
+    alt="Detailed Sentry insights into the “ConnectionError” issue"
+  />
+  <figcaption>
+    <i>Detailed insights into the “ConnectionError” issue</i>
+  </figcaption>
 </figure>
 
-
-
 It also offers code-level observability by pinpointing the exact location of the issue within your code. Sentry fetches the code context, providing not only the line that is causing the error but also the surrounding lines of code for better context and understanding.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-error-line-sentry.webp" alt="Sentry identifies the line of code causing issues"/>
-    <figcaption><i>Sentry identifies the line of code causing issues</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-error-line-sentry.webp"
+    alt="Sentry identifies the line of code causing issues"
+  />
+  <figcaption>
+    <i>Sentry identifies the line of code causing issues</i>
+  </figcaption>
 </figure>
 
-
 Both tools have really good error monitoring capabilities but I found that Sentry provides more granular and detailed error information compared to New Relic.
 
 <NewRelicVsSigNoz />
@@ -135,32 +161,47 @@ New Relic’s APM feature provides a unified monitoring service for all your app
 
 Setting up APM involves installing the appropriate agent for your application. In my case, I installed the Python agent. Once the agent is integrated into your application and it's up and running, New Relic seamlessly collects performance data from your application for monitoring.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-apm-nr.webp" alt="Python application being monitored in New Relic APM"/>
-    <figcaption><i>Python application being monitored in New Relic APM</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-apm-nr.webp"
+    alt="Python application being monitored in New Relic APM"
+  />
+  <figcaption>
+    <i>Python application being monitored in New Relic APM</i>
+  </figcaption>
 </figure>
 
-
 New Relic's APM is equipped with pre-configured dashboards and visualizations that helped me quickly understand my application performance without any customization. It also includes features like service maps, issues & activities tracking, service levels monitoring, SLA reports, vulnerability management, and more. These advanced capabilities provide a comprehensive view of the application environment, enabling users to optimize performance and ensure reliability effectively.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-tracing-nr.webp" alt="Tracing information from my application in New Relic’s APM"/>
-    <figcaption><i>Tracing information from my application</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-tracing-nr.webp"
+    alt="Tracing information from my application in New Relic’s APM"
+  />
+  <figcaption>
+    <i>Tracing information from my application</i>
+  </figcaption>
 </figure>
 
-
 ### Sentry APM
 
 Sentry tracks application performance by measuring metrics like throughput and latency within applications. The Performance UI provided an overview of the metrics and transactions it was tracking against my application. Because I configured my application for performance monitoring when integrating Sentry with my application, Sentry was able to detect common performance problems my application had and grouped them into issues for better management and resolution.
 
 The “View Trends” page also helped me assess if my application's performance was improving or deteriorating over time and identify potential bottlenecks or issues that may be affecting user experience.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-apm-sentry.webp" alt="Performance overview of application frontend in Sentry"/>
-    <figcaption><i>Performance overview of application frontend</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-apm-sentry.webp"
+    alt="Performance overview of application frontend in Sentry"
+  />
+  <figcaption>
+    <i>Performance overview of application frontend</i>
+  </figcaption>
 </figure>
 
-
 Sentry's APM capabilities are less extensive compared to New Relic, which offers comprehensive insights into application performance.
 
 ## Log Management: New Relic for enhanced log management capabilities
@@ -171,15 +212,20 @@ New Relic log management automatically ingests logs from your applications and h
 
 New Relic's log management platform is designed to help you uncover insights from your logs. It enables you to search for patterns and trends within your log data, which is crucial for identifying anomalies and potential issues that could impact your application's performance and reliability. I was able to run queries against my logs using the New Relic Query language (NRQL) and Lucene (an open-source search engine library) to get the exact log information that I needed. It also allows parsing of logs, making your log messages easier to query, search, and chart.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/newrelic-vs-sentry-log-nr.webp" alt="Log management in New Relic"/>
-    <figcaption><i>Log management in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/newrelic-vs-sentry-log-nr.webp"
+    alt="Log management in New Relic"
+  />
+  <figcaption>
+    <i>Log management in New Relic</i>
+  </figcaption>
 </figure>
 
-
 ### Sentry
 
-While logging provides a trail of events, including errors and informational messages, Sentry's core functionality revolves around capturing actionable errors and crashes in your applications. 
+While logging provides a trail of events, including errors and informational messages, Sentry's core functionality revolves around capturing actionable errors and crashes in your applications.
 
 Sentry's approach to log management involves capturing events and storing them in a way that is optimized for error tracking and debugging. Sentry works alongside your existing logging infrastructure and integrates directly with it. It does not replace the need for traditional logs but complements them by providing detailed context for debugging.
 
@@ -199,7 +245,7 @@ Both tools can be cost-effective and also expensive to use. New Relic’s free f
 
 ## Choosing Between New Relic and Sentry
 
-Choosing between New Relic and Sentry ultimately depends on your specific monitoring and observability needs. 
+Choosing between New Relic and Sentry ultimately depends on your specific monitoring and observability needs.
 
 Here’s a use-case-based guide to help you:
 
@@ -223,7 +269,7 @@ Compared to New Relic and Sentry, SigNoz is more cost-effective. Unlike these pl
 
 ## Frequently Asked Questions
 
-**Q:  What is the major difference between New Relic and Sentry?**
+**Q: What is the major difference between New Relic and Sentry?**
 
 **A:** New Relic primarily focuses on comprehensive application performance monitoring (APM) and provides insights into the overall health and performance of applications, infrastructure, and user experiences. On the other hand, Sentry specializes in error tracking and exception monitoring, offering detailed insights into individual errors and exceptions within applications, along with user-reported issues.
 
@@ -238,4 +284,3 @@ Compared to New Relic and Sentry, SigNoz is more cost-effective. Unlike these pl
 **[Top 11 New Relic Alternatives & Competitors [Updated for 2024]](https://signoz.io/blog/new-relic-alternatives/#top-11-new-relic-alternatives--competitors-at-a-glance)**
 
 **[SigNoz vs New Relic](https://signoz.io/product-comparison/signoz-vs-newrelic/)**
-
diff --git a/data/comparisons/newrelic-vs-splunk.mdx b/data/comparisons/newrelic-vs-splunk.mdx
index 1d0fbd9cf..7dfaa93a7 100644
--- a/data/comparisons/newrelic-vs-splunk.mdx
+++ b/data/comparisons/newrelic-vs-splunk.mdx
@@ -1,52 +1,51 @@
 ---
 title: New Relic vs Splunk - Which Monitoring Tool should you choose? [2025 Guide]
-slug: newrelic-vs-splunk
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: We have compared New Relic and Splunk by sending data from a sample application to both platforms and comparing our experience. Check out a practical review of New Relic vs Splunk across key aspects like getting started, APM, log management, application security...
 image: /img/blog/2024/03/newrelic-vs-splunk-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [newrelic-vs-splunk,splunk,newrelic,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [newrelic-vs-splunk, splunk, newrelic, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
 New Relic and Splunk are popular monitoring and observability tools that provide a wide range of products with similar features. In this post, I have compared New Relic and Splunk on important features like APM, log management, search capability, application security, etc.
 
 <Admonition type="info">
-💡 I instrumented a sample application and sent data to New Relic and Splunk to evaluate my experience. Some takeaways are subjective and based on personal preference.
+  💡 I instrumented a sample application and sent data to New Relic and Splunk to evaluate my
+  experience. Some takeaways are subjective and based on personal preference.
 </Admonition>
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-cover.webp"
+    alt=""
+  />
 </figure>
 
-
-
 ## New Relic vs Splunk: Overview
 
-New Relic and Splunk are monitoring and observability tools with similar features. However, both tools differ in terms of their application and use cases. 
+New Relic and Splunk are monitoring and observability tools with similar features. However, both tools differ in terms of their application and use cases.
 
 New Relic is easier to get started and is cheaper to use compared to Splunk. Splunk on the other hand has more strength in log management and application security.
 
 Here’s a quick overview of the overall platform features and functionality of New Relic and Splunk.
 
-| Feature | New Relic | Splunk |
-| --- | --- | --- |
-| Getting Started | ✅  | 🟡 |
-| APM | ✅  | ✅  |
-| Log Management | ✅ | ✅ ✅  |
-| Cloud SIEM | ❌ | ✅  |
-| Application Security | 🟡 | ✅  |
-| Infrastructure Monitoring | ✅ | ✅  |
-| OpenTelemetry Support | 🟡 | ✅  |
-| Real User Monitoring | ✅  | ✅  |
-| Synthetic Monitoring | ✅  | ✅  |
-| UI/UX | ✅ | 🟡 |
-| Free Tier | ✅ (Free forever) | 🟡 (15 days free trial) |
+| Feature                   | New Relic         | Splunk                  |
+| ------------------------- | ----------------- | ----------------------- |
+| Getting Started           | ✅                | 🟡                      |
+| APM                       | ✅                | ✅                      |
+| Log Management            | ✅                | ✅ ✅                   |
+| Cloud SIEM                | ❌                | ✅                      |
+| Application Security      | 🟡                | ✅                      |
+| Infrastructure Monitoring | ✅                | ✅                      |
+| OpenTelemetry Support     | 🟡                | ✅                      |
+| Real User Monitoring      | ✅                | ✅                      |
+| Synthetic Monitoring      | ✅                | ✅                      |
+| UI/UX                     | ✅                | 🟡                      |
+| Free Tier                 | ✅ (Free forever) | 🟡 (15 days free trial) |
 
 ✅ - Available
 
@@ -66,34 +65,47 @@ Overall, New Relic is easier to get started with.
 
 I instrumented a sample Python application and sent data to both New Relic and Splunk for APM. The steps taken in New Relic were straightforward and simpler compared to Splunk. New Relic required the installation of the New Relic agent as well as the agent specific to my application, which, in my case, was the Python agent. Splunk had more setup steps.
 
-With New Relic, you can effectively monitor your application's trace data through its pre-built dashboards. Within the Distributed Tracing page, you can filter traces by Trace Groups, Root entry span, Root entity, and Errors. This allowed me to focus more on specific traces with failures and latency issues. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-apm.webp" alt="APM in New Relic"/>
-    <figcaption><i>APM in New Relic</i></figcaption>
+With New Relic, you can effectively monitor your application's trace data through its pre-built dashboards. Within the Distributed Tracing page, you can filter traces by Trace Groups, Root entry span, Root entity, and Errors. This allowed me to focus more on specific traces with failures and latency issues.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-apm.webp"
+    alt="APM in New Relic"
+  />
+  <figcaption>
+    <i>APM in New Relic</i>
+  </figcaption>
 </figure>
 
-
-
 The visualization options it offers helped me better understand and analyze my trace data. This includes flame graphs, service maps, tables, and charts. The flamegraphs, most especially, provided end-to-end visibility into the time spent on each function or service call, which I find useful for troubleshooting.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-flamegraph.webp" alt="Visualization using flamegraphs in New Relic"/>
-    <figcaption><i>Visualization using flamegraphs</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-flamegraph.webp"
+    alt="Visualization using flamegraphs in New Relic"
+  />
+  <figcaption>
+    <i>Visualization using flamegraphs</i>
+  </figcaption>
 </figure>
 
-
-
 With Splunk, you can efficiently collect and analyze all your trace data to get insights into your application’s performance. Additionally, it supports tag-based grouping of traces and provides visualization options such as service maps and flame graphs for better analysis.
 
-Splunk employs AI-driven directed troubleshooting to quickly identify and highlight the root causes of issues within microservices, even in high-volume environments, offering a centralized view of trends in latency and errors, ranked by error rate or latency. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-trace.webp" alt="Trace visualization in Splunk"/>
-    <figcaption><i>Trace visualization in Splunk</i></figcaption>
+Splunk employs AI-driven directed troubleshooting to quickly identify and highlight the root causes of issues within microservices, even in high-volume environments, offering a centralized view of trends in latency and errors, ranked by error rate or latency.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-trace.webp"
+    alt="Trace visualization in Splunk"
+  />
+  <figcaption>
+    <i>Trace visualization in Splunk</i>
+  </figcaption>
 </figure>
 
-
 Some other Splunk APM features include:
 
 - Infinite cardinality exploration: To understand how different factors impact your application’s performance.
@@ -106,13 +118,17 @@ For a seamless APM experience, New Relic’s APM feature is a good option. If yo
 
 New Relic doesn’t require an extra setup for log management. It automatically collected the logs from my application and displayed them in the Logs tab. These logs can be queried through the use of Lucene, an open-source search library, and the New Relic Query Language (NRQL). If you're familiar with SQL queries, using NRQL should be straightforward due to its SQL-like syntax.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-logs.webp" alt="Log management in New Relic"/>
-    <figcaption><i>Log management in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-logs.webp"
+    alt="Log management in New Relic"
+  />
+  <figcaption>
+    <i>Log management in New Relic</i>
+  </figcaption>
 </figure>
 
-
-
 Some other log management features New Relic provides include:
 
 - Attributes: Provides additional context and information about the event being logged, such as error codes or user IDs.
@@ -123,12 +139,17 @@ Splunk is well known for its log management capabilities, it can manage large vo
 
 Log management in Splunk can be carried out using the <a href = "https://www.splunk.com/en_us/products/log-observer-connect.html" rel="noopener noreferrer nofollow" target="_blank" >Log Observer Connect</a> feature. This allows for the correlation of logs with real-time metrics and traces, and log-based analysis to better understand patterns in your data.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-log-observer.webp" alt="Log observer in Splunk"/>
-    <figcaption><i>Log observer in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-log-observer.webp"
+    alt="Log observer in Splunk"
+  />
+  <figcaption>
+    <i>Log observer in Splunk</i>
+  </figcaption>
 </figure>
 
-
 For enterprise-level log management capabilities, Splunk is an excellent choice. If you have less log management requirements, you can consider New Relic.
 
 <NewRelicVsSigNoz />
@@ -137,14 +158,18 @@ For enterprise-level log management capabilities, Splunk is an excellent choice.
 
 Application security in New Relic is carried out using the <a href = "https://docs.newrelic.com/docs/iast/introduction/" rel="noopener noreferrer nofollow" target="_blank" >Interactive Application Security Testing</a> (IAST) feature. IAST was able to identify and fix vulnerabilities in my application environment. It displayed the types of risk being introduced into the environment and categorized them based on the level of severity. Currently, IAST supports only Java, Node.js, and Go.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-security.webp" alt="Application security in New Relic"/>
-    <figcaption><i>Application security in New Relic</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-security.webp"
+    alt="Application security in New Relic"
+  />
+  <figcaption>
+    <i>Application security in New Relic</i>
+  </figcaption>
 </figure>
 
-
-
-Splunk on the other hand has different security products and apps that protect applications and the overall system from attacks. 
+Splunk on the other hand has different security products and apps that protect applications and the overall system from attacks.
 
 Here’s what some of Splunk’s security products can do:
 
@@ -152,13 +177,17 @@ Here’s what some of Splunk’s security products can do:
 - The Splunk Enterprise Security tool allows users to understand their organization's security posture. It also identifies potential security risks by analyzing diverse data sources and recognizing suspicious patterns indicative of attacks.
 - The Splunk attack analyzer helps to discover and investigate cyber-attacks and threats. It also provides information on how they can be rectified.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/newrelic-vs-splunk-security-monitoring.webp" alt="Security monitoring in Splunk"/>
-    <figcaption><i>Security monitoring in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/newrelic-vs-splunk-security-monitoring.webp"
+    alt="Security monitoring in Splunk"
+  />
+  <figcaption>
+    <i>Security monitoring in Splunk</i>
+  </figcaption>
 </figure>
 
-
-
 If you want to focus on the security of your applications alone, New Relic is a better choice. If you want a comprehensive security tool that focuses on both your applications and the overall system, then go for Splunk.
 
 ## OpenTelemetry Support: Splunk
@@ -176,8 +205,8 @@ New Relic and Splunk are costly to use. The following points might help you deci
 ### New Relic
 
 - Pricing is based on two things:
-    - Amount of data ingested
-    - User Seats
+  - Amount of data ingested
+  - User Seats
 - New Relic provides a free forever plan with 100GB of free data ingest each month.
 - Post 100GB, you need to pay \$0.3/GB or \$0.5/GB ingested based on your plan.
 - User seats can get [expensive](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/#no-user-based-pricing-collaborate-seamlessly-with-signoz). New Relic allows only 5 full platform users in its standard plan, and the cost of full platform users can be up to \$549/user per month for enterprise plans.
@@ -221,7 +250,6 @@ Here’s how SigNoz fits the case for a New Relic and Splunk alternative with it
 - SigNoz’s log management is equipped with a powerful search and filter query builder.
 - It provides exception monitoring to track exceptions and errors in your application.
 
-
 ## Getting Started with SigNoz
 
 <GetStartedSigNoz />
@@ -230,7 +258,6 @@ Here’s how SigNoz fits the case for a New Relic and Splunk alternative with it
 
 **Further Reading:**
 
-
 **[DataDog vs New Relic - The Real Winner](https://signoz.io/blog/datadog-vs-newrelic/)**
 
 **[Top 11 Splunk Alternatives [Includes Free & Open-Source Tools]](https://signoz.io/blog/splunk-alternatives/)**
diff --git a/data/comparisons/open-source-datadog-alternatives.mdx b/data/comparisons/open-source-datadog-alternatives.mdx
index 76488035e..d19f5bd09 100644
--- a/data/comparisons/open-source-datadog-alternatives.mdx
+++ b/data/comparisons/open-source-datadog-alternatives.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Top 5 Open Source Alternatives to DataDog in 2025
-slug: open-source-datadog-alternatives
 date: 2025-01-02
 tags: [tools-comparisons]
 authors: [sushant_gaurav]
 description: Discover the top 5 open source alternatives to DataDog for cost-effective, flexible monitoring and observability solutions in 2024.
-keywords: [open source datadog alternatives, monitoring tools, observability platforms, sigNoz, grafana, prometheus, zabbix, netdata]
-
+keywords:
+  [
+    open source datadog alternatives,
+    monitoring tools,
+    observability platforms,
+    sigNoz,
+    grafana,
+    prometheus,
+    zabbix,
+    netdata,
+  ]
 ---
 
 Are you tired of paying a high price for DataDog's monitoring services? Numerous companies seek more cost-effective, flexible choices that don't compromise performance. This article will look at the top 5 open-source [DataDog alternatives](https://signoz.io/blog/datadog-alternatives/#who-is-datadogs-biggest-competitor) in 2024—solutions that offer strong monitoring tools while remaining within your budget. By the end of the article, you'll know which tool is best for your infrastructure.
@@ -31,13 +38,13 @@ Let's check out some of the key reasons why open-source solutions may be more us
 
 When you are analyzing the open-source [alternatives to DataDog](https://signoz.io/blog/datadog-alternatives/#choosing-the-right-datadog-alternative) then it is important to consider features, community support, and scalability. Let's first compare the top 5 alternatives based on these criteria:
 
-| Tool | Key Strength | Best For |
-| --- | --- | --- |
-| SigNoz | Native OpenTelemetry support | Full-stack observability |
-| Grafana | Visualization and dashboards | Multi-source data visualization |
-| Prometheus | Time-series data and alerting | Infrastructure monitoring |
-| Zabbix | Network and server monitoring | Large-scale IT infrastructures |
-| Netdata | Real-time performance insights | Resource-efficient monitoring |
+| Tool       | Key Strength                   | Best For                        |
+| ---------- | ------------------------------ | ------------------------------- |
+| SigNoz     | Native OpenTelemetry support   | Full-stack observability        |
+| Grafana    | Visualization and dashboards   | Multi-source data visualization |
+| Prometheus | Time-series data and alerting  | Infrastructure monitoring       |
+| Zabbix     | Network and server monitoring  | Large-scale IT infrastructures  |
+| Netdata    | Real-time performance insights | Resource-efficient monitoring   |
 
 This table provides a quick overview of each tool’s primary strength and its best use case. Now let’s dive deeper into what makes these tools stand out.
 
@@ -65,7 +72,7 @@ receivers:
 
 exporters:
   signoz:
-    endpoint: "http://<your-sigNoz-instance>:4317"
+    endpoint: 'http://<your-sigNoz-instance>:4317'
 
 service:
   pipelines:
@@ -163,7 +170,7 @@ Uptrace is a popular open-source tool which is designed for distributed tracing
 
 ### Apache SkyWalking
 
-Apache SkyWalking is also a powerful open-source observability platform for monitoring, tracing, and diagnosing distributed systems. It supports a range of languages like Java, .NET, Python, and Go which makes it versatile across different applications. It is natively integrated with OpenTelemetry which enables SkyWalking to seamlessly trace, collect metrics, and monitor for cloud-native and microservices-based applications. 
+Apache SkyWalking is also a powerful open-source observability platform for monitoring, tracing, and diagnosing distributed systems. It supports a range of languages like Java, .NET, Python, and Go which makes it versatile across different applications. It is natively integrated with OpenTelemetry which enables SkyWalking to seamlessly trace, collect metrics, and monitor for cloud-native and microservices-based applications.
 
 SkyWalking also offers a highly customizable dashboard and alerting system which allows users to visualize and manage their data through a clean, intuitive interface. The backend of Apache SkyWalking supports various storage options, such as ElasticSearch and H2, making it suitable for different scales and use cases. This set of features makes SkyWalking a good choice for teams looking for a scalable and adaptable observability tool.
 
@@ -210,14 +217,14 @@ Tip: The best tool is the one that aligns with your organization’s unique need
 For example in your application’s entry file, you can configure [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) as:
 
 ```jsx
-const { NodeTracerProvider } = require('@opentelemetry/sdk-node');
-const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
-const { CollectorTraceExporter } = require('@opentelemetry/exporter-collector');
+const { NodeTracerProvider } = require('@opentelemetry/sdk-node')
+const { SimpleSpanProcessor } = require('@opentelemetry/tracing')
+const { CollectorTraceExporter } = require('@opentelemetry/exporter-collector')
 
 // Initialize OpenTelemetry Tracer
-const provider = new NodeTracerProvider();
-provider.addSpanProcessor(new SimpleSpanProcessor(new CollectorTraceExporter()));
-provider.register();
+const provider = new NodeTracerProvider()
+provider.addSpanProcessor(new SimpleSpanProcessor(new CollectorTraceExporter()))
+provider.register()
 ```
 
 Read the full guide here - [Using SigNoz with NodeJS](https://signoz.io/opentelemetry/nodejs-tutorial-overview).
@@ -227,15 +234,15 @@ Once instrumentation is complete, you'll be able to monitor your services in rea
 ## Key Takeaways
 
 - Several open-source alternatives to DataDog offer significant advantages, including cost savings, flexibility, and customization.
-    - SigNoz: It is full-stack observability with OpenTelemetry support.
-    - Grafana: It is a powerful visualization and dashboarding.
-    - Prometheus: It has exceptional time-series data handling and scalability.
-    - Zabbix: It is comprehensive network and server monitoring.
-    - Netdata: It provides real-time performance insights with minimal resource usage.
-    - Uptrace: It is focused on simplicity and flexibility, offering deep insights into application latency and error rates.
-    - Apache SkyWalking: It is a versatile observability platform with strong support for multiple languages and cloud-native applications.
-    - Jaeger: It is effective for visualizing request flows in microservices, with robust tools for performance optimization.
-    - OpenTracing: It provides a vendor-neutral API for distributed tracing, promoting interoperability with various tracing tools.
+  - SigNoz: It is full-stack observability with OpenTelemetry support.
+  - Grafana: It is a powerful visualization and dashboarding.
+  - Prometheus: It has exceptional time-series data handling and scalability.
+  - Zabbix: It is comprehensive network and server monitoring.
+  - Netdata: It provides real-time performance insights with minimal resource usage.
+  - Uptrace: It is focused on simplicity and flexibility, offering deep insights into application latency and error rates.
+  - Apache SkyWalking: It is a versatile observability platform with strong support for multiple languages and cloud-native applications.
+  - Jaeger: It is effective for visualizing request flows in microservices, with robust tools for performance optimization.
+  - OpenTracing: It provides a vendor-neutral API for distributed tracing, promoting interoperability with various tracing tools.
 - When choosing an alternative, you should consider your specific needs, team expertise, and scalability requirements.
 - [SigNoz](https://signoz.io/) is one of the best options if you seek a comprehensive and user-friendly [alternative to DataDog](https://signoz.io/blog/datadog-alternatives/#signoz).
 
@@ -277,4 +284,4 @@ When you are migrating from DataDog to an open-source alternative, you should ke
 3. Learning curve: Prepare your team for the learning curve associated with the new tool, especially if moving to a platform with different configurations.
 4. Integration impact: Evaluate how current integrations (e.g., with AWS, Kubernetes) will be impacted and ensure the open-source tool has similar capabilities.
 5. Phased migration: Avoid disruption by migrating in stages, allowing time for proper validation and adjustment.
-6. Community and support: Ensure you have adequate support through documentation, community resources, or dedicated services.
\ No newline at end of file
+6. Community and support: Ensure you have adequate support through documentation, community resources, or dedicated services.
diff --git a/data/comparisons/opensearch-vs-splunk.mdx b/data/comparisons/opensearch-vs-splunk.mdx
index 2edd93a58..5bcb5b40d 100644
--- a/data/comparisons/opensearch-vs-splunk.mdx
+++ b/data/comparisons/opensearch-vs-splunk.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenSearch vs Splunk - Key Differences for Log Analytics
-slug: opensearch-vs-splunk
+
 date: 2025-03-10
 tags: [observability, logging]
 authors: [abdulsalaam_noibi]
 description: Discover the key differences between OpenSearch and Splunk for log analytics. Compare features, costs, and performance to choose the right tool for your needs.
-keywords: [opensearch vs splunk, log analytics, data ingestion, search capabilities, cost comparison, scalability, security features]
-
+keywords:
+  [
+    opensearch vs splunk,
+    log analytics,
+    data ingestion,
+    search capabilities,
+    cost comparison,
+    scalability,
+    security features,
+  ]
 ---
 
 **OpenSearch** and **Splunk** are leading log analytics platforms with distinct approaches to data management. The key differences include:
@@ -24,7 +31,11 @@ This comparison examines these platforms across performance, scalability, securi
 
 OpenSearch is an **open-source analytics suite** built as a community-driven fork of Elasticsearch and Kibana. Developed and backed by AWS, it provides tools for scalable full-text search, real-time analytics, and interactive dashboards to process massive volumes of logs.
 
-<Figure src="/img/comparisons/2025/03/opensearch-vs-splunk-images_(5).webp" alt="Overview of OpenSearch Dashboard" caption="Overview of OpenSearch Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/opensearch-vs-splunk-images_(5).webp"
+  alt="Overview of OpenSearch Dashboard"
+  caption="Overview of OpenSearch Dashboard"
+/>
 
 ### Key Features of OpenSearch
 
@@ -36,7 +47,11 @@ OpenSearch is an **open-source analytics suite** built as a community-driven for
 
 Splunk is a proprietary log management and analytics platform that excels in data ingestion, indexing, and analysis at scale, recognized for its enterprise-grade security monitoring (SIEM) and IT operations management.
 
-<Figure src="/img/comparisons/2025/03/opensearch-vs-splunk-images_(18).webp" alt="Overview of Splunk Dashboard" caption="Overview of Splunk Dashboard" />
+<Figure
+  src="/img/comparisons/2025/03/opensearch-vs-splunk-images_(18).webp"
+  alt="Overview of Splunk Dashboard"
+  caption="Overview of Splunk Dashboard"
+/>
 
 ### Main Capabilities of Splunk
 
@@ -50,14 +65,14 @@ Cost is a critical factor when choosing a log analytics platform. OpenSearch and
 
 **Cost Breakdown of Both OpenSearch and Splunk**
 
-| **Features**  | **OpenSearch**  | **Splunk**  |
-| --- | --- | --- |
-| **Pricing Model** | Free, open-source with optional paid support | Licensing based on data ingestion (GB/day) |
-| **Infrastructure Cost** | <a href="https://aws.amazon.com/opensearch-service/pricing/?utm_source=chatgpt.com" rel="noopener noreferrer nofollow" target="_blank">OpenSearch</a> Service charges based on instance hours | <a href="https://docs.splunk.com/Documentation/Splunk/9.4.0/Capacity/Referencehardware" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> hardware requirements based on data ingestion rates and search loads |
-| **Managed Options** | Pay-per-use for AWS OpenSearch Service | Subscription-based Splunk Cloud |
-| **Training and Staffing** | Limited formal training programs | Official training programs and certifications with associated costs |
+| **Features**                | **OpenSearch**                                                                                                                                                                                     | **Splunk**                                                                                                                                                                                                                       |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Pricing Model**           | Free, open-source with optional paid support                                                                                                                                                       | Licensing based on data ingestion (GB/day)                                                                                                                                                                                       |
+| **Infrastructure Cost**     | <a href="https://aws.amazon.com/opensearch-service/pricing/?utm_source=chatgpt.com" rel="noopener noreferrer nofollow" target="_blank">OpenSearch</a> Service charges based on instance hours      | <a href="https://docs.splunk.com/Documentation/Splunk/9.4.0/Capacity/Referencehardware" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> hardware requirements based on data ingestion rates and search loads       |
+| **Managed Options**         | Pay-per-use for AWS OpenSearch Service                                                                                                                                                             | Subscription-based Splunk Cloud                                                                                                                                                                                                  |
+| **Training and Staffing**   | Limited formal training programs                                                                                                                                                                   | Official training programs and certifications with associated costs                                                                                                                                                              |
 | **Support and Maintenance** | <a href="https://coralogix.com/guides/opensearch/opensearch-pricing" rel="noopener noreferrer nofollow" target="_blank">AWS OpenSearch</a> Service reduces maintenance but adds service plan costs | <a href="https://www.splunk.com/en_us/products/pricing/cyber-security.html" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> offers standard support with all subscriptions and premium support at additional costs |
-| **Scaling cost** | <a href="https://docs.aws.amazon.com/opensearch-service/latest/developerguide/bp.html" rel="noopener noreferrer nofollow" target="_blank">OpenSearch</a> costs increase with additional servers | <a href="https://www.splunk.com/en_us/products/pricing.html" rel="noopener noreferrer nofollow" target="_blank">Splunk's</a> pricing increases with data ingestion volume |
+| **Scaling cost**            | <a href="https://docs.aws.amazon.com/opensearch-service/latest/developerguide/bp.html" rel="noopener noreferrer nofollow" target="_blank">OpenSearch</a> costs increase with additional servers    | <a href="https://www.splunk.com/en_us/products/pricing.html" rel="noopener noreferrer nofollow" target="_blank">Splunk's</a> pricing increases with data ingestion volume                                                        |
 
 ### Pricing Model
 
@@ -74,6 +89,7 @@ Performance and Scalability are important factors to look out for when choosing
 **OpenSearch** scales horizontally by distributing data across multiple nodes through **sharding**. Its specialized node roles (Master, Data, and Coordinating) can handle up to **500GB/day** with proper configuration. Poor shard strategy can lead to degraded performance.
 
 **Splunk** uses a three-component architecture:
+
 - **Indexers**: Process and store incoming data
 - **Search heads**: Handle user queries and present results
 - **Forwarders**: Collect and forward logs to indexers
@@ -95,8 +111,8 @@ Effective log analytics capabilities are essential for developers and IT teams t
 **Splunk's Search Processing Language (SPL)** enables advanced querying:
 
 ```sql
-index=security sourcetype=access_logs "login failed"  
-| stats count by user, src_ip  
+index=security sourcetype=access_logs "login failed"
+| stats count by user, src_ip
 ```
 
 ### Real-Time Log Ingestion and Processing
@@ -117,8 +133,8 @@ Modern log analytics relies heavily on detecting patterns and anomalies.
 
 ## Integration and Ecosystem
 
-When choosing a log analytics platform, integration, and ecosystem are critical factors that can significantly impact implementation ease, scalability, and long-term usability. 
-Here's how **OpenSearch** and **Splunk** measure up in this regard: 
+When choosing a log analytics platform, integration, and ecosystem are critical factors that can significantly impact implementation ease, scalability, and long-term usability.
+Here's how **OpenSearch** and **Splunk** measure up in this regard:
 
 ### OpenSearch's Compatibility with the ELK Stack
 
@@ -166,7 +182,7 @@ When choosing a [log analytics tool](https://signoz.io/comparisons/log-analysis-
 
 ### Adoption Trends
 
-Adoption is based  on the organization's size and priorities which may include: 
+Adoption is based on the organization's size and priorities which may include:
 
 - **Startups and Small Teams** prefer OpenSearch for cost-effectiveness and open-source freedom
 - **Large Enterprises** choose Splunk for its comprehensive features, support, and compliance capabilities
@@ -177,7 +193,7 @@ Choosing the right deployment strategy for your log analytics platform is a crit
 
 ### OpenSearch Self-Hosted & Cloud Options
 
-OpenSearch provides two primary deployment models: 
+OpenSearch provides two primary deployment models:
 
 - **Self-Hosted**: You can deploy OpenSearch on-premises, in containers (e.g., Docker), or virtual machines. This approach gives you complete control but it requires hands-on management, including configuration, scaling, and updates.
 
@@ -201,7 +217,7 @@ OpenSearch and Splunk prioritize data integrity and availability but approach th
 
 ## Security and Compliance
 
-Security and compliance are important concerns for organizations leveraging powerful data platforms like OpenSearch and Splunk.  However, as these platforms collect and process vast amounts of sensitive information, maintaining robust security protocols and adhering to compliance standards is non-negotiable. So the need to understand how to implement security and compliance best practices within OpenSearch and Splunk is important for maintaining trust and integrity.
+Security and compliance are important concerns for organizations leveraging powerful data platforms like OpenSearch and Splunk. However, as these platforms collect and process vast amounts of sensitive information, maintaining robust security protocols and adhering to compliance standards is non-negotiable. So the need to understand how to implement security and compliance best practices within OpenSearch and Splunk is important for maintaining trust and integrity.
 
 ### OpenSearch Security Practices
 
@@ -235,21 +251,24 @@ OpenSearch and Splunk are good [log management tools](https://signoz.io/blog/ope
 
 SigNoz is a comprehensive, full-stack [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/) platform designed to offer deep insights into your infrastructure and applications. It efficiently generates the essential telemetry data required for monitoring your systems - Metrics, Logs, and Traces, in a single pane of glass.
 
-<Figure src="/img/comparisons/2025/03/opensearch-vs-splunk-ec2-infra.webp" alt="Overview of SigNoz Dashboard" caption="Overview of SigNoz Dashboard" />
-
+<Figure
+  src="/img/comparisons/2025/03/opensearch-vs-splunk-ec2-infra.webp"
+  alt="Overview of SigNoz Dashboard"
+  caption="Overview of SigNoz Dashboard"
+/>
 
 It is available both as an [**open-source software**](https://github.com/SigNoz/signoz) and a [**cloud offering**](https://signoz.io/teams/).
 
-**Here is a comparison of the features offered by SigNoz vs OpenSearch and Splunk** 
+**Here is a comparison of the features offered by SigNoz vs OpenSearch and Splunk**
 
 - **[Unified Observability](https://signoz.io/unified-observability/)**: Unlike OpenSearch, which primarily focuses on log analytics, and Splunk, which requires additional modules for APM, SigNoz combines logs, metrics, and traces in one platform.
-    
-   <div className="overflow-hidden rounded-xl shadow-2xl">
-        <video autoPlay muted loop className="lg:w-[120%]">
-        <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
-        Your browser does not support the video tag.
-        </video>
-    </div>
+
+  <div className="overflow-hidden rounded-xl shadow-2xl">
+    <video autoPlay muted loop className="lg:w-[120%]">
+      <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
+      Your browser does not support the video tag.
+    </video>
+  </div>
 
 - **Query Language**: [SigNoz](https://signoz.io/docs/introduction/) uses PromQL, which make it approachable for developers familiar with Prometheus, compared to OpenSearch's Lucene and Splunk's SPL(Search Processing Language).
 - **Cost Model**: SigNoz is fully open-source, free from ingestion-based licensing. Splunk, on the other hand, can become expensive for high data volumes.
@@ -278,4 +297,4 @@ Yes, with proper configuration, OpenSearch can scale similarly, though Splunk ha
 
 ### What are the main advantages of using Splunk over OpenSearch?
 
-Splunk offers seamless SIEM integration, enterprise-grade support, and an extensive app ecosystem, though it comes with higher costs.
\ No newline at end of file
+Splunk offers seamless SIEM integration, enterprise-grade support, and an extensive app ecosystem, though it comes with higher costs.
diff --git a/data/comparisons/opentelemetry-api-vs-sdk.mdx b/data/comparisons/opentelemetry-api-vs-sdk.mdx
index a220168ca..7b438764f 100644
--- a/data/comparisons/opentelemetry-api-vs-sdk.mdx
+++ b/data/comparisons/opentelemetry-api-vs-sdk.mdx
@@ -1,26 +1,24 @@
 ---
-
 title: OpenTelemetry API vs SDK - Key Differences Explained
-slug: opentelemetry-api-vs-sdk
+
 date: 2024-10-23
 tags: [Opentelemetry]
 authors: [sushant_gaurav]
 description: Explore the key differences between OpenTelemetr   y API and SDK, learn when to use each, and discover how to enhance your observability strategy.
 keywords: [OpenTelemetry, API, SDK, observability, instrumentation, telemetry, monitoring]
-
 ---
 
 OpenTelemetry is revolutionizing observability in modern software systems by providing a standardized method for capturing [distributed tracing](https://signoz.io/blog/distributed-tracing/), metrics, and logs. As observability becomes more important in managing complex, distributed applications, understanding the differences between OpenTelemetry's API and SDK will help you select the best tool for your project. This article discusses the important differences that can help you plan your implementation strategy.
 
 ### Quick Guide: API vs SDK
 
-| Aspect | OpenTelemetry API | OpenTelemetry SDK |
-| --- | --- | --- |
-| Purpose | Provides an interface to generate telemetry data (e.g., traces, metrics, logs). | Implements the collection, processing, and exporting of telemetry data. |
-| Audience | Application developers looking to instrument their applications. | DevOps, SREs, and developers configuring telemetry collection and exporting. |
-| Stability | More stable, with less frequent updates. | Subject to changes, with updates to optimize telemetry processing. |
-| Implementation | No actual data collection or export logic. | Provides the actual logic for collecting and exporting data. |
-| Dependency | Lightweight, minimal dependencies. | Typically heavier, includes actual exporters and processors. |
+| Aspect         | OpenTelemetry API                                                               | OpenTelemetry SDK                                                            |
+| -------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| Purpose        | Provides an interface to generate telemetry data (e.g., traces, metrics, logs). | Implements the collection, processing, and exporting of telemetry data.      |
+| Audience       | Application developers looking to instrument their applications.                | DevOps, SREs, and developers configuring telemetry collection and exporting. |
+| Stability      | More stable, with less frequent updates.                                        | Subject to changes, with updates to optimize telemetry processing.           |
+| Implementation | No actual data collection or export logic.                                      | Provides the actual logic for collecting and exporting data.                 |
+| Dependency     | Lightweight, minimal dependencies.                                              | Typically heavier, includes actual exporters and processors.                 |
 
 ## What is the OpenTelemetry API?
 
@@ -32,7 +30,11 @@ The key components of the API are:
 - Meters: It is used to track application metrics (such as latency and failures).
 - Loggers: It is for creating structured log entries.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-api-vs-sdk-image.webp" alt="Credits: OpenTelemetry Docs" caption="Credits: OpenTelemetry Docs" /> 
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-api-vs-sdk-image.webp"
+  alt="Credits: OpenTelemetry Docs"
+  caption="Credits: OpenTelemetry Docs"
+/>
 
 The OpenTelemetry API plays a crucial role in application development by:
 
@@ -55,23 +57,23 @@ Here’s a simple example of how you might use the OpenTelemetry API for tracing
 
 ```jsx
 // Import the OpenTelemetry API
-const { trace } = require('@opentelemetry/api');
+const { trace } = require('@opentelemetry/api')
 
 // Get a tracer instance
-const tracer = trace.getTracer('example-tracer');
+const tracer = trace.getTracer('example-tracer')
 
 // Start a span
-const span = tracer.startSpan('operation-name');
+const span = tracer.startSpan('operation-name')
 
 // Perform some operations
-doWork();
+doWork()
 
 // End the span when work is done
-span.end();
+span.end()
 
 function doWork() {
-    // Simulate work
-    for (let i = 0; i < 1000000; i++) {}
+  // Simulate work
+  for (let i = 0; i < 1000000; i++) {}
 }
 ```
 
@@ -110,42 +112,41 @@ Let us now take a look at some of the key components of SDK:
 Here’s a simple code snippet demonstrating how to configure the OpenTelemetry SDK for trace exporting:
 
 ```jsx
-const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
-const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
-const { ConsoleSpanExporter } = require('@opentelemetry/sdk-trace-base');
-const { Resource } = require('@opentelemetry/resources');
-const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node')
+const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base')
+const { ConsoleSpanExporter } = require('@opentelemetry/sdk-trace-base')
+const { Resource } = require('@opentelemetry/resources')
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions')
 
 // Set up a resource to provide service name metadata
 const resource = new Resource({
   [SemanticResourceAttributes.SERVICE_NAME]: 'example-service',
-});
+})
 
 // Create a tracer provider and associate it with the resource
 const provider = new NodeTracerProvider({
   resource: resource,
-});
+})
 
 // Set up an exporter (ConsoleSpanExporter for debugging purposes)
-const exporter = new ConsoleSpanExporter();
+const exporter = new ConsoleSpanExporter()
 
 // Add a span processor (SimpleSpanProcessor for direct exporting of spans)
-provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
+provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
 
 // Register the provider to begin tracing
-provider.register();
+provider.register()
 
 // Example tracer usage
-const tracer = provider.getTracer('example-tracer');
+const tracer = provider.getTracer('example-tracer')
 
 // Start a span and simulate work
-const span = tracer.startSpan('example-operation');
-span.setAttribute('key', 'value');  // Add attributes to the span
+const span = tracer.startSpan('example-operation')
+span.setAttribute('key', 'value') // Add attributes to the span
 setTimeout(() => {
-  span.end();  // End the span
-  console.log('Trace data sent to the console!');
-}, 1000);
-
+  span.end() // End the span
+  console.log('Trace data sent to the console!')
+}, 1000)
 ```
 
 In this example, we use the OpenTelemetry SDK to create a tracer provider and configure it to export trace data to Jaeger. The SDK handles the actual trace processing and exporting.
@@ -155,78 +156,77 @@ In this example, we use the OpenTelemetry SDK to create a tracer provider and co
 Understanding the differences between the OpenTelemetry API and SDK is essential for proper observability implementation. Here are the main distinctions:
 
 1. Abstraction Level:
-    - API: Provides abstract APIs for capturing telemetry data.
-    - SDK: Implements these interfaces, including capabilities for processing and exporting telemetry data.
+   - API: Provides abstract APIs for capturing telemetry data.
+   - SDK: Implements these interfaces, including capabilities for processing and exporting telemetry data.
 2. Dependency Management:
-    - API: Lightweight and minimal dependencies. It serves as the instrumentation layer without relying on large libraries.
-    - SDK: Includes entire implementations and other dependencies for telemetry data processing and exporting.
+   - API: Lightweight and minimal dependencies. It serves as the instrumentation layer without relying on large libraries.
+   - SDK: Includes entire implementations and other dependencies for telemetry data processing and exporting.
 3. Functionality:
-    - API: Defines "what" telemetry data is gathered (e.g., beginning spans, recording metrics).
-    - SDK: Implements "how" the telemetry data is handled, exported, and sampled.
+   - API: Defines "what" telemetry data is gathered (e.g., beginning spans, recording metrics).
+   - SDK: Implements "how" the telemetry data is handled, exported, and sampled.
 4. Use Case:
-    - API: Suitable for library or framework developers looking to add instrumentation without requiring a specific SDK.
-    - SDK: Suitable for applications requiring complete telemetry features, such as data processing and exporting.
+   - API: Suitable for library or framework developers looking to add instrumentation without requiring a specific SDK.
+   - SDK: Suitable for applications requiring complete telemetry features, such as data processing and exporting.
 
 Comparison Table of [OpenTelemetry API vs SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/#code-snippet-configuring-opentelemetry-sdk)
 
-| Feature | OpenTelemetry API | OpenTelemetry SDK |
-| --- | --- | --- |
-| Abstraction Level | Abstract interfaces and definitions | Concrete implementations |
-| Dependency Management | Lightweight, minimal dependencies | Full implementation, larger footprint |
-| Flexibility | Highly portable | Environment-specific |
-| Functionality | Defines possible operations | Implements how operations are performed |
-| Use Case | Ideal for libraries and frameworks | Suited for applications with full telemetry |
+| Feature               | OpenTelemetry API                   | OpenTelemetry SDK                           |
+| --------------------- | ----------------------------------- | ------------------------------------------- |
+| Abstraction Level     | Abstract interfaces and definitions | Concrete implementations                    |
+| Dependency Management | Lightweight, minimal dependencies   | Full implementation, larger footprint       |
+| Flexibility           | Highly portable                     | Environment-specific                        |
+| Functionality         | Defines possible operations         | Implements how operations are performed     |
+| Use Case              | Ideal for libraries and frameworks  | Suited for applications with full telemetry |
 
 ## How to Choose Between OpenTelemetry API and SDK
 
 The nature of your project and your observability requirements will determine whether you use the OpenTelemetry API or the SDK. Let’s compare them through a table so that it can be easier to decide:
 
-| Factor | OpenTelemetry API | OpenTelemetry SDK |
-| --- | --- | --- |
-| Project Type | Use the API to instrument code and ensure interoperability with various SDKs or backends. | Use the SDK for complete telemetry processing and exporting. |
-| Instrumentation Needs | Suitable for lightweight instrumentation only. | Offers full trace gathering, sampling, and export options. |
-| Performance and Resource Constraints | Minimizes your application's footprint, ideal for resource-constrained environments. | Requires more resources (memory, compute), but provides additional capabilities. |
-| Compatibility Requirements | Maintains flexibility and portability across different observability backends. | Optimized exporters for seamless integration with specific backends (e.g., Jaeger, SigNoz). |
+| Factor                               | OpenTelemetry API                                                                         | OpenTelemetry SDK                                                                           |
+| ------------------------------------ | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Project Type                         | Use the API to instrument code and ensure interoperability with various SDKs or backends. | Use the SDK for complete telemetry processing and exporting.                                |
+| Instrumentation Needs                | Suitable for lightweight instrumentation only.                                            | Offers full trace gathering, sampling, and export options.                                  |
+| Performance and Resource Constraints | Minimizes your application's footprint, ideal for resource-constrained environments.      | Requires more resources (memory, compute), but provides additional capabilities.            |
+| Compatibility Requirements           | Maintains flexibility and portability across different observability backends.            | Optimized exporters for seamless integration with specific backends (e.g., Jaeger, SigNoz). |
 
 ## Implementing OpenTelemetry in Your Project
 
 To effectively implement OpenTelemetry, you can follow these steps:
 
 1. Integrating the API for Basic Instrumentation:
-    - Add the OpenTelemetry API dependency to your project based on the language you're using (e.g., `@opentelemetry/api` for Node.js). For example, using npm:
-    
-    ```bash
-    npm install @opentelemetry/api
-    ```
-    
-    - Use tracers, meters, and loggers to instrument key areas of your code. For example, instrument-critical paths like HTTP request handling or database queries capture meaningful telemetry data.
-    - Keep instrumentation code independent of the SDK. This ensures that your application remains portable and can be used with different [OpenTelemetry backends](https://signoz.io/blog/opentelemetry-backend/).
-    - Example:
-    
-    ```jsx
-    const { trace } = require('@opentelemetry/api');
-    
-    const tracer = trace.getTracer('example-tracer');
-    
-    const span = tracer.startSpan('operation-name');
-        // Add your logic here
-    span.end();
-    ```
-    
+   - Add the OpenTelemetry API dependency to your project based on the language you're using (e.g., `@opentelemetry/api` for Node.js). For example, using npm:
+
+   ```bash
+   npm install @opentelemetry/api
+   ```
+
+   - Use tracers, meters, and loggers to instrument key areas of your code. For example, instrument-critical paths like HTTP request handling or database queries capture meaningful telemetry data.
+   - Keep instrumentation code independent of the SDK. This ensures that your application remains portable and can be used with different [OpenTelemetry backends](https://signoz.io/blog/opentelemetry-backend/).
+   - Example:
+
+   ```jsx
+   const { trace } = require('@opentelemetry/api')
+
+   const tracer = trace.getTracer('example-tracer')
+
+   const span = tracer.startSpan('operation-name')
+   // Add your logic here
+   span.end()
+   ```
+
 2. To set up the SDK for complete telemetry capabilities, include the OpenTelemetry SDK in your project to manage the entire telemetry pipeline.
-    - Configure resource providers, samplers, and exporters to meet your observability requirements. Set up exporters to deliver data to the appropriate backend (such as Jaeger or SigNoz).
-    - Create data processing pipelines to control how telemetry data is handled, sampled, and exported.
-    - Example:
-    
-    ```jsx
-    const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
-    const { ConsoleSpanExporter, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
-    
-    const provider = new NodeTracerProvider();
-    provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));
-    provider.register();
-    ```
-    
+   - Configure resource providers, samplers, and exporters to meet your observability requirements. Set up exporters to deliver data to the appropriate backend (such as Jaeger or SigNoz).
+   - Create data processing pipelines to control how telemetry data is handled, sampled, and exported.
+   - Example:
+
+   ```jsx
+   const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node')
+   const { ConsoleSpanExporter, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base')
+
+   const provider = new NodeTracerProvider()
+   provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()))
+   provider.register()
+   ```
 
 ### Best Practices for Using API and SDK Together
 
@@ -281,4 +281,4 @@ To ensure accurate and full telemetry data, adhere to best practices such as foc
 
 ### What are the performance implications of using the SDK versus just the API?
 
-Using the SDK generally incurs a higher performance overhead compared to using just the API. This is because the SDK includes functionalities for data processing, sampling, and exporting, which require more resources. The API alone does not provide actual telemetry capabilities; it only defines interfaces. If performance is a concern, configure your SDK with appropriate samplers and processors to minimize resource usage.
\ No newline at end of file
+Using the SDK generally incurs a higher performance overhead compared to using just the API. This is because the SDK includes functionalities for data processing, sampling, and exporting, which require more resources. The API alone does not provide actual telemetry capabilities; it only defines interfaces. If performance is a concern, configure your SDK with appropriate samplers and processors to minimize resource usage.
diff --git a/data/comparisons/opentelemetry-collector-vs-agent.mdx b/data/comparisons/opentelemetry-collector-vs-agent.mdx
index f5e741025..204074eba 100644
--- a/data/comparisons/opentelemetry-collector-vs-agent.mdx
+++ b/data/comparisons/opentelemetry-collector-vs-agent.mdx
@@ -1,13 +1,12 @@
 ---
-
 title: OpenTelemetry Collector vs Agent - Key Differences Explained
-slug: opentelemetry-collector-vs-agent
+
 date: 2024-10-30
 tags: [OpenTelemetry]
 authors: [niyati_thakkar]
 description: Discover the key differences between OpenTelemetry Collectors and Agents. Learn when to use each for optimal observability in your infrastructure.
-keywords: [opentelemetry collector vs agent, observability, telemetry data, monitoring, data collection]
-
+keywords:
+  [opentelemetry collector vs agent, observability, telemetry data, monitoring, data collection]
 ---
 
 Observability has become a critical aspect of modern software systems. As applications become complex, efficient telemetry data collection and processing becomes paramount. OpenTelemetry, a vendor-neutral framework, provides a unified approach to collecting, analyzing, and visualizing telemetry data. However, navigating the landscape of OpenTelemetry components, particularly Collectors and Agents, can be challenging. This article highlights the key distinctions between these two components, empowering you to make informed choices for your [observability infrastructure](https://signoz.io/blog/observability-tools/).
@@ -16,7 +15,7 @@ Observability has become a critical aspect of modern software systems. As applic
 
 OpenTelemetry is an open-source, vendor-neutral framework designed to streamline the collection, processing, and export of telemetry data. It provides a standardized approach for instrumenting applications and gathering observability data, enabling organizations to gain valuable insights into their applications' performance, behavior, and health.
 
-OpenTelemetry was formed in 2019 through the merger of two observability projects, OpenTracing and OpenCensus, combining their strengths in distributed tracing and telemetry collection. Governed by the Cloud Native Computing Foundation (CNCF), OpenTelemetry provides a unified solution for collecting and exporting traces, metrics, and logs. 
+OpenTelemetry was formed in 2019 through the merger of two observability projects, OpenTracing and OpenCensus, combining their strengths in distributed tracing and telemetry collection. Governed by the Cloud Native Computing Foundation (CNCF), OpenTelemetry provides a unified solution for collecting and exporting traces, metrics, and logs.
 
 The primary purpose of OpenTelemetry is to simplify telemetry data collection from cloud-native and distributed systems, allowing developers to instrument applications once and send observability data to various backends.
 
@@ -47,52 +46,55 @@ The OpenTelemetry Collector is a vendor-neutral, open-source component in the Op
 The OpenTelemetry Collector offers several core functionalities that help organizations gather, process, and send telemetry data effectively:
 
 1. Receiving Telemetry Data:
-    - The collector can ingest data from various sources through receivers. These receivers support multiple formats and protocols, such as OpenTelemetry Protocol (OTLP), Prometheus, Zipkin, and Jaeger.
+   - The collector can ingest data from various sources through receivers. These receivers support multiple formats and protocols, such as OpenTelemetry Protocol (OTLP), Prometheus, Zipkin, and Jaeger.
 2. Processing Telemetry Data:
-    - Once the data is received, it can be processed via processors. Processors allow for modifications like sampling, batching, and filtering. This enables optimizations such as data reduction, transformation, or enrichment before exporting. This ensures that telemetry data is refined for efficient storage or meets specific analysis requirements (e.g., reducing high-cardinality metrics).
+   - Once the data is received, it can be processed via processors. Processors allow for modifications like sampling, batching, and filtering. This enables optimizations such as data reduction, transformation, or enrichment before exporting. This ensures that telemetry data is refined for efficient storage or meets specific analysis requirements (e.g., reducing high-cardinality metrics).
 3. Exporting Telemetry Data:
-    - After processing, data is sent to observability backends using exporters. The OpenTelemetry Collector supports exporting to numerous backends, including Prometheus, Jaeger, Zipkin, Elasticsearch, and cloud services like AWS or Google Cloud Monitoring. This allows the same data to be used by different platforms, enabling more comprehensive monitoring and analysis across the system.
+   - After processing, data is sent to observability backends using exporters. The OpenTelemetry Collector supports exporting to numerous backends, including Prometheus, Jaeger, Zipkin, Elasticsearch, and cloud services like AWS or Google Cloud Monitoring. This allows the same data to be used by different platforms, enabling more comprehensive monitoring and analysis across the system.
 
-<Figure src="/img/comparisons/2024/10/otel-collector-architecture_(1).svg" alt="How the OpenTelemetry Collector works" caption="How the OpenTelemetry Collector works" />
+<Figure
+  src="/img/comparisons/2024/10/otel-collector-architecture_(1).svg"
+  alt="How the OpenTelemetry Collector works"
+  caption="How the OpenTelemetry Collector works"
+/>
 
 ### Key Features of OpenTelemetry Collectors
 
 OpenTelemetry Collectors offer a range of features that enhance observability and streamline telemetry data management. Here are the key points that demonstrate their user value:
 
 1. Multi-format Support:
-    
-    Collectors can ingest and export data in various formats, including OTLP, Jaeger, and Prometheus, allowing seamless integration with existing observability tools and infrastructure. It also allows for consolidation of telemetry data from various sources into a single pipeline, facilitating easier analysis and reporting. This means organizations can leverage their preferred backend systems without worrying about compatibility issues.
-    
+
+   Collectors can ingest and export data in various formats, including OTLP, Jaeger, and Prometheus, allowing seamless integration with existing observability tools and infrastructure. It also allows for consolidation of telemetry data from various sources into a single pipeline, facilitating easier analysis and reporting. This means organizations can leverage their preferred backend systems without worrying about compatibility issues.
+
 2. Data Processing:
-    
-    Built-in processors allow for data manipulation, filtering, and enrichment. Users can customize the telemetry data flow to meet their specific needs, ensuring that only relevant data is processed and sent to backends. This capability helps reduce noise in observability data, enabling teams to focus on meaningful insights that drive better decision-making and performance optimization.
-    
+
+   Built-in processors allow for data manipulation, filtering, and enrichment. Users can customize the telemetry data flow to meet their specific needs, ensuring that only relevant data is processed and sent to backends. This capability helps reduce noise in observability data, enabling teams to focus on meaningful insights that drive better decision-making and performance optimization.
+
 3. Extensibility:
-    
-    Custom components and plugins can be added to extend functionality. This feature empowers users to adapt the collector to their unique environments and requirements. Organizations can implement custom receivers or exporters to meet specific telemetry needs, enhancing their observability practices without being constrained by out-of-the-box solutions.
-    
+
+   Custom components and plugins can be added to extend functionality. This feature empowers users to adapt the collector to their unique environments and requirements. Organizations can implement custom receivers or exporters to meet specific telemetry needs, enhancing their observability practices without being constrained by out-of-the-box solutions.
+
 4. High Performance:
-    
-    Designed to handle large volumes of data efficiently, OpenTelemetry Collectors ensure minimal impact on application performance. This high performance is crucial for organizations operating in high-throughput environments, where latency and resource consumption must be minimized.
-    
+
+   Designed to handle large volumes of data efficiently, OpenTelemetry Collectors ensure minimal impact on application performance. This high performance is crucial for organizations operating in high-throughput environments, where latency and resource consumption must be minimized.
+
 5. Deployment Flexibility:
-    
-    OpenTelemetry Collectors can be deployed as agents on individual hosts or as centralized gateways. This flexibility allows users to choose the deployment architecture that best fits their infrastructure. Whether organizations prefer a distributed model or a centralized approach, they can optimize data collection while minimizing network latency, adapting to their operational needs seamlessly.
-    
+
+   OpenTelemetry Collectors can be deployed as agents on individual hosts or as centralized gateways. This flexibility allows users to choose the deployment architecture that best fits their infrastructure. Whether organizations prefer a distributed model or a centralized approach, they can optimize data collection while minimizing network latency, adapting to their operational needs seamlessly.
+
 6. Security and Compliance:
-    
-    Collectors can sanitize and encrypt telemetry data before forwarding it to backends, ensuring that sensitive information is protected. This feature is essential for organizations needing to comply with regulations regarding data privacy and security.
-    
+
+   Collectors can sanitize and encrypt telemetry data before forwarding it to backends, ensuring that sensitive information is protected. This feature is essential for organizations needing to comply with regulations regarding data privacy and security.
 
 ### Deployment Options for OpenTelemetry Collectors
 
 OpenTelemetry Collectors can be deployed in various configurations to suit different environments and requirements:
 
 - Standalone: The Standalone deployment mode operates independently on each host, making it ideal for environments where simplicity and minimal integration overhead are priorities. It efficiently collects telemetry data at the host level, offering straightforward scalability by adding instances as needed.
-- Sidecar: In the Sidecar deployment model, the Collector runs alongside applications within containerized environments, ensuring tight integration and low-latency data collection. 
-This approach is best suited for microservices architectures where capturing telemetry data directly from application instances is crucial. It minimizes data transmission latency and optimizes resource utilization within containers.
-- Gateway: Acting as a central service, the Gateway deployment aggregates and forwards data from multiple sources, making it optimal for centralized data processing strategies. 
-It simplifies management and security enforcement by centralizing telemetry data flows, making it easier to manage and secure data across distributed environments.
+- Sidecar: In the Sidecar deployment model, the Collector runs alongside applications within containerized environments, ensuring tight integration and low-latency data collection.
+  This approach is best suited for microservices architectures where capturing telemetry data directly from application instances is crucial. It minimizes data transmission latency and optimizes resource utilization within containers.
+- Gateway: Acting as a central service, the Gateway deployment aggregates and forwards data from multiple sources, making it optimal for centralized data processing strategies.
+  It simplifies management and security enforcement by centralizing telemetry data flows, making it easier to manage and secure data across distributed environments.
 
 ### Advantages of using Collectors in Observability Pipelines
 
@@ -136,14 +138,14 @@ When deploying Agents, consider the following strategies to optimize data collec
 
 To understand when to use a Collector or an Agent, let's compare their key aspects:
 
-| Feature | Collector | Agent |
-| --- | --- | --- |
-| Primary Role | Centralized or distributed data processing and exporting. | Local data collection and pre-processing. |
-| Deployment Model | Can be deployed as standalone, centralized (gateway), or as sidecars/DaemonSets. | Typically deployed as sidecars (per-service) or host-level agents (per-node). |
-| Data Collection | Collects telemetry data from various agents, services, or directly from applications. | Collects telemetry data directly from a specific application or service instance. |
-| Data Processing | Performs advanced processing, filtering, and aggregation of telemetry data. | Limited processing capabilities; may apply basic filtering or sampling. |
-| Configuration | More complex configuration due to multiple pipelines and processing stages. | Simpler configuration; usually focused on a single application or service. |
-| Scalability | Handles data from multiple sources, scales horizontally | Scales with the number of application instances |
+| Feature          | Collector                                                                             | Agent                                                                             |
+| ---------------- | ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| Primary Role     | Centralized or distributed data processing and exporting.                             | Local data collection and pre-processing.                                         |
+| Deployment Model | Can be deployed as standalone, centralized (gateway), or as sidecars/DaemonSets.      | Typically deployed as sidecars (per-service) or host-level agents (per-node).     |
+| Data Collection  | Collects telemetry data from various agents, services, or directly from applications. | Collects telemetry data directly from a specific application or service instance. |
+| Data Processing  | Performs advanced processing, filtering, and aggregation of telemetry data.           | Limited processing capabilities; may apply basic filtering or sampling.           |
+| Configuration    | More complex configuration due to multiple pipelines and processing stages.           | Simpler configuration; usually focused on a single application or service.        |
+| Scalability      | Handles data from multiple sources, scales horizontally                               | Scales with the number of application instances                                   |
 
 ### When to Choose a Collector over an Agent
 
@@ -239,4 +241,4 @@ Agents typically have a lower performance impact as they run alongside your appl
 
 ### Are OpenTelemetry Collectors and Agents vendor-neutral?
 
-Yes, both Collectors and Agents are designed to be vendor-neutral. They can work with various backend systems and data formats, allowing you to avoid vendor lock-in and choose the best tools for your needs.
\ No newline at end of file
+Yes, both Collectors and Agents are designed to be vendor-neutral. They can work with various backend systems and data formats, allowing you to avoid vendor lock-in and choose the best tools for your needs.
diff --git a/data/comparisons/opentelemetry-collector-vs-fluentbit.mdx b/data/comparisons/opentelemetry-collector-vs-fluentbit.mdx
index 504382e28..d7eabdaed 100644
--- a/data/comparisons/opentelemetry-collector-vs-fluentbit.mdx
+++ b/data/comparisons/opentelemetry-collector-vs-fluentbit.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry Collector vs. Fluentbit - Key Differences
-slug: opentelemetry-collector-vs-fluentbit
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [sushant_gaurav]
 description: Explore the key differences between OpenTelemetry Collector and Fluentbit for observability. Learn about features, performance, and use cases to make an informed choice.
-keywords: [OpenTelemetry Collector, Fluentbit, observability, telemetry data, log collection, data processing, performance comparison]
-
+keywords:
+  [
+    OpenTelemetry Collector,
+    Fluentbit,
+    observability,
+    telemetry data,
+    log collection,
+    data processing,
+    performance comparison,
+  ]
 ---
 
 In terms of observability and monitoring, selecting the appropriate tools for your telemetry pipeline is important. OpenTelemetry Collector and FluentBit are two common solutions, with each having unique strengths and capabilities. This comparison focuses on their significant distinctions, allowing you to make an educated decision about your [observability stack](https://signoz.io/guides/observability-stack/). We'll look at their features, performance, and optimal use cases to help you optimize your monitoring system.
@@ -53,7 +60,7 @@ Let's discuss the key features and capabilities of OpenTelemetry Collector and F
 
 The OpenTelemetry Collector is built with flexibility and extensibility in mind, supporting multiple telemetry types and seamless integration with various observability backends. Its core features include:
 
-1. Multi-Data Type Support:  It handles logs, metrics, and traces, allowing for unified telemetry data collection and processing across distributed systems.
+1. Multi-Data Type Support: It handles logs, metrics, and traces, allowing for unified telemetry data collection and processing across distributed systems.
 2. Extensible Architecture: The OpenTelemetry Collector is designed around a modular architecture with pluggable components: receivers, processors, and exporters. Receivers are responsible for collecting telemetry data from various sources, processors handle the transformation and enrichment of the data after it's received and exporters are used to send the processed data to external systems for analysis or storage. This extensibility makes it adaptable for varied environments and use cases, letting users configure components to suit specific monitoring needs.
 3. Backend Compatibility: It includes built-in exporters for many popular backends, such as Prometheus, Jaeger, and Zipkin, making it simple to send telemetry data to multiple backends without being tied to a single vendor.
 4. Advanced Processing: It provides built-in transformation features for filtering, sampling, and enhancing telemetry data, helping teams preprocess telemetry data to reduce noise, add metadata, or transform data formats before exporting.
@@ -148,9 +155,9 @@ Telemetry pipelines frequently require data processing and modification before i
 ### OpenTelemetry Collector
 
 - It includes a variety of built-in processors such as `batch` (for batching data), `memory_limiter` (to prevent resource depletion), and `attributes` (for adding, modifying, or removing data attributes). The collector includes a variety of built-in processors that are essential for data processing:
-    - Batch: Batching data into manageable chunks for efficient processing.
-    - Memory_limiter: Preventing resource depletion by limiting memory usage.
-    - Attributes: Adding, modifying, or removing data attributes to customize the processing pipeline.
+  - Batch: Batching data into manageable chunks for efficient processing.
+  - Memory_limiter: Preventing resource depletion by limiting memory usage.
+  - Attributes: Adding, modifying, or removing data attributes to customize the processing pipeline.
 - It includes extensive features for data filtering, sampling, and transformation. You may set up the collector to handle complicated data routing and enrichment depending on attributes like [trace ID](https://signoz.io/comparisons/opentelemetry-trace-id-vs-span-id/), service name, and geolocation.
 - It supports complex routing, which means you may route different types of telemetry data to multiple observability platforms based on circumstances or metadata.
 
@@ -162,13 +169,13 @@ Telemetry pipelines frequently require data processing and modification before i
 
 ## Monitoring and Observability with SigNoz
 
-To maximize the potential of both OpenTelemetry Collector and FluentBit, consider integrating them with a robust observability platform like [SigNoz](https://signoz.io/). 
+To maximize the potential of both OpenTelemetry Collector and FluentBit, consider integrating them with a robust observability platform like [SigNoz](https://signoz.io/).
 
 SigNoz is an open-source observability platform that offers end-to-end visibility into system performance by capturing metrics, traces, and logs. Built with native support for OpenTelemetry, SigNoz provides a powerful, centralized solution for tracking application health, performance, and user experience, making it a valuable tool for modern observability. It’s designed to provide real-time insights into application performance, allowing users to visualize critical metrics, track dependencies, and detect issues quickly across distributed systems.
 
 ### How SigNoz Complements Both OpenTelemetry Collector and Fluent Bit
 
-SigNoz works well in tandem with both OpenTelemetry Collector and Fluent Bit. OpenTelemetry Collector is ideal for capturing and forwarding telemetry data across different backend systems, while Fluent Bit is an efficient solution for log collection and parsing, particularly in resource-constrained environments. 
+SigNoz works well in tandem with both OpenTelemetry Collector and Fluent Bit. OpenTelemetry Collector is ideal for capturing and forwarding telemetry data across different backend systems, while Fluent Bit is an efficient solution for log collection and parsing, particularly in resource-constrained environments.
 
 By integrating with both tools, SigNoz enables a unified observability pipeline, seamlessly handling metrics, traces, and logs. This combination allows teams to manage complex observability data from multiple sources, correlating logs with traces to create a complete picture of application behavior.
 
@@ -205,13 +212,13 @@ While both OpenTelemetry Collector and [FluentBit](https://signoz.io/docs/usergu
 The observability landscape is rapidly evolving. Here’s what to expect from these tools and the industry soon:
 
 1. OpenTelemetry Collector:
-    - Accessibility: Enhancements are being made to make the collector more accessible for diverse deployment environments.
-    - Cloud Native Support: As more enterprises embrace serverless and cloud-native architectures, OpenTelemetry will continue to improve its support for these settings, including improved out-of-the-box integrations.
+   - Accessibility: Enhancements are being made to make the collector more accessible for diverse deployment environments.
+   - Cloud Native Support: As more enterprises embrace serverless and cloud-native architectures, OpenTelemetry will continue to improve its support for these settings, including improved out-of-the-box integrations.
 2. FluentBit:
-    - Edge computing improvements: As edge computing grows in popularity, FluentBit will expand its interactions with emerging platforms, providing more nuanced functionality for dispersed situations.
+   - Edge computing improvements: As edge computing grows in popularity, FluentBit will expand its interactions with emerging platforms, providing more nuanced functionality for dispersed situations.
 3. Industry-Wide Trends:
-    - Unified observability: The industry is moving toward combining logging, metrics, and tracing into a single, unified observability solution. Tools like OpenTelemetry will continue to lead the way in this approach.
-    - Real-time processing: A higher focus will be placed on real-time telemetry data processing, allowing enterprises to respond more quickly to performance issues and abnormalities across their systems.
+   - Unified observability: The industry is moving toward combining logging, metrics, and tracing into a single, unified observability solution. Tools like OpenTelemetry will continue to lead the way in this approach.
+   - Real-time processing: A higher focus will be placed on real-time telemetry data processing, allowing enterprises to respond more quickly to performance issues and abnormalities across their systems.
 
 ## Key Takeaways
 
@@ -237,4 +244,4 @@ FluentBit offers a gentler learning curve because of its simplified, log-focused
 
 ### What are the main differences in data output formats between the two tools?
 
-OpenTelemetry Collector supports a range of output formats, including OpenTelemetry Protocol (OTLP), Prometheus, and Jaeger. FluentBit, on the other hand, is mainly focused on log-oriented formats such as Elasticsearch, Fluentd, and Kafka, although it can be expanded with plugins to support additional formats.
\ No newline at end of file
+OpenTelemetry Collector supports a range of output formats, including OpenTelemetry Protocol (OTLP), Prometheus, and Jaeger. FluentBit, on the other hand, is mainly focused on log-oriented formats such as Elasticsearch, Fluentd, and Kafka, although it can be expanded with plugins to support additional formats.
diff --git a/data/comparisons/opentelemetry-events-vs-logs.mdx b/data/comparisons/opentelemetry-events-vs-logs.mdx
index d869e34f5..97b45b074 100644
--- a/data/comparisons/opentelemetry-events-vs-logs.mdx
+++ b/data/comparisons/opentelemetry-events-vs-logs.mdx
@@ -1,16 +1,14 @@
 ---
-
 title: OpenTelemetry Events vs Logs - Key Differences Explained
-slug: opentelemetry-events-vs-logs
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [niyati_thakkar]
 description: Discover the key differences between OpenTelemetry events and logs, their use cases, and best practices for implementing them in your observability strategy.
 keywords: [OpenTelemetry, events, logs, observability, telemetry, monitoring, SigNoz]
-
 ---
 
-In the world of modern observability, managing and interpreting vast amounts of telemetry data is crucial for ensuring application health and performance. OpenTelemetry has emerged as a leading standard for collecting telemetry data, encompassing events, logs, metrics, and traces. While metrics and traces are often discussed in detail, events and logs play equally vital roles but can sometimes be misunderstood or used interchangeably. 
+In the world of modern observability, managing and interpreting vast amounts of telemetry data is crucial for ensuring application health and performance. OpenTelemetry has emerged as a leading standard for collecting telemetry data, encompassing events, logs, metrics, and traces. While metrics and traces are often discussed in detail, events and logs play equally vital roles but can sometimes be misunderstood or used interchangeably.
 
 Understanding the key differences between OpenTelemetry events and logs is essential for designing an effective observability strategy. This article delves into the key differences between OpenTelemetry events and logs, exploring their unique characteristics, use cases, and implementation strategies.
 
@@ -29,10 +27,10 @@ Consider an e-commerce application that generates an event when a user places an
 - Timestamp: When the order was placed.
 - Event Type: `Order Placed`
 - Attributes:
-    - `user_id`: Unique identifier of the user.
-    - `order_id`: Unique identifier of the order.
-    - `total_amount`: Total value of the order.
-    - `payment_status`: Status of the payment (e.g., pending, completed).
+  - `user_id`: Unique identifier of the user.
+  - `order_id`: Unique identifier of the order.
+  - `total_amount`: Total value of the order.
+  - `payment_status`: Status of the payment (e.g., pending, completed).
 
 ### Logs in OpenTelemetry
 
@@ -46,10 +44,10 @@ Using the same e-commerce application, a log entry might be generated when an er
 - Log Level: `ERROR`
 - Message: `Failed to process payment for order #12345`
 - Attributes:
-    - `order_id`: `12345`
-    - `user_id`: `67890`
-    - `error_code`: `PAYMENT_FAILURE`
-    - `error_message`: `Insufficient funds`
+  - `order_id`: `12345`
+  - `user_id`: `67890`
+  - `error_code`: `PAYMENT_FAILURE`
+  - `error_message`: `Insufficient funds`
 
 ### Importance of Events and Logs in Application Telemetry
 
@@ -63,68 +61,59 @@ Both events and logs are essential components of application telemetry, offering
 
 Understanding the distinctions between events and logs is crucial for effective application monitoring. Here’s a summary of their core differences:
 
-| Aspect | OpenTelemetry Events | OpenTelemetry Logs |
-| --- | --- | --- |
-| Structure | Highly structured data points with predefined fields and formats | Semi-structured or unstructured, allowing flexibility in content |
-| Temporal Aspect | Captures specific moments in time (discrete occurrences) | Continuous stream of information, showing chronological activity |
-| Granularity | Focused on specific actions or state changes with precise details | Broader system information, ranging from detailed debug messages to system status |
-| Query & Analysis | Easily searchable and analyzable due to structured data | Requires complex parsing and analysis tools, especially for unstructured data |
-| Use Case Example | User actions, state changes (e.g., user authentication success) | Detailed context (e.g., logs recording authentication methods and debug messages) |
+| Aspect           | OpenTelemetry Events                                              | OpenTelemetry Logs                                                                |
+| ---------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| Structure        | Highly structured data points with predefined fields and formats  | Semi-structured or unstructured, allowing flexibility in content                  |
+| Temporal Aspect  | Captures specific moments in time (discrete occurrences)          | Continuous stream of information, showing chronological activity                  |
+| Granularity      | Focused on specific actions or state changes with precise details | Broader system information, ranging from detailed debug messages to system status |
+| Query & Analysis | Easily searchable and analyzable due to structured data           | Requires complex parsing and analysis tools, especially for unstructured data     |
+| Use Case Example | User actions, state changes (e.g., user authentication success)   | Detailed context (e.g., logs recording authentication methods and debug messages) |
 
 Let’s dive deeper into each key difference.
 
 ### Structure
 
 - Events: In OpenTelemetry, events are highly structured data associated with specific spans, detailing precise actions or states within an application's trace. They include attributes like `timestamp`, `traceId`, and `spanId`, which enable detailed tracking and analysis of events.
-    
-    Example Event:
-    
-    ```json
-    {
-        "name": "user.login",
-        "timestamp": "2024-01-01T10:00:00Z",
-        "attributes": {
-            "user_id": "12345",
-            "login_method": "oauth",
-            "success": true,
-            "client_ip": "192.168.1.1",
-            "user_agent": "Mozilla/5.0...",
-            "authentication_provider": "Google"
-        },
-        "traceId": "abcdef123456",
-        "spanId": "789012",
-        "severity": "INFO",
-        "dropoff_timestamp": "2024-01-01T10:00:00.123Z"
-    }
-    ```
-    
+  Example Event:
+  ```json
+  {
+    "name": "user.login",
+    "timestamp": "2024-01-01T10:00:00Z",
+    "attributes": {
+      "user_id": "12345",
+      "login_method": "oauth",
+      "success": true,
+      "client_ip": "192.168.1.1",
+      "user_agent": "Mozilla/5.0...",
+      "authentication_provider": "Google"
+    },
+    "traceId": "abcdef123456",
+    "spanId": "789012",
+    "severity": "INFO",
+    "dropoff_timestamp": "2024-01-01T10:00:00.123Z"
+  }
+  ```
 - Logs: Logs, on the other hand, are often semi-structured or even unstructured text records. They capture diverse details, including messages and contextual information like service name, error details, and severity level. Logs are useful for recording general system activity and error messages
-    
-    Example Log
-    
-    1. Unstructured log
-    
-    ```python
-    2024-01-01 10:00:00 INFO [AuthService] User 12345 logged in successfully via OAuth
-    ```
-    
-    b. Structured log
-    
-    ```json
-    {
-        "timestamp": "2024-01-01T10:00:00Z",
-        "level": "INFO",
-        "service": "AuthService",
-        "message": "User login successful",
-        "context": {
-            "user_id": "12345",
-            "method": "oauth",
-            "ip_address": "192.168.1.1"
-        },
-        "stack_trace": null
-    }
-    ```
-    
+  Example Log
+  1. Unstructured log
+  ```python
+  2024-01-01 10:00:00 INFO [AuthService] User 12345 logged in successfully via OAuth
+  ```
+  b. Structured log
+  ```json
+  {
+    "timestamp": "2024-01-01T10:00:00Z",
+    "level": "INFO",
+    "service": "AuthService",
+    "message": "User login successful",
+    "context": {
+      "user_id": "12345",
+      "method": "oauth",
+      "ip_address": "192.168.1.1"
+    },
+    "stack_trace": null
+  }
+  ```
 
 ### Temporal Aspects
 
@@ -200,14 +189,14 @@ def process_purchase(order_id: str, items: list, amount: float):
             "order.amount": amount,
             "order.items_count": len(items)
         })
-        
+
         # Add event for purchase completion
         span.add_event("purchase_completed", {
             "order_id": order_id,
             "amount": amount,
             "items": len(items)
         })
-        
+
         # Log the processing
         logging.info(f"Processing order {order_id}: {len(items)} items, total ${amount:.2f}")
         logging.debug(f"Order {order_id} details: {items}")
@@ -220,7 +209,7 @@ if __name__ == "__main__":
         "items": ["SKU001", "SKU002", "SKU003"],
         "amount": 99.99
     }
-    
+
     # Process the purchase
     process_purchase(
         sample_order["order_id"],
@@ -285,14 +274,14 @@ From the output generated by the provided script, we can see how events and logs
 
 1. Real-Time Notifications via Events: The event recorded in the output—`"name": "purchase_completed"`—serves as a real-time indicator that a specific action has taken place: the completion of a purchase. This event includes attributes such as `order_id`, `amount`, and `items`, providing immediate insights into the transaction's details. It allows teams to quickly identify that an important milestone in the order processing has been reached, prompting further analysis if needed.
 2. Detailed Context from Logs: The logs provide contextual information that supplements the event. For example, the log entry:
-    
-    ```ruby
-    INFO:root:Processing order ORD-123: 3 items, total $99.99
-    DEBUG:root:Order ORD-123 details: ['SKU001', 'SKU002', 'SKU003']
-    ```
-    
-    captures not only the action (processing the order) but also specific details about the order, such as the total amount and the items included. This context is crucial for understanding the circumstances surrounding the event and helps teams comprehend the broader operational picture.
-    
+
+   ```ruby
+   INFO:root:Processing order ORD-123: 3 items, total $99.99
+   DEBUG:root:Order ORD-123 details: ['SKU001', 'SKU002', 'SKU003']
+   ```
+
+   captures not only the action (processing the order) but also specific details about the order, such as the total amount and the items included. This context is crucial for understanding the circumstances surrounding the event and helps teams comprehend the broader operational picture.
+
 3. Linking Events and Logs for Troubleshooting: If issues arise—such as a payment failure—teams can refer to the recorded event and its associated logs to diagnose the problem. For instance, if the `purchase_completed` event triggers an alert for an error, the logs will provide information about what happened during processing (e.g., the items involved and the total amount). This linkage enables more effective troubleshooting by allowing teams to follow the trail from the event to its contextual details.
 4. Correlated Data for Enhanced Analysis: The output combines both event and log information, allowing teams to correlate the transaction's success (the event) with the detailed processing steps (the logs). This correlation aids in understanding patterns and behaviors within the application, such as the typical flow of transactions and how different variables (like the number of items) impact outcomes.
 
@@ -306,10 +295,29 @@ Events can be managed through two primary mechanisms: span events within the Tra
 
 - Span Events: In OpenTelemetry, events are primarily implemented as span events within the Tracing API. This approach allows events to be recorded as part of spans, which are fundamental units of work that represent operations in your application. By linking events to spans, developers can maintain contextual awareness throughout their tracing, enabling better correlation between different telemetry signals and providing insights into application performance.
 - Events API: OpenTelemetry also includes a dedicated Events API, designed to enhance event management capabilities. This API consists of two main components:
-    - <a href="https://opentelemetry.io/docs/specs/otel/logs/event-api/#eventloggerprovider" rel="noopener noreferrer nofollow" target="_blank">EventLoggerProvider</a>: This is the entry point of the Events API. It provides access to `EventLogger` instances, serving as a factory for creating loggers for various components of your application. By centralizing the management of event loggers, the provider simplifies the process of emitting events across different application contexts.
-    - <a href="https://opentelemetry.io/docs/specs/otel/logs/event-api/#eventlogger" rel="noopener noreferrer nofollow" target="_blank">EventLogger</a>: The `EventLogger` is responsible for emitting events. It allows applications to record significant occurrences with structured data, enabling developers to capture and track events such as user interactions, system alerts, or status changes effectively.
-
-It's important to note that the Events API is still under development, which means that its features and functionalities may evolve over time. While both mechanisms exist in the specification, developers currently work primarily with span events through the Tracing API. 
+  - <a
+      href="https://opentelemetry.io/docs/specs/otel/logs/event-api/#eventloggerprovider"
+      rel="noopener noreferrer nofollow"
+      target="_blank"
+    >
+      EventLoggerProvider
+    </a>
+    : This is the entry point of the Events API. It provides access to `EventLogger` instances,
+    serving as a factory for creating loggers for various components of your application. By
+    centralizing the management of event loggers, the provider simplifies the process of emitting
+    events across different application contexts.
+  - <a
+      href="https://opentelemetry.io/docs/specs/otel/logs/event-api/#eventlogger"
+      rel="noopener noreferrer nofollow"
+      target="_blank"
+    >
+      EventLogger
+    </a>
+    : The `EventLogger` is responsible for emitting events. It allows applications to record
+    significant occurrences with structured data, enabling developers to capture and track events
+    such as user interactions, system alerts, or status changes effectively.
+
+It's important to note that the Events API is still under development, which means that its features and functionalities may evolve over time. While both mechanisms exist in the specification, developers currently work primarily with span events through the Tracing API.
 
 For example:
 
@@ -317,7 +325,7 @@ For example:
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter
- 
+
 tracer_provider = TracerProvider()
 tracer = tracer_provider.get_tracer(__name__)
 console_exporter = ConsoleSpanExporter()
@@ -335,7 +343,7 @@ with tracer.start_as_current_span("user_login") as span:
         "status": "success",
         "timestamp": 1679580000000
     })
-    
+
     # Add another event
     span.add_event("User logged in successfully")
 
@@ -351,7 +359,7 @@ For logs, OpenTelemetry integrates seamlessly with existing logging frameworks l
 Example of Logging with OpenTelemetry:
 
 ```python
-import logging 
+import logging
 from opentelemetry.instrumentation.logging import LoggingInstrumentor
 
 # Instrument logging to add context and set format
@@ -381,11 +389,11 @@ To maximize the value of your telemetry data, consider these best practices:
 1. Choose Wisely: Use events for specific, structured occurrences and logs for broader, contextual information.
 2. Consistent Naming: Establish a clear naming convention for events and log messages to ensure consistency across your application.
 3. Structured Data: Even for logs, use structured data where possible to facilitate easier analysis:
-    
-    ```python
-    logging.info("User action", extra={"action": "login", "user_id": "12345"})
-    ```
-    
+
+   ```python
+   logging.info("User action", extra={"action": "login", "user_id": "12345"})
+   ```
+
 4. Avoid Duplication: Don't repeat information in both events and logs. Instead, use them to complement each other.
 5. Performance Considerations: Be mindful of the performance impact, especially when emitting high-frequency events or verbose logs.
 6. Context Propagation: Utilize OpenTelemetry's context propagation to link events and logs with relevant [traces and spans](https://signoz.io/comparisons/opentelemetry-trace-vs-span/).
@@ -404,15 +412,15 @@ With SigNoz, users can easily capture a wide range of telemetry data, including
 [SigNoz Cloud](https://signoz.io/) offers a managed observability platform that simplifies the setup process, removing the need to maintain your infrastructure. It provides powerful tools for real-time monitoring and historical analysis, helping you gain insights into your application's health and performance.
 
 - Sign Up for SigNoz Cloud: Create your account on SigNoz Cloud to access its powerful observability platform. This managed service eliminates the hassle of infrastructure maintenance, allowing you to focus on deriving insights from your data.
-    
-    <GetStartedSigNoz />
-    
+  <GetStartedSigNoz />
 - Explore the Sample Application: SigNoz comes with a sample application pre-configured to help you explore its capabilities. This application allows you to visualize how telemetry data is captured and displayed, making it easier to understand the features available.
 - Instrumentation: For detailed guidance on instrumenting your applications, refer to the blog post on [Instrumenting Applications with OpenTelemetry](https://signoz.io/docs/instrumentation/opentelemetry-python/).
 - Data Visualization: Once your application is instrumented and sending data, you can utilize SigNoz’s powerful analytics features. Check guides on [SigNoz](https://signoz.io/docs/userguide/manage-dashboards/) to learn how to set up dashboards tailored to your specific needs, allowing for effective monitoring of key performance indicators.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-events-vs-logs-image.webp" alt="SigNoz Analysis Dashboard" caption="SigNoz Analysis Dashboard" />
-    
+  <Figure
+    src="/img/comparisons/2024/11/opentelemetry-events-vs-logs-image.webp"
+    alt="SigNoz Analysis Dashboard"
+    caption="SigNoz Analysis Dashboard"
+  />
 
 [SigNoz](https://signoz.io/) Cloud provides powerful tools for real-time monitoring and historical analysis, helping you gain insights into your application's health and performance.
 
@@ -432,7 +440,7 @@ As observability practices evolve, several trends are shaping the future of Open
 - Choose events for precise tracking of actions and state changes; use logs for debugging and [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/).
 - OpenTelemetry offers a standardized approach to both events and logs, simplifying data collection and analysis.
 - Effective observability strategies often combine events and logs for comprehensive insights.
-- Tools like SigNoz can significantly streamline the management and analysis of OpenTelemetry events and logs.  
+- Tools like SigNoz can significantly streamline the management and analysis of OpenTelemetry events and logs.
 - Future trends point towards more integrated, AI-driven approaches to event and log analysis in observability practices.
 
 ## FAQs
@@ -451,4 +459,4 @@ Events can be associated with specific spans in a distributed trace, providing a
 
 ### Are there performance implications when choosing between events and logs?
 
-Yes, events generally have less performance overhead due to their structured nature and typically lower volume. Logs, especially if verbose, can have a more significant impact on performance. It's important to strike a balance based on your observability needs and system resources.
\ No newline at end of file
+Yes, events generally have less performance overhead due to their structured nature and typically lower volume. Logs, especially if verbose, can have a more significant impact on performance. It's important to strike a balance based on your observability needs and system resources.
diff --git a/data/comparisons/opentelemetry-grpc-vs-http.mdx b/data/comparisons/opentelemetry-grpc-vs-http.mdx
index 0897ea217..1025ccf7c 100644
--- a/data/comparisons/opentelemetry-grpc-vs-http.mdx
+++ b/data/comparisons/opentelemetry-grpc-vs-http.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: OpenTelemetry - gRPC vs HTTP for Efficient Tracing
-slug: opentelemetry-grpc-vs-http
+
 date: 2024-11-20
 tags: [OpenTelemetry]
 authors: [bhavya_sachdeva]
 description: Explore the key differences between gRPC and HTTP protocols in OpenTelemetry tracing. Learn which protocol suits your needs for efficient observability.
 keywords: [OpenTelemetry, gRPC, HTTP, tracing, observability, OTLP, protocol comparison]
-
 ---
 
 In the world of distributed systems and microservices, observability has become crucial for maintaining and troubleshooting complex applications. OpenTelemetry stands at the forefront of this observability revolution, providing a standardized way to collect and transmit telemetry data. But when it comes to implementing OpenTelemetry, you face a critical decision: should you use gRPC or HTTP for your tracing data transmission? This choice can significantly impact your system's performance, efficiency, and overall observability strategy.
@@ -29,7 +27,7 @@ In OpenTelemetry, the two main protocols are gRPC and HTTP. gRPC is faster and m
 
 Understanding gRPC in OpenTelemetry
 
-gRPC, which stands for *gRPC Remote Procedure Call*, is a high-performance communication protocol developed by Google, designed to make data transfer fast and efficient. In OpenTelemetry, gRPC is often used for sending large amounts of telemetry data, such as traces and metrics, because of its speed and low-latency capabilities. A key part of gRPC’s design is its use of Protocol Buffers, a language-neutral, binary serialization format that makes data compact and quick to transmit. This helps OpenTelemetry systems efficiently manage data flow between various microservices and components.
+gRPC, which stands for _gRPC Remote Procedure Call_, is a high-performance communication protocol developed by Google, designed to make data transfer fast and efficient. In OpenTelemetry, gRPC is often used for sending large amounts of telemetry data, such as traces and metrics, because of its speed and low-latency capabilities. A key part of gRPC’s design is its use of Protocol Buffers, a language-neutral, binary serialization format that makes data compact and quick to transmit. This helps OpenTelemetry systems efficiently manage data flow between various microservices and components.
 
 Key Features of gRPC:
 
@@ -82,7 +80,11 @@ message ExportTraceServiceResponse {
 
 This definition sets the foundation for robust data communication between clients and servers, specifying the data structure for trace information.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-grpc-vs-http-Screenshot_2024-11-11_at_1.52.18_PM.webp" alt="Python gRPC Open Telemetry" caption="Python gRPC Open Telemetry" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-grpc-vs-http-Screenshot_2024-11-11_at_1.52.18_PM.webp"
+  alt="Python gRPC Open Telemetry"
+  caption="Python gRPC Open Telemetry"
+/>
 
 ### Advantages of Using HTTP/2 in gRPC
 
@@ -178,15 +180,15 @@ When implementing OpenTelemetry for tracing distributed systems, the choice betw
 
 The table below highlights the primary differences between gRPC and HTTP in various operational aspects relevant to OpenTelemetry:
 
-| Feature | gRPC | HTTP |
-| --- | --- | --- |
-| Speed | Faster due to HTTP/2 | Slower, depends on version (HTTP/1.1, HTTP/2) |
-| Efficiency | High, with binary serialization | Lower, especially with textual data |
-| Ease of use | Complex setup and maintenance | Simpler and more straightforward |
-| Compatibility | May require specific configurations | Widely supported by existing infrastructures |
-| Streaming | Supports bi-directional streaming | Primarily unidirectional (HTTP/2 improves this) |
-| Data format | Primarily binary (Protocol Buffers) | More flexible (supports JSON, Binary) |
-| Browser support | Limited, not natively supported in browsers | Extensive, direct browser support |
+| Feature         | gRPC                                        | HTTP                                            |
+| --------------- | ------------------------------------------- | ----------------------------------------------- |
+| Speed           | Faster due to HTTP/2                        | Slower, depends on version (HTTP/1.1, HTTP/2)   |
+| Efficiency      | High, with binary serialization             | Lower, especially with textual data             |
+| Ease of use     | Complex setup and maintenance               | Simpler and more straightforward                |
+| Compatibility   | May require specific configurations         | Widely supported by existing infrastructures    |
+| Streaming       | Supports bi-directional streaming           | Primarily unidirectional (HTTP/2 improves this) |
+| Data format     | Primarily binary (Protocol Buffers)         | More flexible (supports JSON, Binary)           |
+| Browser support | Limited, not natively supported in browsers | Extensive, direct browser support               |
 
 ### Network Infrastructure Considerations
 
@@ -293,4 +295,4 @@ gRPC uses Protocol Buffers, which provides efficient binary encoding. HTTP can u
 
 ### Are there any security implications to consider when choosing between gRPC and HTTP for OpenTelemetry?
 
-Both protocols can be secured with TLS. However, HTTP has a more mature ecosystem of security tools and practices, while gRPC's security features are still evolving in some areas.
\ No newline at end of file
+Both protocols can be secured with TLS. However, HTTP has a more mature ecosystem of security tools and practices, while gRPC's security features are still evolving in some areas.
diff --git a/data/comparisons/opentelemetry-trace-id-vs-span-id.mdx b/data/comparisons/opentelemetry-trace-id-vs-span-id.mdx
index 0174ff887..e50b0df2b 100644
--- a/data/comparisons/opentelemetry-trace-id-vs-span-id.mdx
+++ b/data/comparisons/opentelemetry-trace-id-vs-span-id.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Understanding OpenTelemetry - Trace ID vs. Span ID
-slug: opentelemetry-trace-id-vs-span-id
+
 date: 2024-11-14
 tags: [OpenTelemetry]
 authors: [vivek_goswami]
 description: Explore the key differences between Trace ID and Span ID in OpenTelemetry. Learn how these concepts improve distributed tracing and system observability.
-keywords: [OpenTelemetry, Trace ID, Span ID, distributed tracing, observability, SigNoz, application performance monitoring]
-
+keywords:
+  [
+    OpenTelemetry,
+    Trace ID,
+    Span ID,
+    distributed tracing,
+    observability,
+    SigNoz,
+    application performance monitoring,
+  ]
 ---
 
 Distributed systems pose unique challenges for developers and operations teams. How do you track a request as it travels through multiple services? Enter OpenTelemetry — a powerful observability framework that's changing the game. At its core, OpenTelemetry uses two key concepts: Trace ID and [Span ID](https://signoz.io/comparisons/opentelemetry-trace-id-vs-span-id/). But what exactly are these, and how do they differ?
@@ -99,82 +106,59 @@ In practice, OpenTelemetry libraries and instrumentation handle much of the comp
 A span is the fundamental unit of work in distributed tracing. Each span represents a specific operation or task performed within a larger process, and it captures crucial information such as start time, end time, and the operations executed within that task. Multiple spans are combined to create traces, which represent the complete workflow of a request as it moves through different services or systems.
 
 - Anatomy of a Span:
-    
-    A span records essential details of an operation:
-    
-    - Start time: Marks the time when the operation begins.
-    - End time: Captures when the operation is completed.
-    - Operation name: Describes the task being performed within the span.
-    - Tags and metadata: Additional information can be added, such as [error logs](https://signoz.io/guides/error-log/) or other relevant data for context.
-    - Parent-child relationship: Spans may have parent spans, representing hierarchical relationships in complex workflows.
+  A span records essential details of an operation:
+  - Start time: Marks the time when the operation begins.
+  - End time: Captures when the operation is completed.
+  - Operation name: Describes the task being performed within the span.
+  - Tags and metadata: Additional information can be added, such as [error logs](https://signoz.io/guides/error-log/) or other relevant data for context.
+  - Parent-child relationship: Spans may have parent spans, representing hierarchical relationships in complex workflows.
 - Span IDs and Trace IDs:
-    
-    Each span has a unique identifier known as a Span ID. These Span IDs are essential for distinguishing between operations within the same trace. Trace IDs tie multiple spans together, indicating they are part of the same overarching request. Span IDs are typically generated as random 64-bit integers, ensuring that each span can be uniquely identified.
-    
+  Each span has a unique identifier known as a Span ID. These Span IDs are essential for distinguishing between operations within the same trace. Trace IDs tie multiple spans together, indicating they are part of the same overarching request. Span IDs are typically generated as random 64-bit integers, ensuring that each span can be uniquely identified.
 - Relationship Between Span IDs and Trace IDs:
-    
-    Span IDs are linked to a common Trace ID during the same request or transaction. The Trace ID is a shared identifier that ties together all spans generated by that request, showing the entire journey of the request across services. Span IDs are individual pieces within that larger trace, representing specific operations.
-    
+  Span IDs are linked to a common Trace ID during the same request or transaction. The Trace ID is a shared identifier that ties together all spans generated by that request, showing the entire journey of the request across services. Span IDs are individual pieces within that larger trace, representing specific operations.
 
 ### Practical Examples
 
 - Web Request to a Microservice:
-    
-    A span might represent the time to process a user request to a web service. The span could start when the request reaches the web server and end when the response is sent back to the user. During that time, the span would capture the operations performed, such as database queries or interactions with other microservices.
-    
+  A span might represent the time to process a user request to a web service. The span could start when the request reaches the web server and end when the response is sent back to the user. During that time, the span would capture the operations performed, such as database queries or interactions with other microservices.
 - Database Query Operation:
-    
-    Consider a scenario where a web application makes a call to a database. A span would represent this database call, capturing the start and end time of the query execution. In this case, the span might contain metadata about the query, such as the SQL statement or details about any errors.
-    
+  Consider a scenario where a web application makes a call to a database. A span would represent this database call, capturing the start and end time of the query execution. In this case, the span might contain metadata about the query, such as the SQL statement or details about any errors.
 - Service-to-Service Communication:
-    
-    In a microservices architecture, when one service calls another, a span can represent the duration of that request. This allows tracking of how long it took for one service to send a request and receive a response from another service, including any errors or delays.
-    
+  In a microservices architecture, when one service calls another, a span can represent the duration of that request. This allows tracking of how long it took for one service to send a request and receive a response from another service, including any errors or delays.
 
 ### Span Attributes and Events
 
 Span attributes and events are key elements in distributed tracing, providing deeper visibility and context. Attributes describe the metadata associated with a span, while events track significant occurrences within the span's lifecycle.
 
 - Understanding Span Attributes and Their Importance
-    
-    Span attributes are key-value pairs that provide important context for a span, such as HTTP methods, user IDs, or transaction identifiers. These attributes are used for filtering and querying traces, making it easier to pinpoint specific actions or problems. For example, an HTTP request span might have attributes like the HTTP method, URL, and user ID, which help identify and filter traces related to a particular user request.
-    
+  Span attributes are key-value pairs that provide important context for a span, such as HTTP methods, user IDs, or transaction identifiers. These attributes are used for filtering and querying traces, making it easier to pinpoint specific actions or problems. For example, an HTTP request span might have attributes like the HTTP method, URL, and user ID, which help identify and filter traces related to a particular user request.
 - How to Use Span Events to Mark Significant Occurrences
-    
-    Span events are timestamped markers within a span that capture key moments, such as errors, retries, or transitions between stages. These events can indicate specific occurrences like the start of a database query or when a response is sent. For example, in an e-commerce application, events might be added to a span to mark when an order is processed, when an error occurs during payment, or when the order is completed.
-    
+  Span events are timestamped markers within a span that capture key moments, such as errors, retries, or transitions between stages. These events can indicate specific occurrences like the start of a database query or when a response is sent. For example, in an e-commerce application, events might be added to a span to mark when an order is processed, when an error occurs during payment, or when the order is completed.
 - Best Practices for Adding Context to Spans
-    - Include Relevant Metadata: When adding attributes to spans, focus on data that provides meaningful context. For instance, include attributes like service names, request paths, and user identifiers. This helps trace data be more useful for debugging and performance monitoring.
-    - Consistency is Key: Use standardized naming conventions for attributes and events across services. This ensures that traces are consistent, making it easier to analyze them collectively.
-    - Use Clear Naming: Use names that clearly describe the purpose or action of the attribute or event. For example, use `http.method` for the HTTP request method or `request_received` for the event marking the receipt of a request.
-    
+  - Include Relevant Metadata: When adding attributes to spans, focus on data that provides meaningful context. For instance, include attributes like service names, request paths, and user identifiers. This helps trace data be more useful for debugging and performance monitoring.
+  - Consistency is Key: Use standardized naming conventions for attributes and events across services. This ensures that traces are consistent, making it easier to analyze them collectively.
+  - Use Clear Naming: Use names that clearly describe the purpose or action of the attribute or event. For example, use `http.method` for the HTTP request method or `request_received` for the event marking the receipt of a request.
     Examples of useful attributes:
-    
-    - `http.method: "POST"`
-    - `http.url: "/api/orders"`
-    - `user.id: "1234"`
-    
+  - `http.method: "POST"`
+  - `http.url: "/api/orders"`
+  - `user.id: "1234"`
     Examples of useful events:
-    
-    - `request_received`: Marked when the request is first received.
-    - `order_processed`: Indicates when the order is fully processed.
-    - `response_sent`: Captures when the response is sent to the client.
+  - `request_received`: Marked when the request is first received.
+  - `order_processed`: Indicates when the order is fully processed.
+  - `response_sent`: Captures when the response is sent to the client.
 - Balancing Detail and Performance in Span Creation
-    - Avoid Overloading with Details: While it's important to capture enough information to diagnose problems, too many attributes or events can increase the overhead of tracing. Focus on the most relevant and impactful data that will aid in troubleshooting without affecting performance.
-    - Optimize for Performance: Keep spans lightweight for routine operations, such as basic CRUD operations. However, include more detailed information to improve observability for complex transactions or error scenarios.
-    
+  - Avoid Overloading with Details: While it's important to capture enough information to diagnose problems, too many attributes or events can increase the overhead of tracing. Focus on the most relevant and impactful data that will aid in troubleshooting without affecting performance.
+  - Optimize for Performance: Keep spans lightweight for routine operations, such as basic CRUD operations. However, include more detailed information to improve observability for complex transactions or error scenarios.
     Example:
-    
     In a Node.js application, a span tracking an HTTP request might include:
-    
-    - Attributes like:
-        - `http.method: "POST"`
-        - `http.url: "/api/orders"`
-        - `user.id: "1234"`
-    - Events like:
-        - `request_received`
-        - `order_processed`
-        - `response_sent`
+  - Attributes like:
+    - `http.method: "POST"`
+    - `http.url: "/api/orders"`
+    - `user.id: "1234"`
+  - Events like:
+    - `request_received`
+    - `order_processed`
+    - `response_sent`
 
 ### Trace ID vs. Span ID: Key Differences and Use Cases
 
@@ -185,12 +169,12 @@ Understanding the distinction between Trace ID and Span ID is essential for effi
 
 ### Key Differences:
 
-| Aspect | Trace ID | Span ID |
-| --- | --- | --- |
-| Scope | Represents the entire flow of a request across services. | Represents a single operation or unit of work within the trace. |
-| Persistence | Remains the same throughout the transaction. | Unique to each service or operation in the transaction. |
-| Use Case | Tracking a request’s journey through multiple services, identifying bottlenecks, and troubleshooting across the entire transaction. | Measuring the latency or performance of individual operations in a service. |
-| Visibility | Provides a high-level overview of the request path. | Provides detailed insights into the individual steps of the request. |
+| Aspect      | Trace ID                                                                                                                            | Span ID                                                                     |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| Scope       | Represents the entire flow of a request across services.                                                                            | Represents a single operation or unit of work within the trace.             |
+| Persistence | Remains the same throughout the transaction.                                                                                        | Unique to each service or operation in the transaction.                     |
+| Use Case    | Tracking a request’s journey through multiple services, identifying bottlenecks, and troubleshooting across the entire transaction. | Measuring the latency or performance of individual operations in a service. |
+| Visibility  | Provides a high-level overview of the request path.                                                                                 | Provides detailed insights into the individual steps of the request.        |
 
 ### Working Together:
 
@@ -209,83 +193,77 @@ OpenTelemetry is an open-source framework designed for observability, enabling t
 ### Step-by-Step Guide to Instrumenting Your Application with OpenTelemetry
 
 1. Set Up [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/):
-    - Start by installing the OpenTelemetry SDK for the relevant language. For instance, in JavaScript:
-        
-        ```bash
-        npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http
-        
-        ```
-        
+   - Start by installing the OpenTelemetry SDK for the relevant language. For instance, in JavaScript:
+
+     ```bash
+     npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http
+
+     ```
+
 2. Initialize the Tracer:
-    - Create and configure the tracer to capture traces. Example in JavaScript:
-        
-        ```jsx
-        const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-base');
-        const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base');
-        const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
-        
-        const provider = new NodeTracerProvider();
-        provider.addSpanProcessor(new SimpleSpanProcessor(new OTLPTraceExporter()));
-        provider.register();
-        ```
-        
+   - Create and configure the tracer to capture traces. Example in JavaScript:
+
+     ```jsx
+     const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-base')
+     const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base')
+     const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http')
+
+     const provider = new NodeTracerProvider()
+     provider.addSpanProcessor(new SimpleSpanProcessor(new OTLPTraceExporter()))
+     provider.register()
+     ```
+
 3. Create Traces and Spans:
-    - Create a trace by starting a root span. Each span represents a specific operation in the trace.
-        
-        ```jsx
-        const { trace } = require('@opentelemetry/api');
-        const tracer = trace.getTracer('example-tracer');
-        
-        const span = tracer.startSpan('example-span');
-        // Perform some operations here
-        span.end();
-        
-        ```
-        
+   - Create a trace by starting a root span. Each span represents a specific operation in the trace.
+
+     ```jsx
+     const { trace } = require('@opentelemetry/api')
+     const tracer = trace.getTracer('example-tracer')
+
+     const span = tracer.startSpan('example-span')
+     // Perform some operations here
+     span.end()
+     ```
+
 4. Add Attributes to Spans:
-    - Add custom attributes to spans for additional context.
-        
-        ```jsx
-        span.setAttribute('component', 'web-server');
-        span.setAttribute('status', 'success');
-        
-        ```
-        
+   - Add custom attributes to spans for additional context.
+     ```jsx
+     span.setAttribute('component', 'web-server')
+     span.setAttribute('status', 'success')
+     ```
 5. Export Traces:
-    - Export the trace data to a backend service, such as SigNoz, Jaeger, or Zipkin.
+   - Export the trace data to a backend service, such as SigNoz, Jaeger, or Zipkin.
 
 ### Best Practices for Generating and Propagating Trace and Span IDs
 
 - Unique Trace and Span IDs:
-    - Ensure that each trace and span has a unique identifier. This will allow traces to be grouped together across services.
-    - For instance, Trace ID can be generated using UUIDs and Span IDs can be sequential or based on the parent-child relationship.
+  - Ensure that each trace and span has a unique identifier. This will allow traces to be grouped together across services.
+  - For instance, Trace ID can be generated using UUIDs and Span IDs can be sequential or based on the parent-child relationship.
 - Propagate Context Across Boundaries:
-    - Use HTTP headers or messaging protocols to propagate Trace and Span IDs across different services. For HTTP, the `traceparent` header is commonly used.
-        
-        ```
-        GET /api/your-endpoint HTTP/1.1
-        Host: yourapi.example.com
-        User-Agent: YourApp/1.0
-        Accept: application/json
-        Authorization: Bearer your-api-keys
-        Content-Type: application/json
-        traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0b1a5b9a-01
-        tracestate: congo=t61rcWkgMzE
-        ```
-        
+  - Use HTTP headers or messaging protocols to propagate Trace and Span IDs across different services. For HTTP, the `traceparent` header is commonly used.
+    ```
+    GET /api/your-endpoint HTTP/1.1
+    Host: yourapi.example.com
+    User-Agent: YourApp/1.0
+    Accept: application/json
+    Authorization: Bearer your-api-keys
+    Content-Type: application/json
+    traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0b1a5b9a-01
+    tracestate: congo=t61rcWkgMzE
+    ```
 - Correlation of Trace and Span IDs:
-    - Maintain correlation by ensuring the trace and span context is passed along when making requests to other services. This is vital for tracing requests that span multiple services or microservices.
+  - Maintain correlation by ensuring the trace and span context is passed along when making requests to other services. This is vital for tracing requests that span multiple services or microservices.
 - Consistent Context Management:
-    - Use context management libraries available in OpenTelemetry to share trace context automatically across different operations and asynchronous tasks.
+  - Use context management libraries available in OpenTelemetry to share trace context automatically across different operations and asynchronous tasks.
 
 ### Ensuring Consistent Tracing Across Different Services and Languages
 
 - Standardized [Context Propagation](https://signoz.io/blog/opentelemetry-context-propagation/):
-    - OpenTelemetry provides a standard format for propagating trace context across different systems. By using this standard (like `traceparent` header), it is easy to propagate traces across services written in different languages.
+  - OpenTelemetry provides a standard format for propagating trace context across different systems. By using this standard (like `traceparent` header), it is easy to propagate traces across services written in different languages.
 - Instrument Multiple Services:
-    - Each service in a distributed system should be instrumented with OpenTelemetry to ensure consistent tracing. For example, a microservice written in Go can have its own OpenTelemetry setup, but the trace and span context is propagated using standard HTTP headers when interacting with a Java-based service.
+  - Each service in a distributed system should be instrumented with OpenTelemetry to ensure consistent tracing. For example, a microservice written in Go can have its own OpenTelemetry setup, but the trace and span context is propagated using standard HTTP headers when interacting with a Java-based service.
 - Unified Trace Management with SigNoz:
-    - Signoz can be used to collect, manage, and visualize trace data across multiple services, regardless of the programming language used. Integrating OpenTelemetry with Signoz allows trace data from different services to be aggregated into a single view for easy analysis.
+  - Signoz can be used to collect, manage, and visualize trace data across multiple services, regardless of the programming language used. Integrating OpenTelemetry with Signoz allows trace data from different services to be aggregated into a single view for easy analysis.
 
 ### Tools and Libraries for Simplifying Trace and Span ID Management
 
@@ -346,4 +324,4 @@ Yes, and it usually does. A single Trace ID will have multiple Span IDs, one for
 
 ### How long should I retain Trace and Span ID data?
 
-Retention periods depend on your specific needs and regulatory requirements. Generally, keeping trace data for 7-30 days is common. For debugging recent issues, shorter retention (like 7 days) might suffice. For longer-term analysis, you can keep data for a month or more.
\ No newline at end of file
+Retention periods depend on your specific needs and regulatory requirements. Generally, keeping trace data for 7-30 days is common. For debugging recent issues, shorter retention (like 7 days) might suffice. For longer-term analysis, you can keep data for a month or more.
diff --git a/data/comparisons/opentelemetry-trace-vs-span.mdx b/data/comparisons/opentelemetry-trace-vs-span.mdx
index 262dd091e..a068fc28c 100644
--- a/data/comparisons/opentelemetry-trace-vs-span.mdx
+++ b/data/comparisons/opentelemetry-trace-vs-span.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: OpenTelemetry - Understanding Traces vs. Spans
-slug: opentelemetry-trace-vs-span
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [soumya_gupta]
 description: Explore the differences between traces and spans in OpenTelemetry, their relationship, and how they enhance distributed system observability.
 keywords: [opentelemetry, traces, spans, distributed tracing, observability, sigNoz, monitoring]
-
 ---
 
 Distributed systems have become increasingly complex, making monitoring and troubleshooting performance issues challenging. OpenTelemetry emerges as a powerful solution to this problem, offering standardized observability for cloud-native applications. At the heart of OpenTelemetry's tracing capabilities lie two fundamental concepts: traces and spans. Understanding the distinction between these elements is crucial for developers and operations teams seeking to implement robust observability in their systems.
@@ -18,9 +16,13 @@ OpenTelemetry is an open-source observability framework designed to generate and
 
 OpenTelemetry consists of three key components:
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-Untitled.webp" alt="Three Pillars of Observability" caption="Three Pillars of Observability" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-Untitled.webp"
+  alt="Three Pillars of Observability"
+  caption="Three Pillars of Observability"
+/>
 
-1. Traces: Represent the journey of a request as it travels through the various components and services within a distributed system. Traces help identify performance bottlenecks, pinpoint the root causes of latency, and provide a holistic view of how services interact and respond under different conditions. 
+1. Traces: Represent the journey of a request as it travels through the various components and services within a distributed system. Traces help identify performance bottlenecks, pinpoint the root causes of latency, and provide a holistic view of how services interact and respond under different conditions.
 2. Metrics: Capture numerical measurements of system performance over time, including values like CPU usage, memory consumption, error rates, and request latency. Metrics are typically gathered in intervals and can be used to analyze trends, set alerts, and quickly assess the health and performance of services.
 3. Logs: Record discrete events within the system, capturing detailed information about what happened at specific times. Logs provide the granular details needed to understand why and how issues occur, supplementing traces and metrics with information about specific errors, exceptions, or unexpected behavior within each component.
 
@@ -38,7 +40,11 @@ The importance of OpenTelemetry lies in its ability to:
 
 In OpenTelemetry, a trace captures the complete journey of a request as it navigates through different components in a distributed system. It serves as a detailed map, outlining each step of the request’s lifecycle from entry to final response.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image.webp" alt="Visualizing Request Flows" caption="Visualizing Request Flows" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image.webp"
+  alt="Visualizing Request Flows"
+  caption="Visualizing Request Flows"
+/>
 
 OpenTelemetry Tracing is especially beneficial in microservices architectures, where applications consist of numerous independent services collaborating to handle user requests. In such architectures, traces are invaluable as a single user action can initiate a series of internal service calls. Tracing these requests enables you to:
 
@@ -51,33 +57,38 @@ OpenTelemetry Tracing is especially beneficial in microservices architectures, w
 To fully grasp the concept of traces, let's break down their key components:
 
 1. Start and End Timestamps: Every trace has a defined beginning and end, marking the duration of the entire operation.
-2. Trace Context: This is a set of globally unique identifiers that are propagated across service boundaries. It includes a Trace ID, Span ID and Trace Flags. Let’s take an example to understand this concept. 
-    
-     Imagine you're a user placing an order on an e-commerce site. You add items to your cart, proceed to checkout, and finalize the purchase. In the background, this entire flow is captured with tracing data, which helps developers monitor each part of the process for potential issues. Here’s how the flow goes:
-    
-    - Trace ID: The system then assigns a unique Trace ID, like `12345-abcde`, to track your order from start to finish. This ID links every step of your transaction, ensuring each part of the flow is associated with your specific order.
-    - Span ID: Each operation within this trace is tracked with a Span ID, a unique identifier for each step. For instance:
-        - Adding items to your cart has a Span ID (`span1`).
-        - Checking out has a different Span ID (`span2`).
-        - Processing the payment has yet another Span ID (`span3`).
-        
-        By linking each [Span ID](https://signoz.io/blog/distributed-tracing-span/) to the same Trace ID, systems like Loki can group related spans, providing a full view of your order journey.
-        
-    - Trace Flags: These flags contain additional metadata about your trace, like whether it was sampled for performance analysis or if an error occurred. For example, if your payment fails, Trace Flags might highlight an error in the payment span (`span3`), making it easy for developers to pinpoint and troubleshoot the issue.
-    
-    Using this approach, a developer can filter logs by the correlation ID (such as `correlation-id: 12345-abcde`) to see all log entries related to your specific order. This way, if a step in your order process encounters an error, Loki can quickly surface the problem by connecting each span back to the Trace ID.
-    
+2. Trace Context: This is a set of globally unique identifiers that are propagated across service boundaries. It includes a Trace ID, Span ID and Trace Flags. Let’s take an example to understand this concept.
+
+   Imagine you're a user placing an order on an e-commerce site. You add items to your cart, proceed to checkout, and finalize the purchase. In the background, this entire flow is captured with tracing data, which helps developers monitor each part of the process for potential issues. Here’s how the flow goes:
+   - Trace ID: The system then assigns a unique Trace ID, like `12345-abcde`, to track your order from start to finish. This ID links every step of your transaction, ensuring each part of the flow is associated with your specific order.
+   - Span ID: Each operation within this trace is tracked with a Span ID, a unique identifier for each step. For instance:
+     - Adding items to your cart has a Span ID (`span1`).
+     - Checking out has a different Span ID (`span2`).
+     - Processing the payment has yet another Span ID (`span3`).
+       By linking each [Span ID](https://signoz.io/blog/distributed-tracing-span/) to the same Trace ID, systems like Loki can group related spans, providing a full view of your order journey.
+   - Trace Flags: These flags contain additional metadata about your trace, like whether it was sampled for performance analysis or if an error occurred. For example, if your payment fails, Trace Flags might highlight an error in the payment span (`span3`), making it easy for developers to pinpoint and troubleshoot the issue.
+
+   Using this approach, a developer can filter logs by the correlation ID (such as `correlation-id: 12345-abcde`) to see all log entries related to your specific order. This way, if a step in your order process encounters an error, Loki can quickly surface the problem by connecting each span back to the Trace ID.
+
 3. Trace Propagation: The mechanism by which trace context is passed between different services or components. This ensures that all parts of a distributed operation are connected under the same trace.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%201.webp" alt="Trace Propagation Flow" caption="Trace Propagation Flow" />
-    
-    In our example, once you placed the order, the frontend service assigned a unique Trace ID to represent your entire transaction. This ID traveled with your request to the backend Order Service, which processed it and handed it off to the Payment and Authentication services, each retaining and logging the Trace ID. By consistently passing the Trace ID across all these services, developers can follow the transaction end-to-end, easily identifying any issues (such as payment failure) by filtering logs with the shared Trace ID and viewing each service’s actions within the context of the complete order process.
-    
+
+   <Figure
+     src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%201.webp"
+     alt="Trace Propagation Flow"
+     caption="Trace Propagation Flow"
+   />
+
+   In our example, once you placed the order, the frontend service assigned a unique Trace ID to represent your entire transaction. This ID traveled with your request to the backend Order Service, which processed it and handed it off to the Payment and Authentication services, each retaining and logging the Trace ID. By consistently passing the Trace ID across all these services, developers can follow the transaction end-to-end, easily identifying any issues (such as payment failure) by filtering logs with the shared Trace ID and viewing each service’s actions within the context of the complete order process.
+
 4. Span Hierarchy: This describes the connections between spans in a trace, typically organized in a tree structure. In OpenTelemetry, spans define causal relationships, allowing a trace to be viewed as a directed acyclic graph (DAG) of spans, where parent-child relationships are represented as edges. A trace includes multiple spans, with the root span representing the overall operation and child spans indicating sub-operations or service calls. As a request flows through a service, the trace context is propagated via trace headers, enabling downstream services to join the trace. Each service generates its own span, updating the trace context with its operation's duration and relevant metadata.
 
 Here's a simplified example of how a trace might look in a microservices environment:
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%202.webp" alt="Trace in a Microservice environment" caption="Trace in a Microservice environment" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%202.webp"
+  alt="Trace in a Microservice environment"
+  caption="Trace in a Microservice environment"
+/>
 
 This structure allows you to see not just the overall duration of the login process, but also the time taken by each sub-operation and their relationships.
 
@@ -128,15 +139,15 @@ A Span can link to multiple related Spans through `SpanContext`, across the same
 
 Each span has a status, which can be one of three values:
 
-| Status | Explanation |
-| --- | --- |
-| `Unset` | It is the default status, indicating that the tracked operation completed successfully without errors. |
-| `Error` | It signifies that an error occurred during the tracked operation, such as an HTTP 500 error on a server. |
-| `Ok` | It means the span has been explicitly marked as error-free by the developer. While it may seem counterintuitive, it is not necessary to set a span status to Ok if it has completed without error, as this is covered by Unset. The Ok status serves to provide a clear "final call" on the span's status, ensuring that it is interpreted as "successful.” |
+| Status  | Explanation                                                                                                                                                                                                                                                                                                                                                 |
+| ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Unset` | It is the default status, indicating that the tracked operation completed successfully without errors.                                                                                                                                                                                                                                                      |
+| `Error` | It signifies that an error occurred during the tracked operation, such as an HTTP 500 error on a server.                                                                                                                                                                                                                                                    |
+| `Ok`    | It means the span has been explicitly marked as error-free by the developer. While it may seem counterintuitive, it is not necessary to set a span status to Ok if it has completed without error, as this is covered by Unset. The Ok status serves to provide a clear "final call" on the span's status, ensuring that it is interpreted as "successful.” |
 
 ## Span Operations
 
-Let’s take a look at various span operations: 
+Let’s take a look at various span operations:
 
 - HTTP requests: Spans can represent individual HTTP requests within an application, capturing the start and end times, request and response details, status codes, and latency. By tracking HTTP spans, you can see how long requests take, whether they encounter errors, and which endpoints are performing optimally. This helps identify bottlenecks and optimize the flow of requests through your system.
 - Database queries: Spans are useful for tracing database queries, recording the time taken for each query execution, the type of query (e.g., `SELECT`, `INSERT`), and any error messages. By observing these spans, you can find slow or inefficient queries, analyze database performance, and optimize data access patterns to reduce latency and improve overall application performance.
@@ -158,7 +169,7 @@ pip install Flask opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otl
 Let’s take a basic example in Python:
 
 ```python
- 
+
 from flask import Flask
 from opentelemetry import trace
 from opentelemetry.sdk.resources import Resource
@@ -174,7 +185,7 @@ tracer = trace.get_tracer(__name__)
 # Configure OTLP exporter for tracing with SigNoz
 span_exporter = OTLPSpanExporter(
     endpoint="https://ingest.in.signoz.cloud:443",
-    headers=(("authorization", "Bearer INSERT_TOKEN_HERE"),)   
+    headers=(("authorization", "Bearer INSERT_TOKEN_HERE"),)
     # Replace with your token
 ) span_processor = BatchSpanProcessor(span_exporter)
 trace.get_tracer_provider().add_span_processor(span_processor)
@@ -198,22 +209,27 @@ if __name__ == "__main__":
     app.run(debug=True)
 ```
 
-After accessing the endpoint at `127.0.0.1:5000`, the message "Tracing complete!" will appear on the site. You can now visit SigNoz to review the traces that have been received. 
+After accessing the endpoint at `127.0.0.1:5000`, the message "Tracing complete!" will appear on the site. You can now visit SigNoz to review the traces that have been received.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%203.webp" alt="SigNoz Traces Dashboard" caption="SigNoz Traces Dashboard" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%203.webp"
+  alt="SigNoz Traces Dashboard"
+  caption="SigNoz Traces Dashboard"
+/>
 
 ## Traces vs. Spans: Understanding the Relationship
 
 Now that we've explored traces and spans individually, let's clarify their relationship:
 
-| Concept | Relationship |
-| --- | --- |
+| Concept                       | Relationship                                                                                                                                                          |
+| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Hierarchy of Spans in a Trace | Spans form a parent-child hierarchy, showing operation order and dependencies. The parent span represents a main operation, while child spans capture sub-operations. |
-| Root Span | The root span is the trace's top-level span, representing the initial request (e.g., a frontend HTTP request) and sets contexts for all other spans. |
-| Child Spans | Represent specific actions within the parent operation, breaking down the workflow into detailed steps that contribute to the main request. |
-| Trace as a Tree | A trace resembles a tree: the trace itself is the full tree, and each span acts as a node within this tree. |
-| Nodes and Branches | Each node in the tree is a span, with the root node as the root span. Branches represent the relationships between parent and child spans. |
-| Benefits of Trace Structure | 1. Operation Flow: Visualize the path and dependencies within a request.
+| Root Span                     | The root span is the trace's top-level span, representing the initial request (e.g., a frontend HTTP request) and sets contexts for all other spans.                  |
+| Child Spans                   | Represent specific actions within the parent operation, breaking down the workflow into detailed steps that contribute to the main request.                           |
+| Trace as a Tree               | A trace resembles a tree: the trace itself is the full tree, and each span acts as a node within this tree.                                                           |
+| Nodes and Branches            | Each node in the tree is a span, with the root node as the root span. Branches represent the relationships between parent and child spans.                            |
+| Benefits of Trace Structure   | 1. Operation Flow: Visualize the path and dependencies within a request.                                                                                              |
+
 2. Latency Insight: Identify spans with high latency to target optimizations.
 3. Error Tracking: Trace errors in spans to see how they impact related operations. |
 
@@ -261,7 +277,11 @@ This example creates a simple trace with one span, adds an attribute and an even
 
 While OpenTelemetry provides the instrumentation, you need a robust backend system to analyze and visualize your trace data. SigNoz is an open-source, full-stack observability platform that seamlessly integrates with OpenTelemetry.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%204.webp" alt="SigNoz Trace Dashboard" caption="SigNoz Trace Dashboard" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-trace-vs-span-image%204.webp"
+  alt="SigNoz Trace Dashboard"
+  caption="SigNoz Trace Dashboard"
+/>
 
 SigNoz offers several advantages for OpenTelemetry trace analysis:
 
@@ -279,14 +299,12 @@ SigNoz’s combination of visualization, filtering, insights, anomaly detection,
 
 Adhering to best practices in trace and span implementation is crucial for effective observability with OpenTelemetry; let’s dive into the recommended approaches for optimizing trace accuracy and span utility for actionable insights.
 
-| Trace | Span |
-| --- | --- |
-| Right Level of Granularity: Maintain a balance in span detail to avoid overloading your traces with minor operations while still capturing critical actions. Focus on spans that highlight key performance metrics and potential bottlenecks. | Attributes: Add relevant attributes to provide context. For example, in an HTTP request span, include the URL, method, and response status code. These attributes help to enrich the trace data and enable better understanding and troubleshooting of the requests. |
-| Handle High-Cardinality Data: High-cardinality attributes, like user IDs, can increase storage and processing demands. Use sampling to manage data volume and prioritize capturing traces with errors or unusual latency. | Scope Management: Be mindful of span lifetimes and ensure they're closed properly to avoid leaks. Properly managing the start and end of spans prevents resource exhaustion and ensures accurate representation of the time taken for operations. |
-| Propagate Context Correctly: Ensure trace context flows across all services and asynchronous tasks to keep the trace intact. This provides a complete view of request dependencies and execution flow. | Events: Use events to mark significant occurrences within a span's lifetime. Events allow you to capture specific milestones or important actions, such as when a request was received or when a processing step was completed, providing valuable insights during debugging and analysis. |
-| Balance Performance Impact: Tracing can add overhead, so monitor and adjust data collection to avoid performance degradation. Focus tracing on essential transactions or error scenarios in high-performance environments. | Error Handling: Set the appropriate status on spans, especially when errors occur. This includes marking spans as `ERROR` when an exception is thrown, which helps in quickly identifying failure points and understanding the overall health of the system. |
-
-  
+| Trace                                                                                                                                                                                                                                         | Span                                                                                                                                                                                                                                                                                       |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Right Level of Granularity: Maintain a balance in span detail to avoid overloading your traces with minor operations while still capturing critical actions. Focus on spans that highlight key performance metrics and potential bottlenecks. | Attributes: Add relevant attributes to provide context. For example, in an HTTP request span, include the URL, method, and response status code. These attributes help to enrich the trace data and enable better understanding and troubleshooting of the requests.                       |
+| Handle High-Cardinality Data: High-cardinality attributes, like user IDs, can increase storage and processing demands. Use sampling to manage data volume and prioritize capturing traces with errors or unusual latency.                     | Scope Management: Be mindful of span lifetimes and ensure they're closed properly to avoid leaks. Properly managing the start and end of spans prevents resource exhaustion and ensures accurate representation of the time taken for operations.                                          |
+| Propagate Context Correctly: Ensure trace context flows across all services and asynchronous tasks to keep the trace intact. This provides a complete view of request dependencies and execution flow.                                        | Events: Use events to mark significant occurrences within a span's lifetime. Events allow you to capture specific milestones or important actions, such as when a request was received or when a processing step was completed, providing valuable insights during debugging and analysis. |
+| Balance Performance Impact: Tracing can add overhead, so monitor and adjust data collection to avoid performance degradation. Focus tracing on essential transactions or error scenarios in high-performance environments.                    | Error Handling: Set the appropriate status on spans, especially when errors occur. This includes marking spans as `ERROR` when an exception is thrown, which helps in quickly identifying failure points and understanding the overall health of the system.                               |
 
 ## Key Takeaways
 
@@ -318,4 +336,4 @@ Common challenges include:
 - Managing the volume of trace data in high-traffic systems
 - Balancing the performance impact of tracing with its benefits
 - Standardizing span naming and attribute conventions across teams
-- Correlating trace data with other observability signals like logs and metrics
\ No newline at end of file
+- Correlating trace data with other observability signals like logs and metrics
diff --git a/data/comparisons/opentelemetry-traces-vs-metrics.mdx b/data/comparisons/opentelemetry-traces-vs-metrics.mdx
index 47cdf1bdd..451273d4b 100644
--- a/data/comparisons/opentelemetry-traces-vs-metrics.mdx
+++ b/data/comparisons/opentelemetry-traces-vs-metrics.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry - Comparing Traces vs Metrics for Monitoring
-slug: opentelemetry-traces-vs-metrics
+
 date: 2024-11-20
 tags: [OpenTelemetry]
 authors: [ayush_srivastava]
 description: Explore the differences between OpenTelemetry traces and metrics for effective system monitoring. Learn when to use each and how they complement each other.
-keywords: [OpenTelemetry, traces, metrics, monitoring, observability, distributed systems, performance analysis]
-
+keywords:
+  [
+    OpenTelemetry,
+    traces,
+    metrics,
+    monitoring,
+    observability,
+    distributed systems,
+    performance analysis,
+  ]
 ---
 
 Effective monitoring is key to keeping applications running smoothly. OpenTelemetry is a powerful framework that helps you collect important telemetry data. Traces and metrics are two critical components of this framework, each offering unique insights into your application’s performance. In this article, we’ll explore the differences between traces and metrics, their use cases, and how to leverage both to improve your observability strategy.
@@ -24,7 +31,7 @@ OpenTelemetry consists of several key components that work together to enable ef
 
 - APIs: APIs define the standard interfaces and data models for telemetry collection. They ensure that developers can instrument their applications consistently, regardless of the underlying implementation or backend system.
 - SDKs: Software Development Kits (SDKs) implement the APIs and offer additional functionality for capturing and managing telemetry data.
-- Collectors: The Collectors act as an intermediary layer between instrumented applications and observability backends.  These components are responsible for gathering, processing, and forwarding telemetry data to various storage and analysis tools.
+- Collectors: The Collectors act as an intermediary layer between instrumented applications and observability backends. These components are responsible for gathering, processing, and forwarding telemetry data to various storage and analysis tools.
 
 ### Importance in Modern Distributed Systems Monitoring
 
@@ -70,15 +77,15 @@ The following concepts are fundamental to leveraging tracing effectively within
 
 Span Creation and Management
 
-Span creation and management are foundational to OpenTelemetry tracing. A *span* is created by using the OpenTelemetry API, which allows developers to instrument their code easily. When a request is initiated, a new span is generated, capturing the start time, and when the operation is completed, the span records the end time. Developers can add attributes (metadata) to spans, providing context about the operation being traced, and they can nest spans to represent parent-child relationships in distributed systems. 
+Span creation and management are foundational to OpenTelemetry tracing. A _span_ is created by using the OpenTelemetry API, which allows developers to instrument their code easily. When a request is initiated, a new span is generated, capturing the start time, and when the operation is completed, the span records the end time. Developers can add attributes (metadata) to spans, providing context about the operation being traced, and they can nest spans to represent parent-child relationships in distributed systems.
 
 Context Propagation Across Service Boundaries
 
-[Context propagation](https://signoz.io/blog/opentelemetry-context-propagation/) is another critical concept, ensuring that trace data is transmitted from one service to another as a request navigates through a distributed system. This process links multiple services within a single trace by carrying trace IDs across different types of calls, such as HTTP requests or gRPC calls. 
+[Context propagation](https://signoz.io/blog/opentelemetry-context-propagation/) is another critical concept, ensuring that trace data is transmitted from one service to another as a request navigates through a distributed system. This process links multiple services within a single trace by carrying trace IDs across different types of calls, such as HTTP requests or gRPC calls.
 
 Sampling Strategies for Trace Data
 
-Tracing all requests in high-traffic systems can be resource-intensive. Sampling strategies play a significant role in managing the volume of trace data collected, enabling developers to control which requests are traced. Common strategies include *Always On*, where every request is traced (often useful for testing but impractical in production), *Probabilistic Sampling*, which traces a defined percentage of requests (e.g., 10%) to reduce overhead, and *Tail-based Sampling*, where sampling decisions are made after the request completes, allowing for the capture of slow or error-prone requests.
+Tracing all requests in high-traffic systems can be resource-intensive. Sampling strategies play a significant role in managing the volume of trace data collected, enabling developers to control which requests are traced. Common strategies include _Always On_, where every request is traced (often useful for testing but impractical in production), _Probabilistic Sampling_, which traces a defined percentage of requests (e.g., 10%) to reduce overhead, and _Tail-based Sampling_, where sampling decisions are made after the request completes, allowing for the capture of slow or error-prone requests.
 
 Correlation with Logs and Metrics
 
@@ -93,11 +100,11 @@ Types of Metrics
 OpenTelemetry provides several types of metrics, each serving a specific purpose in monitoring application and system health.
 
 1. Counters: Increment-only values that track the number of occurrences of an event (e.g., HTTP requests).
-    - Example: Counting the total number of API requests received by a service.
+   - Example: Counting the total number of API requests received by a service.
 2. Gauges: Measure a value that can go up or down, representing a point-in-time snapshot (e.g., memory usage).
-    - Example: Monitoring the current number of active database connections.
+   - Example: Monitoring the current number of active database connections.
 3. Histograms: Track the distribution of values over time, providing insights into variations (e.g., response times).
-    - Example: Recording the distribution of API response times to understand performance under different loads.
+   - Example: Recording the distribution of API response times to understand performance under different loads.
 
 Benefits of Using Metrics
 
@@ -112,11 +119,11 @@ Common Use Cases for Metrics
 Metrics are widely used across various aspects of system monitoring, offering critical insights into applications, infrastructure, and service levels.
 
 - Application Monitoring: Metrics provide insight into application performance by tracking request rates, error rates, and response times.
-Example: Using a counter metric to track how many requests return a 500 error in a given time frame.
+  Example: Using a counter metric to track how many requests return a 500 error in a given time frame.
 - [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/): Metrics help monitor server and network health, including resource utilization like CPU, memory, and disk I/O.
-Example: Gauging memory usage across servers to predict capacity needs.
+  Example: Gauging memory usage across servers to predict capacity needs.
 - Service Level Objectives (SLOs): Metrics are often used to measure and maintain SLOs by tracking uptime and response times.
-Example: Ensuring that 99% of API requests respond within 200 ms to meet the service level agreement (SLA).
+  Example: Ensuring that 99% of API requests respond within 200 ms to meet the service level agreement (SLA).
 
 ### OpenTelemetry Metric Instruments
 
@@ -128,23 +135,21 @@ The Meter Provider and Meter are foundational elements in OpenTelemetry’s metr
 
 - The Meter Provider is responsible for managing Meters, which are used to create and define metric instruments.
 - A Meter is your entry point for creating metrics in your application. In a web application, you could use a Meter to define a counter to track the total number of HTTP requests.
-    
-    Example: In this snippet, a meter is created with the module name, allowing you to define metrics like counters and gauges within this meter.
-    
-    ```python
-    from opentelemetry import metrics
-    
-    # Get the global MeterProvider
-    meter_provider = metrics.get_meter_provider()
-    
-    # Create a named Meter instance
-    meter = meter_provider.get_meter(
-        name="my_service",
-        version="0.1.0",
-        schema_url="https://opentelemetry.io/schemas/1.9.0"
-    )
-    ```
-    
+  Example: In this snippet, a meter is created with the module name, allowing you to define metrics like counters and gauges within this meter.
+
+  ```python
+  from opentelemetry import metrics
+
+  # Get the global MeterProvider
+  meter_provider = metrics.get_meter_provider()
+
+  # Create a named Meter instance
+  meter = meter_provider.get_meter(
+      name="my_service",
+      version="0.1.0",
+      schema_url="https://opentelemetry.io/schemas/1.9.0"
+  )
+  ```
 
 Metric Data Collection and Aggregation
 
@@ -163,7 +168,7 @@ Aggregation reduces the volume of data while still providing valuable insights i
 
 Views and Customization of Metric Data
 
-Views allow for the customization of metrics, letting you control what data is aggregated and how it’s represented to suit your needs. For example, you can configure a view to track request counts per HTTP method (GET, POST) instead of the total number of requests. 
+Views allow for the customization of metrics, letting you control what data is aggregated and how it’s represented to suit your needs. For example, you can configure a view to track request counts per HTTP method (GET, POST) instead of the total number of requests.
 
 Customization enables more granular or specific insights, tailored to the system’s needs.
 
@@ -177,25 +182,21 @@ Exporters can be configured to send data in intervals, ensuring minimal impact o
 
 Below is an overview table highlighting the key differences between traces and metrics:
 
-| Aspect | Traces | Metrics |
-| --- | --- | --- |
-| Granularity | Captures details of individual requests (e.g., start/end time, specific errors) | Aggregated data over time (e.g., CPU usage, request rates) |
-| Time Scope | Ideal for short-term debugging and investigating specific issues | Useful for long-term performance monitoring and identifying trends |
-| Resource Usage | Higher storage and processing requirements due to the detailed nature of each request | Lower resource usage since data is aggregated into summaries (e.g., averages, sums) |
-| Use Cases | Use for tracing specific user journeys, pinpointing bottlenecks in distributed systems | Use for monitoring resource utilization, setting alerts, and tracking long-term performance metrics |
+| Aspect         | Traces                                                                                 | Metrics                                                                                             |
+| -------------- | -------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Granularity    | Captures details of individual requests (e.g., start/end time, specific errors)        | Aggregated data over time (e.g., CPU usage, request rates)                                          |
+| Time Scope     | Ideal for short-term debugging and investigating specific issues                       | Useful for long-term performance monitoring and identifying trends                                  |
+| Resource Usage | Higher storage and processing requirements due to the detailed nature of each request  | Lower resource usage since data is aggregated into summaries (e.g., averages, sums)                 |
+| Use Cases      | Use for tracing specific user journeys, pinpointing bottlenecks in distributed systems | Use for monitoring resource utilization, setting alerts, and tracking long-term performance metrics |
 
 Now lets take a look at them in detail.
 
 ### Granularity: Individual Requests vs. Aggregated Data
 
 - Traces: Focus on individual requests or transactions as they propagate through different services. They provide detailed context, such as timing, error information, and service interactions.
-    
-    Example: A single user’s request journey across a microservices architecture.
-    
+  Example: A single user’s request journey across a microservices architecture.
 - Metrics: Represent aggregated data over time. They include numerical measurements like request counts, error rates, or memory usage.
-    
-    Example: Average response time of a service over a 5-minute interval.
-    
+  Example: Average response time of a service over a 5-minute interval.
 
 ### Time Scope: Short-Term Debugging vs. Long-Term Trends
 
@@ -217,80 +218,64 @@ Metrics, on the other hand, are ideal for monitoring overall system health and p
 
 Traces and metrics, while serving distinct purposes, complement each other to provide a holistic view of system performance and behavior. Together, they enable effective observability in modern applications.
 
-- How Traces and Metrics Work Together: Metrics provide a high-level overview of system performance, while traces offer detailed, request-level insights. Together, they give a complete view of your system’s health—metrics highlight *what* is happening, and traces help you understand *why* it's happening.
+- How Traces and Metrics Work Together: Metrics provide a high-level overview of system performance, while traces offer detailed, request-level insights. Together, they give a complete view of your system’s health—metrics highlight _what_ is happening, and traces help you understand _why_ it's happening.
 - Correlating Trace Data with Metric Anomalies: When a metric shows an anomaly (e.g., a spike in response time), traces can be used to drill down and identify the root cause.
-    
-    Example: A sudden increase in [API latency](https://signoz.io/guides/open-ai-api-latency/) could lead you to inspect the traces of specific requests to identify slow database queries or network issues.
-    
+  Example: A sudden increase in [API latency](https://signoz.io/guides/open-ai-api-latency/) could lead you to inspect the traces of specific requests to identify slow database queries or network issues.
 - Using Metrics to Identify Areas for Trace Investigation: Metrics act as an early warning system by revealing performance issues, allowing you to focus trace investigations on problem areas.
-    
-    Example: If a CPU utilization metric consistently exceeds a threshold, you can trace requests during that period to understand which processes or services are responsible.
-    
+  Example: If a CPU utilization metric consistently exceeds a threshold, you can trace requests during that period to understand which processes or services are responsible.
 - Balancing Trace and Metric Collection for Optimal Performance: Collecting every trace can be resource-intensive. Metrics provide a lightweight way to monitor general health, while traces can be selectively sampled for in-depth analysis. Combining both approaches helps balance observability performance and resource usage, ensuring visibility without overwhelming storage or processing capacity.
-    
-    Example: Use metrics for real-time monitoring and alerting, while tracing only a percentage of requests to capture detailed insights for critical or anomalous operations.
-    
+  Example: Use metrics for real-time monitoring and alerting, while tracing only a percentage of requests to capture detailed insights for critical or anomalous operations.
 
 ## Implementing OpenTelemetry Traces and Metrics
 
 Implementing OpenTelemetry involves integrating its components into your application to collect, process, and export observability data effectively. Below are the key steps to get started:
 
 - Install the OpenTelemetry SDK:
-    
-    Start by installing the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) and necessary instrumentation libraries for your programming language.
-    
+  Start by installing the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) and necessary instrumentation libraries for your programming language.
 - Instrument Your Code:
-    
-    For traces, create and manage spans to track the flow of requests across services. Use metrics instruments like counters, gauges, and histograms to collect data. Example in Python:
-    
-    ```python
-    from opentelemetry import trace, metrics
-    from opentelemetry.sdk.trace import TracerProvider
-    from opentelemetry.sdk.metrics import MeterProvider
-    
-    # Set up tracing
-    trace.set_tracer_provider(TracerProvider())
-    tracer = trace.get_tracer(__name__)
-    
-    # Set up metrics
-    metrics.set_meter_provider(MeterProvider())
-    meter = metrics.get_meter(__name__)
-    
-    # Use tracing and metrics in your code
-    with tracer.start_as_current_span("my_span"):
-        counter = meter.create_counter("my_counter")
-        counter.add(1)
-    ```
-    
-    The tracer tracks spans (units of work) in your application, while the meter captures metrics like counters to monitor key performance indicators.
-    
+  For traces, create and manage spans to track the flow of requests across services. Use metrics instruments like counters, gauges, and histograms to collect data. Example in Python:
+
+  ```python
+  from opentelemetry import trace, metrics
+  from opentelemetry.sdk.trace import TracerProvider
+  from opentelemetry.sdk.metrics import MeterProvider
+
+  # Set up tracing
+  trace.set_tracer_provider(TracerProvider())
+  tracer = trace.get_tracer(__name__)
+
+  # Set up metrics
+  metrics.set_meter_provider(MeterProvider())
+  meter = metrics.get_meter(__name__)
+
+  # Use tracing and metrics in your code
+  with tracer.start_as_current_span("my_span"):
+      counter = meter.create_counter("my_counter")
+      counter.add(1)
+  ```
+
+  The tracer tracks spans (units of work) in your application, while the meter captures metrics like counters to monitor key performance indicators.
+
 - Configure the OpenTelemetry Collector
-    
-    The OpenTelemetry Collector allows you to receive, process, and export traces and metrics to various backends (e.g., Prometheus, Jaeger). 
-    
-    - Installation:
-        
-        Download and install the OpenTelemetry Collector binary or container image.
-        
-    - Configuration: Create a `config.yaml` file for the collector specifying receivers (e.g., OTLP), processors (e.g., batching), and exporters (e.g., to Prometheus or Jaeger).
-        
-        Example:
-        
-        ```yaml
-        receivers:
-          otlp:
-            protocols:
-              grpc:
-        exporters:
-          prometheus:
-            endpoint: "0.0.0.0:9090"
-        service:
-          pipelines:
-            metrics:
-              receivers: [otlp]
-              exporters: [prometheus]
-        ```
-        
+  The OpenTelemetry Collector allows you to receive, process, and export traces and metrics to various backends (e.g., Prometheus, Jaeger).
+  - Installation:
+    Download and install the OpenTelemetry Collector binary or container image.
+  - Configuration: Create a `config.yaml` file for the collector specifying receivers (e.g., OTLP), processors (e.g., batching), and exporters (e.g., to Prometheus or Jaeger).
+    Example:
+    ```yaml
+    receivers:
+      otlp:
+        protocols:
+          grpc:
+    exporters:
+      prometheus:
+        endpoint: '0.0.0.0:9090'
+    service:
+      pipelines:
+        metrics:
+          receivers: [otlp]
+          exporters: [prometheus]
+    ```
 
 ### Best Practices for Data Sampling and Filtering
 
@@ -313,7 +298,7 @@ Converting traces into metrics offers several advantages:
 
 ### Using the OpenTelemetry Collector for Trace-to-Metric Transformation
 
-The [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) includes a `span metrics connector` to extract metrics from spans in trace data. This allows automatic derivation of metrics like latency distributions, error rates, and request counts. 
+The [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) includes a `span metrics connector` to extract metrics from spans in trace data. This allows automatic derivation of metrics like latency distributions, error rates, and request counts.
 
 The OpenTelemetry Collector supports trace-to-metric transformation by aggregating spans (from traces) into metric data points. This enables you to derive valuable metrics like request count, latency distribution, and error rate from trace spans.
 
@@ -321,7 +306,7 @@ The OpenTelemetry Collector supports trace-to-metric transformation by aggregati
 
 Configuring the OpenTelemetry Collector’s span metrics connector is essential for generating metrics from trace data. This example shows how to set it up for common metrics like latency histograms and error rates.
 
-You can configure the OpenTelemetry Collector to transform spans into metrics using the *spanmetrics* processor. Example:
+You can configure the OpenTelemetry Collector to transform spans into metrics using the _spanmetrics_ processor. Example:
 
 ```yaml
 receivers:
@@ -337,7 +322,7 @@ processors:
 
 exporters:
   prometheus:
-    endpoint: "0.0.0.0:9090"
+    endpoint: '0.0.0.0:9090'
 
 service:
   pipelines:
@@ -405,4 +390,4 @@ Yes, using both traces and metrics together enhances observability. Traces provi
 
 ### What are the performance implications of collecting both traces and metrics?
 
-Collecting both traces and metrics can introduce some overhead, as both require processing and storage. However, with proper sampling strategies and configurations in place, the impact can be minimized. Balancing data collection with resource usage is crucial to maintaining application performance.
\ No newline at end of file
+Collecting both traces and metrics can introduce some overhead, as both require processing and storage. However, with proper sampling strategies and configurations in place, the impact can be minimized. Balancing data collection with resource usage is crucial to maintaining application performance.
diff --git a/data/comparisons/opentelemetry-vs-apm.mdx b/data/comparisons/opentelemetry-vs-apm.mdx
index 07c037f56..fedfb90b0 100644
--- a/data/comparisons/opentelemetry-vs-apm.mdx
+++ b/data/comparisons/opentelemetry-vs-apm.mdx
@@ -1,23 +1,23 @@
 ---
-
 title: OpenTelemetry vs APM - Which Monitoring Approach Wins?
-slug: opentelemetry-vs-apm
+
 date: 2025-01-22
 tags: [OpenTelemetry]
 authors: [manjunath_irukulla]
 description: Explore the key differences between OpenTelemetry and APM, their strengths, and how to choose the right monitoring approach for your needs.
-keywords: [opentelemetry, apm, monitoring, observability, performance, comparison, signoz, cloud native]
-
+keywords:
+  [opentelemetry, apm, monitoring, observability, performance, comparison, signoz, cloud native]
 ---
+
 OpenTelemetry and Application Performance Monitoring (APM) are two leading approaches to monitoring modern software systems. While they serve similar goals, they have distinct characteristics and use cases.
 
 This article compares OpenTelemetry and APM head-to-head, examining their key differences and helping you determine which solution best fits your monitoring needs.
 
 ## What is OpenTelemetry and How Does it Differ from APM?
 
-OpenTelemetry is an open-source observability framework designed to provide a standardised method of collecting and exporting telemetry data from applications and infrastructure. It creates a unified set of APIs, libraries, agents, and instrumentation to capture [distributed traces](https://signoz.io/blog/distributed-tracing/), metrics, and logs across cloud-native, microservices-based environments. 
+OpenTelemetry is an open-source observability framework designed to provide a standardised method of collecting and exporting telemetry data from applications and infrastructure. It creates a unified set of APIs, libraries, agents, and instrumentation to capture [distributed traces](https://signoz.io/blog/distributed-tracing/), metrics, and logs across cloud-native, microservices-based environments.
 
-On the other hand, APM (Application Performance Monitoring) is a monitoring solution focused on tracking and optimizing software performance, user experience, and business transactions. APM tools offer end-to-end visibility into the health and responsiveness of applications, often providing out-of-the-box monitoring solutions. 
+On the other hand, APM (Application Performance Monitoring) is a monitoring solution focused on tracking and optimizing software performance, user experience, and business transactions. APM tools offer end-to-end visibility into the health and responsiveness of applications, often providing out-of-the-box monitoring solutions.
 
 ### How They Complement Each Other
 
@@ -26,9 +26,13 @@ On the other hand, APM (Application Performance Monitoring) is a monitoring solu
 
 ## Why OpenTelemetry is Gaining Traction in the Monitoring Landscape
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-apm-3ab1918c-ba6c-4dd8-8128-fe0e194f5f06.webp" alt="Key Benefits of OpenTelemetry" caption="Key Benefits of OpenTelemetry" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-apm-3ab1918c-ba6c-4dd8-8128-fe0e194f5f06.webp"
+  alt="Key Benefits of OpenTelemetry"
+  caption="Key Benefits of OpenTelemetry"
+/>
 
-OpenTelemetry's popularity is growing rapidly, driven by several key factors: 
+OpenTelemetry's popularity is growing rapidly, driven by several key factors:
 
 - **Open-Source and Vendor-Neutral**: OpenTelemetry’s open-source, community-driven nature ensures organizations are not tied to any specific vendor, granting the flexibility to choose the most suitable tools and platforms for their unique requirements. This vendor-neutral approach promotes broader adoption and innovation.
 - **Flexibility and Modularity**: OpenTelemetry’s modular design allows for seamless integration across diverse environments and systems, providing the freedom to customize data collection as per application needs. This flexibility ensures that it can be tailored to suit both simple and complex infrastructure.
@@ -39,32 +43,40 @@ OpenTelemetry's popularity is growing rapidly, driven by several key factors:
 
 ## How APM Solutions are Evolving in Response to OpenTelemetry
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-apm-ca96f4df-51c6-4a57-93e4-6c6d7a9485d3.webp" alt="Evolution of APM in Response to OpenTelemetry" caption="Evolution of APM in Response to OpenTelemetry" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-apm-ca96f4df-51c6-4a57-93e4-6c6d7a9485d3.webp"
+  alt="Evolution of APM in Response to OpenTelemetry"
+  caption="Evolution of APM in Response to OpenTelemetry"
+/>
 
-APM vendors are recognizing the advantages of OpenTelemetry and adapting to remain competitive. Here’s how they are responding: 
+APM vendors are recognizing the advantages of OpenTelemetry and adapting to remain competitive. Here’s how they are responding:
 
-1. **Seamless Integration with OpenTelemetry**: Recognizing the growing influence of OpenTelemetry, many traditional APM vendors are adapting by offering built-in support for OpenTelemetry. 
-    - This allows organizations to combine OpenTelemetry’s flexible telemetry data collection with the advanced analytics provided by [APM tools](https://signoz.io/blog/open-source-apm-tools/), maximizing the strengths of both approaches.
-2. **Embracing Open Data Collection Methods**: To stay competitive, APM vendors are shifting toward more open and flexible data collection methodologies, aligning their capabilities with the flexibility that OpenTelemetry offers. 
-    - This move enables organizations to gather data from a broader range of environments without being restricted to proprietary systems.
-3. **Advanced Data Visualization**: APM solutions are placing greater emphasis on their data analysis and visualization features, integrating cutting-edge tools such as machine learning and AI-driven insights. 
-    - This helps users make sense of complex datasets and detect performance trends more effectively, offering a competitive edge in monitoring and troubleshooting.
-4. **AI-Powered Monitoring**: To improve [proactive monitoring](https://signoz.io/guides/proactive-monitoring/), APM vendors are increasingly embedding AI into their platforms. 
-    - This enables predictive insights, allowing teams to identify potential performance issues before they escalate, minimizing downtime and optimizing system performance.
+1. **Seamless Integration with OpenTelemetry**: Recognizing the growing influence of OpenTelemetry, many traditional APM vendors are adapting by offering built-in support for OpenTelemetry.
+   - This allows organizations to combine OpenTelemetry’s flexible telemetry data collection with the advanced analytics provided by [APM tools](https://signoz.io/blog/open-source-apm-tools/), maximizing the strengths of both approaches.
+2. **Embracing Open Data Collection Methods**: To stay competitive, APM vendors are shifting toward more open and flexible data collection methodologies, aligning their capabilities with the flexibility that OpenTelemetry offers.
+   - This move enables organizations to gather data from a broader range of environments without being restricted to proprietary systems.
+3. **Advanced Data Visualization**: APM solutions are placing greater emphasis on their data analysis and visualization features, integrating cutting-edge tools such as machine learning and AI-driven insights.
+   - This helps users make sense of complex datasets and detect performance trends more effectively, offering a competitive edge in monitoring and troubleshooting.
+4. **AI-Powered Monitoring**: To improve [proactive monitoring](https://signoz.io/guides/proactive-monitoring/), APM vendors are increasingly embedding AI into their platforms.
+   - This enables predictive insights, allowing teams to identify potential performance issues before they escalate, minimizing downtime and optimizing system performance.
 
 ## Understanding OpenTelemetry and APM: A Complementary Approach
 
 Rather than comparing OpenTelemetry and APM as competing solutions, it's more accurate to understand how they complement each other in a modern [observability stack](https://signoz.io/guides/observability-stack/). Let's explore their distinct roles and how they work together:
 
 ### OpenTelemetry's Role
+
 OpenTelemetry serves as a standardized framework for:
+
 - Collecting telemetry data (traces, metrics, and logs) from applications
 - Providing vendor-neutral instrumentation libraries
 - Ensuring consistent data collection across different environments
 - Offering flexibility in how and where data is exported
 
 ### APM's Role
+
 APM tools provide:
+
 - Advanced analytics and visualization capabilities
 - Pre-built monitoring dashboards and alerts
 - Business transaction monitoring
@@ -97,61 +109,73 @@ This complementary approach allows organizations to leverage the strengths of bo
 
 Choosing between OpenTelemetry and APM depends on your organization’s needs, infrastructure, and long-term goals. While both tools serve the purpose of monitoring and observability, their differences make each suitable for specific use cases.
 
-Understanding when to choose one over the other or when to use them together can significantly impact your monitoring strategy’s effectiveness. 
+Understanding when to choose one over the other or when to use them together can significantly impact your monitoring strategy’s effectiveness.
 
 ### OpenTelemetry excels in:
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-apm-OpenTelemetry.webp" alt="Key Use Cases of OpenTelemetry" caption="Key Use Cases of OpenTelemetry" /> 
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-apm-OpenTelemetry.webp"
+  alt="Key Use Cases of OpenTelemetry"
+  caption="Key Use Cases of OpenTelemetry"
+/>
 
 - Multi-Cloud and Hybrid Environments: OpenTelemetry is designed with flexibility in mind, allowing seamless integration across multiple cloud providers and hybrid infrastructures.
-    - Its vendor-agnostic approach ensures consistent data collection and observability, no matter the environment.
+  - Its vendor-agnostic approach ensures consistent data collection and observability, no matter the environment.
 - Microservices and Distributed Systems: in highly distributed, cloud-native architectures like microservices, OpenTelemetry’s modular design is ideal.
-    - It captures granular traces, metrics, and logs across complex, dynamic systems, providing full visibility into distributed transactions.
+  - It captures granular traces, metrics, and logs across complex, dynamic systems, providing full visibility into distributed transactions.
 - Customer Instrumentation Needs: For organizations that demand tailored observability, OpenTelemetry’s flexibility allows for deep customization.
-    - Developers can instrument specific metrics and traces, ensuring the monitoring solution adapts to unique business needs and evolving architectures.
+  - Developers can instrument specific metrics and traces, ensuring the monitoring solution adapts to unique business needs and evolving architectures.
 - Open-Source and Community-Driven Projects: If your organization prioritizes open standards, transparency, and community-driven innovation, OpenTelemetry offers cutting-edge, rapidly evolving features and broad ecosystem support.
 
 ### When APM Shines:
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-apm-APM.webp" alt="Key Use Cases for APM Solutions" caption="Key Use Cases for APM Solutions" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-apm-APM.webp"
+  alt="Key Use Cases for APM Solutions"
+  caption="Key Use Cases for APM Solutions"
+/>
 
 - Legacy Monolithic Applications: In stable, monolithic environments, traditional APM tools excel.
-    - These applications often require out-of-the-box monitoring, and APM provides ready-made solutions that offer immediate insights with minimal setup.
+  - These applications often require out-of-the-box monitoring, and APM provides ready-made solutions that offer immediate insights with minimal setup.
 - Quick and Easy Deployment: For teams under time constraints or without extensive DevOps expertise, APM solutions deliver pre-configured dashboards, automated monitoring, and actionable insights right out of the box.
-    - This enables faster time-to-value, critical for teams needing rapid observability without extensive custom setup.
+  - This enables faster time-to-value, critical for teams needing rapid observability without extensive custom setup.
 - Limited In-House Expertise: For organizations that don’t have specialized monitoring or development teams, APM is an excellent fit.
-    - The plug-and-play nature of APM solutions reduces the need for ongoing maintenance, configuration, or technical deep drives, making it a straightforward option for less technically adept teams.
+  - The plug-and-play nature of APM solutions reduces the need for ongoing maintenance, configuration, or technical deep drives, making it a straightforward option for less technically adept teams.
 
 ### Why a Hybrid Might Be Best:
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-apm-4a2f30bf-27df-4477-98c1-d2dafcaee762.webp" alt="Integrating APM and OpenTelemetry for Hybrid Monitoring" caption="Integrating APM and OpenTelemetry for Hybrid Monitoring" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-apm-4a2f30bf-27df-4477-98c1-d2dafcaee762.webp"
+  alt="Integrating APM and OpenTelemetry for Hybrid Monitoring"
+  caption="Integrating APM and OpenTelemetry for Hybrid Monitoring"
+/>
 
 - Leveraging the Best of Both Worlds: Many organizations find that a hybrid approach allows them to enjoy the strengths of both solutions.
-    - By using OpenTelemetry for flexible and custom data collection, and combining it with APM’s powerful analytics and visualization features, teams can ensure comprehensive observability across both modern and legacy systems.
+  - By using OpenTelemetry for flexible and custom data collection, and combining it with APM’s powerful analytics and visualization features, teams can ensure comprehensive observability across both modern and legacy systems.
 - Gradual Transition to Modern Monitoring: Teams looking to modernize their monitoring stack can begin by adopting OpenTelemtry incrementally, while still benefiting from the out-of-the-box insights of APM.
-    - This gradual approach helps balance immediate monitoring needs with a long-term strategy toward open standards and greater flexibility.
+  - This gradual approach helps balance immediate monitoring needs with a long-term strategy toward open standards and greater flexibility.
 - Maximizing Existing Investments: For organizations heavily invested in APM tools but eager to avoid vendor lock-in to adopt new technologies, integrating OpenTelemetry can enhance data collection while maintaining the familiar analytics dashboards and workflows of APM solutions.
 
 ## The Future of Monitoring: OpenTelemetry and APM Convergence
 
-As the observability landscape evolves, the distinctions between OpenTelemetry and APM are becoming less pronounced. The future of monitoring is heading towards a convergence of both technologies, driven by the following key trends: 
-
-1. [Unified observability platforms](https://signoz.io/unified-observability/): The future is moving toward integrated observability that combines the flexibility and open standards of OpenTelemetry with the robust analytics and ease of use that APM tools offer. 
-    - These unified platforms will allow organizations to collect telemetry data in a vendor-neutral way, while still leveraging sophisticated, pre-built dashboards, alerting systems, and data visualization tools.
-    - By blending the strengths of both, organizations can have full control over their data pipelines and instrumentation while enjoying turnkey solutions for analysis and reporting, bridging the gap between customizability and usability.
-2. Advanced correlation and analysis: Modern platforms are evolving to provide deeper, more meaningful insights by correlating data from multiple telemetry sources such as metrics, logs, traces, and events into a single cohesive view. 
-    - These platforms will enable a holistic understanding of system health, user experience, and root cause analysis, breaking down silos between different types of telemetry data.
-    - The convergence of OpenTelemetry and APM will also allow for improved context-aware analysis, helping teams identify not just the symptoms of issues but also the underlying causes faster and more efficiently.
-3. AI-powered anomaly detection: Both OpenTelemetry and APM solutions are increasingly leveraging AI and machine learning to enhance monitoring capabilities. 
-    - AI-driven insights transform observability by detecting real-time anomalies, predicting potential failures before they occur, and automatically identifying performance bottlenecks.
-    - As AI algorithms become more advanced, future monitoring platforms will proactively suggest optimizations, automate root analysis, and even trigger self-healing mechanisms within distributed systems, reducing manual intervention and increasing system reliability.
-4. Flexible Data Ownership and Vendor-Agnostic Ecosystems: A significant benefit of OpenTelemetry-APM convergence is the shift toward greater data ownership. 
-    - As more platforms embrace open-source standards, organizations will be less reliant on proprietary vendor ecosystems, allowing them to maintain control over their telemetry data.
-    - This shift will enable greater flexibility in integrating different tools, avoiding vendor lock-in, and ensuring that monitoring solutions can evolve alongside the changing infrastructure and technology landscape.
+As the observability landscape evolves, the distinctions between OpenTelemetry and APM are becoming less pronounced. The future of monitoring is heading towards a convergence of both technologies, driven by the following key trends:
+
+1. [Unified observability platforms](https://signoz.io/unified-observability/): The future is moving toward integrated observability that combines the flexibility and open standards of OpenTelemetry with the robust analytics and ease of use that APM tools offer.
+   - These unified platforms will allow organizations to collect telemetry data in a vendor-neutral way, while still leveraging sophisticated, pre-built dashboards, alerting systems, and data visualization tools.
+   - By blending the strengths of both, organizations can have full control over their data pipelines and instrumentation while enjoying turnkey solutions for analysis and reporting, bridging the gap between customizability and usability.
+2. Advanced correlation and analysis: Modern platforms are evolving to provide deeper, more meaningful insights by correlating data from multiple telemetry sources such as metrics, logs, traces, and events into a single cohesive view.
+   - These platforms will enable a holistic understanding of system health, user experience, and root cause analysis, breaking down silos between different types of telemetry data.
+   - The convergence of OpenTelemetry and APM will also allow for improved context-aware analysis, helping teams identify not just the symptoms of issues but also the underlying causes faster and more efficiently.
+3. AI-powered anomaly detection: Both OpenTelemetry and APM solutions are increasingly leveraging AI and machine learning to enhance monitoring capabilities.
+   - AI-driven insights transform observability by detecting real-time anomalies, predicting potential failures before they occur, and automatically identifying performance bottlenecks.
+   - As AI algorithms become more advanced, future monitoring platforms will proactively suggest optimizations, automate root analysis, and even trigger self-healing mechanisms within distributed systems, reducing manual intervention and increasing system reliability.
+4. Flexible Data Ownership and Vendor-Agnostic Ecosystems: A significant benefit of OpenTelemetry-APM convergence is the shift toward greater data ownership.
+   - As more platforms embrace open-source standards, organizations will be less reliant on proprietary vendor ecosystems, allowing them to maintain control over their telemetry data.
+   - This shift will enable greater flexibility in integrating different tools, avoiding vendor lock-in, and ensuring that monitoring solutions can evolve alongside the changing infrastructure and technology landscape.
 
 ## Implementing OpenTelemetry with SigNoz: A Practical Approach
 
-For those looking to implement OpenTelemetry effortlessly, SigNoz is an excellent open-source APM tool built natively to support OpenTelemetry. It provides full-stack observability for distributed systems with minimal configuration, making it an ideal choice for organizations aiming to adopt OpenTelemetry quickly. 
+For those looking to implement OpenTelemetry effortlessly, SigNoz is an excellent open-source APM tool built natively to support OpenTelemetry. It provides full-stack observability for distributed systems with minimal configuration, making it an ideal choice for organizations aiming to adopt OpenTelemetry quickly.
 
 ### Why Choose SigNoz?
 
@@ -159,7 +183,7 @@ For those looking to implement OpenTelemetry effortlessly, SigNoz is an excellen
 - Native OpenTelemetry Integration: SigNoz seamlessly collects data through OpenTelemetry, simplifying the monitoring process.
 - Flexible Deployment Options: Offers both cloud-hosted and open-source models, providing a cost-effective solution based on your specific needs.
 
-To get started with OpenTelemetry and SigNoz, check out this [Complete guide on Implementing OpenTelemetry with SigNoz](https://signoz.io/blog/opentelemetry-collector-complete-guide/), where you’ll find detailed instructions and tips to optimize your observability setup.  
+To get started with OpenTelemetry and SigNoz, check out this [Complete guide on Implementing OpenTelemetry with SigNoz](https://signoz.io/blog/opentelemetry-collector-complete-guide/), where you’ll find detailed instructions and tips to optimize your observability setup.
 
 <GetStartedSigNoz />
 
@@ -180,7 +204,7 @@ To get started with OpenTelemetry and SigNoz, check out this [Complete guide on
 
 ### What are the main challenges in adopting OpenTelemetry?
 
-OpenTelemetry adoption can present several challenges: 
+OpenTelemetry adoption can present several challenges:
 
 - Initial setup and configuration complexity: Setting up OpenTelemetry requires more manual effort than traditional APM tools, including configuring various components like instrumentation libraries, collectors, and exporters.
 - Integrating OpenTelemetry with existing monitoring infrastructure: While OpenTelemetry is designed for modern cloud-native environments, integrating it with older or monitoring applications can be difficult, requiring custom solutions.
@@ -188,7 +212,7 @@ OpenTelemetry adoption can present several challenges:
 
 ### How does OpenTelemetry impact the total cost of ownership for monitoring?
 
-OpenTelemetry’s open-source nature can reduce upfront software costs, as there are no licensing fees. However, organizations should account for additional costs related to: 
+OpenTelemetry’s open-source nature can reduce upfront software costs, as there are no licensing fees. However, organizations should account for additional costs related to:
 
 - Training: Teams may need to invest time and resources in learning how to set up and use OpenTelemetry effectively.
 - Custom Solutions: Since OpenTelemetry requires more manual configuration, organizations may need to spend resources on custom integrations, instrumentation, and ongoing maintenance.
@@ -196,6 +220,6 @@ OpenTelemetry’s open-source nature can reduce upfront software costs, as there
 
 ### Is it possible to use OpenTelemetry with existing APM tools?
 
-Yes, OpenTelemetry can be integrated with many APM tools. Most modern APM platforms have added support for OpenTelemetry, allowing organizations to collect data while benefiting from the analytical and visualization capabilities of their existing APM solutions. 
+Yes, OpenTelemetry can be integrated with many APM tools. Most modern APM platforms have added support for OpenTelemetry, allowing organizations to collect data while benefiting from the analytical and visualization capabilities of their existing APM solutions.
 
-- This integration allows for a flexible and comprehensive monitoring strategy, combining OpenTelemetry’s open-source, vendor-neutral telemetry collection with APM’s advanced features for performance monitoring and troubleshooting.
\ No newline at end of file
+- This integration allows for a flexible and comprehensive monitoring strategy, combining OpenTelemetry’s open-source, vendor-neutral telemetry collection with APM’s advanced features for performance monitoring and troubleshooting.
diff --git a/data/comparisons/opentelemetry-vs-application-insights.mdx b/data/comparisons/opentelemetry-vs-application-insights.mdx
index fbb4facec..59c3477e5 100644
--- a/data/comparisons/opentelemetry-vs-application-insights.mdx
+++ b/data/comparisons/opentelemetry-vs-application-insights.mdx
@@ -1,28 +1,29 @@
 ---
-
 title: OpenTelemetry vs. Application Insights - Key Differences
-slug: opentelemetry-vs-application-insights
 date: 2025-01-22
 tags: [OpenTelemetry]
 authors: [manjunath_irukulla]
 description: Compare OpenTelemetry and Application Insights to find the best fit for your application monitoring needs.
 keywords: [OpenTelemetry, Application Insights, Azure DevOps, Observability, SigNoz]
-
 ---
 
-OpenTelemetry is an open-source framework that standardizes the collection of telemetry data (traces, metrics, and logs) across various programming languages, enabling flexible monitoring without vendor lock-in. 
+OpenTelemetry is an open-source framework that standardizes the collection of telemetry data (traces, metrics, and logs) across various programming languages, enabling flexible monitoring without vendor lock-in.
 
-Application Insights, part of Microsoft’s Azure Monitor, focuses on application performance management and integrates seamlessly with Azure for AI-driven insights and anomaly detection. 
+Application Insights, part of Microsoft’s Azure Monitor, focuses on application performance management and integrates seamlessly with Azure for AI-driven insights and anomaly detection.
 
-This article explores the key differences between OpenTelemetry and Application Insights, their features, integration methods, and how to choose the right tool for your needs. you’ll also gain insights into optimizing multi-cloud and Azure-centric setups to enhance your application’s observability and performance management. 
+This article explores the key differences between OpenTelemetry and Application Insights, their features, integration methods, and how to choose the right tool for your needs. you’ll also gain insights into optimizing multi-cloud and Azure-centric setups to enhance your application’s observability and performance management.
 
 ## What is OpenTelemetry?
 
 OpenTelemetry is an open-source project designed to provide a standardized way of collecting telemetry data (traces, metrics, and logs) from applications. It supports various programming languages and allows developers to instrument their code once, enabling flexibility in choosing the monitoring backend. It’s vendor-agnostic, meaning you can choose the observability solution that best fits your needs without worrying about vendor lock-in.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-application-insights-image.webp" alt="OpenTelemetry features like OpenSource and community-driven, telemetry collection, vendor neutrality." caption="OpenTelemetry features like OpenSource and community-driven, telemetry collection, vendor neutrality." /> 
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-application-insights-image.webp"
+  alt="OpenTelemetry features like OpenSource and community-driven, telemetry collection, vendor neutrality."
+  caption="OpenTelemetry features like OpenSource and community-driven, telemetry collection, vendor neutrality."
+/>
 
-Key Features of OpenTelemetry: 
+Key Features of OpenTelemetry:
 
 - Open-Source and Community-Driven: Backend by a broad community, including major cloud providers like AWS, Google Cloud, and Microsoft.
 - Unified Telemetry Collection: Standardize the collection of metrics, traces, and logs in a single solution.
@@ -32,11 +33,15 @@ Key Features of OpenTelemetry:
 
 ## What is Application Insights?
 
-Application Insights is a part of Microsoft’s Azure Monitor service and focuses on application performance management (APM) for cloud-hosted applications. It integrates seamlessly with Azure services and provides powerful AI-driven insights and anomaly detection. While primarily designed for Azure environments, it can also monitor applications running in other environments, such as on-premises or multi-cloud. 
+Application Insights is a part of Microsoft’s Azure Monitor service and focuses on application performance management (APM) for cloud-hosted applications. It integrates seamlessly with Azure services and provides powerful AI-driven insights and anomaly detection. While primarily designed for Azure environments, it can also monitor applications running in other environments, such as on-premises or multi-cloud.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-application-insights-image%201.webp" alt="Application Insights" caption="Application Insights" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-application-insights-image%201.webp"
+  alt="Application Insights"
+  caption="Application Insights"
+/>
 
-Main Capabilities of Application Insights: 
+Main Capabilities of Application Insights:
 
 - Azure-native Integration: Automatically integrates with Azure services like App Service, Kubernetes, and Virtual Machines.
 - Advanced Analytics and AI insights: Provides AI-powered root-cause analysis, user behavior tracking, and performance monitoring.
@@ -44,87 +49,87 @@ Main Capabilities of Application Insights:
 
 ## Why Choose Between OpenTelemetry and Application Insights?
 
-As modern applications become increasingly complex and spread across multiple services, cloud environments, and geographical regions, monitoring becomes essential to ensure reliability, performance, and user satisfaction. OpenTelemetry and Application Insights both offer powerful monitoring capabilities, but their core differences lie in their approach and target users. 
+As modern applications become increasingly complex and spread across multiple services, cloud environments, and geographical regions, monitoring becomes essential to ensure reliability, performance, and user satisfaction. OpenTelemetry and Application Insights both offer powerful monitoring capabilities, but their core differences lie in their approach and target users.
 
-### Why should you consider these tools? 
+### Why should you consider these tools?
 
 - Comprehensive Observability: Modern applications rely on distributed architectures, where monitoring a single service isn’t enough. You need full-stack observability spanning front-end, back-end, and third-party services.
-    - Both OpenTelemetry and Application Insights aim to provide this, but OpenTelemetry’s vendor-neutral approach offers standardized telemetry across diverse environments, while Application Insights seamlessly integrates into the Azure ecosystem.
-- Multi-Cloud and Hybrid Environments: With many organizations adopting multi-cloud and hybrid infrastructures, monitoring can quickly become complex. OpenTelemetry excels in multi-cloud and hybrid scenarios,  supporting various environments beyond Azure, including AWS, Google Cloud, and on-premises systems.
-    - On the other hand, Application Insights provides a more streamlined experience for those heavily invested in Azure, with built-in support for monitoring Azure native services.
+  - Both OpenTelemetry and Application Insights aim to provide this, but OpenTelemetry’s vendor-neutral approach offers standardized telemetry across diverse environments, while Application Insights seamlessly integrates into the Azure ecosystem.
+- Multi-Cloud and Hybrid Environments: With many organizations adopting multi-cloud and hybrid infrastructures, monitoring can quickly become complex. OpenTelemetry excels in multi-cloud and hybrid scenarios, supporting various environments beyond Azure, including AWS, Google Cloud, and on-premises systems.
+  - On the other hand, Application Insights provides a more streamlined experience for those heavily invested in Azure, with built-in support for monitoring Azure native services.
 - Vendor Independence vs Integration: The choice often comes down to your infrastructure and future goals. OpenTelemetry’s vendor-agnostic nature makes it a flexible option for teams that prioritize freedom to move between platforms without being locked into a specific vendor’s ecosystem.
-    - Meanwhile, Application Insights offers unparalleled integration with Azure. It combines its telemetry with Azure Monitor's analytics and AI-driven insights, making it ideal for Azure-based applications.
+  - Meanwhile, Application Insights offers unparalleled integration with Azure. It combines its telemetry with Azure Monitor's analytics and AI-driven insights, making it ideal for Azure-based applications.
 
 ### Can They Be Used Together?
-Yes! [Azure Application Insights](https://signoz.io/guides/azure-app-insights/) supports OpenTelemetry. You can instrument your application using OpenTelemetry and send the telemetry data to Azure Application Insights as the backend. This approach allows you to benefit from OpenTelemetry’s vendor-neutral instrumentation while leveraging Application Insights’ advanced analytics and Azure integrations.
 
+Yes! [Azure Application Insights](https://signoz.io/guides/azure-app-insights/) supports OpenTelemetry. You can instrument your application using OpenTelemetry and send the telemetry data to Azure Application Insights as the backend. This approach allows you to benefit from OpenTelemetry’s vendor-neutral instrumentation while leveraging Application Insights’ advanced analytics and Azure integrations.
 
 ## Core Differences: OpenTelemetry vs Application Insights
 
 Let's examine the key differences between OpenTelemetry and Application Insights. OpenTelemetry provides flexible, vendor-neutral monitoring across platforms, while Application Insights offers deep Azure integration and specialized monitoring capabilities.
 
-| Criteria  | OpenTelemetry  | Application Insights |
-| --- | --- | --- |
-| Type | Open-source observability framework for collecting and exporting telemetry data | Managed APM solution provided by Microsoft Azure |
-| Data Collection Methods | Unified approach using language-specific SDKs and standardized formats for traces, metrics, and logs.   | Uses proprietary SDKs optimized for Azure services.  |
-| Vendor Lock-In | Vendor-agnostic offers flexibility in choosing backends for observability data.  | Tightly integrated with Azure ecosystem, leading to vendor lock-in if you use Azure services.  |
-| Customization and Extensibility | Open standards allow extensive customization and tailoring to specific use cases.  | Offers proprietary features and customization, but is limited to what Microsoft offers.  |
-| Community Support and Ecosystem | Strong, open-source community with broad adoption across multiple cloud providers and observability tools.  | Backed by Microsoft, integrated deeply into Azure's broader monitoring ecosystem.  |
+| Criteria                        | OpenTelemetry                                                                                              | Application Insights                                                                          |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
+| Type                            | Open-source observability framework for collecting and exporting telemetry data                            | Managed APM solution provided by Microsoft Azure                                              |
+| Data Collection Methods         | Unified approach using language-specific SDKs and standardized formats for traces, metrics, and logs.      | Uses proprietary SDKs optimized for Azure services.                                           |
+| Vendor Lock-In                  | Vendor-agnostic offers flexibility in choosing backends for observability data.                            | Tightly integrated with Azure ecosystem, leading to vendor lock-in if you use Azure services. |
+| Customization and Extensibility | Open standards allow extensive customization and tailoring to specific use cases.                          | Offers proprietary features and customization, but is limited to what Microsoft offers.       |
+| Community Support and Ecosystem | Strong, open-source community with broad adoption across multiple cloud providers and observability tools. | Backed by Microsoft, integrated deeply into Azure's broader monitoring ecosystem.             |
 
 ### Performance and Scalability comparison
 
-Performance and scalability are critical factors when evaluating monitoring solutions. OpenTelemetry is designed to be lightweight and adaptable, making it suitable for various environments, while Application Insights excels in Azure settings with robust monitoring capabilities. 
+Performance and scalability are critical factors when evaluating monitoring solutions. OpenTelemetry is designed to be lightweight and adaptable, making it suitable for various environments, while Application Insights excels in Azure settings with robust monitoring capabilities.
 
-The following comparision highlights key aspects of both tools resource consumption, data ingestion, sampling, and real-time processing, providing insights into their respective strenghts and limitations. 
+The following comparision highlights key aspects of both tools resource consumption, data ingestion, sampling, and real-time processing, providing insights into their respective strenghts and limitations.
 
-| Criteria | OpenTelemetry  | Application Insights |
-| --- | --- | --- |
-| Overhead and Resource Consumption | Lightweight, but depends on configuration (sampling rates, exporters)  | Optimized for Azure environments, but may introduce overhead when used outside Azure.  |
-| Support for High-Volume Data Ingestion Sapling and Data Retention | Can handle large-scale telemetry data with customizable sampling techniques.  | Optimized for Azure and handles large data volumes, but costs may increase based on ingestion size.  |
-| Sampling Data and Retention | Customizable sampling strategies to manage data volumes | Built-in sampling and retention settings based on Azure Monitor policies.  |
-| Real-time Processing and Alerting | Depends on the chosen backend (e.g, Prometheus, Grafana) for real-time analysis and alerting.  | Offers real-time monitoring, AI-powered insights, and built-in alerting mechanisms within Azure.  |
+| Criteria                                                          | OpenTelemetry                                                                                 | Application Insights                                                                                |
+| ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Overhead and Resource Consumption                                 | Lightweight, but depends on configuration (sampling rates, exporters)                         | Optimized for Azure environments, but may introduce overhead when used outside Azure.               |
+| Support for High-Volume Data Ingestion Sapling and Data Retention | Can handle large-scale telemetry data with customizable sampling techniques.                  | Optimized for Azure and handles large data volumes, but costs may increase based on ingestion size. |
+| Sampling Data and Retention                                       | Customizable sampling strategies to manage data volumes                                       | Built-in sampling and retention settings based on Azure Monitor policies.                           |
+| Real-time Processing and Alerting                                 | Depends on the chosen backend (e.g, Prometheus, Grafana) for real-time analysis and alerting. | Offers real-time monitoring, AI-powered insights, and built-in alerting mechanisms within Azure.    |
 
 ## Leveraging Application Insights in Azure Environments
 
-Azure’s native integration with Application Insights offers a powerful, streamlined way to monitor applications running on its platform. 
+Azure’s native integration with Application Insights offers a powerful, streamlined way to monitor applications running on its platform.
 
-Whether working with web apps, virtual machines, or other Azure services, you can easily enable monitoring to gain real-time insights. Below are some ways to make the most of Application Insights in Azure environments: 
+Whether working with web apps, virtual machines, or other Azure services, you can easily enable monitoring to gain real-time insights. Below are some ways to make the most of Application Insights in Azure environments:
 
 - Enabling Application Insights for Azure Services: Application Insights is natively integrated with Azure, making it easy to enable various Azure services such as web apps, functions, and virtual machines.
-    - By turning it on with just a few clicks in the Azure portal, you can start monitoring your applications without needing any additional configuration.
-    - Application Insights automatically collects data on performance, errors, dependencies, and request rates, giving you detailed insights into how your Azure-based applications are running.
+  - By turning it on with just a few clicks in the Azure portal, you can start monitoring your applications without needing any additional configuration.
+  - Application Insights automatically collects data on performance, errors, dependencies, and request rates, giving you detailed insights into how your Azure-based applications are running.
 - Integrating Application Insights with Non-Azure Application: Although tightly integrated with Azure, Application Insights is not limited to Azure environments.
-    - You can also use it to monitor applications hosted on other platforms, such as on-premises servers, AWS, or GCP.
-    - By integrating the Application Insights SDK into your code, you can collect telemetry data from non-Azure environments, giving you the same rich set of monitoring features and insights across all your services, regardless of where they are hosted.
+  - You can also use it to monitor applications hosted on other platforms, such as on-premises servers, AWS, or GCP.
+  - By integrating the Application Insights SDK into your code, you can collect telemetry data from non-Azure environments, giving you the same rich set of monitoring features and insights across all your services, regardless of where they are hosted.
 - Utilizing Application Insights AI-Powered Features: One of the standout features of Application Insights is its AI-powered anomaly detection and proactive diagnostics.
-    - By leveraging machine learning, it can automatically detect unusual patterns in your application’s performance such as spikes in failure rates, or unexpected latency, and provide actionable insights.
-    - This helps you identify and resolve issues faster, often before they impact your users. The AI capabilities also include intelligent alerts and deep analytics for better root cause analytics.
+  - By leveraging machine learning, it can automatically detect unusual patterns in your application’s performance such as spikes in failure rates, or unexpected latency, and provide actionable insights.
+  - This helps you identify and resolve issues faster, often before they impact your users. The AI capabilities also include intelligent alerts and deep analytics for better root cause analytics.
 - Maximizing Value Through Azure Monitor Integration: Application Insights integrates seamlessly Azure Monitor, providing a complete solution for observability across Azure environments.
-    - Azure Monitor extends the capabilities of Application Insights by combining metrics, logs, and traces from all your Azure resources in one place.
-    - With this integration, you can set up custom dashboards, query your telemetry data using Kusto Query Language (KQL), and create alerts for any abnormal behaviour in your application’s performance, giving you end-to-end visibility.
+  - Azure Monitor extends the capabilities of Application Insights by combining metrics, logs, and traces from all your Azure resources in one place.
+  - With this integration, you can set up custom dashboards, query your telemetry data using Kusto Query Language (KQL), and create alerts for any abnormal behaviour in your application’s performance, giving you end-to-end visibility.
 
 ## OpenTelemetry with Application Insights: Best of Both Worlds?
 
-By combining the vendor-agnostic capabilities of OpenTelemetry with the deep integration and powerful analytics of Application Insights, you can create a more flexible and comprehensive observability solution. 
+By combining the vendor-agnostic capabilities of OpenTelemetry with the deep integration and powerful analytics of Application Insights, you can create a more flexible and comprehensive observability solution.
 
-This hybrid approach enables you to collect standardized telemetry data while benefiting from the insights provided by Application Insights. Here’s how you can leverage the best of both: 
+This hybrid approach enables you to collect standardized telemetry data while benefiting from the insights provided by Application Insights. Here’s how you can leverage the best of both:
 
 - Using OpenTelemetry to Collect Data for Application Insights: OpenTelemetry is a vendor-neutral observability framework that allows you to instrument your applications and export telemetry data to various backends, including Application Insights.
-    - By using OpenTelemetry alongside Application Insights, you can gather standardized trace, metrics, log data in a format that is not tied to any specific vendor.
-    - This allows for flexibility in monitoring your application across multi-cloud or hybrid environments, while still leveraging Application Insights for analysis and insights.
+  - By using OpenTelemetry alongside Application Insights, you can gather standardized trace, metrics, log data in a format that is not tied to any specific vendor.
+  - This allows for flexibility in monitoring your application across multi-cloud or hybrid environments, while still leveraging Application Insights for analysis and insights.
 - Benefits of Combining OpenTelemetry’s Flexibility with Application Insights Tools: Combining OpenTelemetry with Application Insights offers the best of both worlds.
-    - OpenTelemetry’s  vendor-agnostic instrumentation gives you the freedom to switch or integrate with other observability backends if needed, while Application Insights powerful analysis and AI-driven insights enhance you ability to monitor, disgnose and optimize application performance.
-    - This combination allows you to instrument your applications once and use the data across different platforms while still taking advantage of Application Insights deep integration with Azure services.
+  - OpenTelemetry’s vendor-agnostic instrumentation gives you the freedom to switch or integrate with other observability backends if needed, while Application Insights powerful analysis and AI-driven insights enhance you ability to monitor, disgnose and optimize application performance.
+  - This combination allows you to instrument your applications once and use the data across different platforms while still taking advantage of Application Insights deep integration with Azure services.
 - Potential Challenges and Considerations for This Hybrid Approach: While the combination of OpenTelemetry and Application Insights provides significant benefits, there are challenges to consider.
-    - For example, integrating OpenTelemetry with Application Insights may require additional configuration, and you’ll need to ensure that the telemetry data collected through OpenTelemetry aligns with the format expected by Application Insights.
-    - Another consideration is the cost of using Application Insights, especially as you scale and ingest more telemetry data through OpenTelemtry. Careful planning and budgeting are essential to ensure that the hybrid setup is cost-effective.
-- Future  Outlook on OpenTelemetry and Application Insights Integration: The future of combining OpenTelemetry with Application Insights looks promising as the [OpenTelemetry project](https://signoz.io/blog/opentelemetry-apm/) continues to evolve and gain wider adoption
-    - Microsoft has shown strong support for OpenTelemetry, and with time, the integration between OpenTelemetry and Application Insights will likely become even more seamless.
-    - As more organizations adopt OpenTelemetry for their multi-cloud and hybrid environments, this hybrid approach will become a go-to solution for achieving both flexibility and advanced monitoring capabilities.
+  - For example, integrating OpenTelemetry with Application Insights may require additional configuration, and you’ll need to ensure that the telemetry data collected through OpenTelemetry aligns with the format expected by Application Insights.
+  - Another consideration is the cost of using Application Insights, especially as you scale and ingest more telemetry data through OpenTelemtry. Careful planning and budgeting are essential to ensure that the hybrid setup is cost-effective.
+- Future Outlook on OpenTelemetry and Application Insights Integration: The future of combining OpenTelemetry with Application Insights looks promising as the [OpenTelemetry project](https://signoz.io/blog/opentelemetry-apm/) continues to evolve and gain wider adoption
+  - Microsoft has shown strong support for OpenTelemetry, and with time, the integration between OpenTelemetry and Application Insights will likely become even more seamless.
+  - As more organizations adopt OpenTelemetry for their multi-cloud and hybrid environments, this hybrid approach will become a go-to solution for achieving both flexibility and advanced monitoring capabilities.
 
 ## SigNoz: A Comprehensive Alternative
 
-SigNoz is a strong open-source option that blends the flexibility of OpenTelemetry with full observability features. It provides a unified platform to monitor traces, metrics, and logs while avoiding vendor lock-in. 
+SigNoz is a strong open-source option that blends the flexibility of OpenTelemetry with full observability features. It provides a unified platform to monitor traces, metrics, and logs while avoiding vendor lock-in.
 
 - OpenTelemetry Integration: [SigNoz](https://signoz.io/docs/introduction/) fully supports OpenTelemetry, allowing you to collect telemetry data while using SigNoz for storage and analysis. it’s simple to set up, and you can start tracking your system’s performance right away.
 - Complete Monitoring Solution: SigNoz offers built-in tracing, metrics, and logs, giving a full view of your system’s health.
@@ -133,26 +138,26 @@ SigNoz is a strong open-source option that blends the flexibility of OpenTelemet
 
 To get started with SigNoz:
 
-1. Visit the SigNoz website: https:/signoz.io to explore the platform. 
+1. Visit the SigNoz website: https:/signoz.io to explore the platform.
 2. Review their detailed documentation for guides on setting up and [integrating with OpenTelemetry.](https://signoz.io/blog/opentelemetry-spring-boot/)
-3. Try their live demo or deploy a local instance to see how SigNoz works in real-time. 
+3. Try their live demo or deploy a local instance to see how SigNoz works in real-time.
 
-<GetStartedSigNoz/>   
+<GetStartedSigNoz />
 
 ## Making the Right Choice: Factors to Consider
 
-When choosing between OpenTelemetry and Application Insights, several factors should guide your decision. Both tools offer robust observability features, but their fit depends on your specific needs and goals. 
+When choosing between OpenTelemetry and Application Insights, several factors should guide your decision. Both tools offer robust observability features, but their fit depends on your specific needs and goals.
 
 - Existing Technology Stack and Cloud Provider Preferences: If your infrastructure relies heavily on Azure services, Application Insights offers deep integration and out-of-the-box monitoring for Azure-native applications.
-    - On the other hand, OpenTelemetry provides flexibility across multiple cloud providers (AWS, Google Cloud, etc) and on-premises systems, making it ideal for organizations with a diverse or hybrid infrastructure.
+  - On the other hand, OpenTelemetry provides flexibility across multiple cloud providers (AWS, Google Cloud, etc) and on-premises systems, making it ideal for organizations with a diverse or hybrid infrastructure.
 - Team Expertise and Learning Curve Considerations: Application Insights is a more turnkey solution, with Azure-native features that are easy to set up and use for teams already familiar with the Azure ecosystem.
-    - OpenTelemetry, being a vendor-neutral framework, offers more flexibility but requires a steeper learning curve.
-    - Teams should consider their expertise and whether they are ready to manage the complexity of custom instrumentation and integration with various backend systems.
+  - OpenTelemetry, being a vendor-neutral framework, offers more flexibility but requires a steeper learning curve.
+  - Teams should consider their expertise and whether they are ready to manage the complexity of custom instrumentation and integration with various backend systems.
 - Budget Constraints and Licensing Models: Application Insights operates on a pay-as-you-go model, which might be more predictable if you are invested in Azure. OpenTelemetry, being open-source, has no upfront costs, but using it with third-party backends may incur additional expenses depending on the storage and analysis tools you integrate with it.
-    - Understanding your budget limitations will help determine which solution fits within your financial parameters.
+  - Understanding your budget limitations will help determine which solution fits within your financial parameters.
 - Long-Term Scalability and Vendor Independence Requirements: If you anticipate growing your infrastructure across multiple cloud platforms, OpenTelemetry’s vendor-agnostic nature ensures that you are not locked into any one ecosystem.
-    - This allows for easier scaling across cloud providers and services without needing to re-instrument your application.
-    - On the other hand, if you’re committed to staying within Azure, Application Insights tight integration provides a scalable solution without the need for managing multiple observability tools.
+  - This allows for easier scaling across cloud providers and services without needing to re-instrument your application.
+  - On the other hand, if you’re committed to staying within Azure, Application Insights tight integration provides a scalable solution without the need for managing multiple observability tools.
 
 ## Key Takeaways
 
@@ -166,16 +171,16 @@ When choosing between OpenTelemetry and Application Insights, several factors sh
 
 ### Can OpenTelemetry replace Application Insights completely?
 
-Yes, OpenTelemetry can replace Application Insights for telemetry data collection, but you will need a backend for data analysis, alerting, and visualization. 
+Yes, OpenTelemetry can replace Application Insights for telemetry data collection, but you will need a backend for data analysis, alerting, and visualization.
 
 ### Is it possible to use OpenTelemetry with Azure services?
 
-Yes, OpenTelemetry can export data to Application Insights or Azure Monitor, providing flexibility in data collection and analysis. 
+Yes, OpenTelemetry can export data to Application Insights or Azure Monitor, providing flexibility in data collection and analysis.
 
 ### How does the pricing model differ between OpenTelemetry and Application Insights?
 
-OpenTelemetry is open-source and free to use, but storage and backend costs will vary depending on the chosen observability solution. Application Insights charges based on data ingested and retained, which could lead to higher costs for larger-scale applications. 
+OpenTelemetry is open-source and free to use, but storage and backend costs will vary depending on the chosen observability solution. Application Insights charges based on data ingested and retained, which could lead to higher costs for larger-scale applications.
 
 ### What are the main challenges in migrating from Application Insights to OpenTelemetry?
 
-The main challenges include instrumentation changes, backend setup, and ensuring data consistency between OpenTelemetry and existing Application Insights data.
\ No newline at end of file
+The main challenges include instrumentation changes, backend setup, and ensuring data consistency between OpenTelemetry and existing Application Insights data.
diff --git a/data/comparisons/opentelemetry-vs-aws-xray.mdx b/data/comparisons/opentelemetry-vs-aws-xray.mdx
index 056eba3ab..8f9e10950 100644
--- a/data/comparisons/opentelemetry-vs-aws-xray.mdx
+++ b/data/comparisons/opentelemetry-vs-aws-xray.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry vs AWS X-Ray - Which Tracing Tool to Choose?
-slug: opentelemetry-vs-aws-xray
+
 date: 2024-11-14
 tags: [OpenTelemetry]
 authors: [sushant_gaurav]
-description: Compare OpenTelemetry and AWS X-Ray to choose the right distributed 
-keywords: [opentelemetry vs aws xray, distributed tracing, aws monitoring, opentelemetry implementation, xray tracing, cloud monitoring, observability tools]
-
+description: Compare OpenTelemetry and AWS X-Ray to choose the right distributed
+keywords:
+  [
+    opentelemetry vs aws xray,
+    distributed tracing,
+    aws monitoring,
+    opentelemetry implementation,
+    xray tracing,
+    cloud monitoring,
+    observability tools,
+  ]
 ---
 
 Modern distributed systems need effective tracing to ensure both performance and reliability. As applications grow more complex, selecting the right tool, such as OpenTelemetry or AWS X-Ray, becomes quite important. OpenTelemetry and AWS X-Ray offer distributed tracing but serve different needs with unique trade-offs.
@@ -48,12 +55,12 @@ OpenTelemetry is a vendor-neutral, open-source framework for collecting, process
 Let's first look at OpenTelemetry's architecture and components.
 
 - Software Development Kits (SDKs): SDKs provide language-specific implementations to collect telemetry data. SDKs offer:
-    - Automatic Instrumentation: It can autogenerate spans for supported libraries, minimizing manual effort.
-    - Manual Instrumentation: It allows users to customize trace data with specific spans for unique operations.
+  - Automatic Instrumentation: It can autogenerate spans for supported libraries, minimizing manual effort.
+  - Manual Instrumentation: It allows users to customize trace data with specific spans for unique operations.
 - Collector: A collector receives data, processes it, and exports it to the designated backend. The collector handles:
-    - Data Reception: It collects data from multiple SDKs and agents.
-    - Processing: It supports filtering, batching, and enhancing data before sending.
-    - Export Configuration: It defines how and where to export collected data (e.g., SigNoz, Prometheus).
+  - Data Reception: It collects data from multiple SDKs and agents.
+  - Processing: It supports filtering, batching, and enhancing data before sending.
+  - Export Configuration: It defines how and where to export collected data (e.g., SigNoz, Prometheus).
 
 An example for [OpenTelemetry Collector configuration](https://signoz.io/blog/opentelemetry-collector-complete-guide/):
 
@@ -66,7 +73,7 @@ receivers:
 
 exporters:
   otlp:
-    endpoint: "your-backend-endpoint:4317"
+    endpoint: 'your-backend-endpoint:4317'
 ```
 
 ### Supported Languages and Integration Capabilities
@@ -88,7 +95,7 @@ The OpenTelemetry ecosystem is robust. Its growing community of contributors ens
 
 ### Customization Capabilities
 
-OpenTelemetry offers flexible options for customizing telemetry data collection, processing, and export, providing developers with a customized observability experience. 
+OpenTelemetry offers flexible options for customizing telemetry data collection, processing, and export, providing developers with a customized observability experience.
 
 For example, developers can add custom attributes to spans, such as user IDs or specific transaction details, to gain more granular insights. They can also configure sampling rates to reduce data volume in high-traffic environments or selectively export data to different backends, ensuring performance without compromising on essential metrics.
 
@@ -101,29 +108,28 @@ To sett up OpenTelemetry, you should be careful as it involves a few critical st
 Let's look at a Python example for better understanding:
 
 1. Install the SDK for Your Language:
-    
-    ```bash
-    pip install opentelemetry-api opentelemetry-sdk
-    ```
-    
+
+   ```bash
+   pip install opentelemetry-api opentelemetry-sdk
+   ```
+
 2. Configure the Tracer:
-    
-    ```python
-    from opentelemetry import trace
-    from opentelemetry.sdk.trace import TracerProvider
-    
-    provider = TracerProvider()
-    trace.set_tracer_provider(provider)
-    ```
-    
+
+   ```python
+   from opentelemetry import trace
+   from opentelemetry.sdk.trace import TracerProvider
+
+   provider = TracerProvider()
+   trace.set_tracer_provider(provider)
+   ```
+
 3. Set Up Exporters:
-    
-    ```python
-    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-    
-    otlp_exporter = OTLPSpanExporter(endpoint="<http://your-collector:4317>")
-    ```
-    
+
+   ```python
+   from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+   otlp_exporter = OTLPSpanExporter(endpoint="<http://your-collector:4317>")
+   ```
 
 ### Data Collection and Export Options
 
@@ -151,7 +157,11 @@ Let us now look at the architecture and components of X-Ray.
 - Service Map Visualization: X-Ray automatically creates a map showing how services connect and where delays might occur.
 - Trace Analytics and Performance Insights: It breaks down request paths and performance data and helps you troubleshoot and improve AWS applications.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-aws-xray-image.webp" alt="Diagram of X-Ray architecture and its components" caption="Diagram of X-Ray architecture and its components" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-aws-xray-image.webp"
+  alt="Diagram of X-Ray architecture and its components"
+  caption="Diagram of X-Ray architecture and its components"
+/>
 
 ### Native AWS Service Integrations
 
@@ -199,25 +209,25 @@ While AWS X-Ray typically has a low-performance impact (around 2-4%), this may v
 
 ### Performance benchmarks
 
-OpenTelemetry generally incurs a 3-5% overhead depending on the instrumentation and data volume, making it more suitable for cross-cloud and vendor-neutral setups. 
+OpenTelemetry generally incurs a 3-5% overhead depending on the instrumentation and data volume, making it more suitable for cross-cloud and vendor-neutral setups.
 
 On the other hand, AWS X-Ray generally introduces a 2-4% performance impact, which is optimized for AWS environments directly integrated with native AWS services.
 
 ### Cost Analysis for Different Scales
 
-The cost of OpenTelemetry varies by the choice of backend. Since it’s vendor-neutral, you can control storage and retention costs by selecting a cost-effective backend like [SigNoz](https://signoz.io/). 
+The cost of OpenTelemetry varies by the choice of backend. Since it’s vendor-neutral, you can control storage and retention costs by selecting a cost-effective backend like [SigNoz](https://signoz.io/).
 
 On the other hand, the pricing of AWS X-Ray is tied to AWS, with costs incurred per trace and storage. AWS-native applications might benefit from X-Ray's efficiency and native integration, but costs can rise with heavy usage across services.
 
 ### Integration Capabilities
 
-OpenTelemetry offers broad integration capabilities across cloud providers, databases, and third-party services, providing flexibility for multi-cloud architectures. 
+OpenTelemetry offers broad integration capabilities across cloud providers, databases, and third-party services, providing flexibility for multi-cloud architectures.
 
 On the other hand, AWS X-Ray is designed with AWS-centric integrations, delivering excellent performance within AWS but limited to non-AWS environments.
 
 ### Learning Curve and Developer Experience
 
-OpenTelemetry requires you to be familiar with SDKs, exporters, and configuration. Although setup is more involved, the framework’s flexibility makes it ideal for diverse architectures. 
+OpenTelemetry requires you to be familiar with SDKs, exporters, and configuration. Although setup is more involved, the framework’s flexibility makes it ideal for diverse architectures.
 
 On the other hand, AWS X-Ray has a lower learning curve for AWS users due to its native integration and simplified setup which makes it an excellent choice for teams already invested in AWS.
 
@@ -225,16 +235,16 @@ On the other hand, AWS X-Ray has a lower learning curve for AWS users due to its
 
 We have discussed OpenTelemetry and AWS X-Ray in detail. In this section, we’ll compare OpenTelemetry and AWS X-Ray based on several critical features.
 
-| Feature | OpenTelemetry | AWS X-Ray |
-| --- | --- | --- |
-| Vendor Lock-in | No | Yes (AWS-specific) |
-| Setup Complexity | Moderate, customizable | Low for AWS environments |
-| Cost | Varies by backend; free core | AWS pricing applies |
-| Language Support | Extensive, cross-platform | Limited to AWS SDKs |
-| Cloud Support | Multi-cloud | AWS-focused |
-| Instrumentation | Automatic & Manual options | Primarily Automatic for AWS services |
-| Native Integrations | Platform-agnostic | Deep AWS service integration |
-| Data Export Options | Flexible (SigNoz, Prometheus) | Restricted to AWS |
+| Feature             | OpenTelemetry                 | AWS X-Ray                            |
+| ------------------- | ----------------------------- | ------------------------------------ |
+| Vendor Lock-in      | No                            | Yes (AWS-specific)                   |
+| Setup Complexity    | Moderate, customizable        | Low for AWS environments             |
+| Cost                | Varies by backend; free core  | AWS pricing applies                  |
+| Language Support    | Extensive, cross-platform     | Limited to AWS SDKs                  |
+| Cloud Support       | Multi-cloud                   | AWS-focused                          |
+| Instrumentation     | Automatic & Manual options    | Primarily Automatic for AWS services |
+| Native Integrations | Platform-agnostic             | Deep AWS service integration         |
+| Data Export Options | Flexible (SigNoz, Prometheus) | Restricted to AWS                    |
 
 You can check out the article [OpenTelemetry vs. X-ray](https://signoz.io/comparisons/opentelemetry-vs-xray/) for more clarity.
 
@@ -265,7 +275,7 @@ AWS X-Ray is perfect for AWS-centric environments needing quick, native integrat
 
 ### Scaling Considerations
 
-OpenTelemetry scales effectively across multi-cloud and hybrid setups, which is ideal for businesses that may expand to other providers or platforms over time. 
+OpenTelemetry scales effectively across multi-cloud and hybrid setups, which is ideal for businesses that may expand to other providers or platforms over time.
 
 On the other hand, AWS X-Ray scales within the AWS ecosystem, handling high traffic for AWS services. However, it may be limited if your infrastructure extends significantly beyond AWS.
 
@@ -277,7 +287,7 @@ AWS X-Ray works well for teams with existing AWS expertise, offering straightfor
 
 ### Budget Implications
 
-OpenTelemetry allows you to control costs with customizable trace sampling but may require more setup time and potentially higher costs if combined with other data backends. 
+OpenTelemetry allows you to control costs with customizable trace sampling but may require more setup time and potentially higher costs if combined with other data backends.
 
 On the other hand, AWS X-Ray offers cost-effective tracing within AWS, but costs may add up as the volume of traced data grows, especially with high-frequency sampling.
 
@@ -316,4 +326,4 @@ AWS X-Ray is generally a better choice for AWS-native applications, thanks to it
 ### What are each's main technical limitations?
 
 - AWS X-Ray limits export options to AWS services, making it less flexible for non-AWS use cases.
-- OpenTelemetry requires more configuration and maintenance, especially in multi-cloud or multi-language deployments, where SDK setup and collector configurations may vary.
\ No newline at end of file
+- OpenTelemetry requires more configuration and maintenance, especially in multi-cloud or multi-language deployments, where SDK setup and collector configurations may vary.
diff --git a/data/comparisons/opentelemetry-vs-azure-monitor.mdx b/data/comparisons/opentelemetry-vs-azure-monitor.mdx
index 073513650..2606e19d1 100644
--- a/data/comparisons/opentelemetry-vs-azure-monitor.mdx
+++ b/data/comparisons/opentelemetry-vs-azure-monitor.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry vs Azure Monitor - Choosing the Right Tool
-slug: opentelemetry-vs-azure-monitor
+
 date: 2025-01-22
 tags: [opentelemetry, tools-comparison]
 authors: [manjunath_irukulla]
 description: Explore the key differences between OpenTelemetry and Azure Monitor to make an informed decision for your observability strategy.
-keywords: [OpenTelemetry, Azure Monitor, observability, monitoring, telemetry, cloud-native, application performance]
-
+keywords:
+  [
+    OpenTelemetry,
+    Azure Monitor,
+    observability,
+    monitoring,
+    telemetry,
+    cloud-native,
+    application performance,
+  ]
 ---
 
 OpenTelemetry and Azure Monitor serve different but complementary roles in application observability.
@@ -22,21 +29,29 @@ OpenTelemetry is a powerful open-source observability framework tailored for clo
 - **Comprehensive Telemetry Coverage**: Supporting [distributed tracing](https://signoz.io/distributed-tracing/), metrics, and logs for end-to-end visibility.
 - **Extensible Architecture**: Built to integrate with multiple tools and services, enhancing its adaptability across various tech stacks.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-image.webp" alt="Key Features of OpenTelemetry" caption="Key Features of OpenTelemetry" /> 
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-image.webp"
+  alt="Key Features of OpenTelemetry"
+  caption="Key Features of OpenTelemetry"
+/>
 
 ## What is Azure Monitor?
 
-Azure Monitor, on the other hand, is a full-fledged, integrated monitoring service from Microsoft designed to oversee both Azure cloud environments and hybrid infrastructures. It offers a broad set of capabilities through its core components: 
+Azure Monitor, on the other hand, is a full-fledged, integrated monitoring service from Microsoft designed to oversee both Azure cloud environments and hybrid infrastructures. It offers a broad set of capabilities through its core components:
 
 - **Application Insights**: Focused on tracking application performance and user behaviour, it provides detailed insights into bottlenecks, slow queries, and usage patterns.
 - **Log Analytics**: A centralized platform for collecting, analyzing, and querying logs, offering robust log management for troubleshooting and auditing.
 - **Azure Monitor for Containers**: Specially designed for Kubernetes environments, it provides real-time monitoring of containerized workloads.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-image%201.webp" alt="Key Features of Azure Monitor" caption="Key Features of Azure Monitor" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-image%201.webp"
+  alt="Key Features of Azure Monitor"
+  caption="Key Features of Azure Monitor"
+/>
 
 ### Historical Context and Development
 
-Understanding the evolution of OpenTelemetry and Azure Monitor helps highlight their key roles in addressing modern observability challenges. 
+Understanding the evolution of OpenTelemetry and Azure Monitor helps highlight their key roles in addressing modern observability challenges.
 
 - OpenTelemetry emerged from the convergence of the OpenCensus and OpenTracing projects, two prominent open-source initiatives. The goal was to standardize observability across diverse environments, a need born from the complexity of cloud-native, distributed systems.
 - By creating a unified standard, OpenTelemetry has made significant strides toward simplifying observability in a microservices-heavy world.
@@ -45,7 +60,7 @@ Understanding the evolution of OpenTelemetry and Azure Monitor helps highlight t
 
 ### Industry Trends Driving This Evolution Include:
 
-The rise of microservices, distributed systems, and the shift to multi-cloud strategies have shaped the monitoring landscape. Here’s how these trends impact OpenTelemetry and Azure Monitor: 
+The rise of microservices, distributed systems, and the shift to multi-cloud strategies have shaped the monitoring landscape. Here’s how these trends impact OpenTelemetry and Azure Monitor:
 
 - Demand for Insights: Microservices and distributed architectures require real-time, granular system performance insights, which OpenTelemetry addresses with its distributed tracking capabilities.
 - Multi-Cloud Flexibility: As cloud adoption rises, Azure Monitor supports hybrid and multi-cloud environments, ensuring comprehensive monitoring for diverse infrastructures.
@@ -56,192 +71,193 @@ The rise of microservices, distributed systems, and the shift to multi-cloud str
 
 ## Why Compare OpenTelemetry and Azure Monitor?
 
-Comparing OpenTelemetry and Azure Monitor is crucial for several reasons, each reflecting the growing importance of observability in today’s complex IT environments: 
+Comparing OpenTelemetry and Azure Monitor is crucial for several reasons, each reflecting the growing importance of observability in today’s complex IT environments:
 
-1. The Critical Role of Observability in Modern Architectures: Observability is no longer a luxury but a necessity in cloud-native and distributed systems. Microservices, serverless architectures, and containerized applications demand deep insights into performance, dependencies, and issues. 
-2. The Need for Standardized Telemetry Across Diverse Environments: As IT landscapes become more hybrid and multi-cloud, the need for consistent, standardized telemetry grows. OpenTelemetry excels at providing vendor-neutral, standardized telemetry data across any environment. 
-3. The Challenge of Choosing Between Open-source and Proprietary Solutions: The decision between open-source tools like OpenTelemetry and a proprietary solution like Azure Monitor can impact flexibility, cost, and control. OpenTelemetry offers unmatched flexibility with its open-source nature and wide compatibility, allowing organisations to avoid vendor lock-in. 
-4. Potential Benefits of Integrating OpenTelemetry with Azure Monitor: One of the more intriguing reasons to compare these tools is the opportunity for integration. Microsoft’s support for OpenTelemetry allows organizations to collect telemetry data using OpenTelemetry’s vendor-neutral APIs and SDKs while leveraging Azure Monitor’s powerful analytics, dashboards, and AI-driven insights. . 
+1. The Critical Role of Observability in Modern Architectures: Observability is no longer a luxury but a necessity in cloud-native and distributed systems. Microservices, serverless architectures, and containerized applications demand deep insights into performance, dependencies, and issues.
+2. The Need for Standardized Telemetry Across Diverse Environments: As IT landscapes become more hybrid and multi-cloud, the need for consistent, standardized telemetry grows. OpenTelemetry excels at providing vendor-neutral, standardized telemetry data across any environment.
+3. The Challenge of Choosing Between Open-source and Proprietary Solutions: The decision between open-source tools like OpenTelemetry and a proprietary solution like Azure Monitor can impact flexibility, cost, and control. OpenTelemetry offers unmatched flexibility with its open-source nature and wide compatibility, allowing organisations to avoid vendor lock-in.
+4. Potential Benefits of Integrating OpenTelemetry with Azure Monitor: One of the more intriguing reasons to compare these tools is the opportunity for integration. Microsoft’s support for OpenTelemetry allows organizations to collect telemetry data using OpenTelemetry’s vendor-neutral APIs and SDKs while leveraging Azure Monitor’s powerful analytics, dashboards, and AI-driven insights. .
 
 ## Key Differences Between OpenTelemetry and Azure Monitor
 
 Understanding the core distinctions between OpenTelemetry and Azure Monitor is essential for choosing the right tool for your observability needs. Here are the key areas where they differ:
 
-| Aspect | OpenTelemetry | Azure Monitor |
-| --- | --- | --- |
-| Scope | A framework and set of APIs for collecting, generating, and exporting telemetry data (traces, metrics, logs). Does not provide a backend or dashboard. | Full-stack monitoring solution with built-in analytics, dashboards, alerting, and AI-driven insights. All-in-one tool for cloud and hybrid environments, especially Azure services. |
-| Vendor Neutrality  | Designed for cross-platform and multi-cloud environments. Allows telemetry to be sent to any backend (e.g., Prometheus, SigNoz, Jaeger, Datadog, New Relic). | Optimized for Azure services but can monitor non-Azure environments. Deep integration with Azure services offers enhanced visibility for Azure workloads. |
-| Data Collection | Provides a unified API and SDK for collecting traces, metrics, and logs from a single instrumentation point. | Employs multiple methods for data collection, including agents, SDKs, and integrations with Azure services like Application Insights and Log Analytics. |
-| Extensibility  | Highly extensible with a modular plugin architecture and wide support for open-source integrations, enabling broad customization and flexibility. | Extensible within the Microsoft ecosystem, integrating well with services like Azure Sentinel and Azure Security Center, but less flexible in non-Microsoft environments. |
+| Aspect            | OpenTelemetry                                                                                                                                                | Azure Monitor                                                                                                                                                                       |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Scope             | A framework and set of APIs for collecting, generating, and exporting telemetry data (traces, metrics, logs). Does not provide a backend or dashboard.       | Full-stack monitoring solution with built-in analytics, dashboards, alerting, and AI-driven insights. All-in-one tool for cloud and hybrid environments, especially Azure services. |
+| Vendor Neutrality | Designed for cross-platform and multi-cloud environments. Allows telemetry to be sent to any backend (e.g., Prometheus, SigNoz, Jaeger, Datadog, New Relic). | Optimized for Azure services but can monitor non-Azure environments. Deep integration with Azure services offers enhanced visibility for Azure workloads.                           |
+| Data Collection   | Provides a unified API and SDK for collecting traces, metrics, and logs from a single instrumentation point.                                                 | Employs multiple methods for data collection, including agents, SDKs, and integrations with Azure services like Application Insights and Log Analytics.                             |
+| Extensibility     | Highly extensible with a modular plugin architecture and wide support for open-source integrations, enabling broad customization and flexibility.            | Extensible within the Microsoft ecosystem, integrating well with services like Azure Sentinel and Azure Security Center, but less flexible in non-Microsoft environments.           |
 
 ### Performance and Scalability Considerations
 
-When assessing the performance and scalability of OpenTelemetry and Azure Monitor, several factors come into play: 
+When assessing the performance and scalability of OpenTelemetry and Azure Monitor, several factors come into play:
 
-| Feature | OpenTelemetry | Azure Monitor |
-| --- | --- | --- |
-| Scalability | OpenTelemetry collectors can be horizontally scaled, effectively handling massive amounts of telemetry data across distributed systems and high-traffic environments. 
+| Feature     | OpenTelemetry                                                                                                                                                         | Azure Monitor |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
+| Scalability | OpenTelemetry collectors can be horizontally scaled, effectively handling massive amounts of telemetry data across distributed systems and high-traffic environments. |
 
-It offers flexibility to meet the demands of complex applications with minimal configuration. | Azure Monitor is built for scale and provides automatic scaling for telemetry ingestion and processing. 
+It offers flexibility to meet the demands of complex applications with minimal configuration. | Azure Monitor is built for scale and provides automatic scaling for telemetry ingestion and processing.
 
 It can manage large volumes of data out of the box, especially when monitoring Azure-hosted resources, making it suitable for enterprises requiring seamless scaling with minimal configuration. |
-| Data Retention and Query Performance | OpenTelemetry does not include a backend, so long-term data retention depends on the selected storage solution (e.g., Prometheus, Jaeger). 
+| Data Retention and Query Performance | OpenTelemetry does not include a backend, so long-term data retention depends on the selected storage solution (e.g., Prometheus, Jaeger).
 
 This may require additional infrastructure planning for large-scale deployments. | Azure Monitor offers configurable retention periods and is optimized for efficient querying through Log Analytics.
 
 Its native support for scalable querying and analysis ensures performance even with large datasets, allowing users to quickly retrieve insights and reports. |
-| Cost Implications | OpenTelemetry is open-source and free; however, costs may arise from maintaining additional infrastructure, such as storage backends for telemetry data. 
+| Cost Implications | OpenTelemetry is open-source and free; however, costs may arise from maintaining additional infrastructure, such as storage backends for telemetry data.
 
-Operational costs can vary depending on the chosen backend and deployment scale. | Azure Monitor operates on a pay-per-ingestion and retention model, with costs scaling based on the amount of telemetry data collected. 
+Operational costs can vary depending on the chosen backend and deployment scale. | Azure Monitor operates on a pay-per-ingestion and retention model, with costs scaling based on the amount of telemetry data collected.
 
 For high-volume, long-retention setups, pricing can significantly increase, necessitating users to balance their observability needs with effective cost management. |
 
 ## How to Implement OpenTelemetry with Azure Monitor
 
-In this section, we’ll detail the process of enabling and configuring OpenTelemetry-based data collection within Azure Monitor’s Application Insights for Node.js application. Microsoft offers an Azure Monitor OpenTelemetry Distro that simplifies telemetry collection, offering automatic instrumentation, telemetry collection, and custom telemetry options. Follow these steps to implement OpenTelemetry with Azure Monitor for your application. 
+In this section, we’ll detail the process of enabling and configuring OpenTelemetry-based data collection within Azure Monitor’s Application Insights for Node.js application. Microsoft offers an Azure Monitor OpenTelemetry Distro that simplifies telemetry collection, offering automatic instrumentation, telemetry collection, and custom telemetry options. Follow these steps to implement OpenTelemetry with Azure Monitor for your application.
 
 ### Prerequisites
 
-Before you begin, ensure you have the following: 
+Before you begin, ensure you have the following:
 
-1. Azure Subscription: You can <a href="https://azure.microsoft.com/free/" rel="noopener noreferrer nofollow" target="_blank">Create an Azure subscription for free.</a> 
-2. Application Insights Resource: <a href="https://learn.microsoft.com/en-us/azure/azure-monitor/app/create-workspace-resource#create-a-workspace-based-resource" rel="noopener noreferrer nofollow" target="_blank">Create an Application insights resource.</a> 
+1. Azure Subscription: You can <a href="https://azure.microsoft.com/free/" rel="noopener noreferrer nofollow" target="_blank">Create an Azure subscription for free.</a>
+2. Application Insights Resource: <a href="https://learn.microsoft.com/en-us/azure/azure-monitor/app/create-workspace-resource#create-a-workspace-based-resource" rel="noopener noreferrer nofollow" target="_blank">Create an Application insights resource.</a>
 3. OpenTelemetry Supported Runtimes: Ensure your application is running a supported version of the runtime for Node.js
 
 ### Steps to Enable OpenTelemetry for Azure Monitor
 
 1. Install the Client Library:
-    
-    Start by installing the necessary OpenTelemetry and Azure Monitor libraries for your application: 
-    
-    - For Node.js: Use `npm` to install the `@azure/monitor-opentelemetry` package.
-        
-        ```abap
-        npm install @azure/monitor-opentelemetry
-        npm install @opentelemetry/api @opentelemetry/sdk-metrics @opentelemetry/resources @opentelemetry/semantic-conventions @opentelemetry/sdk-trace-base
-        ```
-        
-2. Modify Your Application: 
-    
-    Now, configure your application to use OpenTelemetry for Azure Monitor. 
-    
-    - For Node.js: Import the `useAzureMonitor()` function and call it to configure OpenTelemetry:
-        
-        ```abap
-        const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
-        useAzureMonitor();
-        ```
-        
-3. Configure Application Insights Connection: 
-    
-    The next step is configuring the Application Insights connection string. This string is unique to your Application Insights resource and dictates where telemetry is sent. 
-    
-    - Retrieve the Connection String:
-        - Go to the Azure portal, and navigate to your Application Insights resource.
-        - Copy the connection string from the Overview tab.
-        
-        <Figure src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-migrate-from-instrumentation-keys-to-connection-strings.webp" alt="Application Insights resource - Connection String (credits - Microsoft Azure)" caption="Application Insights resource - Connection String (credits - Microsoft Azure)" />
-        
-    - Set the Connection String:
-        - Environment Variable: Set the environment variable:
-        
-        ```abap
-        APPLICATIONINSIGHTS_CONNECTION_STRING=<Your connection string>
-        ```
-        
-        - Code Configuration: Set the connection string in the code (recommended only for local development)
-4. Confirm Data Flow: 
-    
-    Once your application is configured, run it, and return to the Azure portal. Open the Application Insights resource and verify that data is being collected. Metrics like server requests and response time should begin to populate the overview tab. 
-    
-    <Figure src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-004d06bc-3041-4dac-b53e-20200b81b0fc.webp" alt="Application monitoring with Azure OpenTelemetry Distro in Azure Monitor resource - (credits - Microsoft Azure)" caption="Application monitoring with Azure OpenTelemetry Distro in Azure Monitor resource - (credits - Microsoft Azure)" /> 
-    
+
+   Start by installing the necessary OpenTelemetry and Azure Monitor libraries for your application:
+   - For Node.js: Use `npm` to install the `@azure/monitor-opentelemetry` package.
+     ```abap
+     npm install @azure/monitor-opentelemetry
+     npm install @opentelemetry/api @opentelemetry/sdk-metrics @opentelemetry/resources @opentelemetry/semantic-conventions @opentelemetry/sdk-trace-base
+     ```
+
+2. Modify Your Application:
+
+   Now, configure your application to use OpenTelemetry for Azure Monitor.
+   - For Node.js: Import the `useAzureMonitor()` function and call it to configure OpenTelemetry:
+     ```abap
+     const { useAzureMonitor } = require("@azure/monitor-opentelemetry");
+     useAzureMonitor();
+     ```
+
+3. Configure Application Insights Connection:
+
+   The next step is configuring the Application Insights connection string. This string is unique to your Application Insights resource and dictates where telemetry is sent.
+   - Retrieve the Connection String:
+     - Go to the Azure portal, and navigate to your Application Insights resource.
+     - Copy the connection string from the Overview tab.
+       <Figure
+         src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-migrate-from-instrumentation-keys-to-connection-strings.webp"
+         alt="Application Insights resource - Connection String (credits - Microsoft Azure)"
+         caption="Application Insights resource - Connection String (credits - Microsoft Azure)"
+       />
+   - Set the Connection String:
+     - Environment Variable: Set the environment variable:
+
+     ```abap
+     APPLICATIONINSIGHTS_CONNECTION_STRING=<Your connection string>
+     ```
+
+     - Code Configuration: Set the connection string in the code (recommended only for local development)
+
+4. Confirm Data Flow:
+
+   Once your application is configured, run it, and return to the Azure portal. Open the Application Insights resource and verify that data is being collected. Metrics like server requests and response time should begin to populate the overview tab.
+
+   <Figure
+     src="/img/comparisons/2024/10/opentelemetry-vs-azure-monitor-004d06bc-3041-4dac-b53e-20200b81b0fc.webp"
+     alt="Application monitoring with Azure OpenTelemetry Distro in Azure Monitor resource - (credits - Microsoft Azure)"
+     caption="Application monitoring with Azure OpenTelemetry Distro in Azure Monitor resource - (credits - Microsoft Azure)"
+   />
 
 ### Use Cases and Scenarios
 
 Here are some refined, practical applications of how OpenTelemetry can be used with Azure Monitor, offering flexibility, scalability, and improved observability for complex environments:
 
-| Monitoring Aspect | Description | Benefits |
-|-------------------|-------------|----------|
-| Microservices Monitoring | OpenTelemetry facilitates seamless instrumentation across diverse microservices architectures, providing consistent telemetry data across various languages and platforms.<br />Azure Monitor offers a centralized platform for aggregating, analyzing, and visualizing this telemetry data, with AI-powered insights. | Organizations can achieve full visibility into their microservices ecosystem, quickly identify latency bottlenecks, and enhance overall application performance through faster anomaly detection. |
-| Multi-Cloud Observability | OpenTelemetry enables organizations to standardize observability across multiple cloud providers, offering a vendor-neutral approach to instrumenting services irrespective of the underlying infrastructure.<br />Azure Monitor consolidates telemetry data from various multi-cloud environments into a single dashboard. | Teams can effectively monitor workloads across Azure, AWS, GCP, and other cloud platforms, fostering comprehensive insights into application performance across different cloud environments. |
-| Hybrid Cloud Monitoring | OpenTelemetry can be deployed in both on-premises systems and cloud-native environments, ensuring consistent data collection from all parts of the infrastructure.<br />Azure Monitor consolidates this telemetry data into a cohesive dashboard for effective monitoring. | Teams gain a unified observability layer for multi-cloud deployments, simplifying cross-cloud performance tracking and issue resolution, thereby enhancing operational efficiency. |
-| Migration from Application Insights | OpenTelemetry can be gradually adopted alongside existing Application Insights SDKs, allowing for a phased migration that minimizes disruption.<br />Azure Monitor serves as an integrated backend for storing and visualizing OpenTelemetry data, providing continuity and enhancing observability. | This gradual approach reduces migration risks, enabling organizations to explore OpenTelemetry's flexibility while retaining the robust features of Azure Monitor, ensuring scalability and adaptability in observability practices. |
+| Monitoring Aspect                   | Description                                                                                                                                                                                                                                                                                                                 | Benefits                                                                                                                                                                                                                             |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Microservices Monitoring            | OpenTelemetry facilitates seamless instrumentation across diverse microservices architectures, providing consistent telemetry data across various languages and platforms.<br />Azure Monitor offers a centralized platform for aggregating, analyzing, and visualizing this telemetry data, with AI-powered insights.      | Organizations can achieve full visibility into their microservices ecosystem, quickly identify latency bottlenecks, and enhance overall application performance through faster anomaly detection.                                    |
+| Multi-Cloud Observability           | OpenTelemetry enables organizations to standardize observability across multiple cloud providers, offering a vendor-neutral approach to instrumenting services irrespective of the underlying infrastructure.<br />Azure Monitor consolidates telemetry data from various multi-cloud environments into a single dashboard. | Teams can effectively monitor workloads across Azure, AWS, GCP, and other cloud platforms, fostering comprehensive insights into application performance across different cloud environments.                                        |
+| Hybrid Cloud Monitoring             | OpenTelemetry can be deployed in both on-premises systems and cloud-native environments, ensuring consistent data collection from all parts of the infrastructure.<br />Azure Monitor consolidates this telemetry data into a cohesive dashboard for effective monitoring.                                                  | Teams gain a unified observability layer for multi-cloud deployments, simplifying cross-cloud performance tracking and issue resolution, thereby enhancing operational efficiency.                                                   |
+| Migration from Application Insights | OpenTelemetry can be gradually adopted alongside existing Application Insights SDKs, allowing for a phased migration that minimizes disruption.<br />Azure Monitor serves as an integrated backend for storing and visualizing OpenTelemetry data, providing continuity and enhancing observability.                        | This gradual approach reduces migration risks, enabling organizations to explore OpenTelemetry's flexibility while retaining the robust features of Azure Monitor, ensuring scalability and adaptability in observability practices. |
 
 ## Benefits of Using OpenTelemetry with Azure Monitor
 
-Integrating OpenTelemetry with Azure Monitor brings together the best of both tools, providing significant advantages for organizations looking at their observability strategies: 
-
-1. Simplified Instrumentation: 
-    - OpenTelemetry’s consistent APIs and SDKs across multiple languages allow developers to instrument applications seamlessly, regardless of the programming languages or platform. This reduces the complexity of setting up observability for polyglot microservices architectures.
-    - Benefit: Developers can quickly onboard to OpenTelemetry, reducing setup time and minimizing errors while ensuring uniform telemetry data collection across distributed services.
-2. Enhanced Portability: 
-    - OpenTelemetry’s vendor-neutral design makes it easier to transition between various monitoring backends, giving organizations the flexibility to switch or experiment with different platforms without needing to re-instrument their applications.
-    - Benefit: Businesses can adopt a truly multi-cloud or hybrid [cloud strategy](https://signoz.io/blog/cloud-strategy/), migrating their [observability stack](https://signoz.io/guides/observability-stack/) as needed without being locked into a single vendor, which can significantly lower long-term costs and technical debt.
-3. Future-Proofing: 
-    - By adopting OpenTelemetry, which is built on open standards, organizations safeguard their observability practices against future vendor-specific limitations or service changes. This helps ensure compatibility with emerging industry trends and technologies.
-    - Benefit: Organizations gain the flexibility to adapt to the evolving observability landscape, reducing the risk of being tied to proprietary systems and benefiting from community-driven innovation.
+Integrating OpenTelemetry with Azure Monitor brings together the best of both tools, providing significant advantages for organizations looking at their observability strategies:
+
+1. Simplified Instrumentation:
+   - OpenTelemetry’s consistent APIs and SDKs across multiple languages allow developers to instrument applications seamlessly, regardless of the programming languages or platform. This reduces the complexity of setting up observability for polyglot microservices architectures.
+   - Benefit: Developers can quickly onboard to OpenTelemetry, reducing setup time and minimizing errors while ensuring uniform telemetry data collection across distributed services.
+2. Enhanced Portability:
+   - OpenTelemetry’s vendor-neutral design makes it easier to transition between various monitoring backends, giving organizations the flexibility to switch or experiment with different platforms without needing to re-instrument their applications.
+   - Benefit: Businesses can adopt a truly multi-cloud or hybrid [cloud strategy](https://signoz.io/blog/cloud-strategy/), migrating their [observability stack](https://signoz.io/guides/observability-stack/) as needed without being locked into a single vendor, which can significantly lower long-term costs and technical debt.
+3. Future-Proofing:
+   - By adopting OpenTelemetry, which is built on open standards, organizations safeguard their observability practices against future vendor-specific limitations or service changes. This helps ensure compatibility with emerging industry trends and technologies.
+   - Benefit: Organizations gain the flexibility to adapt to the evolving observability landscape, reducing the risk of being tied to proprietary systems and benefiting from community-driven innovation.
 4. Advanced Analytics and Insights:
-    - The combination of OpenTelemetry’s detailed telemetry data with Azure Monitor’s advanced analytics. AI-driven insights and rich visualization tools create a robust monitoring ecosystem. Azure Monitor enables organizations to derive actionable insights from OpenTelemetry data through intuitive dashboards, automated alerts, and in-depth query capabilities.
-    - Benefits: Teams can leverage real-time insights to proactively resolve performance issues, improve system reliability, and optimize resource utilization, all while having full control over the data collection and analysis process.
+   - The combination of OpenTelemetry’s detailed telemetry data with Azure Monitor’s advanced analytics. AI-driven insights and rich visualization tools create a robust monitoring ecosystem. Azure Monitor enables organizations to derive actionable insights from OpenTelemetry data through intuitive dashboards, automated alerts, and in-depth query capabilities.
+   - Benefits: Teams can leverage real-time insights to proactively resolve performance issues, improve system reliability, and optimize resource utilization, all while having full control over the data collection and analysis process.
 
 ## Challenges and Limitations
 
-While the combination of OpenTelemetry and Azure Monitor offers many advantages, it also presents several challenges that organizations must consider: 
+While the combination of OpenTelemetry and Azure Monitor offers many advantages, it also presents several challenges that organizations must consider:
 
 - Learning Curve:
-    - OpenTelemetry, though powerful, has a steep learning curve, particularly for teams unfamiliar with its core concepts like spans, traces, and metrics. The need to configure multiple components (instrumentation, libraries, collectors, and exporters) can make initial implementation complex.
-    - Impact: Development teams may require additional training and time to fully grasp OpenTelemetry’s architecture and usage, potentially delaying deployment.
+  - OpenTelemetry, though powerful, has a steep learning curve, particularly for teams unfamiliar with its core concepts like spans, traces, and metrics. The need to configure multiple components (instrumentation, libraries, collectors, and exporters) can make initial implementation complex.
+  - Impact: Development teams may require additional training and time to fully grasp OpenTelemetry’s architecture and usage, potentially delaying deployment.
 - Feature Parity:
-    - Although OpenTelemetry is a robust, open standard for observability, some advanced features native to Azure Monitor (e.g., AI-driven insights, specialized Azure service monitoring) might not be fully accessible when using OpenTelemetry for data collection.
-    - Impact: Teams might face limitations in leveraging all the out-of-the-box capabilities of Azure Monitor, particularly for scenarios that require integrations with Azure services.
+  - Although OpenTelemetry is a robust, open standard for observability, some advanced features native to Azure Monitor (e.g., AI-driven insights, specialized Azure service monitoring) might not be fully accessible when using OpenTelemetry for data collection.
+  - Impact: Teams might face limitations in leveraging all the out-of-the-box capabilities of Azure Monitor, particularly for scenarios that require integrations with Azure services.
 - Compatibility:
-    - While OpenTelemetry is designed to be vendor-neutral, specific Azure-specific monitoring features 9such as integration with Azure-specific metrics or Application insights) may require additional configuration or workarounds when used alongside OpenTelemetry. 
-    - Impact: Ensuring full compatibility between OpenTelemetry and Azure Monitor’s native capabilities might involve extra setup, creating operational overhead for maintaining configurations or developing custom integrations.
+  - While OpenTelemetry is designed to be vendor-neutral, specific Azure-specific monitoring features 9such as integration with Azure-specific metrics or Application insights) may require additional configuration or workarounds when used alongside OpenTelemetry.
+  - Impact: Ensuring full compatibility between OpenTelemetry and Azure Monitor’s native capabilities might involve extra setup, creating operational overhead for maintaining configurations or developing custom integrations.
 - Performance Overhead:
-    - In high-throughput or highly distributed environments, telemetry collection can introduce performance overhead. OpenTelemetry, if not configured properly, may add additional latency or resource consumption, especially when dealing with large volumes of traces and metrics.
-    - Impact: Organizations need to carefully tune OpenTelemetry settings and Azure Monitor’s data ingestion pipelines to balance observability with system performance, which might require performance testing and optimization efforts.
+  - In high-throughput or highly distributed environments, telemetry collection can introduce performance overhead. OpenTelemetry, if not configured properly, may add additional latency or resource consumption, especially when dealing with large volumes of traces and metrics.
+  - Impact: Organizations need to carefully tune OpenTelemetry settings and Azure Monitor’s data ingestion pipelines to balance observability with system performance, which might require performance testing and optimization efforts.
 
 ## Alternative Approaches: SigNoz as a Comprehensive Solution
 
-For organizations looking for an open-source, full-stack observability platform, [SigNoz](https://signoz.io/docs/introduction/) offers a compelling alternative to the combination of OpenTelemetry and Azure Monitor. It merges the flexibility and vendor-neutral benefits of OpenTelemetry with comprehensive monitoring, all within a unified platform. 
+For organizations looking for an open-source, full-stack observability platform, [SigNoz](https://signoz.io/docs/introduction/) offers a compelling alternative to the combination of OpenTelemetry and Azure Monitor. It merges the flexibility and vendor-neutral benefits of OpenTelemetry with comprehensive monitoring, all within a unified platform.
 
 - Full Compatibility with OpenTelemetry Standards:
-    - SigNoz seamlessly integrates with OpenTelemetry, adhering to its vendor-neutral approach. This means organizations can instrument their applications with OpenTelemetry while using SigNoz as the observability backend for data collection, storage, and analysis.
+  - SigNoz seamlessly integrates with OpenTelemetry, adhering to its vendor-neutral approach. This means organizations can instrument their applications with OpenTelemetry while using SigNoz as the observability backend for data collection, storage, and analysis.
 - [End-To-End Application Monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) Capabilities
-    - SigNoz offers a complete monitoring solution with built-in capabilities for distributed tracing, metrics, and logs. It’s designed to provide deep insights into application performance, similar to commercial observability tools, without vendor lock-in.
+  - SigNoz offers a complete monitoring solution with built-in capabilities for distributed tracing, metrics, and logs. It’s designed to provide deep insights into application performance, similar to commercial observability tools, without vendor lock-in.
 - Advanced Tracing, Metrics, and Logging Features
-    - The platform delivers powerful features like root-cause analysis, real-time visualizations, and customizable dashboards, giving engineering teams a holistic view of their system health and helping them troubleshoot issues quickly.
+  - The platform delivers powerful features like root-cause analysis, real-time visualizations, and customizable dashboards, giving engineering teams a holistic view of their system health and helping them troubleshoot issues quickly.
 - Self-Hosted Option For Complete Data Control
-    - One of SigNoz’s key advantages is its self-hosted nature. This gives organizations full control over their observability data, enabling them to manage their telemetry data internally for greater security, compliance, and privacy. It also allows companies to avoid the ongoing costs of SaaS monitoring tools, making SigNoz an attractive option for organizations prioritizing data sovereignty.
+  - One of SigNoz’s key advantages is its self-hosted nature. This gives organizations full control over their observability data, enabling them to manage their telemetry data internally for greater security, compliance, and privacy. It also allows companies to avoid the ongoing costs of SaaS monitoring tools, making SigNoz an attractive option for organizations prioritizing data sovereignty.
 
 To get started with SigNoz:
 
-1. Visit the SigNoz website: [https://signoz.io](https://signoz.io/) for an overview of the platform. 
-2. Review the documentation: Explore the detailed guides to learn about features, setups, and integration with OpenTelemetry, 
-3. Try the demo: Experiment with the live demo or deploy a local instance to test SigNoz in your own environment. 
+1. Visit the SigNoz website: [https://signoz.io](https://signoz.io/) for an overview of the platform.
+2. Review the documentation: Explore the detailed guides to learn about features, setups, and integration with OpenTelemetry,
+3. Try the demo: Experiment with the live demo or deploy a local instance to test SigNoz in your own environment.
 
-<GetStartedSigNoz /> 
+<GetStartedSigNoz />
 
 ## Future Trends in Observability and Monitoring
 
-Observability continues to evolve alongside cloud-native and distributed systems, several key trends are shaping its future: 
+Observability continues to evolve alongside cloud-native and distributed systems, several key trends are shaping its future:
 
 1. Increased OpenTelemetry Adoption:
-    - Wider Integration: OpenTelemetry is rapidly becoming the industry standard for telemetry collection, and its adoption will continue to grow. More platforms, tools, and observability vendors will offer out-of-the-box for OpenTelemetry, simplifying its implementation and making it easier for organizations to unify their telemetry data.
-    - Unified Ecosystem: As OpenTelemetry matures, the observability ecosystem will become more interoperable, reducing the need for vendor-specific solutions.
-2. Enhanced Azure Monitor OpenTelemetry Support: 
-    - Tighter Integration: Microsoft is likely to expand Azure Monitor’s support for OpenTelemetry, providing more seamless integration for users who want to leverage both tools. This could include improved tooling for exposing data from OpenTelemetry to Azure Monitor and enhanced support for hybrid and multi-cloud environments.
-    - Cross-Cloud Monitoring: As OpenTelemetry continues to dominate the open-source space, Azure Monitor will likely optimize its features to accommodate multi-cloud observability, leveraging OpenTelemetry to monitor workloads across non-Azure environments.
-3. AI-Driven Observability: 
-    - Smart Insights: Artificial Intelligence (AI) and Machine Learning will increasingly be used for advanced observability tasks, such as anomaly detection, root-cause analysis, and predictive analytics. This will reduce the manual effort required to troubleshoot issues and enable faster, automated responses to potential problems.
-    - [Proactive Monitoring](https://signoz.io/guides/proactive-monitoring/): ML-powered observability tools will predict performance degradation, capacity issues, or failure points before they occur, allowing teams to proactively mitigate risks.
-4. [Observability as Code](https://signoz.io/guides/observability-as-code/): 
-    - Infrastructure-as-Code (IaC): Observability configurations will increasingly be integrated into infrastructure-as-code practices, enabling teams to automate monitoring setups as part of their deployment pipelines. This trend will push organizations toward observability-as-code, where monitoring becomes an inherent part of the software development lifecycle.
-    - Version Control for Observability: Observability configurations and dashboards will be treated like code, subject to version control review and automated deployment across different environments.
-5. Shift-Left Observability: 
-    - Earlier in the Dev Lifecycle: Developers are becoming more involved in observability, with a focus on shift-left observability, where telemetry and monitoring are embedded into applications earlier in development and testing, reducing the burden on operations teams post-deployment.
-    - DevOps Synergy: Integrating observability with continuous integration/continuous delivery (CI/CD) pipelines will ensure that monitoring is built into every stage of the software development lifecycle, enhancing visibility and fostering better collaboration between developers and operations teams.
+   - Wider Integration: OpenTelemetry is rapidly becoming the industry standard for telemetry collection, and its adoption will continue to grow. More platforms, tools, and observability vendors will offer out-of-the-box for OpenTelemetry, simplifying its implementation and making it easier for organizations to unify their telemetry data.
+   - Unified Ecosystem: As OpenTelemetry matures, the observability ecosystem will become more interoperable, reducing the need for vendor-specific solutions.
+2. Enhanced Azure Monitor OpenTelemetry Support:
+   - Tighter Integration: Microsoft is likely to expand Azure Monitor’s support for OpenTelemetry, providing more seamless integration for users who want to leverage both tools. This could include improved tooling for exposing data from OpenTelemetry to Azure Monitor and enhanced support for hybrid and multi-cloud environments.
+   - Cross-Cloud Monitoring: As OpenTelemetry continues to dominate the open-source space, Azure Monitor will likely optimize its features to accommodate multi-cloud observability, leveraging OpenTelemetry to monitor workloads across non-Azure environments.
+3. AI-Driven Observability:
+   - Smart Insights: Artificial Intelligence (AI) and Machine Learning will increasingly be used for advanced observability tasks, such as anomaly detection, root-cause analysis, and predictive analytics. This will reduce the manual effort required to troubleshoot issues and enable faster, automated responses to potential problems.
+   - [Proactive Monitoring](https://signoz.io/guides/proactive-monitoring/): ML-powered observability tools will predict performance degradation, capacity issues, or failure points before they occur, allowing teams to proactively mitigate risks.
+4. [Observability as Code](https://signoz.io/guides/observability-as-code/):
+   - Infrastructure-as-Code (IaC): Observability configurations will increasingly be integrated into infrastructure-as-code practices, enabling teams to automate monitoring setups as part of their deployment pipelines. This trend will push organizations toward observability-as-code, where monitoring becomes an inherent part of the software development lifecycle.
+   - Version Control for Observability: Observability configurations and dashboards will be treated like code, subject to version control review and automated deployment across different environments.
+5. Shift-Left Observability:
+   - Earlier in the Dev Lifecycle: Developers are becoming more involved in observability, with a focus on shift-left observability, where telemetry and monitoring are embedded into applications earlier in development and testing, reducing the burden on operations teams post-deployment.
+   - DevOps Synergy: Integrating observability with continuous integration/continuous delivery (CI/CD) pipelines will ensure that monitoring is built into every stage of the software development lifecycle, enhancing visibility and fostering better collaboration between developers and operations teams.
 
 ## Key Takeaways
 
@@ -254,11 +270,11 @@ Observability continues to evolve alongside cloud-native and distributed systems
 
 ### What are the main advantages of using OpenTelemetry over proprietary monitoring solutions?
 
-OpenTelemetry provides vendor-neutral, open-source instrumentation, eliminating vendor lock-in and enabling seamless migration between observability  backends. it supports consistent APIs across multiple languages and integrates with a wide range of technologies, making it perfect for diverse, modern tech stacks. This flexibility, combined with broad compatibility, makes OpenTelemetry a future-proof solution for unified, scalable observability across any infrastructure. 
+OpenTelemetry provides vendor-neutral, open-source instrumentation, eliminating vendor lock-in and enabling seamless migration between observability backends. it supports consistent APIs across multiple languages and integrates with a wide range of technologies, making it perfect for diverse, modern tech stacks. This flexibility, combined with broad compatibility, makes OpenTelemetry a future-proof solution for unified, scalable observability across any infrastructure.
 
 ### How does Azure Monitor's OpenTelemetry support compare to other cloud providers?
 
-Azure Monitor's OpenTelemetry support rapidly evolving. While it may not be yet match the maturity of some cloud-agnostic solutions, Microsoft is making significant strides to enhance compatibility and features. Other leading cloud providers similarly  advancing their OpenTelemetry capabilities, making it a strong and growing option for cross-platform observability.
+Azure Monitor's OpenTelemetry support rapidly evolving. While it may not be yet match the maturity of some cloud-agnostic solutions, Microsoft is making significant strides to enhance compatibility and features. Other leading cloud providers similarly advancing their OpenTelemetry capabilities, making it a strong and growing option for cross-platform observability.
 
 ### Can I use OpenTelemetry with Azure Monitor in a multi-cloud environment?
 
@@ -266,4 +282,4 @@ Yes, you can use OpenTelemetry to collect telemetry data from multiple cloud env
 
 ### What are the performance implications of adopting OpenTelemetry in a large-scale Azure deployment?
 
-In large-scale Azure deployments, the performance impact of OpenTelemetry depends on how it's configured. Optimizing settings like sampling rates and fine-tuning collectors is key to minimizing overhead. While there may be a slight performance difference compared to native Azure SDKs, the benefits of standardization, flexibility, and portability often outweigh these concerns, especially for complex environments.
\ No newline at end of file
+In large-scale Azure deployments, the performance impact of OpenTelemetry depends on how it's configured. Optimizing settings like sampling rates and fine-tuning collectors is key to minimizing overhead. While there may be a slight performance difference compared to native Azure SDKs, the benefits of standardization, flexibility, and portability often outweigh these concerns, especially for complex environments.
diff --git a/data/comparisons/opentelemetry-vs-brave.mdx b/data/comparisons/opentelemetry-vs-brave.mdx
index a0bdf4ed8..1238e6634 100644
--- a/data/comparisons/opentelemetry-vs-brave.mdx
+++ b/data/comparisons/opentelemetry-vs-brave.mdx
@@ -1,29 +1,34 @@
 ---
-
 title: OpenTelemetry vs Brave - A Practical Comparison Guide
-slug: opentelemetry-vs-brave
-date: 2024-11-29    
+
+date: 2024-11-29
 tags: [OpenTelemetry]
 authors: [bhavya_sachdeva]
 description: Compare OpenTelemetry and Brave for distributed tracing. Learn key differences, migration strategies, and how to choose the right solution for your needs.
-keywords: [opentelemetry vs brave, distributed tracing comparison, spring boot tracing, brave tracer, opentelemetry implementation]
-
+keywords:
+  [
+    opentelemetry vs brave,
+    distributed tracing comparison,
+    spring boot tracing,
+    brave tracer,
+    opentelemetry implementation,
+  ]
 ---
 
-Choosing between OpenTelemetry and Brave for distributed tracing is a significant decision that can shape the way you monitor and debug your applications. Distributed tracing is essential in understanding microservices' performance and dependencies,  as it provides the visibility necessary to troubleshoot latency issues and optimize resource usage, especially in complex and distributed systems. While both OpenTelemetry and Brave provide robust tracing capabilities, each tool has unique features, advantages, and trade-offs that suit different use cases.
+Choosing between OpenTelemetry and Brave for distributed tracing is a significant decision that can shape the way you monitor and debug your applications. Distributed tracing is essential in understanding microservices' performance and dependencies, as it provides the visibility necessary to troubleshoot latency issues and optimize resource usage, especially in complex and distributed systems. While both OpenTelemetry and Brave provide robust tracing capabilities, each tool has unique features, advantages, and trade-offs that suit different use cases.
 
 In this comprehensive guide, we’ll delve into the key differences, pros and cons, implementation strategies, and practical insights to help you decide on the right tracing solution for your applications.
 
 ## Quick Comparison Table
 
-| Feature/Criteria | OpenTelemetry | Brave | Best Use Case |
-| --- | --- | --- | --- |
-| Tracing Protocols | Supports OTLP (OpenTelemetry Protocol), gRPC, HTTP, and more. | Focuses on Zipkin protocol and integrations. | Large-scale distributed systems requiring diverse protocol support. |
-| Instrumentation | Extensive auto-instrumentation libraries for multiple languages. | Limited auto-instrumentation; manual setup often required. | Applications requiring language-specific instrumentation. |
-| Ecosystem Support | Broad compatibility with numerous observability and APM tools. | Primarily integrates with Zipkin-compatible systems. | Organizations with existing Zipkin infrastructure. |
-| Customization | Highly flexible, supports custom collectors and pipelines. | Limited customization options. | Complex observability pipelines needing tailored data flows. |
-| Community Support | Large, active open-source community. | Smaller but dedicated user base. | Teams seeking community-backed solutions with fast updates. |
-| Best Use Case | Observing and managing complex, heterogeneous environments. | Lightweight tracing for Zipkin-focused setups. | See individual cells for ideal usage. |
+| Feature/Criteria  | OpenTelemetry                                                    | Brave                                                      | Best Use Case                                                       |
+| ----------------- | ---------------------------------------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------- |
+| Tracing Protocols | Supports OTLP (OpenTelemetry Protocol), gRPC, HTTP, and more.    | Focuses on Zipkin protocol and integrations.               | Large-scale distributed systems requiring diverse protocol support. |
+| Instrumentation   | Extensive auto-instrumentation libraries for multiple languages. | Limited auto-instrumentation; manual setup often required. | Applications requiring language-specific instrumentation.           |
+| Ecosystem Support | Broad compatibility with numerous observability and APM tools.   | Primarily integrates with Zipkin-compatible systems.       | Organizations with existing Zipkin infrastructure.                  |
+| Customization     | Highly flexible, supports custom collectors and pipelines.       | Limited customization options.                             | Complex observability pipelines needing tailored data flows.        |
+| Community Support | Large, active open-source community.                             | Smaller but dedicated user base.                           | Teams seeking community-backed solutions with fast updates.         |
+| Best Use Case     | Observing and managing complex, heterogeneous environments.      | Lightweight tracing for Zipkin-focused setups.             | See individual cells for ideal usage.                               |
 
 ## Why Distributed Tracing Matters
 
@@ -36,25 +41,22 @@ However, not all tracing tools are the same. Two popular options, OpenTelemetry
 Both OpenTelemetry and Brave offer solutions for tracing, but they come with different methodologies:
 
 1. OpenTelemetry: Designed to support a wide array of observability signals, including metrics, traces, and logs, in a unified framework. OpenTelemetry is the result of a merger between OpenTracing and OpenCensus and is now widely accepted as an industry standard backed by the Cloud Native Computing Foundation (CNCF).
-    
-    Key Features:
-    
-    - Works with multiple programming languages.
-    - Easily integrates with existing tools like Prometheus, Grafana, or Jaeger.
-    - Supports advanced use cases like tracing requests across hybrid environments (cloud and on-premises).
-    
-    Best For: Teams looking for a flexible, future-proof solution that works across diverse systems and observability needs.
-    
+
+   Key Features:
+   - Works with multiple programming languages.
+   - Easily integrates with existing tools like Prometheus, Grafana, or Jaeger.
+   - Supports advanced use cases like tracing requests across hybrid environments (cloud and on-premises).
+
+   Best For: Teams looking for a flexible, future-proof solution that works across diverse systems and observability needs.
+
 2. Brave: A high-performance tracing tool specifically tailored for Java applications, designed to work closely with Zipkin for tracing data visualization. Brave’s performance is optimized to work with low overhead, making it a solid choice for Java-based systems where Zipkin is already implemented.
-    
-    Key Features:
-    
-    - Optimized for Java-based systems.
-    - Minimal overhead to ensure performance isn’t impacted.
-    - Out-of-the-box integration with Zipkin for fast setup and visualization.
-    
-    Best For: Teams heavily invested in Java and Zipkin who prioritize efficiency and simplicity over broad feature sets.
-    
+
+   Key Features:
+   - Optimized for Java-based systems.
+   - Minimal overhead to ensure performance isn’t impacted.
+   - Out-of-the-box integration with Zipkin for fast setup and visualization.
+
+   Best For: Teams heavily invested in Java and Zipkin who prioritize efficiency and simplicity over broad feature sets.
 
 ---
 
@@ -71,17 +73,11 @@ If Brave were a GPS tracker, it would be a high-performance, specialized device
 ### Key Features of Brave:
 
 - Native [Java Instrumentation](https://signoz.io/opentelemetry/java-auto-instrumentation/):
-    
-    Brave is purpose-built for Java applications. This specialization allows it to be lightweight and efficient, much like a GPS designed only for delivery trucks—optimized for speed and reliability without unnecessary features.
-    
+  Brave is purpose-built for Java applications. This specialization allows it to be lightweight and efficient, much like a GPS designed only for delivery trucks—optimized for speed and reliability without unnecessary features.
 - Built-in Zipkin Compatibility:
-    
-    Brave integrates seamlessly with Zipkin, a widely-used distributed tracing system originally developed by Twitter. If Zipkin is your map, Brave is the tracker feeding it data. This combination ensures that latency and trace data can be easily captured and visualized with minimal setup.
-    
+  Brave integrates seamlessly with Zipkin, a widely-used distributed tracing system originally developed by Twitter. If Zipkin is your map, Brave is the tracker feeding it data. This combination ensures that latency and trace data can be easily captured and visualized with minimal setup.
 - Proven in Production:
-    
-    Brave is designed for high-performance environments where system overhead must be minimal, making it ideal for real-time delivery routes (production systems) that cannot afford delays.
-    
+  Brave is designed for high-performance environments where system overhead must be minimal, making it ideal for real-time delivery routes (production systems) that cannot afford delays.
 
 ### Strengths of Brave:
 
@@ -97,21 +93,13 @@ On the other hand, OpenTelemetry is like a multi-purpose GPS and analytics syste
 ### Key Features of OpenTelemetry:
 
 - A Unified Observability Standard:
-    
-    Unlike Brave, OpenTelemetry isn’t just about traces. It’s like a GPS system that also tracks fuel consumption (metrics) and driver logs (logs), providing a complete picture of the journey.
-    
+  Unlike Brave, OpenTelemetry isn’t just about traces. It’s like a GPS system that also tracks fuel consumption (metrics) and driver logs (logs), providing a complete picture of the journey.
 - Multi-Signal Support:
-    
-    OpenTelemetry doesn’t stop at tracing. It integrates with tools to monitor logs and metrics, enabling a broader observability strategy. This is invaluable for teams that want a holistic understanding of their system's performance.
-    
+  OpenTelemetry doesn’t stop at tracing. It integrates with tools to monitor logs and metrics, enabling a broader observability strategy. This is invaluable for teams that want a holistic understanding of their system's performance.
 - Vendor-Neutral Approach:
-    
-    Data collected through OpenTelemetry can be exported to a wide range of tools, including Prometheus, Jaeger, Datadog, and others. This vendor-neutral design means you’re not locked into a specific ecosystem, giving you the freedom to choose the tools that best fit your needs.
-    
+  Data collected through OpenTelemetry can be exported to a wide range of tools, including Prometheus, Jaeger, Datadog, and others. This vendor-neutral design means you’re not locked into a specific ecosystem, giving you the freedom to choose the tools that best fit your needs.
 - Broad Language Support:
-    
-    With support for 11+ programming languages, OpenTelemetry is highly versatile, making it the preferred choice for teams with a diverse tech stack. It’s like having a GPS that works for trucks, cars, motorcycles, and even bicycles.
-    
+  With support for 11+ programming languages, OpenTelemetry is highly versatile, making it the preferred choice for teams with a diverse tech stack. It’s like having a GPS that works for trucks, cars, motorcycles, and even bicycles.
 
 ### Strengths of OpenTelemetry:
 
@@ -198,11 +186,11 @@ Steps for Manual Instrumentation:
 
 1. Annotate Methods: Use `@WithSpan` to create spans for method invocations.
 2. Create Custom Spans:
-    - Use `tracer.spanBuilder()` to name and configure spans.
-    - Add attributes like `orderId` for contextual data.
+   - Use `tracer.spanBuilder()` to name and configure spans.
+   - Add attributes like `orderId` for contextual data.
 3. Handle Span Lifecycle:
-    - Call `startSpan()` at the beginning of the operation.
-    - Call `span.end()` after completing the operation.
+   - Call `startSpan()` at the beginning of the operation.
+   - Call `span.end()` after completing the operation.
 
 ### Instrumentation Approach in Brave
 
@@ -253,22 +241,21 @@ spring:
       enabled: true
     sampler:
       probability: 1.0
-
 ```
 
 Steps to Integrate:
 
 1. Add Sleuth Dependency:
-    
-    ```xml
-    <dependency>
-        <groupId>org.springframework.cloud</groupId>
-        <artifactId>spring-cloud-starter-sleuth</artifactId>
-        <version>3.1.6</version>
-    </dependency>
-    
-    ```
-    
+
+   ```xml
+   <dependency>
+       <groupId>org.springframework.cloud</groupId>
+       <artifactId>spring-cloud-starter-sleuth</artifactId>
+       <version>3.1.6</version>
+   </dependency>
+
+   ```
+
 2. Enable Brave Tracing: Configure Sleuth to use Brave in `application.yml`.
 3. Customize Sampling: Set the `sampler.probability` for desired trace coverage.
 
@@ -283,22 +270,21 @@ management:
       probability: 1.0
     opentelemetry:
       enabled: true
-
 ```
 
 Steps to Integrate:
 
 1. Add Micrometer Dependency:
-    
-    ```xml
-    <dependency>
-        <groupId>io.micrometer</groupId>
-        <artifactId>micrometer-tracing-bridge-otel</artifactId>
-        <version>1.1.0</version>
-    </dependency>
-    
-    ```
-    
+
+   ```xml
+   <dependency>
+       <groupId>io.micrometer</groupId>
+       <artifactId>micrometer-tracing-bridge-otel</artifactId>
+       <version>1.1.0</version>
+   </dependency>
+
+   ```
+
 2. Enable OpenTelemetry Tracing: Configure `management.tracing` in `application.yml`.
 3. Adjust Sampling: Set `sampling.probability` to control trace data volume.
 
@@ -369,11 +355,11 @@ public class BraveConfig {
 Detailed Explanation:
 
 1. `localServiceName`:
-    - Sets the name of the service for identification in Zipkin.
-    - Example: Use names like `"order-service"` or `"payment-service"` to represent different modules.
+   - Sets the name of the service for identification in Zipkin.
+   - Example: Use names like `"order-service"` or `"payment-service"` to represent different modules.
 2. `Sampler.ALWAYS_SAMPLE`:
-    - Configures all requests to be sampled (useful during development and testing).
-    - In production, you can adjust this to sample a percentage of requests (e.g., `Sampler.create(0.1f)` for 10%).
+   - Configures all requests to be sampled (useful during development and testing).
+   - In production, you can adjust this to sample a percentage of requests (e.g., `Sampler.create(0.1f)` for 10%).
 
 ---
 
@@ -409,13 +395,13 @@ public class OrderService {
 Detailed Explanation:
 
 1. `tracer.nextSpan()`:
-    - Creates a new span with a custom name (`"process-order"`) to track a specific operation.
+   - Creates a new span with a custom name (`"process-order"`) to track a specific operation.
 2. `tag()`:
-    - Adds metadata to the span, such as `orderId` for contextual tracing.
+   - Adds metadata to the span, such as `orderId` for contextual tracing.
 3. `Tracer.SpanInScope`:
-    - Ensures the span is active for the current thread, allowing child spans to link correctly.
+   - Ensures the span is active for the current thread, allowing child spans to link correctly.
 4. `span.finish()`:
-    - Marks the end of the operation, completing the trace.
+   - Marks the end of the operation, completing the trace.
 
 ---
 
@@ -500,14 +486,14 @@ public class OpenTelemetryConfig {
 Detailed Explanation:
 
 1. `OtlpGrpcSpanExporter`:
-    - Configures the exporter to send trace data to an OpenTelemetry Collector using the OTLP protocol.
-    - Replace `http://localhost:4317` with your collector’s actual endpoint.
+   - Configures the exporter to send trace data to an OpenTelemetry Collector using the OTLP protocol.
+   - Replace `http://localhost:4317` with your collector’s actual endpoint.
 2. `SdkTracerProvider`:
-    - Sets up the tracing provider and attaches a span processor for batching and exporting spans.
+   - Sets up the tracing provider and attaches a span processor for batching and exporting spans.
 3. `Resource`:
-    - Defines metadata like `service.name` to identify your service in the trace.
+   - Defines metadata like `service.name` to identify your service in the trace.
 4. `GlobalOpenTelemetry.set()`:
-    - Registers the SDK globally, making the tracer available throughout your application.
+   - Registers the SDK globally, making the tracer available throughout your application.
 
 ---
 
@@ -545,11 +531,11 @@ public class OrderService {
 Detailed Explanation:
 
 1. `spanBuilder()`:
-    - Starts building a new span with a name (`"process-order"`) and attributes.
+   - Starts building a new span with a name (`"process-order"`) and attributes.
 2. `setAttribute()`:
-    - Adds metadata to the span, such as the `orderId`.
+   - Adds metadata to the span, such as the `orderId`.
 3. `span.end()`:
-    - Ends the span after the operation is complete.
+   - Ends the span after the operation is complete.
 
 ---
 
@@ -560,22 +546,22 @@ Detailed Explanation:
 ### When to Choose OpenTelemetry
 
 - Multi-language and multi-signal observability needs:
-    - Use OpenTelemetry if your application requires tracing, metrics, and logs across different programming languages.
+  - Use OpenTelemetry if your application requires tracing, metrics, and logs across different programming languages.
 - Vendor-neutral integrations:
-    - OpenTelemetry integrates with multiple backends like Jaeger, Zipkin, Prometheus, and others.
+  - OpenTelemetry integrates with multiple backends like Jaeger, Zipkin, Prometheus, and others.
 - Future-proofing:
-    - OpenTelemetry is the industry standard for modern observability stacks, with growing support.
+  - OpenTelemetry is the industry standard for modern observability stacks, with growing support.
 
 ---
 
 ### When to Choose Brave
 
 - Java-only applications:
-    - Brave is optimized for Java applications and tightly integrates with Zipkin.
+  - Brave is optimized for Java applications and tightly integrates with Zipkin.
 - High-performance requirements with minimal overhead:
-    - Choose Brave if performance is critical and resource usage must be minimal.
+  - Choose Brave if performance is critical and resource usage must be minimal.
 - Established [observability stack](https://signoz.io/guides/observability-stack/):
-    - If your organization already uses Zipkin, Brave is a natural fit with minimal setup.
+  - If your organization already uses Zipkin, Brave is a natural fit with minimal setup.
 
 ## Implementing Efficient Tracing with SigNoz
 
@@ -596,13 +582,13 @@ To set up SigNoz for efficient tracing:
 1. Install [SigNoz](https://signoz.io/docs/introduction/) using Docker or Kubernetes.
 2. Configure your application to send telemetry data to SigNoz.
 3. For OpenTelemetry Users:
-    - Use OpenTelemetry Protocol (OTLP) exporters to send telemetry data directly to SigNoz.
-    - Configure the endpoint to match the SigNoz OTLP ingestion URL.
-    - Ensure that traces, metrics, and logs are appropriately instrumented in your application.
+   - Use OpenTelemetry Protocol (OTLP) exporters to send telemetry data directly to SigNoz.
+   - Configure the endpoint to match the SigNoz OTLP ingestion URL.
+   - Ensure that traces, metrics, and logs are appropriately instrumented in your application.
 4. For Brave Users:
-    - Configure Brave to send traces via a Zipkin-compatible endpoint.
-    - Ensure the Zipkin endpoint in your Brave configuration points to SigNoz.
-    - Verify that your tracing spans are reaching SigNoz for visualization.
+   - Configure Brave to send traces via a Zipkin-compatible endpoint.
+   - Ensure the Zipkin endpoint in your Brave configuration points to SigNoz.
+   - Verify that your tracing spans are reaching SigNoz for visualization.
 5. Use the SigNoz UI to analyze your traces, metrics, and logs.
 
 <GetStartedSigNoz />
@@ -635,4 +621,4 @@ OpenTelemetry provides extensive auto-instrumentation libraries, while Brave pri
 
 ### 4. Which tool is more suitable for modern applications?
 
-OpenTelemetry is better for modern applications requiring diverse observability needs, while Brave is ideal for simpler setups focusing on Java-based tracing.
\ No newline at end of file
+OpenTelemetry is better for modern applications requiring diverse observability needs, while Brave is ideal for simpler setups focusing on Java-based tracing.
diff --git a/data/comparisons/opentelemetry-vs-cloudwatch.mdx b/data/comparisons/opentelemetry-vs-cloudwatch.mdx
index 6de190767..026c62418 100644
--- a/data/comparisons/opentelemetry-vs-cloudwatch.mdx
+++ b/data/comparisons/opentelemetry-vs-cloudwatch.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: OpenTelemetry vs. CloudWatch - Choosing the Right Monitoring Tool
-slug: opentelemetry-vs-cloudwatch
+
 date: 2024-10-23
 tags: [OpenTelemetry]
 authors: [manjunath_irukulla]
 description: Discover the key differences between OpenTelemetry and CloudWatch for application monitoring. Learn which tool best fits your observability needs.
 keywords: [OpenTelemetry, CloudWatch, observability, monitoring, AWS, DevOps, SigNoz]
-
 ---
 
 In today's complex software landscape, choosing the right monitoring tool is crucial for maintaining healthy, performant applications. OpenTelemetry and CloudWatch are two popular options, each with its strengths and use cases. This leads you to ask the following questions
@@ -19,171 +17,171 @@ This comprehensive guide will help you navigate the OpenTelemetry vs CloudWatch
 
 ## What Is OpenTelemetry?
 
-OpenTelemetry is an open-source observability framework designed to standardize the collection of telemetry data, traces, metrics and logs across distributed systems. It’s vendor-agnostic and supports various programming languages, offering flexibility in collecting and processing observability data. 
+OpenTelemetry is an open-source observability framework designed to standardize the collection of telemetry data, traces, metrics and logs across distributed systems. It’s vendor-agnostic and supports various programming languages, offering flexibility in collecting and processing observability data.
 
-Key features include: 
+Key features include:
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-cloudwatch-image.webp" alt="OpenTelemetry key features: multi-language support, extensibility, standardized data formats, and vendor-agnostic architecture." caption="OpenTelemetry key features: multi-language support, extensibility, standardized data formats, and vendor-agnostic architecture." />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-cloudwatch-image.webp"
+  alt="OpenTelemetry key features: multi-language support, extensibility, standardized data formats, and vendor-agnostic architecture."
+  caption="OpenTelemetry key features: multi-language support, extensibility, standardized data formats, and vendor-agnostic architecture."
+/>
 
 - Vendor-Agnostic Architecture: You can send your telemetry data to multiple backends like Prometheus, Jaeger, Zipkin, and CloudWatch. This flexibility allows you to switch between tools without re-instrumenting your code.
 - Support for Multiple Programming Languages: OpenTelemetry provides SDKs for popular programming languages like Java, Python, JavaScript, Go, and more, ensuring that teams can use it across various services and applications.
 - Extensibility: Its modular design means you can extend OpenTelemetry to fit the specific needs of your infrastructure or applications, whether it’s adding custom exporters or integrating with new tools.
 - Standardized Data Formats: OpenTelemetry enforces standardized formats for telemetry data, ensuring that traces, metrics, and logs are collected consistently. This makes it easier to integrate with various backends and visualization tools.
 
-This standardization and flexibility make OpenTelemetry ideal for organizations managing multi-cloud or hybrid-cloud environments, where observability needs to extend beyond a single provider. 
+This standardization and flexibility make OpenTelemetry ideal for organizations managing multi-cloud or hybrid-cloud environments, where observability needs to extend beyond a single provider.
 
-OpenTelemetry is part of the larger Cloud Native Computing Foundation (CNCF) ecosystem, aligning it with other cloud-native tools like Kubernetes and Prometheus. 
+OpenTelemetry is part of the larger Cloud Native Computing Foundation (CNCF) ecosystem, aligning it with other cloud-native tools like Kubernetes and Prometheus.
 
 ## What is CloudWatch?
 
-CloudWatch is a fully managed observability solution built specifically for AWS users. It is deeply integrated with AWS services, providing a real-time view of the performance and health of AWS resources such as EC2 instances, Lambda functions, and S3 buckets. 
+CloudWatch is a fully managed observability solution built specifically for AWS users. It is deeply integrated with AWS services, providing a real-time view of the performance and health of AWS resources such as EC2 instances, Lambda functions, and S3 buckets.
 
-CloudWatch’s primary focus is on offering a turnkey solution for monitoring AWS infrastructure and applications, so you don’t have to worry about setting up and maintaining a monitoring stack. 
+CloudWatch’s primary focus is on offering a turnkey solution for monitoring AWS infrastructure and applications, so you don’t have to worry about setting up and maintaining a monitoring stack.
 
-Key features of CloudWatch include:  
-
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-cloudwatch-napkin-selection_(12).webp" alt="CloudWatch key features: real-time metrics, pre-built dashboards, log aggregation, and alerts/notifications." caption="CloudWatch key features: real-time metrics, pre-built dashboards, log aggregation, and alerts/notifications." />
+Key features of CloudWatch include:
 
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-cloudwatch-napkin-selection_(12).webp"
+  alt="CloudWatch key features: real-time metrics, pre-built dashboards, log aggregation, and alerts/notifications."
+  caption="CloudWatch key features: real-time metrics, pre-built dashboards, log aggregation, and alerts/notifications."
+/>
 
 - Real-Time Metrics Collections and Visualization: CloudWatch automatically collects and monitors performance data from AWS services, making it easy to track key performance indicators like CPU usage, memory utilization, and network activity.
 - Log Aggregation and Analysis: CloudWatch logs allow you to collect, monitor, and analyze log data from AWS services and applications. The service offers log filtering, searching, and automated log analysis, helping you troubleshoot issues quickly.
 - Alerts, Alarms, and Notifications: CloudWatch provides built-in alerting and alarms, enabling you to set thresholds for metrics and receive notifications when they exceed defined limits. Integrated with services like SNS (Simple Notification Service) ensures that you’re notified via email, SMS, or other methods when something goes wrong.
 - Pre-Built Dashboards: CloudWatch has customizable dashboards that allow you to visualize performance metrics and logs in real-time. AWS services automatically populate CloudWatch with metrics, reducing the manual setup typically required.
 
-CloudWatch is tightly coupled with AWS, making it the natural choice for users who are heavily invested in the AWS ecosystem. It is highly optimized for AWS services to automatically populate CloudWatch with metrics, reducing the manual setup typically required. 
+CloudWatch is tightly coupled with AWS, making it the natural choice for users who are heavily invested in the AWS ecosystem. It is highly optimized for AWS services to automatically populate CloudWatch with metrics, reducing the manual setup typically required.
 
 ## Why Compare OpenTelemetry and CloudWatch?
 
 The growing complexity of modern applications has made observability a critical concern for developers and operations teams. Choosing between open-source and proprietary solutions like OpenTelemetry and CloudWatch can significantly impact your monitoring strategy. Here's why this comparison matters:
 
 - Cloud Adoption: As more organizations embrace cloud-native architectures and microservices, observability becomes more complex. Applications often run across multiple cloud providers and environments, requiring tools to handle [distributed tracing](https://signoz.io/blog/distributed-tracing/), log aggregation, and real-time metric collection.
-    - OpenTelemetry provides a cloud-agnostic solution, making it easier to manage observability across multi-cloud setups.
-    - CloudWatch offers a seamless experience for those fully committed to the AWS ecosystem, making the decision highly dependent on your [cloud strategy](https://signoz.io/blog/cloud-strategy/).
+  - OpenTelemetry provides a cloud-agnostic solution, making it easier to manage observability across multi-cloud setups.
+  - CloudWatch offers a seamless experience for those fully committed to the AWS ecosystem, making the decision highly dependent on your [cloud strategy](https://signoz.io/blog/cloud-strategy/).
 - Standardization: With the rise of cloud-native practices, there’s a growing push for standardized observability tools that work across environments. OpenTelemetry’s role in standardizing telemetry data formats for traces, logs, and metrics is especially valuable for organizations that need consistency across systems.
-    - OpenTelemetry enables faster onboarding of new tools, easier integration into existing observability stacks, and reduces complexity in managing diverse telemetry data sources.
-    - CloudWatch is optimized for AWS but lacks vendor-agnostic standardization, which can become a bottleneck if your infrastructure spans multiple cloud providers.
+  - OpenTelemetry enables faster onboarding of new tools, easier integration into existing observability stacks, and reduces complexity in managing diverse telemetry data sources.
+  - CloudWatch is optimized for AWS but lacks vendor-agnostic standardization, which can become a bottleneck if your infrastructure spans multiple cloud providers.
 - Vendor lock-in: When you rely on a proprietary observability service like CloudWatch, you’re locking yourself into the AWS ecosystem. This can limit your flexibility in the future, especially if your organization plans to adopt a multi-cloud strategy or switch providers.
-    - OpenTelemetry’s vendor-agnostic approach helps you maintain freedom and flexibility by allowing you to switch between backend systems or integrate with multiple tools without having to re-instrument your codebase.
-    - OpenTelemetry can be a strategic advantage for companies prioritizing portability and flexibility in their tech stack.
+  - OpenTelemetry’s vendor-agnostic approach helps you maintain freedom and flexibility by allowing you to switch between backend systems or integrate with multiple tools without having to re-instrument your codebase.
+  - OpenTelemetry can be a strategic advantage for companies prioritizing portability and flexibility in their tech stack.
 - Cost considerations: Proprietary cloud-based observability solutions like CloudWatch often come with usage-based costs for metrics, logs, and alerting. These costs can add up quickly for large-scale applications, especially when monitoring multiple services in production environments.
-    - OpenTelemetry allows you to self-host and customize your observability stack, offering more control over costs.
-    - However, self-hosting OpenTelemetry can involve infrastructure overhead, requiring careful consideration of hardware, storage, and scaling.
-    
-    The trade-off here is between cost predictability and control with OpenTelemetry versus managed convenience with CloudWatch. 
-    
+  - OpenTelemetry allows you to self-host and customize your observability stack, offering more control over costs.
+  - However, self-hosting OpenTelemetry can involve infrastructure overhead, requiring careful consideration of hardware, storage, and scaling.
+    The trade-off here is between cost predictability and control with OpenTelemetry versus managed convenience with CloudWatch.
 - Customization vs Ease of Use: OpenTelemetery offers extensive customization options, allowing teams to tailor their [observability stack](https://signoz.io/guides/observability-stack/) to their specific needs, choosing the best-in-class tools for their use cases.
-    - OpenTelemetry’s flexiblity makes it an attractive choice for organizations with complex requirements or multi-cloud deployments.
-    - CloudWatch provides a fully managed service that integrates deeply with AWS, offering ease of use and quick setup.
-    
-    For organizations focused primarily on AWS, CloudWatch might deliver faster time to insight with minimal setup and maintenance effort. 
-    
+  - OpenTelemetry’s flexiblity makes it an attractive choice for organizations with complex requirements or multi-cloud deployments.
+  - CloudWatch provides a fully managed service that integrates deeply with AWS, offering ease of use and quick setup.
+    For organizations focused primarily on AWS, CloudWatch might deliver faster time to insight with minimal setup and maintenance effort.
 
 ## Key Differences: OpenTelemetry vs. CloudWatch
 
-| Feature | OpenTelemetry | CloudWatch |
-| --- | --- | --- |
-| Data Collection | - Lets you add code to collect detailed telemetry data from your app<br/>- Lots of control over what data is collected<br/>- Requires more setup and coding | - Uses a built-in agent to collect data from AWS services<br/>- Easy setup for AWS monitoring<br/>- Less control, especially for non-AWS services |
-| Data Processing and Storage | - Sends data to different systems using an extra component (OpenTelemetry Collector)<br/>- You can choose where to send your data (multiple platforms supported)<br/>- You must manage extra infrastructure | - Automatically processes and stores data in AWS<br/>- No setup is needed for scaling or storage in AWS<br/>- Only works well within AWS, with less flexibility |
-| Visualization and Analysis | - You must use other tools (like Grafana or Prometheus) to see and analyze your data<br/>- You can pick the tools you prefer<br/>- Requires more learning and setup | - Comes with built-in dashboards and tools to view and analyze data in AWS<br/>- Ready to use dashboards for AWS services<br/>- Limited options for customization, AWS-specific |
+| Feature                     | OpenTelemetry                                                                                                                                                                                               | CloudWatch                                                                                                                                                                      |
+| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Data Collection             | - Lets you add code to collect detailed telemetry data from your app<br/>- Lots of control over what data is collected<br/>- Requires more setup and coding                                                 | - Uses a built-in agent to collect data from AWS services<br/>- Easy setup for AWS monitoring<br/>- Less control, especially for non-AWS services                               |
+| Data Processing and Storage | - Sends data to different systems using an extra component (OpenTelemetry Collector)<br/>- You can choose where to send your data (multiple platforms supported)<br/>- You must manage extra infrastructure | - Automatically processes and stores data in AWS<br/>- No setup is needed for scaling or storage in AWS<br/>- Only works well within AWS, with less flexibility                 |
+| Visualization and Analysis  | - You must use other tools (like Grafana or Prometheus) to see and analyze your data<br/>- You can pick the tools you prefer<br/>- Requires more learning and setup                                         | - Comes with built-in dashboards and tools to view and analyze data in AWS<br/>- Ready to use dashboards for AWS services<br/>- Limited options for customization, AWS-specific |
 
 ## When to Choose OpenTelemetry
 
 OpenTelemetry shines in scenarios such as:
 
-1. Multi-Cloud or Hybrid Environments: If you’re using multiple cloud providers (like AWS, Azure, or Google Cloud)  and need a single, consistent way to monitor everything, OpenTelemetry helps unify your data. 
-2. Avoiding Vendor Lock-In: If you want the freedom to switch between cloud providers without being tied to one, OpenTelemetry offers the flexibility to move your monitoring data wherever you want. 
-3. Custom Monitoring: If your application requires specific types of data collection or you want to integrate with multiple tools for deeper analysis, OpenTelemetry provides the customization you need.  
+1. Multi-Cloud or Hybrid Environments: If you’re using multiple cloud providers (like AWS, Azure, or Google Cloud) and need a single, consistent way to monitor everything, OpenTelemetry helps unify your data.
+2. Avoiding Vendor Lock-In: If you want the freedom to switch between cloud providers without being tied to one, OpenTelemetry offers the flexibility to move your monitoring data wherever you want.
+3. Custom Monitoring: If your application requires specific types of data collection or you want to integrate with multiple tools for deeper analysis, OpenTelemetry provides the customization you need.
 4. Open-Source Tools: If you prefer open-source solutions or want to contribute to or build on community-driven tools, OpenTelemetry is the right choice.
 
 ## When to Choose CloudWatch
 
 CloudWatch is ideal in scenarios such as:
 
-1. AWS-Focused Setup: If your system is mainly built on AWS, CloudWatch integrates seamlessly, making monitoring AWS services easier without additional setup. 
-2. Managed Solution: If you prefer a monitoring tool that doesn’t require you to manage any extra infrastructure, CloudWatch offers a fully managed service where everything is taken care of for you. 
-3. Cost Effective for AWS: For smaller setups on AWS, CloudWatch can be more cost-effective and easier to manage than setting up and maintaining OpenTelemetry. 
-4. Compliance and Security: If you have strict security or compliance requirements, CloudWatch integrates well with AWS’s security and compliance services, making it easier to meet those standards. 
+1. AWS-Focused Setup: If your system is mainly built on AWS, CloudWatch integrates seamlessly, making monitoring AWS services easier without additional setup.
+2. Managed Solution: If you prefer a monitoring tool that doesn’t require you to manage any extra infrastructure, CloudWatch offers a fully managed service where everything is taken care of for you.
+3. Cost Effective for AWS: For smaller setups on AWS, CloudWatch can be more cost-effective and easier to manage than setting up and maintaining OpenTelemetry.
+4. Compliance and Security: If you have strict security or compliance requirements, CloudWatch integrates well with AWS’s security and compliance services, making it easier to meet those standards.
 
 ## Combining OpenTelemetry and CloudWatch
 
-Interestingly, you don't always have to choose between OpenTelemetry and CloudWatch. AWS’s monitoring service provides insights into application performance and operational health. For example, integrating OpenTelemetry with CloudWatch allows you to collect and visualize telemetry data from non-AWS services alongside native [AWS metrics](https://signoz.io/blog/cloudwatch-metrics/), all in a single dashboard. 
+Interestingly, you don't always have to choose between OpenTelemetry and CloudWatch. AWS’s monitoring service provides insights into application performance and operational health. For example, integrating OpenTelemetry with CloudWatch allows you to collect and visualize telemetry data from non-AWS services alongside native [AWS metrics](https://signoz.io/blog/cloudwatch-metrics/), all in a single dashboard.
 
-This unified view makes it easier to monitor complex, multi-cloud environments, detect performance bottlenecks across your entire infrastructure, and troubleshot issues quickly by correlating data from different sources in one place. 
+This unified view makes it easier to monitor complex, multi-cloud environments, detect performance bottlenecks across your entire infrastructure, and troubleshot issues quickly by correlating data from different sources in one place.
 
 ### Steps to Use OpenTelemetry with CloudWatch
 
-1. Set Up AWS Distro for OpenTelemetry (ADOT): 
-    
-    Begin by installing the AWS Distro for OpenTelemetry (ADOT) Collector, which simplifies collecting metrics and traces from your applications. 
-    
-    Installing Command: 
-    
-    ```abap
-    curl -sSL https://get.opentelemetry.io/collector | sh
-    ```
-    
-    After installation, edit the configuration file (`/etc/otelcol/config.yaml`) to define how the telemetry data will be gathered and exported. Below is an example configuration snippet: 
-    
-    ```abap
-    receivers:
-      otlp:
-        protocols:
-          grpc:
-            endpoint: localhost:4317
-          http:
-            endpoint: localhost:4318
-    
-    processors:
-      batch:
-        timeout: 60s
-    
-    exporters:
-      awsemf:
-        namespace: "YourNamespace"
-        log_group_name: "YourLogGroup"
-        log_stream_name: "YourLogStream"
-    
-    service:
-      pipelines:
-        metrics:
-          receivers: [otlp]
-          processors: [batch]
-          exporters: [awsemf]
-    ```
-    
-2. Collect Metrics Using CloudWatch EMF: 
-    
-    The ADOT (AWS Distro for OpenTelemetry ) Collector can send application performance data (metrics) to CloudWatch using a specific format called Embedded Metric Format (EMF). This format is designed to handle complex datasets, such as those with many unique labels or values (high-cardinality metrics), which can happen in large-scale applications.
-    
-    - To make sure your metrics are sent correctly, you’ll need to configure the `awsemf` exporter, a tool that sends this formatted data to CloudWatch for monitoring and analysis.
+1. Set Up AWS Distro for OpenTelemetry (ADOT):
+
+   Begin by installing the AWS Distro for OpenTelemetry (ADOT) Collector, which simplifies collecting metrics and traces from your applications.
+
+   Installing Command:
+
+   ```abap
+   curl -sSL https://get.opentelemetry.io/collector | sh
+   ```
+
+   After installation, edit the configuration file (`/etc/otelcol/config.yaml`) to define how the telemetry data will be gathered and exported. Below is an example configuration snippet:
+
+   ```abap
+   receivers:
+     otlp:
+       protocols:
+         grpc:
+           endpoint: localhost:4317
+         http:
+           endpoint: localhost:4318
+
+   processors:
+     batch:
+       timeout: 60s
+
+   exporters:
+     awsemf:
+       namespace: "YourNamespace"
+       log_group_name: "YourLogGroup"
+       log_stream_name: "YourLogStream"
+
+   service:
+     pipelines:
+       metrics:
+         receivers: [otlp]
+         processors: [batch]
+         exporters: [awsemf]
+   ```
+
+2. Collect Metrics Using CloudWatch EMF:
+
+   The ADOT (AWS Distro for OpenTelemetry ) Collector can send application performance data (metrics) to CloudWatch using a specific format called Embedded Metric Format (EMF). This format is designed to handle complex datasets, such as those with many unique labels or values (high-cardinality metrics), which can happen in large-scale applications.
+   - To make sure your metrics are sent correctly, you’ll need to configure the `awsemf` exporter, a tool that sends this formatted data to CloudWatch for monitoring and analysis.
+
 3. Integrate Tracing with AWS X-Ray:
-    
-     To collect traces, configure the ADOT Collector to send trace data to AWS X-Ray by adding the following exporter to your configuration: 
-    
-     
-    
-    ```abap
-    exporters:
-      xray:
-        region: "us-west-2"  # Specify your AWS region
-    ```
-    
-    Use OpenTelemetry SDKs within your application code to instrument your services, enabling trace data collection and sending it to X-Ray. 
-    
-4. Leverage CloudWatch Container Insights: 
-    
-    For containerized applications, CloudWatch Container Insights can provide aggregated and summarized metrics. Configure the ADOT Collector to capture both infrastructure-level such as CPU and memory usage, and application-level metrics like request latency or error rates, using the following configuration: 
-    
-    ```abap
-    receivers:
-      awscontainerinsightreceiver:
-        cluster_name: "YourClusterName"
-    ```
-    
-5. Monitor and Analyze Your Data: 
-    
-    After configuring the ADOT Collector, you can visualize your collected metrics and traces using the AWS Management Console. Create CloudWatch dashboards to display real-time performance data from your applications. Use AWS X-Ray insights to troubleshoot performance bottlenecks or identify issues across your services. 
-    
+
+   To collect traces, configure the ADOT Collector to send trace data to AWS X-Ray by adding the following exporter to your configuration:
+
+   ```abap
+   exporters:
+     xray:
+       region: "us-west-2"  # Specify your AWS region
+   ```
+
+   Use OpenTelemetry SDKs within your application code to instrument your services, enabling trace data collection and sending it to X-Ray.
+
+4. Leverage CloudWatch Container Insights:
+
+   For containerized applications, CloudWatch Container Insights can provide aggregated and summarized metrics. Configure the ADOT Collector to capture both infrastructure-level such as CPU and memory usage, and application-level metrics like request latency or error rates, using the following configuration:
+
+   ```abap
+   receivers:
+     awscontainerinsightreceiver:
+       cluster_name: "YourClusterName"
+   ```
+
+5. Monitor and Analyze Your Data:
+
+   After configuring the ADOT Collector, you can visualize your collected metrics and traces using the AWS Management Console. Create CloudWatch dashboards to display real-time performance data from your applications. Use AWS X-Ray insights to troubleshoot performance bottlenecks or identify issues across your services.
 
 ## SigNoz: A Modern Alternative for OpenTelemetry-based Monitoring
 
@@ -193,7 +191,7 @@ If you're considering OpenTelemetry, you should also explore SigNoz. It's a full
 - Flexible Hosting: You can either run it on your servers (self-hosted) or use their cloud-based service.
 - Integrated Experience: SigNoz offers an all-in-one platform like CloudWatch but with the added flexibility of OpenTelemetry.
 
-SigNoz is a great modern alternative to traditional monitoring tools. It combines the advantages of open-source technology with a smooth, easy-to-use interface, giving you both power and simplicity in monitoring your applications. 
+SigNoz is a great modern alternative to traditional monitoring tools. It combines the advantages of open-source technology with a smooth, easy-to-use interface, giving you both power and simplicity in monitoring your applications.
 
 [SigNoz](https://signoz.io/docs/introduction/) leverages OpenTelemetry for vendor-agnostic data collection, allowing you to trace requests across distributed systems while visualizing metrics and logs in real-time dashboards all without being locked into any specific vendor. This flexibility makes it easier to troubleshoot issues and optimize performance in complex, multi-cloud environments.
 
@@ -204,31 +202,31 @@ SigNoz is a great modern alternative to traditional monitoring tools. It combine
 When comparing OpenTelemetry and CloudWatch, consider their impact on your application's performance:
 
 - Resource usage:
-    - OpenTelemetry: The performance impact of OpenTelemetry largely depends on how it’s set up. By carefully configuring your data collection, you can minimize the overhead on your application. For example, you can adjust the frequency of data collection or selectively choose which data to capture, helping optimize resource usage.
-    - CloudWatch: The performance of CloudWatch is influenced by the configuration of the CloudWatch Agent. Depending on how you set it up, you might see different levels of impact on system resources.
+  - OpenTelemetry: The performance impact of OpenTelemetry largely depends on how it’s set up. By carefully configuring your data collection, you can minimize the overhead on your application. For example, you can adjust the frequency of data collection or selectively choose which data to capture, helping optimize resource usage.
+  - CloudWatch: The performance of CloudWatch is influenced by the configuration of the CloudWatch Agent. Depending on how you set it up, you might see different levels of impact on system resources.
 - Scalability:
-    - Both are designed to scale with your application, but OpenTelemetry offers greater control over data sampling and filtering. This means you can define how much data to collect based on your specific needs, allowing for more efficient scaling in high-traffic environments.
-    - In contrast, while CloudWatch can also scale, it may not provide as much flexibility regarding what data gets collected.
+  - Both are designed to scale with your application, but OpenTelemetry offers greater control over data sampling and filtering. This means you can define how much data to collect based on your specific needs, allowing for more efficient scaling in high-traffic environments.
+  - In contrast, while CloudWatch can also scale, it may not provide as much flexibility regarding what data gets collected.
 - Network usage: CloudWatch may lead to higher network costs, particularly if you monitor resources across different regions or at high frequencies. This is due to the need for data to be sent over the internet to AWS servers, which can add up depending on your usage patterns.
-    - OpenTelemetry, however, allows you to manage and optimize your data flow, potentially reducing network costs.
+  - OpenTelemetry, however, allows you to manage and optimize your data flow, potentially reducing network costs.
 
 ## Cost Analysis: OpenTelemetry vs. CloudWatch
 
-The cost structures for OpenTelemetry and CloudWatch differ significantly, affecting your budgeting decisions: 
+The cost structures for OpenTelemetry and CloudWatch differ significantly, affecting your budgeting decisions:
 
-CloudWatch Costs: 
+CloudWatch Costs:
 
 - It operates on a pay-per-use model. You’ll incur costs charges for various services, including data ingestion, data storage, and queries.
 - This model can be cost-effective for small to medium workloads but may become more expensive as usage increases.
 
-OpenTelemetry Costs: 
+OpenTelemetry Costs:
 
 - It is open-source, which means there are no licensing fees. However, you have to invest in the infrastructure to support data collection, processing, and storage.
 - This can include costs related to servers, databases, and any additional tools you choose to integrate for analysis and visualization.
 
-Hidden Costs: 
+Hidden Costs:
 
-Be aware of potential hidden costs, such as: 
+Be aware of potential hidden costs, such as:
 
 - Data Transfer Fees: CloudWatch may incur additional charges for transferring data across regions, especially if you have a multi-region setup.
 - Operational Overhead: If you choose to self-host OpenTelemetry, you must consider the ongoing costs of managing your infrastructure, including maintenance, updates, and potential scaling needs.
@@ -236,38 +234,38 @@ Be aware of potential hidden costs, such as:
 
 ## Migration Considerations
 
-If you’re contemplating a switch between CloudWatch and OpenTelemetry, consider the following factors to ensure a smooth transition: 
+If you’re contemplating a switch between CloudWatch and OpenTelemetry, consider the following factors to ensure a smooth transition:
 
 - Data Compatibility:
-    - Check if your existing data can be successfully transferred or maintained during the migration.
-    - Understanding the format and structure of your data in both systems is crucial to avoid data loss.
+  - Check if your existing data can be successfully transferred or maintained during the migration.
+  - Understanding the format and structure of your data in both systems is crucial to avoid data loss.
 - Code Changes:
-    - Transitioning to OpenTelemetry typically requires updates to the instrumentation in your codebase.
-    - This means developers must adjust the code to use OpenTelemetry libraries and APIs to capture telemetry data effectively.
+  - Transitioning to OpenTelemetry typically requires updates to the instrumentation in your codebase.
+  - This means developers must adjust the code to use OpenTelemetry libraries and APIs to capture telemetry data effectively.
 - Team Training:
-    - Both tools have unique learning curves, so it’s essential to plan to upskill your team.
-    - Training sessions or resources may be necessary to help your team understand how to use the new system effectively and leverage its features.
+  - Both tools have unique learning curves, so it’s essential to plan to upskill your team.
+  - Training sessions or resources may be necessary to help your team understand how to use the new system effectively and leverage its features.
 - Parallel Development:
-    - To minimize data loss and ensure a smoother transition, consider a phased migration. Running both systems in parallel for a period allows you to validate the new setup while still relying on the existing system.
-    - This approach can help you identify and resolve any issues before fully committing to the switch.
+  - To minimize data loss and ensure a smoother transition, consider a phased migration. Running both systems in parallel for a period allows you to validate the new setup while still relying on the existing system.
+  - This approach can help you identify and resolve any issues before fully committing to the switch.
 
 ## Future Trends and Developments
 
 The observability landscape is evolving rapidly:
 
 - OpenTelemetry’s Growing Popularity:
-    - Increased Adoption: OpenTelemetry is gaining widespread use across industries. With backing from major tech giants like Google, Microsoft, and others, it’s becoming the go-to standard for collecting and analyzing observability data.
-    - Why It Matters: As more companies adopt OpenTelemetry, it’s creating a more unified and vendor-neutral standard for telemetry data, making it easier for businesses to integrate various tools without being tied to a specific vendor.
+  - Increased Adoption: OpenTelemetry is gaining widespread use across industries. With backing from major tech giants like Google, Microsoft, and others, it’s becoming the go-to standard for collecting and analyzing observability data.
+  - Why It Matters: As more companies adopt OpenTelemetry, it’s creating a more unified and vendor-neutral standard for telemetry data, making it easier for businesses to integrate various tools without being tied to a specific vendor.
 - Enhanced AWS Support for OpenTelemetry:
-    - AWS Integration: Amazon Web Services (AWS) is increasingly improving its support for OpenTelemetry, recognizing the need to offer more flexibility to its users.
-        - By allowing OpenTelemetry to work seamlessly within the AWS ecosystem, AWS gives users more choice in how they monitor and analyze their infrastructure.
-    - What This Means: In the future, we’re likely to see more cross-compatibility between proprietary services like CloudWatch and open-source solutions like OpenTelemetry.
-        - This trend indicates that AWS may continue  embracing open-source standards alongside its own managed services, giving users the best of both worlds.
+  - AWS Integration: Amazon Web Services (AWS) is increasingly improving its support for OpenTelemetry, recognizing the need to offer more flexibility to its users.
+    - By allowing OpenTelemetry to work seamlessly within the AWS ecosystem, AWS gives users more choice in how they monitor and analyze their infrastructure.
+  - What This Means: In the future, we’re likely to see more cross-compatibility between proprietary services like CloudWatch and open-source solutions like OpenTelemetry.
+    - This trend indicates that AWS may continue embracing open-source standards alongside its own managed services, giving users the best of both worlds.
 - New Standards Shaping the Market:
-    - Open-Source Influence: The growing adoption of open-source observability frameworks like OpenTelemetry pushes the industry towards more standardized solutions.
-        - This could impact the development of CloudWatch and other proprietary tools, which may need to evolve to remain competitive and meet user demands for flexibility and interoperability.
-    - Looking Forward: As more organizations prioritize open standards, we could see new features in CloudWatch and other services that focus on seamless integration with open-source tools.
-        - This shift would allow businesses to avoid vendor lock-in and choose the most effective tools for their observability needs.
+  - Open-Source Influence: The growing adoption of open-source observability frameworks like OpenTelemetry pushes the industry towards more standardized solutions.
+    - This could impact the development of CloudWatch and other proprietary tools, which may need to evolve to remain competitive and meet user demands for flexibility and interoperability.
+  - Looking Forward: As more organizations prioritize open standards, we could see new features in CloudWatch and other services that focus on seamless integration with open-source tools.
+    - This shift would allow businesses to avoid vendor lock-in and choose the most effective tools for their observability needs.
 
 ## Key Takeaways
 
@@ -283,11 +281,11 @@ The observability landscape is evolving rapidly:
 
 AWS offers the AWS Distro for OpenTelemetry (ADOT), which allows you to collect and send telemetry data from AWS services to various backends, including CloudWatch and other third-party observability platforms.
 
-This makes it easy to integrate OpenTelemetry with AWS infrastructure while maintaining the flexibility to choose your preferred data destination., 
+This makes it easy to integrate OpenTelemetry with AWS infrastructure while maintaining the flexibility to choose your preferred data destination.,
 
 ### How does CloudWatch pricing compare to self-hosted OpenTelemetry?
 
-CloudWatch uses a pay-per-use pricing model, meaning you’re charged based on the volume of data ingested, stored, and queried. In contrast, self-hosted OpenTelemetry has no licensing fees but incurs infrastructure costs for running and maintaining your telemetry collection and storage systems. 
+CloudWatch uses a pay-per-use pricing model, meaning you’re charged based on the volume of data ingested, stored, and queried. In contrast, self-hosted OpenTelemetry has no licensing fees but incurs infrastructure costs for running and maintaining your telemetry collection and storage systems.
 
 - For small to medium AWS deployments, CloudWatch is often more cost-effective because it eliminates the need to manage infrastructure.
 - However, self-hosted OpenTelemetry may provide greater control and potential cost savings for larger environments or multi-cloud setups.
@@ -299,8 +297,8 @@ CloudWatch uses a pay-per-use pricing model, meaning you’re charged based on t
 
 ### What are the main advantages of using SigNoz over traditional monitoring tools?
 
-SigNoz is a modern, full-stack observability platform built on OpenTelemetry. Its key advantages include: 
+SigNoz is a modern, full-stack observability platform built on OpenTelemetry. Its key advantages include:
 
 - A user-friendly interface that makes it easy to visualize and analyze traces, metrics, and logs in one place.
 - The ability to be self-hosted or used as a cloud service, providing flexibility for different operational needs.
-- Seamless integration with OpenTelemetry gives you the benefits of an open-source ecosystem with the ease of use of a traditional platform. SigNoz combines the flexibility of open-source monitoring with a polished, cohesive user experience, making it a powerful alternative to traditional, proprietary tools.
\ No newline at end of file
+- Seamless integration with OpenTelemetry gives you the benefits of an open-source ecosystem with the ease of use of a traditional platform. SigNoz combines the flexibility of open-source monitoring with a polished, cohesive user experience, making it a powerful alternative to traditional, proprietary tools.
diff --git a/data/comparisons/opentelemetry-vs-dynatrace.mdx b/data/comparisons/opentelemetry-vs-dynatrace.mdx
index 56bb3a1c5..0948ec1d3 100644
--- a/data/comparisons/opentelemetry-vs-dynatrace.mdx
+++ b/data/comparisons/opentelemetry-vs-dynatrace.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: OpenTelemetry vs Dynatrace - Which Tool Is Right for You?
-slug: opentelemetry-vs-dynatrace
+
 date: 2024-11-29
 tags: [OpenTelemetry]
 authors: [nilesh_sinha]
 description: Compare OpenTelemetry and Dynatrace to find the best observability solution for your needs. Explore features, use cases, and integration possibilities.
-keywords: [opentelemetry vs dynatrace, observability tools, application monitoring, performance analysis, cloud-native monitoring]
-
+keywords:
+  [
+    opentelemetry vs dynatrace,
+    observability tools,
+    application monitoring,
+    performance analysis,
+    cloud-native monitoring,
+  ]
 ---
 
 OpenTelemetry and Dynatrace serve different but complementary roles in application observability.
@@ -40,7 +45,7 @@ OpenTelemetry offers several advantages that make it an attractive choice for ma
 
 ### Example: Manually Instrumenting a Java Application for Tracing
 
-To understand how tracing works, here's an example demonstrating how to monitor the duration of an operation using OpenTelemetry. 
+To understand how tracing works, here's an example demonstrating how to monitor the duration of an operation using OpenTelemetry.
 
 A trace is a collection of spans that represent operations or requests across services. Each span provides context for how long an operation took, when it started, and how it relates to other spans.
 Thus, the following example helps monitor how long a particular operation took or identify bottlenecks in processing. Once the operation is complete, we need to stop the trace collection.
@@ -57,7 +62,7 @@ public class ExampleApp {
 
         // Start a span for the current operation
         Span span = tracer.spanBuilder("sampleOperation").startSpan();
-        
+
         // Simulate some business logic or operation
         try {
             System.out.println("Executing sample operation...");
@@ -107,7 +112,7 @@ processors:
 
 exporters:
   jaeger:
-    endpoint: "localhost:14250"
+    endpoint: 'localhost:14250'
     insecure: true
 
 service:
@@ -116,7 +121,6 @@ service:
       receivers: [otlp]
       processors: [batch]
       exporters: [jaeger]
-
 ```
 
 - Receivers: The Collector listens for telemetry data using the OTLP (OpenTelemetry Protocol) over gRPC or HTTP.
@@ -125,7 +129,6 @@ service:
 - Pipeline: This pipeline configuration processes traces by receiving, batching, and exporting them.
 
 > The Collector is crucial for scaling, as it handles large volumes of telemetry data and efficiently forwards it to backends without overloading the application. It also centralizes the configuration of telemetry export, reducing complexity in individual applications.
-> 
 
 Instrumentation Libraries:
 
@@ -153,10 +156,11 @@ java -javaagent:/path/to/opentelemetry-javaagent.jar -jar target/app.jar
 
 Explanation:
 
-- The `opentelemetry-javaagent` **automatically instruments common frameworks like Spring Boot, JDBC, and HTTP clients, but some custom libraries or frameworks might require manual instrumentation.
+- The `opentelemetry-javaagent` \*\*automatically instruments common frameworks like Spring Boot, JDBC, and HTTP clients, but some custom libraries or frameworks might require manual instrumentation.
+
 1. Data Export Options:
-    - OpenTelemetry supports exporting data to multiple backends simultaneously, such as Jaeger (traces), Prometheus (metrics), or Elasticsearch (logs).
-    - You can configure exporters to define where telemetry data will be sent.
+   - OpenTelemetry supports exporting data to multiple backends simultaneously, such as Jaeger (traces), Prometheus (metrics), or Elasticsearch (logs).
+   - You can configure exporters to define where telemetry data will be sent.
 
 ## Dynatrace: Strengths and Ideal Scenarios
 
@@ -199,7 +203,6 @@ Predictive Analytics and Proactive Issue Resolution
 Beyond simply identifying current problems, Davis uses predictive analytics to foresee potential issues before they affect users. By analyzing trends and patterns in historical data, the AI can proactively recommend fixes or optimizations. This helps to resolve problems before they occur, minimizing downtime and ensuring smoother operations.
 
 > While Dynatrace is a proprietary platform and abstracts much of its functionality (like the Davis AI engine) behind its UI, API integrations, and agent-based monitoring, you can still integrate its OneAgent and make use of Dynatrace's API for interacting with monitoring data.
-> 
 
 Here’s an example of how you might query Dynatrace using its API to fetch some monitoring insights programmatically, focusing on automated problem detection:
 
@@ -212,7 +215,7 @@ import java.net.URL;
 public class DynatraceProblemQuery {
     private static final String API_URL = "https://<your-dynatrace-url>/api/v2/problems";
     // Add your Dynatrace API token
-    private static final String API_TOKEN = "<your-api-token>"; 
+    private static final String API_TOKEN = "<your-api-token>";
 
     public static void main(String[] args) {
         try {
@@ -220,17 +223,17 @@ public class DynatraceProblemQuery {
             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
             connection.setRequestMethod("GET");
             connection.setRequestProperty("Authorization", "Api-Token " + API_TOKEN);
-            
+
             // Read the response from the API
             BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
             String inputLine;
             StringBuilder content = new StringBuilder();
-            
+
             while ((inputLine = in.readLine()) != null) {
                 content.append(inputLine);
             }
             in.close();
-            
+
             // Output the fetched problem detection data
             System.out.println("Detected problems: " + content.toString());
         } catch (Exception e) {
@@ -276,73 +279,74 @@ When comparing OpenTelemetry and Dynatrace, it's essential to look at how each t
 Dynatrace is simpler to set up for companies looking for a ready-made solution. OpenTelemetry provides more flexibility but requires more effort.
 
 - OpenTelemetry:
-    - Open-source and community-driven, offering flexibility.
-    - Implementation can require manual instrumentation or configuration, especially if using multiple telemetry types (traces, metrics, logs).
-    - Requires integrating and maintaining third-party backend systems (e.g., Prometheus, Grafana, Jaeger).
+  - Open-source and community-driven, offering flexibility.
+  - Implementation can require manual instrumentation or configuration, especially if using multiple telemetry types (traces, metrics, logs).
+  - Requires integrating and maintaining third-party backend systems (e.g., Prometheus, Grafana, Jaeger).
 - Dynatrace:
-    - OneAgent provides seamless setup and automatic instrumentation without needing much configuration.
-    - Offers out-of-the-box integration for multiple environments and cloud platforms, reducing complexity for users.
-    - The platform handles backend management, requiring minimal configuration for insights.
+  - OneAgent provides seamless setup and automatic instrumentation without needing much configuration.
+  - Offers out-of-the-box integration for multiple environments and cloud platforms, reducing complexity for users.
+  - The platform handles backend management, requiring minimal configuration for insights.
 
 ### Depth of Insights and Analysis Capabilities
 
 Dynatrace wins in terms of deep, AI-powered insights and proactive analysis. OpenTelemetry can offer detailed data but requires third-party tools for deeper insights.
 
 - OpenTelemetry:
-    - Provides rich observability capabilities (traces, metrics, logs), but the depth of analysis depends on the integrated backend systems.
-    - Lacks advanced, AI-driven insights natively, as it’s primarily a data collection framework.
-    - Can be extended by integrating with tools like SigNoz, Grafana, or Jaeger for visualizations and monitoring.
+  - Provides rich observability capabilities (traces, metrics, logs), but the depth of analysis depends on the integrated backend systems.
+  - Lacks advanced, AI-driven insights natively, as it’s primarily a data collection framework.
+  - Can be extended by integrating with tools like SigNoz, Grafana, or Jaeger for visualizations and monitoring.
 - Dynatrace:
-    - Comes with Davis AI, which automatically detects anomalies and performs root-cause analysis.
-    - Provides detailed insights with real-time topology mapping, service-level dependencies, and predictive analytics.
-    - Built-in features for full-stack monitoring, including cloud infrastructure, applications, and user experience.
+  - Comes with Davis AI, which automatically detects anomalies and performs root-cause analysis.
+  - Provides detailed insights with real-time topology mapping, service-level dependencies, and predictive analytics.
+  - Built-in features for full-stack monitoring, including cloud infrastructure, applications, and user experience.
 
 ### Scalability and Performance Impact
 
 Dynatrace offers more polished scalability options out of the box. OpenTelemetry is flexible but may need careful tuning to avoid performance bottlenecks.
 
 - OpenTelemetry:
-    - Highly scalable due to its vendor-neutral design. It can be adapted to fit multiple backends and growing infrastructures.
-    - However, the performance impact depends on the backend and sampling configurations. Misconfiguration could lead to high overhead in large-scale systems.
-    - Requires manual optimization to minimize resource usage.
+  - Highly scalable due to its vendor-neutral design. It can be adapted to fit multiple backends and growing infrastructures.
+  - However, the performance impact depends on the backend and sampling configurations. Misconfiguration could lead to high overhead in large-scale systems.
+  - Requires manual optimization to minimize resource usage.
 - Dynatrace:
-    - Designed for enterprise-grade scalability, with minimal overhead thanks to OneAgent, which is optimized for performance.
-    - Includes built-in optimization techniques to avoid performance hits while monitoring large, distributed systems.
-    - Scales well without additional configuration as your infrastructure grows.
+  - Designed for enterprise-grade scalability, with minimal overhead thanks to OneAgent, which is optimized for performance.
+  - Includes built-in optimization techniques to avoid performance hits while monitoring large, distributed systems.
+  - Scales well without additional configuration as your infrastructure grows.
 
 ### Cost Considerations and Long-Term ROI
 
 OpenTelemetry can be cost-effective in the right hands, especially for smaller teams. Dynatrace is pricier but provides a quicker ROI for enterprises due to its all-in-one nature and automation.
 
 - OpenTelemetry:
-    - Being open-source, there is no direct licensing cost, but infrastructure costs (e.g., storing, analyzing data in Prometheus, Grafana) need to be considered.
-    - The return on investment depends on how effectively it's implemented and maintained.
-    - DIY Approach: More cost-efficient for tech-savvy teams, but the cost of managing backend systems and infrastructure can add up.
+  - Being open-source, there is no direct licensing cost, but infrastructure costs (e.g., storing, analyzing data in Prometheus, Grafana) need to be considered.
+  - The return on investment depends on how effectively it's implemented and maintained.
+  - DIY Approach: More cost-efficient for tech-savvy teams, but the cost of managing backend systems and infrastructure can add up.
 - Dynatrace:
-    - Proprietary SaaS platform with subscription-based pricing. Costs are tied to the size of the infrastructure monitored.
-    - Offers a clear ROI for organizations that prioritize a managed service with automated insights and full-stack monitoring without needing to maintain infrastructure.
-    - Higher upfront costs but offers a comprehensive all-in-one solution, which can save resources over time.
+  - Proprietary SaaS platform with subscription-based pricing. Costs are tied to the size of the infrastructure monitored.
+  - Offers a clear ROI for organizations that prioritize a managed service with automated insights and full-stack monitoring without needing to maintain infrastructure.
+  - Higher upfront costs but offers a comprehensive all-in-one solution, which can save resources over time.
 
 The following table encapsulates the essential aspects of OpenTelemetry and Dynatrace, highlighting their strengths and weaknesses in each area.
 
-| Factor | OpenTelemetry | Dynatrace |
-| --- | --- | --- |
-| Ease of Implementation | - Open-source, community-driven.
+| Factor                 | OpenTelemetry                    | Dynatrace |
+| ---------------------- | -------------------------------- | --------- |
+| Ease of Implementation | - Open-source, community-driven. |
+
 - Requires manual instrumentation/configuration.
 - Integrates with third-party backends (e.g., Prometheus, Grafana). | - Simple setup with OneAgent.
 - Automatic instrumentation.
 - Out-of-the-box integrations for multiple environments. |
-| Depth of Insights | - Provides traces, metrics, and logs.
+  | Depth of Insights | - Provides traces, metrics, and logs.
 - Requires third-party tools for deeper analysis.
 - Lacks AI-driven insights natively. | - Includes Davis AI for anomaly detection and root-cause analysis.
 - Real-time topology mapping and predictive analytics.
 - Full-stack monitoring capabilities. |
-| Scalability and Performance | - Highly scalable and vendor-neutral.
+  | Scalability and Performance | - Highly scalable and vendor-neutral.
 - Performance impact depends on backend configuration.
 - Manual optimization may be needed. | - Enterprise-grade scalability with minimal overhead.
 - OneAgent optimized for performance.
 - Built-in optimization techniques for large systems. |
-| Cost Considerations | - Open-source, no direct licensing costs.
+  | Cost Considerations | - Open-source, no direct licensing costs.
 - Infrastructure costs for storage and analysis.
 - Cost-effective for tech-savvy teams. | - Subscription-based pricing tied to infrastructure size.
 - Higher upfront costs, but clear ROI due to managed services.
@@ -436,35 +440,35 @@ To get started with SigNoz Cloud, follow these steps:
 
 1. Sign Up: Visit the [SigNoz Cloud website](https://signoz.io/) and create an account. This will give you access to the platform's features without needing to manage your own infrastructure.
 2. Configure OpenTelemetry: Integrate your application with OpenTelemetry to start collecting telemetry data. Use the following example to set up the OpenTelemetry SDK for a Java application:
-    
-    ```java
-    import io.opentelemetry.api.OpenTelemetry;
-    import io.opentelemetry.api.trace.Tracer;
-    import io.opentelemetry.exporter.otlp.trace.OtlpTraceExporter;
-    import io.opentelemetry.sdk.OpenTelemetrySdk;
-    import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
-    
-    public class OpenTelemetryConfig {
-    
-        public static void init() {
-            OtlpTraceExporter otlpExporter = OtlpTraceExporter.builder()
-                    .setEndpoint("https://your-signoz-endpoint:4317")
-                    .setHeaders("Authorization=Bearer YOUR_API_KEY")
-                    .build();
-    
-            OpenTelemetrySdk.builder()
-                    .addTracerProvider(tracerProvider -> tracerProvider.addSpanProcessor(SimpleSpanProcessor.create(otlpExporter)))
-                    .buildAndRegisterGlobal();
-        }
-    
-        public static Tracer getTracer() {
-            return OpenTelemetry.getGlobalTracer("YOUR_SERVICE_NAME");
-        }
-    }
-    ```
-    
-    Make sure to replace `your-signoz-endpoint` and `YOUR_API_KEY` with your actual SigNoz endpoint and API key.
-    
+
+   ```java
+   import io.opentelemetry.api.OpenTelemetry;
+   import io.opentelemetry.api.trace.Tracer;
+   import io.opentelemetry.exporter.otlp.trace.OtlpTraceExporter;
+   import io.opentelemetry.sdk.OpenTelemetrySdk;
+   import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+
+   public class OpenTelemetryConfig {
+
+       public static void init() {
+           OtlpTraceExporter otlpExporter = OtlpTraceExporter.builder()
+                   .setEndpoint("https://your-signoz-endpoint:4317")
+                   .setHeaders("Authorization=Bearer YOUR_API_KEY")
+                   .build();
+
+           OpenTelemetrySdk.builder()
+                   .addTracerProvider(tracerProvider -> tracerProvider.addSpanProcessor(SimpleSpanProcessor.create(otlpExporter)))
+                   .buildAndRegisterGlobal();
+       }
+
+       public static Tracer getTracer() {
+           return OpenTelemetry.getGlobalTracer("YOUR_SERVICE_NAME");
+       }
+   }
+   ```
+
+   Make sure to replace `your-signoz-endpoint` and `YOUR_API_KEY` with your actual SigNoz endpoint and API key.
+
 3. Start Collecting Data: Once your application is configured, SigNoz will begin receiving telemetry data, allowing you to visualize performance metrics, traces, and logs.
 4. Explore the Dashboard: Use the SigNoz dashboard to analyze your application's performance, track service dependencies, and identify potential issues.
 
@@ -473,18 +477,18 @@ To get started with SigNoz Cloud, follow these steps:
 If you prefer complete control over your observability stack, SigNoz also offers a self-hosted open-source version. This option allows you to deploy SigNoz on your own infrastructure, providing flexibility in how you manage and store your telemetry data. Here’s how to set it up:
 
 1. Clone the Repository: Start by cloning the SigNoz repository from GitHub.
-    
-    ```bash
-    git clone https://github.com/SigNoz/signoz.git
-    cd signoz
-    ```
-    
+
+   ```bash
+   git clone https://github.com/SigNoz/signoz.git
+   cd signoz
+   ```
+
 2. Run the Installation Script: Use Docker Compose to deploy SigNoz with a single command:
-    
-    ```bash
-    ./scripts/setup.sh
-    ```
-    
+
+   ```bash
+   ./scripts/setup.sh
+   ```
+
 3. Access the Dashboard: Once the setup is complete, you can access the SigNoz dashboard via the default URL (`http://localhost:3301`).
 
 ## Choosing the Right Tool: Decision Framework
@@ -492,20 +496,20 @@ If you prefer complete control over your observability stack, SigNoz also offers
 When selecting an observability tool, it's crucial to evaluate several factors to ensure it aligns with your organization's needs and goals. Here’s a concise decision framework:
 
 1. Assess Your Observability Needs:
-    - Deep Insights: Do you require advanced, AI-powered insights to drive decision-making?
-    - Customization: Is flexibility and customization a priority for your observability strategy?
+   - Deep Insights: Do you require advanced, AI-powered insights to drive decision-making?
+   - Customization: Is flexibility and customization a priority for your observability strategy?
 2. Evaluate Existing Infrastructure:
-    - Complexity: How complex is your current setup? Do you operate in a multi-cloud or hybrid environment?
-    - Diversity: Are you using a wide range of technologies and frameworks that may affect tool compatibility?
+   - Complexity: How complex is your current setup? Do you operate in a multi-cloud or hybrid environment?
+   - Diversity: Are you using a wide range of technologies and frameworks that may affect tool compatibility?
 3. Consider Team Expertise and Resources:
-    - Management Capacity: Does your team have the expertise to manage and configure open-source tools effectively?
-    - Managed Solutions: Would a more managed solution better serve your team's needs?
+   - Management Capacity: Does your team have the expertise to manage and configure open-source tools effectively?
+   - Managed Solutions: Would a more managed solution better serve your team's needs?
 4. Balance Short-Term Ease vs. Long-Term Flexibility:
-    - Vendor Lock-In: Are you concerned about being locked into a single vendor for your observability needs?
-    - Future Strategy: Do you anticipate needing to adapt your observability approach over time?
+   - Vendor Lock-In: Are you concerned about being locked into a single vendor for your observability needs?
+   - Future Strategy: Do you anticipate needing to adapt your observability approach over time?
 5. Evaluate Your Budget:
-    - Cost Justification: Can you justify the investment in a comprehensive solution like Dynatrace?
-    - Open-Source Options: Are you willing to invest time in setting up and configuring open-source alternatives?
+   - Cost Justification: Can you justify the investment in a comprehensive solution like Dynatrace?
+   - Open-Source Options: Are you willing to invest time in setting up and configuring open-source alternatives?
 
 By considering these key points, you can make an informed decision that aligns with your organization's observability strategy and resource availability.
 
@@ -540,4 +544,4 @@ Common challenges in adopting OpenTelemetry include:
 3. Ensuring consistent instrumentation across diverse technology stacks
 4. Keeping up with the rapidly evolving OpenTelemetry ecosystem
 
-However, these challenges are often outweighed by the long-term benefits of flexibility and vendor-neutrality that OpenTelemetry provides.
\ No newline at end of file
+However, these challenges are often outweighed by the long-term benefits of flexibility and vendor-neutrality that OpenTelemetry provides.
diff --git a/data/comparisons/opentelemetry-vs-elastic-apm.mdx b/data/comparisons/opentelemetry-vs-elastic-apm.mdx
index ac51aa39a..883a2eb1e 100644
--- a/data/comparisons/opentelemetry-vs-elastic-apm.mdx
+++ b/data/comparisons/opentelemetry-vs-elastic-apm.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry vs Elastic APM - Which Monitoring Tool to Choose?
-slug: opentelemetry-vs-elastic-apm
+
 date: 2024-11-20
 tags: [OpenTelemetry]
 authors: [nilesh_sinha]
 description: Compare OpenTelemetry and Elastic APM to make the right choice for your monitoring needs. Learn about features, integration options, and key decision factors.
-keywords: [opentelemetry vs elastic apm, application monitoring, observability tools, apm comparison, monitoring solutions, elastic observability, otlp support]
-
+keywords:
+  [
+    opentelemetry vs elastic apm,
+    application monitoring,
+    observability tools,
+    apm comparison,
+    monitoring solutions,
+    elastic observability,
+    otlp support,
+  ]
 ---
 
 OpenTelemetry and Elastic APM serve different but complementary roles in application observability.
@@ -72,14 +79,14 @@ Distributed Tracing
 
 OpenTelemetry and Elastic APM offer distinct features and support options that cater to different observability needs and integration preferences. The table below highlights the key differences between the capabilities of these two tools:
 
-| Feature | OpenTelemetry | Elastic APM |
-| --- | --- | --- |
-| Instrumentation Support | Manual & Automatic | Primarily Automatic |
-| Language Coverage | Java, Python, .NET, Node.js, Ruby, etc. | Java, Python, Go, Node.js, Ruby |
-| Data Collection Method | Uses the OpenTelemetry Collector to gather, process, and export telemetry data | Relies on Elastic APM agents that send data directly to an APM Server |
-| Telemetry Data | Comprehensive: supports traces, metrics, and logs | Primarily traces and logs, with limited support for metrics |
+| Feature                  | OpenTelemetry                                                                                 | Elastic APM                                                                                                  |
+| ------------------------ | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| Instrumentation Support  | Manual & Automatic                                                                            | Primarily Automatic                                                                                          |
+| Language Coverage        | Java, Python, .NET, Node.js, Ruby, etc.                                                       | Java, Python, Go, Node.js, Ruby                                                                              |
+| Data Collection Method   | Uses the OpenTelemetry Collector to gather, process, and export telemetry data                | Relies on Elastic APM agents that send data directly to an APM Server                                        |
+| Telemetry Data           | Comprehensive: supports traces, metrics, and logs                                             | Primarily traces and logs, with limited support for metrics                                                  |
 | Integration Capabilities | Broad integration with observability tools like Jaeger, Prometheus, Grafana Tempo, and Zipkin | Deep integration within the Elastic Stack, leveraging Elasticsearch for storage and Kibana for visualization |
-| Performance Overhead | Configurable (sampling, batching) | Optimized (agent efficiency, sampling) |
+| Performance Overhead     | Configurable (sampling, batching)                                                             | Optimized (agent efficiency, sampling)                                                                       |
 
 Instrumentation Support and Language Coverage
 
@@ -92,7 +99,6 @@ Data Collection Methods and Telemetry types
 - Elastic APM primarily focuses on traces and logs but also gathers some system metrics (like CPU, memory). Elastic APM agents automatically collect these data types, making setup easier for teams with limited instrumentation experience.
 
 > Elastic APM doesn’t require manual instrumentation to track basic traces, but you can add custom spans where needed using the APM agent.
-> 
 
 Integration Capabilities with Other Tools
 
@@ -110,12 +116,12 @@ When choosing between OpenTelemetry and Elastic APM, it’s crucial to weigh eac
 
 Here’s a comparison table that will help you to understand the practical aspects of selecting either OpenTelemetry or Elastic APM based on their organization’s specific needs and resources.
 
-| Decision Factor | OpenTelemetry | Elastic APM |
-| --- | --- | --- |
-| Vendor Lock-in | None, supports multiple backends | High if fully invested in Elastic Stack |
-| Ecosystem Support | CNCF-backed, open-source, large community | Elastic-backed, well-documented |
-| Learning Curve | High, customizable but complex | Lower, easy setup with auto-instrumentation |
-| Cost Implications | Variable, depending on chosen backend | Elastic Cloud or self-hosted (scales with data) |
+| Decision Factor   | OpenTelemetry                             | Elastic APM                                     |
+| ----------------- | ----------------------------------------- | ----------------------------------------------- |
+| Vendor Lock-in    | None, supports multiple backends          | High if fully invested in Elastic Stack         |
+| Ecosystem Support | CNCF-backed, open-source, large community | Elastic-backed, well-documented                 |
+| Learning Curve    | High, customizable but complex            | Lower, easy setup with auto-instrumentation     |
+| Cost Implications | Variable, depending on chosen backend     | Elastic Cloud or self-hosted (scales with data) |
 
 ### Vendor Lock-in Considerations and Flexibility
 
@@ -143,7 +149,7 @@ Integrating OpenTelemetry with Elastic APM provides users the flexibility of Ope
 
 ### Using OpenTelemetry with Elastic APM
 
-OpenTelemetry can be seamlessly integrated with Elastic APM through the OpenTelemetry Collector and Elastic's native OTLP support. Organizations can configure OpenTelemetry-instrumented applications to send their telemetry data (traces, metrics, and logs) to an OpenTelemetry Collector, which then forwards this data to Elastic APM Server using the OTLP exporter. 
+OpenTelemetry can be seamlessly integrated with Elastic APM through the OpenTelemetry Collector and Elastic's native OTLP support. Organizations can configure OpenTelemetry-instrumented applications to send their telemetry data (traces, metrics, and logs) to an OpenTelemetry Collector, which then forwards this data to Elastic APM Server using the OTLP exporter.
 
 Since Elasticsearch 7.13, the APM Server has built-in support for ingesting OTLP data, allowing organizations to leverage OpenTelemetry's vendor-neutral instrumentation while still benefiting from Elastic's powerful storage, analysis, and visualization capabilities in Kibana. This hybrid approach enables teams to maintain flexibility in their instrumentation strategy while utilizing Elastic's robust observability platform, effectively getting the best of both worlds - OpenTelemetry's standardized data collection and Elastic's comprehensive analysis tools.
 
@@ -215,4 +221,4 @@ Elastic APM provides dedicated enterprise support, while OpenTelemetry relies on
 
 ### How do implementation costs compare?
 
-OpenTelemetry is free and open-source, but requires backend infrastructure. Elastic APM includes backend costs within Elastic Cloud or self-hosted deployments.
\ No newline at end of file
+OpenTelemetry is free and open-source, but requires backend infrastructure. Elastic APM includes backend costs within Elastic Cloud or self-hosted deployments.
diff --git a/data/comparisons/opentelemetry-vs-elk.mdx b/data/comparisons/opentelemetry-vs-elk.mdx
index 94a5cd9a4..cc34b165b 100644
--- a/data/comparisons/opentelemetry-vs-elk.mdx
+++ b/data/comparisons/opentelemetry-vs-elk.mdx
@@ -1,13 +1,12 @@
 ---
-
 title: OpenTelemetry vs ELK - Choosing the Right Observability Stack
-slug: opentelemetry-vs-elk
+
 date: 2024-10-30
 tags: [Opentelemetry]
 authors: [bhavya_sachdeva]
 description: Discover the key differences between OpenTelemetry and ELK Stack for observability. Learn which solution best fits your needs and how to implement them effectively.
-keywords: [opentelemetry, elk stack, observability, distributed tracing, logging, metrics, monitoring]
-
+keywords:
+  [opentelemetry, elk stack, observability, distributed tracing, logging, metrics, monitoring]
 ---
 
 In today’s complex and distributed software architectures, observability has become crucial in maintaining system reliability and performance. Two popular observability stacks—OpenTelemetry and ELK (Elasticsearch, Logstash, and Kibana)—offer robust monitoring, tracing, and logging solutions. But how do you choose the right one for your organization?
@@ -139,7 +138,6 @@ service:
     traces:
       receivers: [otlp]
       exporters: [debug]
-
 ```
 
 ### Supported Programming Languages
@@ -151,18 +149,18 @@ OpenTelemetry offers wide language support, with libraries available for Java, P
 ### Data Types
 
 1. Traces
-OpenTelemetry's tracking system allows you to follow a request as it moves through various services in a distributed system. Traces are composed of spans, where each span represents a discrete unit of work within a larger request. This capability is crucial for identifying performance bottlenecks and understanding the behavior of complex transactions.
+   OpenTelemetry's tracking system allows you to follow a request as it moves through various services in a distributed system. Traces are composed of spans, where each span represents a discrete unit of work within a larger request. This capability is crucial for identifying performance bottlenecks and understanding the behavior of complex transactions.
 2. Metrics
-Metrics in OpenTelemetry are designed to provide quantitative information about processes running within your systems. These can be measurements of operational metrics such as CPU and memory usage, or application-specific metrics like queue sizes and the number of active users.
+   Metrics in OpenTelemetry are designed to provide quantitative information about processes running within your systems. These can be measurements of operational metrics such as CPU and memory usage, or application-specific metrics like queue sizes and the number of active users.
 3. Logs
-Logs provide textual records of events that occur within your system. OpenTelemetry aims to unify log management with traces and metrics, providing a cohesive view of observability data. The integration of logs with traces allows developers to correlate log entries with the corresponding trace data, enriching the debugging process.
+   Logs provide textual records of events that occur within your system. OpenTelemetry aims to unify log management with traces and metrics, providing a cohesive view of observability data. The integration of logs with traces allows developers to correlate log entries with the corresponding trace data, enriching the debugging process.
 
 ### Instrumentation Approaches
 
 1. Auto-instrumentation
-OpenTelemetry provides automatic instrumentation capabilities for many popular libraries and frameworks. This means developers can benefit from out-of-the-box traces and metrics without modifying their existing codebase. Auto-instrumentation is a powerful tool for teams looking to quickly enhance their observability with minimal effort.
+   OpenTelemetry provides automatic instrumentation capabilities for many popular libraries and frameworks. This means developers can benefit from out-of-the-box traces and metrics without modifying their existing codebase. Auto-instrumentation is a powerful tool for teams looking to quickly enhance their observability with minimal effort.
 2. Manual Instrumentation
-For scenarios where custom data collection is needed, or where auto-instrumentation may not cover specific use cases, OpenTelemetry allows developers to manually integrate telemetry data collection into their applications. This method offers greater control over which parts of an application are instrumented and how telemetry data is reported.
+   For scenarios where custom data collection is needed, or where auto-instrumentation may not cover specific use cases, OpenTelemetry allows developers to manually integrate telemetry data collection into their applications. This method offers greater control over which parts of an application are instrumented and how telemetry data is reported.
 
 ## ELK Stack: Complete Solution for Logging and Analytics
 
@@ -268,13 +266,13 @@ The ELK Stack is versatile and can be used in many different ways:
 
 [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) and the ELK Stack serve different purposes in observability but complement each other well. OpenTelemetry provides a unified framework to collect traces, metrics, and logs, focusing on seamless integration and reduced manual setup with its automatic instrumentation. Its lightweight design minimizes performance impact, making it highly scalable and suitable for both small applications and large, distributed systems. Supported by major tech companies, OpenTelemetry has a growing ecosystem with regular updates and numerous integrations. On the other hand, the ELK Stack, known for its powerful log management capabilities, is primarily log-centric and requires additional tools, like Beats and APM agents, to handle metrics and traces. Although resource-intensive, ELK excels at handling large data volumes and real-time analytics. With a mature community and extensive plugins, it provides powerful search and visualization options but involves a steeper learning curve due to its multi-component setup.
 
-| Feature | OpenTelemetry | ELK Stack |
-| --- | --- | --- |
-| Data Collection Methods | Unified approach for traces, metrics, and logs with automatic instrumentation | Log-centric; additional tools (e.g., Beats, APM agents) required for metrics and traces |
-| Scalability and Performance | Lightweight and efficient, minimal overhead | Resource-intensive, suited for large data volumes but can be costly |
-| Ease of Implementation | Quick start with auto-instrumentation libraries across languages | Steeper learning curve with multiple components (Elasticsearch, Logstash, Kibana) to configure |
-| Community Support | Backed by major tech players with a growing ecosystem | Mature community with a rich ecosystem of plugins and extensions |
-| Customization Options | Flexible and extensible, customizable data collection and processing | Strong query and visualization capabilities in Kibana and Elasticsearch, customizable ingest pipelines |
+| Feature                     | OpenTelemetry                                                                 | ELK Stack                                                                                              |
+| --------------------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| Data Collection Methods     | Unified approach for traces, metrics, and logs with automatic instrumentation | Log-centric; additional tools (e.g., Beats, APM agents) required for metrics and traces                |
+| Scalability and Performance | Lightweight and efficient, minimal overhead                                   | Resource-intensive, suited for large data volumes but can be costly                                    |
+| Ease of Implementation      | Quick start with auto-instrumentation libraries across languages              | Steeper learning curve with multiple components (Elasticsearch, Logstash, Kibana) to configure         |
+| Community Support           | Backed by major tech players with a growing ecosystem                         | Mature community with a rich ecosystem of plugins and extensions                                       |
+| Customization Options       | Flexible and extensible, customizable data collection and processing          | Strong query and visualization capabilities in Kibana and Elasticsearch, customizable ingest pipelines |
 
 For more details on setting up OpenTelemetry with Python, see [this SigNoz guide](https://signoz.io/opentelemetry/python-overview/), which offers step-by-step insights on installation and integration tailored for Python applications.
 
@@ -374,4 +372,4 @@ OpenTelemetry is a vendor-neutral framework for instrumentation, while Elastic A
 
 ### Is OpenTelemetry suitable for small-scale applications?
 
-Yes, OpenTelemetry can be used for applications of any size. Its auto-instrumentation capabilities make it easy to add observability to small applications, and its lightweight design ensures minimal overhead.
\ No newline at end of file
+Yes, OpenTelemetry can be used for applications of any size. Its auto-instrumentation capabilities make it easy to add observability to small applications, and its lightweight design ensures minimal overhead.
diff --git a/data/comparisons/opentelemetry-vs-fluentbit.mdx b/data/comparisons/opentelemetry-vs-fluentbit.mdx
index 1be5286eb..fcef466dd 100644
--- a/data/comparisons/opentelemetry-vs-fluentbit.mdx
+++ b/data/comparisons/opentelemetry-vs-fluentbit.mdx
@@ -1,20 +1,19 @@
 ---
-
 title: OpenTelemetry vs. Fluent Bit - Which Tool Is Right for You?
-slug: opentelemetry-vs-fluentbit
+
 date: 2024-11-07
-tags: [OpenTelemetry]   
+tags: [OpenTelemetry]
 authors: [sushant_gaurav]
 description: Discover the key differences between OpenTelemetry and Fluent Bit, their use cases, and how to choose the right observability tool for your needs.
-keywords: [opentelemetry, fluentbit, observability, logging, monitoring, data collection, kubernetes]
-
+keywords:
+  [opentelemetry, fluentbit, observability, logging, monitoring, data collection, kubernetes]
 ---
 
 Choosing between OpenTelemetry and Fluent Bit depends on your observability needs. OpenTelemetry is a comprehensive framework for collecting, processing, and exporting traces, metrics, and logs, making it ideal for end-to-end observability. Fluent Bit, on the other hand, is a lightweight log processor and forwarder, optimized for efficient log aggregation and transfer. This article breaks down their differences to help you decide which tool aligns best with your goals.
 
 ## What are OpenTelemetry and Fluent Bit?
 
-OpenTelemetry is an open-source observability platform that standardizes the collection and export of telemetry data (traces, metrics, and logs) from applications and infrastructure.  It provides a unified set of APIs and SDKs that enable developers to instrument their code once and send data to any observability backend. This vendor-neutral approach eliminates vendor lock-in and simplifies the integration of monitoring tools.
+OpenTelemetry is an open-source observability platform that standardizes the collection and export of telemetry data (traces, metrics, and logs) from applications and infrastructure. It provides a unified set of APIs and SDKs that enable developers to instrument their code once and send data to any observability backend. This vendor-neutral approach eliminates vendor lock-in and simplifies the integration of monitoring tools.
 
 Fluent Bit, on the other hand, is a lightweight and fast log processor and forwarder that collects data/logs from multiple sources, processes them (by filtering, parsing, etc.), and forwards them to different outputs like databases, cloud storage, or monitoring systems.
 
@@ -38,16 +37,16 @@ Fluent Bit, on the other hand, is a lightweight and fast log processor and forwa
 
 The below table is an overview of the core differences between OpenTelemetry and Fluent Bit:
 
-| Feature | OpenTelemetry | Fluent Bit |
-| --- | --- | --- |
-| Data Types Handled | Traces, metrics, and logs, ideal for distributed systems and microservices architectures | Primarily focused on log collection and processing |
-| Telemetry Data Processing | Separates pipelines for traces, metrics, and logs, providing a wider reach across infrastructures | Specializes in log filtering, analysis, and forwarding |
-| Architecture | Modular design with components for collection, processing, and export; supports multiple languages | Simple and efficient design focused on low resource usage |
-| Ease of Use | Higher learning curve; requires familiarity with telemetry pipelines | Easier to set up and use, particularly for logging needs |
-| Integration Capabilities | Broad support for languages, frameworks, and cloud providers; integrates with Jaeger, Prometheus, etc. | Integrates with container environments and log-centric technologies like Kubernetes and ElasticSearch |
-| Security Features | Supports secure telemetry transfer with data encryption (e.g., TLS) | Provides TLS-based secure log forwarding |
-| Performance | Scalable but resource-intensive, especially for traces and metrics | Lightweight and efficient, ideal for resource-constrained environments |
-| Delay and Throughput | May introduce delays with complex traces and metrics | Designed for fast log forwarding with minimal overhead |
+| Feature                   | OpenTelemetry                                                                                          | Fluent Bit                                                                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
+| Data Types Handled        | Traces, metrics, and logs, ideal for distributed systems and microservices architectures               | Primarily focused on log collection and processing                                                    |
+| Telemetry Data Processing | Separates pipelines for traces, metrics, and logs, providing a wider reach across infrastructures      | Specializes in log filtering, analysis, and forwarding                                                |
+| Architecture              | Modular design with components for collection, processing, and export; supports multiple languages     | Simple and efficient design focused on low resource usage                                             |
+| Ease of Use               | Higher learning curve; requires familiarity with telemetry pipelines                                   | Easier to set up and use, particularly for logging needs                                              |
+| Integration Capabilities  | Broad support for languages, frameworks, and cloud providers; integrates with Jaeger, Prometheus, etc. | Integrates with container environments and log-centric technologies like Kubernetes and ElasticSearch |
+| Security Features         | Supports secure telemetry transfer with data encryption (e.g., TLS)                                    | Provides TLS-based secure log forwarding                                                              |
+| Performance               | Scalable but resource-intensive, especially for traces and metrics                                     | Lightweight and efficient, ideal for resource-constrained environments                                |
+| Delay and Throughput      | May introduce delays with complex traces and metrics                                                   | Designed for fast log forwarding with minimal overhead                                                |
 
 Let's take a look at the differences in detail:
 
@@ -73,26 +72,25 @@ Let's take a look at the differences in detail:
 
 ## When to Choose OpenTelemetry
 
-When deciding whether to implement OpenTelemetry, consider the specific needs and goals of your observability strategy. 
+When deciding whether to implement OpenTelemetry, consider the specific needs and goals of your observability strategy.
 
 Choose OpenTelemetry when:
 
 1. You have a complex, multi-service environment that requires unified observability.
-    
-    OpenTelemetry enables full-stack insights across distributed services by capturing traces, metrics, and logs, making it easier to identify and troubleshoot issues that span multiple services.
-    
+
+   OpenTelemetry enables full-stack insights across distributed services by capturing traces, metrics, and logs, making it easier to identify and troubleshoot issues that span multiple services.
+
 2. You need standardized telemetry data across different sources.
-    
-    With its vendor-neutral design, OpenTelemetry provides consistent data collection across languages and frameworks, making integration and monitoring straightforward across varied system components.
-    
+
+   With its vendor-neutral design, OpenTelemetry provides consistent data collection across languages and frameworks, making integration and monitoring straightforward across varied system components.
+
 3. You want to future-proof your observability strategy with a widely adopted standard.
-    
-    Backed by major cloud and observability vendors, OpenTelemetry is a continuously evolving and widely supported standard, ensuring long-term compatibility with major platforms.
-    
+
+   Backed by major cloud and observability vendors, OpenTelemetry is a continuously evolving and widely supported standard, ensuring long-term compatibility with major platforms.
+
 4. You require traces, metrics, and logs to be equally prioritized in your observability strategy.
-    
-    OpenTelemetry’s unified approach to capturing all three telemetry types allows for a comprehensive view of system performance and reliability, enabling [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) in complex systems.
-    
+
+   OpenTelemetry’s unified approach to capturing all three telemetry types allows for a comprehensive view of system performance and reliability, enabling [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) in complex systems.
 
 ## When to Choose Fluent Bit
 
@@ -101,38 +99,37 @@ When considering Fluent Bit, evaluate your requirements for log processing and d
 Choose Fluent Bit when:
 
 1. You are working with [Kubernetes logging](https://signoz.io/blog/kubernetes-logging/) scenarios.
-    
-    Fluent Bit is designed to efficiently collect and process logs in containerized environments, making it an ideal choice for Kubernetes clusters where log management is critical for monitoring and debugging.
-    
+
+   Fluent Bit is designed to efficiently collect and process logs in containerized environments, making it an ideal choice for Kubernetes clusters where log management is critical for monitoring and debugging.
+
 2. You need lightweight data collection in resource-constrained environments.
-    
-    With its minimal resource footprint, Fluent Bit is perfect for environments with limited CPU and memory, such as edge computing or IoT devices, where efficient log processing is essential without compromising performance.
-    
+
+   With its minimal resource footprint, Fluent Bit is perfect for environments with limited CPU and memory, such as edge computing or IoT devices, where efficient log processing is essential without compromising performance.
+
 3. You have specific use cases focused on log and event processing.
-    
-    Fluent Bit excels in scenarios that require tailored log handling, such as filtering, parsing, and routing log data to various destinations, making it ideal for organizations that prioritize log management over comprehensive observability.
-    
+
+   Fluent Bit excels in scenarios that require tailored log handling, such as filtering, parsing, and routing log data to various destinations, making it ideal for organizations that prioritize log management over comprehensive observability.
+
 4. You require rapid deployment and minimal configuration.
-    
-    Fluent Bit’s straightforward setup and easy configuration allow for quick implementation, making it suitable for teams that need to get logging solutions up and running without extensive customization or delay.
-    
+
+   Fluent Bit’s straightforward setup and easy configuration allow for quick implementation, making it suitable for teams that need to get logging solutions up and running without extensive customization or delay.
 
 ## Performance Comparison: OpenTelemetry vs. Fluent Bit
 
 When comparing performance, consider the following aspects:
 
 1. CPU and Memory Usage Benchmarks
-    - [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is designed to work in high-throughput situations and generally requires more CPU and memory resources due to its comprehensive data collection capabilities. Tuning may be required to maximize performance at scale.
-    - Fluent Bit's lightweight design allows it to perform well in log-heavy, high-throughput settings while consuming minimum resources.
+   - [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is designed to work in high-throughput situations and generally requires more CPU and memory resources due to its comprehensive data collection capabilities. Tuning may be required to maximize performance at scale.
+   - Fluent Bit's lightweight design allows it to perform well in log-heavy, high-throughput settings while consuming minimum resources.
 2. Data Throughput Capabilities
-    - OpenTelemetry can handle high volumes of telemetry data, but its throughput may vary based on the configuration and the specific data types being collected. While it is capable of processing large amounts of data, the overall performance is influenced by factors such as the complexity of instrumentation and the use of sampling techniques.
-    - Fluent Bit is known for its high throughput capabilities, processing millions of log records per second with low latency. It is specifically designed for efficient log collection and can handle massive volumes of log data, making it ideal for environments with extensive logging requirements.
+   - OpenTelemetry can handle high volumes of telemetry data, but its throughput may vary based on the configuration and the specific data types being collected. While it is capable of processing large amounts of data, the overall performance is influenced by factors such as the complexity of instrumentation and the use of sampling techniques.
+   - Fluent Bit is known for its high throughput capabilities, processing millions of log records per second with low latency. It is specifically designed for efficient log collection and can handle massive volumes of log data, making it ideal for environments with extensive logging requirements.
 3. Latency
-    - OpenTelemetry may introduce some latency in telemetry data collection and transmission, particularly in scenarios involving complex traces or metrics.
-    - Fluent Bit has minimal latency for log processing and forwarding.
+   - OpenTelemetry may introduce some latency in telemetry data collection and transmission, particularly in scenarios involving complex traces or metrics.
+   - Fluent Bit has minimal latency for log processing and forwarding.
 4. Scalability in Large Scale Deployments
-    - OpenTelemetry is highly scalable, suitable for large-scale distributed systems.
-    - Fluent Bit is designed with scalability in mind, easily handling large-scale log collection without significant increases in resource usage.
+   - OpenTelemetry is highly scalable, suitable for large-scale distributed systems.
+   - Fluent Bit is designed with scalability in mind, easily handling large-scale log collection without significant increases in resource usage.
 
 ## Integration and Ecosystem
 
@@ -190,7 +187,7 @@ processors:
 
 exporters:
   prometheus:
-    endpoint: "0.0.0.0:8889"
+    endpoint: '0.0.0.0:8889'
 
 service:
   pipelines:
@@ -207,15 +204,15 @@ In this example, the OTel Collector uses the OTLP receiver to collect data via g
 Instrumentation is the process of integrating OpenTelemetry into your application code to capture telemetry data. OpenTelemetry SDKs are available for various programming languages (such as Java, Python, and Node.js) and can be used to instrument your code automatically or manually. Once the data is collected, the SDK can send it to the OTel Collector through the OTLP receiver configured above. To begin collecting telemetry from your application:
 
 1. Install [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/): Choose and install the SDK for your application’s language. This SDK will handle data collection directly from your application.
-    
-    ```bash
-    # Example for Python
-    pip install opentelemetry-api opentelemetry-sdk opentelemetry-instrumentation
-    ```
-    
+
+   ```bash
+   # Example for Python
+   pip install opentelemetry-api opentelemetry-sdk opentelemetry-instrumentation
+   ```
+
 2. Initialize and Configure Instrumentation:
-    - Automatic Instrumentation: With minimal code changes, you can use language-specific instrumentation libraries to capture data automatically.
-    - Manual Instrumentation: This approach provides finer control, allowing you to specify exactly where and how to capture telemetry data.
+   - Automatic Instrumentation: With minimal code changes, you can use language-specific instrumentation libraries to capture data automatically.
+   - Manual Instrumentation: This approach provides finer control, allowing you to specify exactly where and how to capture telemetry data.
 
 Example of manual instrumentation in Python:
 
@@ -339,37 +336,33 @@ Filters are used to modify or enrich logs before they’re processed by output p
     Record     hostname ${HOSTNAME}
 ```
 
-Note:  Filters are applied in the order they are listed in the configuration. Place filters carefully to control the data flow effectively.
+Note: Filters are applied in the order they are listed in the configuration. Place filters carefully to control the data flow effectively.
 
 1. Optimizing Fluent Bit for Your Specific Use Case
 
 For large-scale or high-traffic environments, Fluent Bit requires optimization to ensure efficient processing and resource utilization.
 
 - Buffering: Configure buffering to handle spikes in log volume without overwhelming output services.
-    
-    ```
-    [OUTPUT]
-        Name           es
-        Host           your-es-host
-        Buffer_Chunk_Size 1M
-        Buffer_Max_Size   5M
-    ```
-    
+  ```
+  [OUTPUT]
+      Name           es
+      Host           your-es-host
+      Buffer_Chunk_Size 1M
+      Buffer_Max_Size   5M
+  ```
 - Multithreading: Enable multithreading to improve log throughput for high-traffic systems.
-    
-    ```
-    [SERVICE]
-        Flush        5
-        Daemon       off
-        Log_Level    info
-        Parsers_File parsers.conf
-        HTTP_Server  On
-        HTTP_Listen  0.0.0.0
-        HTTP_Port    2020
-        storage.path /var/log/fluent-bit-buffers
-        storage.sync normal
-    ```
-    
+  ```
+  [SERVICE]
+      Flush        5
+      Daemon       off
+      Log_Level    info
+      Parsers_File parsers.conf
+      HTTP_Server  On
+      HTTP_Listen  0.0.0.0
+      HTTP_Port    2020
+      storage.path /var/log/fluent-bit-buffers
+      storage.sync normal
+  ```
 - Resource Limits: Set resource limits, especially if running on Kubernetes, to control memory and CPU usage.
 
 ## Enhancing Your Observability Stack with SigNoz
@@ -428,4 +421,4 @@ Fluent Bit has a lower learning curve, with a focus on log gathering and simplif
 Both are open-source, however, costs vary depending on infrastructure requirements:
 
 - Fluent Bit is resource-efficient, resulting in reduced infrastructure and maintenance expenses.
-- OpenTelemetry captures more complete data, which may raise infrastructure requirements and setup complexity while providing more observability and long-term value.
\ No newline at end of file
+- OpenTelemetry captures more complete data, which may raise infrastructure requirements and setup complexity while providing more observability and long-term value.
diff --git a/data/comparisons/opentelemetry-vs-grafana.mdx b/data/comparisons/opentelemetry-vs-grafana.mdx
index 70b647dc2..530571fd8 100644
--- a/data/comparisons/opentelemetry-vs-grafana.mdx
+++ b/data/comparisons/opentelemetry-vs-grafana.mdx
@@ -1,13 +1,21 @@
 ---
-
 title: OpenTelemetry vs Grafana - Key Differences Explained
-slug: opentelemetry-vs-grafana
+
 date: 2024-10-14
 tags: [OpenTelemetry, Grafana, Observability, Monitoring, DevOps]
 authors: [soumya_gupta]
 description: Discover the key differences between OpenTelemetry and Grafana for observability. Learn how to leverage both tools for effective monitoring and visualization.
-keywords: [OpenTelemetry, Grafana, observability, monitoring, data visualization, telemetry, open-source, DevOps]
-
+keywords:
+  [
+    OpenTelemetry,
+    Grafana,
+    observability,
+    monitoring,
+    data visualization,
+    telemetry,
+    open-source,
+    DevOps,
+  ]
 ---
 
 OpenTelemetry and Grafana are two essential but fundamentally different observability tools. OpenTelemetry standardizes data collection across your stack, while Grafana excels at visualization and analysis. Understanding their distinct roles and capabilities is crucial for building an effective observability strategy.
@@ -23,12 +31,12 @@ Grafana, on the other hand, is an open-source platform for data visualization an
 Both tools have emerged as key players in the observability ecosystem, with OpenTelemetry focusing on data collection and Grafana on data visualization. OpenTelemetry was born from the merger of OpenCensus and OpenTracing projects in 2019, while Grafana has been around since 2014, continuously evolving its capabilities.
 
 ### Can They Be Used Together?
+
 Yes, OpenTelemetry and Grafana work very well together:
 
 - **Instrumentation with OTel**: Use OpenTelemetry to instrument your applications and collect traces, metrics, and logs.
 - **Visualization with Grafana**: Export telemetry data from OpenTelemetry to backends like Prometheus (metrics), Loki (logs), or Tempo (traces), and use Grafana to visualize and monitor the data.
 
-
 ## Core Functionalities: OpenTelemetry vs Grafana
 
 The primary distinction between OpenTelemetry and Grafana lies in their core functionalities:
@@ -36,45 +44,38 @@ The primary distinction between OpenTelemetry and Grafana lies in their core fun
 ### OpenTelemetry
 
 - Primary Function: Data collection and standardization
-    
-    OpenTelemetry's primary function is to effectively collect and standardize telemetry data, such as metrics, logs, and traces, from various sources within your application ecosystem. This standardization ensures that data is collected in a consistent and structured format, making it easier to analyze and visualize.
-    
+  OpenTelemetry's primary function is to effectively collect and standardize telemetry data, such as metrics, logs, and traces, from various sources within your application ecosystem. This standardization ensures that data is collected in a consistent and structured format, making it easier to analyze and visualize.
 - Unified Instrumentation Across Languages
-    
-    OpenTelemetry provides a unified approach (API and SDKs) to instrumenting applications regardless of the programming language used. This unified approach reduces complexity and helps developers focus on building features instead of wrestling with different monitoring tools.
-    
+  OpenTelemetry provides a unified approach (API and SDKs) to instrumenting applications regardless of the programming language used. This unified approach reduces complexity and helps developers focus on building features instead of wrestling with different monitoring tools.
 - Multi-Language and Framework Support
-    
-    It supports a wide range of programming languages and frameworks, including popular options like Java, Python, .NET, Go, JavaScript, and Node.js. This broad support enables you to instrument applications built with different technologies, ensuring comprehensive coverage of your telemetry data.
-    
+  It supports a wide range of programming languages and frameworks, including popular options like Java, Python, .NET, Go, JavaScript, and Node.js. This broad support enables you to instrument applications built with different technologies, ensuring comprehensive coverage of your telemetry data.
 - Vendor-Neutral and Agnostic Data Export
-    
-    OpenTelemetry is designed to be vendor-neutral and agnostic, allowing you to export your collected telemetry data to various backend systems for analysis and visualization. This flexibility empowers you to choose the tools that best suit your needs and preferences, without being tied to a specific vendor or proprietary solution.
-    
+  OpenTelemetry is designed to be vendor-neutral and agnostic, allowing you to export your collected telemetry data to various backend systems for analysis and visualization. This flexibility empowers you to choose the tools that best suit your needs and preferences, without being tied to a specific vendor or proprietary solution.
+
 <GetStartedOpenTelemetryButton />
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-grafana-image.webp" alt="OpenTelemetry Structure (Picture from: opentelemetry docs)" caption="OpenTelemetry Structure (Picture from: opentelemetry docs)" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-grafana-image.webp"
+  alt="OpenTelemetry Structure (Picture from: opentelemetry docs)"
+  caption="OpenTelemetry Structure (Picture from: opentelemetry docs)"
+/>
 
 ### Grafana
 
 - Primary Function: Data Visualization and Dashboarding
-    
-    Grafana's primary function is to visualize and analyze telemetry data. With a plethora of visualization types—from heat maps to histograms, it allows users to present data in a way that’s not only informative but also visually appealing. You can even customize these dashboards to meet specific team needs, ensuring that everyone sees the data that matters most to them.
-    
+  Grafana's primary function is to visualize and analyze telemetry data. With a plethora of visualization types—from heat maps to histograms, it allows users to present data in a way that’s not only informative but also visually appealing. You can even customize these dashboards to meet specific team needs, ensuring that everyone sees the data that matters most to them.
 - Integration with Multiple Data Sources
-    
-    Grafana seamlessly integrates with a wide range of data sources, including OpenTelemetry, Prometheus, Graphite, Elasticsearch, InfluxDB, CloudWatch, and many others. This flexibility means you can pull in data from multiple systems and get a holistic view of your application's performance.
-    
+  Grafana seamlessly integrates with a wide range of data sources, including OpenTelemetry, Prometheus, Graphite, Elasticsearch, InfluxDB, CloudWatch, and many others. This flexibility means you can pull in data from multiple systems and get a holistic view of your application's performance.
 - Alerting and Proactive Monitoring
-    
-    You can set up alerts based on metrics thresholds, and Grafana can notify your team through various channels, such as email, Slack, or even custom webhooks. This [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps teams catch issues before they escalate into major outages.
-    
+  You can set up alerts based on metrics thresholds, and Grafana can notify your team through various channels, such as email, Slack, or even custom webhooks. This [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps teams catch issues before they escalate into major outages.
 - Extensibility with Plugins
-    
-    It offers a plugin ecosystem for extensibility as Data source plugins communicate with external sources of data and return the data in a format that Grafana understands. By adding a data source plugin, you can immediately use the data in any of your existing dashboards. You can use data source plugins when you want to import data from external systems
-    
+  It offers a plugin ecosystem for extensibility as Data source plugins communicate with external sources of data and return the data in a format that Grafana understands. By adding a data source plugin, you can immediately use the data in any of your existing dashboards. You can use data source plugins when you want to import data from external systems
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-grafana-image%201.webp" alt="Grafana Building Blocks (Picture from: Grafana)" caption="Grafana Building Blocks (Picture from: Grafana)" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-grafana-image%201.webp"
+  alt="Grafana Building Blocks (Picture from: Grafana)"
+  caption="Grafana Building Blocks (Picture from: Grafana)"
+/>
 
 OpenTelemetry focuses on collecting telemetry data (traces, metrics, and logs) from systems and applications, while Grafana is mainly used for visualizing these telemetry data. OpenTelemetry sends the telemetry data to different backends like Prometheus, Jaeger, and Elasticsearch, Grafana connects to these same data sources for visualization.
 
@@ -106,8 +107,6 @@ rate(http_requests_total{job="api-server"}[5m])
 
 The performance impact of using OpenTelemetry is designed to be minimal. It leverages asynchronous processing and batching, ensuring that your application remains responsive even while gathering telemetry data. Whereas the performance of Grafana largely depends on the complexity of your queries and the volume of data being visualized. Simple queries against indexed data sources will be quick and efficient, while complex queries or those involving large datasets may require more time and resources.
 
-
-
 ## Use Cases and Best Practices
 
 OpenTelemetry excels in cases where you need:
@@ -132,7 +131,7 @@ Grafana shines when you require:
 
 ## Pros and Cons: OpenTelemetry vs Grafana
 
-When it comes to observability, OpenTelemetry and Grafana each play distinct roles, but knowing their strengths and challenges can help you make the most out of both tools. Let’s break down what they offer and where you might run into limitations: 
+When it comes to observability, OpenTelemetry and Grafana each play distinct roles, but knowing their strengths and challenges can help you make the most out of both tools. Let’s break down what they offer and where you might run into limitations:
 
 ### OpenTelemetry Pros
 
@@ -179,7 +178,7 @@ Both OpenTelemetry and Grafana have distinct performance and scalability charact
 
 1. Efficient Sampling Techniques:
 
-OpenTelemetry uses smart sampling techniques to manage the amount of data it collects, like capturing a percentage of requests in high-traffic environments. This helps keep performance smooth without overloading the system. Whereas, Grafana doesn’t have its own sampling capabilities and so it relies on the efficiency of the data sources. This is why it’s recommended to craft well-optimized queries. 
+OpenTelemetry uses smart sampling techniques to manage the amount of data it collects, like capturing a percentage of requests in high-traffic environments. This helps keep performance smooth without overloading the system. Whereas, Grafana doesn’t have its own sampling capabilities and so it relies on the efficiency of the data sources. This is why it’s recommended to craft well-optimized queries.
 
 1. Batching and Compression:
 
@@ -211,7 +210,17 @@ Both projects have active development roadmaps, with OpenTelemetry focusing on e
 
 ## Implementing OpenTelemetry and Grafana with SigNoz
 
-<a href="https://svey-5nsw.in.signoz.cloud/get-started" rel="noopener noreferrer nofollow" target="_blank">SigNoz</a> is a comprehensive observability platform that combines the strengths of both OpenTelemetry and Grafana-like visualizations. It leverages OpenTelemetry for data collection, providing a standardized approach to instrumentation across your services. SigNoz then offers powerful visualization capabilities similar to Grafana, allowing you to create custom dashboards and alerts.
+<a
+  href="https://svey-5nsw.in.signoz.cloud/get-started"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  SigNoz
+</a>
+is a comprehensive observability platform that combines the strengths of both OpenTelemetry and
+Grafana-like visualizations. It leverages OpenTelemetry for data collection, providing a
+standardized approach to instrumentation across your services. SigNoz then offers powerful
+visualization capabilities similar to Grafana, allowing you to create custom dashboards and alerts.
 
 <GrafanaVsSigNoz />
 
@@ -246,4 +255,4 @@ Both tools have their strengths in monitoring cloud-native applications. OpenTel
 
 ### How does SigNoz compare to using OpenTelemetry and Grafana separately?
 
-SigNoz combines the data collection capabilities of OpenTelemetry with visualization features similar to Grafana in a single platform. This integration can simplify your observability stack and provide a more streamlined experience compared to managing OpenTelemetry and Grafana separately.
\ No newline at end of file
+SigNoz combines the data collection capabilities of OpenTelemetry with visualization features similar to Grafana in a single platform. This integration can simplify your observability stack and provide a more streamlined experience compared to managing OpenTelemetry and Grafana separately.
diff --git a/data/comparisons/opentelemetry-vs-honeycomb.mdx b/data/comparisons/opentelemetry-vs-honeycomb.mdx
index c85ed199a..58e09c7ee 100644
--- a/data/comparisons/opentelemetry-vs-honeycomb.mdx
+++ b/data/comparisons/opentelemetry-vs-honeycomb.mdx
@@ -1,22 +1,29 @@
 ---
-
 title: OpenTelemetry vs Honeycomb - Which Observability Tool Wins?
-slug: opentelemetry-vs-honeycomb
+
 date: 2025-01-22
 tags: [OpenTelemetry]
 authors: [soumya_gupta]
 description: Discover the key differences between OpenTelemetry and Honeycomb for observability. Learn which tool best suits your needs in this comprehensive comparison.
-keywords: [opentelemetry, honeycomb, observability, distributed tracing, telemetry data, monitoring, debugging]
-
+keywords:
+  [
+    opentelemetry,
+    honeycomb,
+    observability,
+    distributed tracing,
+    telemetry data,
+    monitoring,
+    debugging,
+  ]
 ---
 
-OpenTelemetry and Honeycomb serve different but complementary roles in application observability. 
+OpenTelemetry and Honeycomb serve different but complementary roles in application observability.
 
 OpenTelemetry is an open-source framework that collects telemetry data through standardized instrumentation. Honeycomb is a observability platform that analyzes and visualizes this data. This comparison will help you understand how they differ and work together.
 
 ## What are OpenTelemetry and Honeycomb?
 
-OpenTelemetry is an open-source observability framework that emerged from the merger of two popular projects - OpenTracing and OpenCensus. It provides a standardized way to generate, collect, and export telemetry data (traces, metrics, and logs) from distributed systems. It provides a vendor-agnostic approach to instrumentation, enabling developers to instrument their applications once and send telemetry data to a variety of backends for analysis and visualization. 
+OpenTelemetry is an open-source observability framework that emerged from the merger of two popular projects - OpenTracing and OpenCensus. It provides a standardized way to generate, collect, and export telemetry data (traces, metrics, and logs) from distributed systems. It provides a vendor-agnostic approach to instrumentation, enabling developers to instrument their applications once and send telemetry data to a variety of backends for analysis and visualization.
 
 ### Key features of OpenTelemetry
 
@@ -25,7 +32,7 @@ OpenTelemetry is an open-source observability framework that emerged from the me
 - **Language-Specific SDKs**: OpenTelemetry provides language-specific SDKs for easy instrumentation across multiple languages, allowing quick integration with minimal coding.
 - **Support for Various Data Formats and Protocols**: OpenTelemetry supports multiple data formats and protocols, allowing seamless integration with existing observability tools and platforms. It can handle trace data from formats like OpenTracing and OpenCensus, ensuring compatibility with diverse ecosystems.
 
-Honeycomb is a cloud-native observability tool that was created to address the limitations of traditional monitoring tools in handling high-cardinality data. It helps teams gain a deeper understanding of system performance by offering real-time analysis of traces, logs, and metrics. Its strength lies in its ability to provide high-resolution telemetry data, allowing you to drill down into specific events and anomalies with unparalleled detail. By capturing and analyzing rich data sets, Honeycomb enables you to identify patterns, correlations, and root causes of issues with ease. 
+Honeycomb is a cloud-native observability tool that was created to address the limitations of traditional monitoring tools in handling high-cardinality data. It helps teams gain a deeper understanding of system performance by offering real-time analysis of traces, logs, and metrics. Its strength lies in its ability to provide high-resolution telemetry data, allowing you to drill down into specific events and anomalies with unparalleled detail. By capturing and analyzing rich data sets, Honeycomb enables you to identify patterns, correlations, and root causes of issues with ease.
 
 ### Key features of Honeycomb
 
@@ -35,6 +42,7 @@ Honeycomb is a cloud-native observability tool that was created to address the l
 - **Collaboration Tools**: Honeycomb includes features for team collaboration, allowing engineers to share insights, dashboards, and findings easily, fostering a culture of observability within organizations.
 
 ### Can They Be Used Together?
+
 Yes! OpenTelemetry can complement Honeycomb:
 
 - **Instrument with OpenTelemetry**: Use OpenTelemetry's SDKs to collect and standardize telemetry data (traces, metrics, logs).
@@ -78,7 +86,11 @@ OpenTelemetry offers instrumentation options to suit different development needs
 
 [OpenTelemetry Collectors](https://signoz.io/blog/opentelemetry-collector-complete-guide/) serve as a central component for data ingestion and processing by gathering, processing, and exporting telemetry data such as traces, metrics, and logs from various sources, including instrumented applications and agents. They apply processing steps like filtering, aggregation, and transformation to enhance data usability, ensuring that only relevant information is sent to the backend for storage and analysis. This versatility allows organizations to integrate their observability stack seamlessly, simplifying the architecture and improving efficiency in monitoring and troubleshooting applications.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-honeycomb-image%201.webp" alt="OpenTelemetry Collector Pipeline" caption="OpenTelemetry Collector Pipeline" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-honeycomb-image%201.webp"
+  alt="OpenTelemetry Collector Pipeline"
+  caption="OpenTelemetry Collector Pipeline"
+/>
 
 ### Extensibility through Custom Processors and Exporters
 
@@ -112,7 +124,7 @@ Honeycomb sets itself apart with innovative capabilities:
 
 - **BubbleUp**: Automatically highlights anomalies by comparing outliers against baseline data, allowing users to quickly identify and resolve issues without extensive manual investigation. It visually pinpoints problematic areas for faster troubleshooting.
 - **High-Cardinality Analysis**: Honeycomb excels at analyzing large volumes of unique events, enabling users to drill down into specific details like individual sessions or requests. This level of granularity uncovers hidden issues that traditional tools might miss.
-- **Collaborative Troubleshooting**: Users can access query history, replay debugging steps, and curate dashboards for new members. With these features, teammates can view, retrieve, and debug queries together, sharing results in real-time. 
+- **Collaborative Troubleshooting**: Users can access query history, replay debugging steps, and curate dashboards for new members. With these features, teammates can view, retrieve, and debug queries together, sharing results in real-time.
 - **Integrations**: Honeycomb's strong integrations with various tools and platforms enhance observability by seamlessly connecting with CI/CD pipelines, notification services, and cloud platforms. This speeds up deployments, encourages smaller changes, and enables faster issue resolution.
 - **Dynamic Sampling**: Its adaptive approach optimizes data collection, reducing storage costs while maintaining accuracy.
 
@@ -198,4 +210,4 @@ OpenTelemetry is free and open source, but you'll need to factor in infrastructu
 
 ### Which tool is better for small startups vs. large enterprises?
 
-Small startups might prefer Honeycomb's ease of use and quick setup. Large enterprises could benefit from OpenTelemetry's flexibility and potential cost savings at scale.
\ No newline at end of file
+Small startups might prefer Honeycomb's ease of use and quick setup. Large enterprises could benefit from OpenTelemetry's flexibility and potential cost savings at scale.
diff --git a/data/comparisons/opentelemetry-vs-logstash.mdx b/data/comparisons/opentelemetry-vs-logstash.mdx
index a891eb206..b9112c444 100644
--- a/data/comparisons/opentelemetry-vs-logstash.mdx
+++ b/data/comparisons/opentelemetry-vs-logstash.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry vs Logstash - Which Logging Tool Is Right for You?
-slug: opentelemetry-vs-logstash
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [sushant_gaurav]
 description: Compare OpenTelemetry and Logstash to make the right choice for your observability needs. Learn key differences, features, and migration strategies.
-keywords: [opentelemetry vs logstash, logging tools comparison, observability platforms, log management, telemetry data collection, elastic stack, monitoring tools]
-
+keywords:
+  [
+    opentelemetry vs logstash,
+    logging tools comparison,
+    observability platforms,
+    log management,
+    telemetry data collection,
+    elastic stack,
+    monitoring tools,
+  ]
 ---
 
 Modern applications produce vast amounts of logs, traces, and metrics, making observability tools essential for monitoring, troubleshooting, and optimizing system performance. Choosing the right tool, whether OpenTelemetry or Logstash, can greatly impact your observability strategy and data handling efficiency. Both are powerful solutions, each with distinct features and purposes suited to specific use cases. In this article, we’ll compare their capabilities, architecture, and how they can best meet your observability needs.
@@ -28,13 +35,13 @@ Let's take a look at the key differences between both of them for more clarity.
 
 ### Primary use cases
 
-OpenTelemetry 
+OpenTelemetry
 
 - It is primarily used for complete observability in distributed systems, covering logs, metrics, and traces within a single, unified framework.
 - It follows a vendor-neutral architecture, making it highly adaptable for cloud-native environments, especially suited for multi-service, microservices-based applications.
 - It integrates easily with numerous monitoring backends, enabling teams to instrument applications with minimal vendor lock-in—ideal for organizations aiming to scale observability as they grow.
 
-Logstash 
+Logstash
 
 - It works well in log-centric data processing workflows, particularly when paired with other Elastic Stack tools like Elasticsearch and Kibana.
 - It is commonly used for [centralized log management](https://signoz.io/blog/centralized-logging/) in large enterprises, where log aggregation and transformation are essential.
@@ -44,19 +51,20 @@ Logstash
 
 Let's now have a look at the various key features of OpenTelemetry and Logstash and how they compare.
 
-| Category | OpenTelemetry | Logstash |
-| --- | --- | --- |
-| Data Collection Capabilities | - Distributed tracing with native support across services. 
-- Flexible metrics collection with multiple format support. 
-- Automatic instrumentation for popular frameworks. 
-- Supports formats like OTLP, Jaeger, and Zipkin. | - Ingests data from multiple sources (files, logs, events) through input plugins. 
-- Advanced log transformation via Grok parsing. 
+| Category                     | OpenTelemetry                                              | Logstash |
+| ---------------------------- | ---------------------------------------------------------- | -------- |
+| Data Collection Capabilities | - Distributed tracing with native support across services. |
+
+- Flexible metrics collection with multiple format support.
+- Automatic instrumentation for popular frameworks.
+- Supports formats like OTLP, Jaeger, and Zipkin. | - Ingests data from multiple sources (files, logs, events) through input plugins.
+- Advanced log transformation via Grok parsing.
 - Supports diverse formats (custom log formats, JSON). |
-| Processing and Transformation | Primarily for telemetry data transformation, with support for batching and processors to streamline data processing. | Customizable pipeline structure with filter plugins, including Grok parsing for data transformation based on patterns and formats. |
-| Integration Options | Vendor-neutral with easy integration to SigNoz, Prometheus, Jaeger, and others. | Works best within the Elastic Stack, but also integrates with Amazon S3, Google Cloud Storage, and Apache Kafka. |
-| Performance and Scalability | Efficient resource use and minimal configuration, scalable for cloud-native architectures. | Scales well but may require higher memory and CPU resources for complex pipelines or high-throughput setups. |
-| Data Retention and Storage Options | Primarily a data collection tool, with retention depending on backend integration and flexibility for various storage solutions. | Limited native storage, but can output to various destinations, allowing customizable retention policies. |
-| Security and Data Privacy | Secure data transport with support for gRPC and HTTP/JSON protocols, encryption options. | Role-based access control (with Elastic Stack), SSL/TLS support for secure data transfer and storage. |
+  | Processing and Transformation | Primarily for telemetry data transformation, with support for batching and processors to streamline data processing. | Customizable pipeline structure with filter plugins, including Grok parsing for data transformation based on patterns and formats. |
+  | Integration Options | Vendor-neutral with easy integration to SigNoz, Prometheus, Jaeger, and others. | Works best within the Elastic Stack, but also integrates with Amazon S3, Google Cloud Storage, and Apache Kafka. |
+  | Performance and Scalability | Efficient resource use and minimal configuration, scalable for cloud-native architectures. | Scales well but may require higher memory and CPU resources for complex pipelines or high-throughput setups. |
+  | Data Retention and Storage Options | Primarily a data collection tool, with retention depending on backend integration and flexibility for various storage solutions. | Limited native storage, but can output to various destinations, allowing customizable retention policies. |
+  | Security and Data Privacy | Secure data transport with support for gRPC and HTTP/JSON protocols, encryption options. | Role-based access control (with Elastic Stack), SSL/TLS support for secure data transfer and storage. |
 
 Example OpenTelemetry Collector Configuration:
 
@@ -65,7 +73,7 @@ receivers:
   otlp:
     protocols:
       grpc:
-        endpoint: "0.0.0.0:4317"
+        endpoint: '0.0.0.0:4317'
 
 processors:
   batch:
@@ -114,7 +122,11 @@ Logstash relies on a powerful pipeline architecture that enables complex data tr
 - Output Plugins: It routes processed data to a variety of destinations, such as Elasticsearch, local storage, and external APIs.
 - Persistent Queues: It enhances reliability with optional disk-based queues, which ensure data is retained even during service interruptions.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-logstash-image.webp" alt="Logstash Pipeline Architecture" caption="Logstash Pipeline Architecture" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-logstash-image.webp"
+  alt="Logstash Pipeline Architecture"
+  caption="Logstash Pipeline Architecture"
+/>
 
 ### Protocol Support
 
@@ -122,11 +134,11 @@ OpenTelemetry and Logstash share support for the HTTP protocol, allowing interop
 
 ### Resource Requirements
 
-| Feature | OpenTelemetry | Logstash |
-| --- | --- | --- |
-| Memory | 512MB - 1GB | 1GB - 4GB |
-| CPU | Low - Medium | Medium - High |
-| Storage | Minimal | Configurable based on queue size |
+| Feature | OpenTelemetry | Logstash                         |
+| ------- | ------------- | -------------------------------- |
+| Memory  | 512MB - 1GB   | 1GB - 4GB                        |
+| CPU     | Low - Medium  | Medium - High                    |
+| Storage | Minimal       | Configurable based on queue size |
 
 ### Data Flow and Processing Efficiency
 
@@ -147,20 +159,20 @@ Let's now look at the implementation considerations for OpenTelemetry and Logsta
 OpenTelemetry:
 
 - Pros:
-    - Auto-Instrumentation Options: It simplifies telemetry data collection by automating instrumentation for supported libraries.
-    - Standard SDK Across Languages: It provides consistent setup across different languages, ensuring a [unified observability](https://signoz.io/unified-observability/) approach.
+  - Auto-Instrumentation Options: It simplifies telemetry data collection by automating instrumentation for supported libraries.
+  - Standard SDK Across Languages: It provides consistent setup across different languages, ensuring a [unified observability](https://signoz.io/unified-observability/) approach.
 - Cons:
-    - Complex Initial Configuration: The initial setup for OpenTelemetry especially for collectors and exporters, can be difficult.
-    - Newer Ecosystem: OpenTelemetry is rapidly evolving but it is still building its community and resource base.
+  - Complex Initial Configuration: The initial setup for OpenTelemetry especially for collectors and exporters, can be difficult.
+  - Newer Ecosystem: OpenTelemetry is rapidly evolving but it is still building its community and resource base.
 
 Logstash:
 
 - Pros:
-    - Extensive Documentation: Logstash provides ample guides and tutorials for setup.
-    - Stability: It offers robust, tested plugins and a stable setup process.
+  - Extensive Documentation: Logstash provides ample guides and tutorials for setup.
+  - Stability: It offers robust, tested plugins and a stable setup process.
 - Cons:
-    - Resource-Intensive: Logstash’s pipeline can demand higher memory and CPU, particularly for complex processing.
-    - Complex Pipeline Configurations: Its multi-stage pipelines add operational overhead, especially for intricate data transformations.
+  - Resource-Intensive: Logstash’s pipeline can demand higher memory and CPU, particularly for complex processing.
+  - Complex Pipeline Configurations: Its multi-stage pipelines add operational overhead, especially for intricate data transformations.
 
 ### Operational Overhead
 
@@ -196,7 +208,11 @@ Logstash's maintenance is ongoing. Especially for configuring and managing pipel
 
 Migrating from Logstash to OpenTelemetry requires a structured approach to maintain data integrity and minimize disruption.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-logstash-image%201.webp" alt="Basic Flow of the Migration" caption="Basic Flow of the Migration" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-logstash-image%201.webp"
+  alt="Basic Flow of the Migration"
+  caption="Basic Flow of the Migration"
+/>
 
 Let's now look at some of the migration strategies for more clarity.
 
@@ -259,16 +275,13 @@ SigNoz offers a cloud-native observability solution tailored for modern, distrib
 SigNoz is built with native OpenTelemetry support which makes integration quite easy. It can automatically collect and visualize OpenTelemetry data without complex configurations which allow teams to get started quickly.
 
 - Example OpenTelemetry Configuration for SigNoz:
-    
-    ```yaml
-    exporters:
-      otlp:
-        endpoint: "https://<sigNoz_endpoint>"
-        headers:
-          api-key: "<api_key>"
-    
-    ```
-    
+  ```yaml
+  exporters:
+    otlp:
+      endpoint: 'https://<sigNoz_endpoint>'
+      headers:
+        api-key: '<api_key>'
+  ```
 
 <GetStartedSigNoz />
 
@@ -307,4 +320,4 @@ OpenTelemetry is open-source and vendor-neutral, allowing flexibility in back-en
 
 ### Is it possible to use both tools together?
 
-Yes, OpenTelemetry and Logstash can be used in tandem for different observability needs. OpenTelemetry can send logs to Logstash as part of a hybrid observability setup, or both tools can be used independently within the same infrastructure to meet specific logging or metric-tracing needs.
\ No newline at end of file
+Yes, OpenTelemetry and Logstash can be used in tandem for different observability needs. OpenTelemetry can send logs to Logstash as part of a hybrid observability setup, or both tools can be used independently within the same infrastructure to meet specific logging or metric-tracing needs.
diff --git a/data/comparisons/opentelemetry-vs-loki.mdx b/data/comparisons/opentelemetry-vs-loki.mdx
index 33db3692a..e812fadd1 100644
--- a/data/comparisons/opentelemetry-vs-loki.mdx
+++ b/data/comparisons/opentelemetry-vs-loki.mdx
@@ -1,18 +1,20 @@
 ---
-
 title: OpenTelemetry vs Loki - Choosing the Right Observability Tool
-slug: opentelemetry-vs-loki 
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [soumya_gupta]
 description: Compare OpenTelemetry and Loki for observability. Learn key features, use cases, and how to choose the right tool for your monitoring needs.
 keywords: [OpenTelemetry, Loki, observability, logging, tracing, monitoring, DevOps]
-
 ---
 
 In the ever-evolving landscape of cloud-native applications, observability has become a critical aspect of maintaining and troubleshooting complex systems. As you navigate this terrain, you'll encounter two prominent tools: OpenTelemetry and Loki. But how do they compare, and which one should you choose for your observability needs? This article dives deep into the world of OpenTelemetry and Loki, exploring their features, use cases, and how they stack up against each other.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image.webp" alt="OpenTelemetry vs Loki" caption="OpenTelemetry vs Loki" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-loki-image.webp"
+  alt="OpenTelemetry vs Loki"
+  caption="OpenTelemetry vs Loki"
+/>
 
 ## What are OpenTelemetry and Loki?
 
@@ -34,18 +36,24 @@ While OpenTelemetry casts a wide net over the observability landscape, Loki zero
 
 ### OpenTelemetry Collector
 
-The OpenTelemetry Collector plays a crucial role in the OpenTelemetry ecosystem. It acts as a vendor-agnostic way to receive, process, and export telemetry data. 
+The OpenTelemetry Collector plays a crucial role in the OpenTelemetry ecosystem. It acts as a vendor-agnostic way to receive, process, and export telemetry data.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%201.webp" alt="Collector Pipeline" caption="Collector Pipeline" /> 
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%201.webp"
+  alt="Collector Pipeline"
+  caption="Collector Pipeline"
+/>
 
 Here's what makes it special:
 
 - Flexible deployment: The Collector can be deployed in two main modes—either as an agent running alongside your application to collect telemetry locally or as a gateway, operating as a standalone service to centralize data collection and forwarding.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%202.webp" alt="Modes of Collector Deployment" caption="Modes of Collector Deployment" />
-    
-    This flexibility ensures that the Collector fits seamlessly into various infrastructure setups, whether distributed or centralized.
-    
+  <Figure
+    src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%202.webp"
+    alt="Modes of Collector Deployment"
+    caption="Modes of Collector Deployment"
+  />
+  This flexibility ensures that the Collector fits seamlessly into various infrastructure setups,
+  whether distributed or centralized.
 - Advanced data processing: Beyond simply forwarding data, the Collector allows for robust data processing. You can modify, filter, and enrich telemetry data in-flight, ensuring that only relevant, cleaned, and enhanced data is sent to your backend systems. This helps reduce noise and improve the quality of your observability data.
 - Extensibility: The Collector’s modular design supports a wide array of receivers, processors, and exporters. This means you can easily customize it to meet your specific telemetry needs, adding functionality for specialized data pipelines, or integrating with multiple backends in parallel.
 - Unified telemetry pipeline: By handling traces, metrics, and logs in a single pipeline, the OpenTelemetry Collector simplifies the complexity of managing multiple telemetry streams. This makes it easier to correlate different types of data and gain a more holistic view of system performance.
@@ -54,30 +62,39 @@ Here's what makes it special:
 
 Loki is a log management solution from Grafana Labs, designed to streamline log storage and retrieval without the heavy indexing used by traditional log systems, making it an efficient choice for teams focused on scalable observability.
 
- It takes a different approach to log management, focusing on efficiency and cost-effectiveness:
+It takes a different approach to log management, focusing on efficiency and cost-effectiveness:
 
 - Minimal Indexing Architecture : Unlike conventional log management systems that index the full content of logs, Loki uses a minimalist approach by only indexing metadata, such as labels. This means that instead of maintaining massive indexes of all log data, Loki limits its indexing to crucial attributes (like tenant IDs, log labels, and timestamps).
 - Log Streams and Labels: Similar to the time-series data model in Prometheus, Loki organizes logs into streams, which are groups of logs associated with a unique set of labels.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%203.webp" alt="Log streams and labels" caption="Log streams and labels" />
-    
-    These labels (e.g., `application`, `environment`, or `pod`) are key to filtering, querying, and analyzing logs. By allowing you to query logs based on their labels rather than content, Loki optimizes the search process, making it faster to retrieve specific logs without sifting through an entire log file. This structure is especially helpful in modern cloud-native environments where logs from distributed microservices need to be efficiently tracked and analyzed.
-    
+  <Figure
+    src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%203.webp"
+    alt="Log streams and labels"
+    caption="Log streams and labels"
+  />
+  These labels (e.g., `application`, `environment`, or `pod`) are key to filtering, querying, and
+  analyzing logs. By allowing you to query logs based on their labels rather than content, Loki
+  optimizes the search process, making it faster to retrieve specific logs without sifting through
+  an entire log file. This structure is especially helpful in modern cloud-native environments where
+  logs from distributed microservices need to be efficiently tracked and analyzed.
 - Multi-Tenancy Support: Loki is designed with multi-tenancy in mind, enabling you to manage logs from multiple sources—whether different teams, environments, or applications—while ensuring isolation between them. When running in multi-tenant mode, Loki uses the `X-Scope-OrgID` HTTP header to assign a tenant ID to each log stream. For instance, if a company has multiple teams, such as Development and Marketing, each team can send logs with their respective `X-Scope-OrgID` values, like dev-team for Development and marketing-team for Marketing. This tenant ID not only partitions data in both memory and long-term storage but also ensures that different log streams are kept isolated from each other. This feature is particularly valuable for large organizations or managed services, where different departments or customers need separate logging environments. In scenarios where Loki is not running in multi-tenant mode, the header is ignored, and the system assigns a default tenant ID (`fake`), which will appear in the index and stored chunks.
 - Cost-Effective Storage: One of the highlights of Loki's design is its object storage backend, which refers to the capability to efficiently manage large volumes of unstructured data. This backend supports cloud storage services like Amazon S3, Google Cloud Storage, and Azure Blob Storage, making it both cost-effective and scalable. Using the index shipper approach (introduced in Loki 2.0), Loki separates index and chunk files in object storage, allowing it to handle massive log volumes without significant increases in operational costs, ensuring high availability and resilience.
 
 ### Indexing Efficiency: Conventional Systems vs. Loki
 
-Conventional log management systems often index a broader set of attributes, including the full content of logs, user IDs, and session data. In contrast, Loki employs a minimalist indexing strategy, focusing solely on crucial metadata such as labels (e.g., tenant IDs, log labels, and timestamps). 
+Conventional log management systems often index a broader set of attributes, including the full content of logs, user IDs, and session data. In contrast, Loki employs a minimalist indexing strategy, focusing solely on crucial metadata such as labels (e.g., tenant IDs, log labels, and timestamps).
 
-| Factors | Conventional Systems | Loki |
-| --- | --- | --- |
-| Storage Costs | The need to maintain extensive indexes results in higher storage requirements. | By indexing only a smaller subset of attributes, Loki can significantly lower storage costs. |
-| CPU Usage | More complex indexing processes demand significant CPU resources, impacting overall performance. | With less data to process, Loki reduces CPU usage, allowing for faster querying and log retrieval |
+| Factors       | Conventional Systems                                                                             | Loki                                                                                              |
+| ------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
+| Storage Costs | The need to maintain extensive indexes results in higher storage requirements.                   | By indexing only a smaller subset of attributes, Loki can significantly lower storage costs.      |
+| CPU Usage     | More complex indexing processes demand significant CPU resources, impacting overall performance. | With less data to process, Loki reduces CPU usage, allowing for faster querying and log retrieval |
 
 ## Promtail: Loki's Log Shipper
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%204.webp" alt="Loki’s Promtail v/s OpenTelemetry’s Collector" caption="Loki’s Promtail v/s OpenTelemetry’s Collector" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%204.webp"
+  alt="Loki’s Promtail v/s OpenTelemetry’s Collector"
+  caption="Loki’s Promtail v/s OpenTelemetry’s Collector"
+/>
 
 Promtail is to Loki what the Collector is to OpenTelemetry. It's responsible for gathering logs and sending them to Loki. It can currently tail logs from two sources: local log files and the `systemd journal`. Promtail's main functions include discovering targets, attaching labels to log streams, and pushing them to a Loki instance.
 
@@ -95,13 +112,16 @@ By configuring the `loki_push_api` in Promtail, you can set up a Promtail instan
 
 To set up a Promtail configuration file for sending logs from a standalone host:
 
-1. Log into Grafana Cloud: Access your Grafana Cloud account and select Launch. 
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%205.webp" alt="" caption="" />2. Go to the Manage Your Stack Page: Once there, choose Loki and select Send Logs.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%206.webp" alt="" caption="" />3. Select Standalone Host: Choose the standalone host option and assign a name to the token that this integration will use.
-    
-    <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%207.webp" alt="" caption="" />4. Review and Save the Configuration File: Scroll down to view the configuration file. Replace `<GrafanaCloudToken>` in the config below with the generated API token and make sure to save it to `promtail/config.yaml`.
+1. Log into Grafana Cloud: Access your Grafana Cloud account and select Launch.
+
+   <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%205.webp" alt="" caption="" />
+   2. Go to the Manage Your Stack Page: Once there, choose Loki and select Send Logs.
+
+   <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%206.webp" alt="" caption="" />
+   3. Select Standalone Host: Choose the standalone host option and assign a name to the token that
+   this integration will use.
+
+   <Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%207.webp" alt="" caption="" />4. Review and Save the Configuration File: Scroll down to view the configuration file. Replace `<GrafanaCloudToken>` in the config below with the generated API token and make sure to save it to `promtail/config.yaml`.
 
 ```yaml
 server:
@@ -115,25 +135,25 @@ clients:
   - url: https://<GrafanaCloudToken>@logs-prod-028.grafana.net/loki/api/v1/push
 
 scrape_configs:
-- job_name: system
-  static_configs:
-  - targets:
-      - localhost
-    labels:
-      job: varlogs
-      __path__: /var/log/*.log
+  - job_name: system
+    static_configs:
+      - targets:
+          - localhost
+        labels:
+          job: varlogs
+          __path__: /var/log/*.log
 ```
 
 ## Comparing OpenTelemetry and Loki
 
 Now that we've explored both tools, let's compare them across several dimensions:
 
-| Factors | OpenTelemetry | Loki |
-| --- | --- | --- |
-| Scope | Covers metrics, traces, and logs for full-stack observability. | Focuses primarily on log management and analysis. |
-| Data Model | Uses a unified data model for all telemetry types. | Employs a log stream model with labels, similar to Prometheus. |
-| Scalability | Designed for distributed tracing, can handle large-scale systems. | Built for horizontal scaling, efficient for high-volume log ingestion. |
-| Ecosystem Integration | Wide support across various observability tools and backends. | Tightly integrated with Grafana and the Prometheus ecosystem. |
+| Factors               | OpenTelemetry                                                     | Loki                                                                   |
+| --------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| Scope                 | Covers metrics, traces, and logs for full-stack observability.    | Focuses primarily on log management and analysis.                      |
+| Data Model            | Uses a unified data model for all telemetry types.                | Employs a log stream model with labels, similar to Prometheus.         |
+| Scalability           | Designed for distributed tracing, can handle large-scale systems. | Built for horizontal scaling, efficient for high-volume log ingestion. |
+| Ecosystem Integration | Wide support across various observability tools and backends.     | Tightly integrated with Grafana and the Prometheus ecosystem.          |
 
 ## Use Cases: When to Choose OpenTelemetry or Loki
 
@@ -157,16 +177,16 @@ Consider a hybrid approach for teams looking to get the best of both worlds. You
 
 When evaluating OpenTelemetry and Loki for your observability needs, consider these performance aspects:
 
-| Factors | OpenTelemetry | Loki |
-| --- | --- | --- |
-| Resource Usage | Can have higher overhead due to its comprehensive approach. | Generally, more lightweight, focusing solely on log management. |
-| Scaling Strategies | Scale the Collector horizontally for high-volume data processing. | Use a distributed deployment model with separate read and write paths. |
-| Query Performance | Trace queries can be complex but powerful for debugging. | Log queries are typically faster due to the index-free architecture. |
+| Factors              | OpenTelemetry                                                                  | Loki                                                                              |
+| -------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------- |
+| Resource Usage       | Can have higher overhead due to its comprehensive approach.                    | Generally, more lightweight, focusing solely on log management.                   |
+| Scaling Strategies   | Scale the Collector horizontally for high-volume data processing.              | Use a distributed deployment model with separate read and write paths.            |
+| Query Performance    | Trace queries can be complex but powerful for debugging.                       | Log queries are typically faster due to the index-free architecture.              |
 | Optimize Performance | Use sampling in OpenTelemetry to reduce data volume for high-traffic services. | Design your label schemes carefully to balance query flexibility and performance. |
 
 ## Implementing OpenTelemetry and Loki Together
 
-Integrating OpenTelemetry with Loki can provide a powerful observability solution. 
+Integrating OpenTelemetry with Loki can provide a powerful observability solution.
 
 When logs are ingested into Loki via the OpenTelemetry protocol (OTLP) ingestion endpoint, part of the data is stored as Structured Metadata. To ensure the logs are accepted, you need to enable `allow_structured_metadata` in your Loki configuration file. Otherwise, Loki will reject the log payload as malformed.
 
@@ -175,9 +195,13 @@ limits_config:
 allow_structured_metadata: true
 ```
 
-Let’s take an in-depth look at how it’s done: 
+Let’s take an in-depth look at how it’s done:
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%208.webp" alt="Integrated use of OpenTelemetry, Loki and Grafana" caption="Integrated use of OpenTelemetry, Loki and Grafana" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-loki-image%208.webp"
+  alt="Integrated use of OpenTelemetry, Loki and Grafana"
+  caption="Integrated use of OpenTelemetry, Loki and Grafana"
+/>
 
 - Use the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/): Set up the OpenTelemetry Collector to gather telemetry data from your applications, including logs, metrics, and traces. The Collector acts as an intermediary, standardizing the way telemetry is collected and processed.
 - Configure the Loki Exporter: In the Collector configuration, use the Loki exporter to send logs directly to Loki. This ensures that your application logs, collected by OpenTelemetry, are efficiently stored and managed in Loki’s index-free architecture.
@@ -230,4 +254,4 @@ While Loki integrates seamlessly with Grafana, it's not limited to Grafana-based
 
 ### What are the main differences in query languages between OpenTelemetry and Loki?
 
-OpenTelemetry doesn't define its own query language; the query language depends on the backend you're using to store and analyze the data. Loki uses LogQL, a query language inspired by PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)), which is designed specifically for querying and analyzing log data.
\ No newline at end of file
+OpenTelemetry doesn't define its own query language; the query language depends on the backend you're using to store and analyze the data. Loki uses LogQL, a query language inspired by PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)), which is designed specifically for querying and analyzing log data.
diff --git a/data/comparisons/opentelemetry-vs-micrometer.mdx b/data/comparisons/opentelemetry-vs-micrometer.mdx
index ab57376f4..589788e32 100644
--- a/data/comparisons/opentelemetry-vs-micrometer.mdx
+++ b/data/comparisons/opentelemetry-vs-micrometer.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: OpenTelemetry vs Micrometer - Choosing the Right Metrics Tool
-slug: opentelemetry-vs-micrometer
+
 date: 2024-10-22
 tags: [OpenTelemetry]
 authors: [nilesh_sinha]
 description: Compare OpenTelemetry and Micrometer for application metrics. Learn their features, performance, and integration to choose the best tool for your needs.
-keywords: [opentelemetry, micrometer, metrics, observability, spring boot, performance monitoring, application telemetry]
-
+keywords:
+  [
+    opentelemetry,
+    micrometer,
+    metrics,
+    observability,
+    spring boot,
+    performance monitoring,
+    application telemetry,
+  ]
 ---
 
 As applications grow in complexity, the need for robust observability solutions becomes paramount. Two popular tools in this space — OpenTelemetry and Micrometer — offer powerful capabilities for collecting and analyzing application metrics. But which one is right for your project? This article compares OpenTelemetry and Micrometer, examining their features, performance, and use cases to help you make an informed decision.
@@ -16,11 +23,11 @@ As applications grow in complexity, the need for robust observability solutions
 
 OpenTelemetry is a Cloud Native Computing Foundation (CNCF) project designed to create a standardized way to collect telemetry data (i.e., traces, metrics, and logs) from various applications and programming languages. It unifies different observability signals under a single framework, making it easier to gain a complete view of application performance and identify issues across distributed systems.
 
-In contrast, Micrometer is a vendor-neutral application metrics facade (tools, libraries, or frameworks that are designed to work with a variety of monitoring, logging, or observability systems without being locked into a specific vendor's ecosystem) for the JVM, primarily used to instrument dimensional metrics (metrics with tags) in Java applications. 
+In contrast, Micrometer is a vendor-neutral application metrics facade (tools, libraries, or frameworks that are designed to work with a variety of monitoring, logging, or observability systems without being locked into a specific vendor's ecosystem) for the JVM, primarily used to instrument dimensional metrics (metrics with tags) in Java applications.
 
 > Dimensional metrics refer to a flexible approach to metrics collection where each metric is associated with multiple attributes, or "dimensions," that provide additional context about the data. This allows you to track and analyze metrics based on different aspects or dimensions, like environment, region, or API endpoint, offering deeper insights.
 
-It provides a consistent abstraction for capturing metrics and is the default metrics library in Spring Boot, making it easy to collect application-level data and export it to popular monitoring systems like Prometheus, Datadog, and more. 
+It provides a consistent abstraction for capturing metrics and is the default metrics library in Spring Boot, making it easy to collect application-level data and export it to popular monitoring systems like Prometheus, Datadog, and more.
 
 Here, we have highlighted the prominent uses of both OpenTelemetry as well as Micrometer.
 
@@ -37,7 +44,6 @@ Here, we have highlighted the prominent uses of both OpenTelemetry as well as Mi
 - Supports integration with major monitoring backends, such as Prometheus, Grafana, and others, making it easy to visualize and [analyze metrics](https://signoz.io/blog/metrics-explorer/).
 
 > You can think of Micrometer as a specialized tool focused solely on metrics collection for Java-based applications, while OpenTelemetry is a broader observability framework that goes beyond just metrics and supports traces, metrics, and logs for applications written in various programming languages.
-> 
 
 ### Historical Context and Development
 
@@ -60,7 +66,7 @@ Community Support and Adoption Rates for Both Tools
 
 ## Comparing OpenTelemetry and Micrometer Performance
 
-If your primary goal is just metrics and your stack is Java-based, Micrometer is your go-to. For a full observability solution across heterogeneous applications, OpenTelemetry offers more capabilities with a minor trade-off in complexity. 
+If your primary goal is just metrics and your stack is Java-based, Micrometer is your go-to. For a full observability solution across heterogeneous applications, OpenTelemetry offers more capabilities with a minor trade-off in complexity.
 
 Let’s justify how we can make use of one of these as per the requirements:
 
@@ -118,64 +124,56 @@ The OpenTelemetry Spring Boot Starter simplifies the integration of OpenTelemetr
 
 Setup Process:
 
-1. Add Dependencies:
-Add the following dependencies to your `pom.xml` for Maven:
-    
-    ```xml
+1.  Add Dependencies:
+    Add the following dependencies to your `pom.xml` for Maven:
+    `xml
     <dependency>
         <groupId>io.opentelemetry.instrumentation</groupId>
         <artifactId>opentelemetry-spring-boot-starter</artifactId>
         <version>1.25.0</version> <!-- Replace with the latest version -->
     </dependency>
-    ```
-    
-2. Add Exporter Dependencies:
-For exporting traces or metrics, add the corresponding exporter, like `otlp` for OpenTelemetry Protocol.
-    
+    `
+2.  Add Exporter Dependencies:
+    For exporting traces or metrics, add the corresponding exporter, like `otlp` for OpenTelemetry Protocol.
     The OpenTelemetry Protocol (OTLP) is a standardized protocol used for transmitting telemetry data, including traces, metrics, and logs, from applications to observability backends. Here are key points about OTLP:
-    
-    - Unified Protocol: OTLP combines different types of telemetry data into a single protocol, simplifying the process of sending data from applications.
-    - Transport Mechanisms: Supports both HTTP and gRPC as transport protocols, allowing flexibility in how data is sent to observability platforms.
-    - Data Format: Uses Protocol Buffers (protobufs) for efficient serialization of telemetry data, resulting in smaller message sizes and faster transmission.
-    - Interoperability: Enables seamless integration between different observability tools and frameworks, ensuring that data can be easily shared and understood across various systems.
-    
-    ```xml
-    <dependency>
-        <groupId>io.opentelemetry.exporter</groupId>
-        <artifactId>opentelemetry-exporter-otlp</artifactId>
-        <version>1.25.0</version>
-    </dependency>
-    ```
-    
-3. Configuration:
-In `application.properties` or `application.yml`, configure the [OpenTelemetry exporter](https://signoz.io/guides/opentelemetry-collector-vs-exporter/):
-    
-    ```
-    # application.properties
-    otel.traces.exporter=otlp
-    otel.metrics.exporter=none
-    otel.exporter.otlp.endpoint=http://localhost:4317
-    ```
-    
-4. Example:
-    
+
+        - Unified Protocol: OTLP combines different types of telemetry data into a single protocol, simplifying the process of sending data from applications.
+        - Transport Mechanisms: Supports both HTTP and gRPC as transport protocols, allowing flexibility in how data is sent to observability platforms.
+        - Data Format: Uses Protocol Buffers (protobufs) for efficient serialization of telemetry data, resulting in smaller message sizes and faster transmission.
+        - Interoperability: Enables seamless integration between different observability tools and frameworks, ensuring that data can be easily shared and understood across various systems.
+
+        ```xml
+        <dependency>
+            <groupId>io.opentelemetry.exporter</groupId>
+            <artifactId>opentelemetry-exporter-otlp</artifactId>
+            <version>1.25.0</version>
+        </dependency>
+        ```
+
+3.  Configuration:
+    In `application.properties` or `application.yml`, configure the [OpenTelemetry exporter](https://signoz.io/guides/opentelemetry-collector-vs-exporter/):
+    `    # application.properties
+otel.traces.exporter=otlp
+otel.metrics.exporter=none
+otel.exporter.otlp.endpoint=http://localhost:4317`
+4.  Example:
+
     ```java
     import io.opentelemetry.api.OpenTelemetry;
     import org.springframework.boot.SpringApplication;
     import org.springframework.boot.autoconfigure.SpringBootApplication;
-    
+
     @SpringBootApplication
     public class MyApp {
         public static void main(String[] args) {
             SpringApplication.run(MyApp.class, args);
-    
+
             // OpenTelemetry instance
             OpenTelemetry openTelemetry = OpenTelemetry.get();
             // You can now use OpenTelemetry for tracing and metrics.
         }
     }
     ```
-    
 
 Expected Output:
 
@@ -189,53 +187,46 @@ Micrometer is natively integrated into Spring Boot, allowing you to collect dime
 
 Setup Process:
 
-1. Add Dependency:
-If you’re using Maven, add the Micrometer dependency to your `pom.xml`:
-    
-    ```xml
+1.  Add Dependency:
+    If you’re using Maven, add the Micrometer dependency to your `pom.xml`:
+    `xml
     <dependency>
         <groupId>io.micrometer</groupId>
         <artifactId>micrometer-core</artifactId>
         <version>1.10.0</version> <!-- Replace with the latest version -->
     </dependency>
-    ```
-    
-2. Enable Metrics Endpoint:
-In `application.properties`, enable the metrics endpoint and specify the Prometheus format:
-    
-    ```
-    # application.properties
-    management.metrics.export.prometheus.enabled=true
-    management.endpoints.web.exposure.include=*
-    ```
-    
-3. Example:
-    
+    `
+2.  Enable Metrics Endpoint:
+    In `application.properties`, enable the metrics endpoint and specify the Prometheus format:
+    `    # application.properties
+management.metrics.export.prometheus.enabled=true
+management.endpoints.web.exposure.include=*`
+3.  Example:
+
     ```java
     import io.micrometer.core.instrument.MeterRegistry;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.web.bind.annotation.GetMapping;
     import org.springframework.web.bind.annotation.RestController;
-    
+
     @RestController
     public class MyController {
         private final MeterRegistry meterRegistry;
-    
+
         @Autowired
         public MyController(MeterRegistry meterRegistry) {
     		    // Injecting MeterRegistry
-            this.meterRegistry = meterRegistry; 
+            this.meterRegistry = meterRegistry;
         }
-    
+
         @GetMapping("/api/data")
         public String getData() {
     		    // Incrementing call counter
-            meterRegistry.counter("api.calls").increment(); 
+            meterRegistry.counter("api.calls").increment();
             return "Data returned successfully!";
         }
     }
     ```
-    
 
 Expected Output:
 
@@ -248,33 +239,33 @@ When the endpoint `/api/data` is accessed, it increments the `api.calls` counter
 Transitioning from Micrometer to OpenTelemetry involves switching dependencies and replacing Micrometer’s metric APIs with OpenTelemetry’s APIs.
 
 1. Replace Dependencies:
-    
-    Remove the `micrometer-registry-*` dependencies from your `pom.xml` and add OpenTelemetry dependencies:
-    
-    ```xml
-    <dependency>
-        <groupId>io.opentelemetry</groupId>
-        <artifactId>opentelemetry-api</artifactId>
-        <version>1.22.0</version> <!-- Replace with the latest version -->
-    </dependency>
-    ```
-    
+
+   Remove the `micrometer-registry-*` dependencies from your `pom.xml` and add OpenTelemetry dependencies:
+
+   ```xml
+   <dependency>
+       <groupId>io.opentelemetry</groupId>
+       <artifactId>opentelemetry-api</artifactId>
+       <version>1.22.0</version> <!-- Replace with the latest version -->
+   </dependency>
+   ```
+
 2. Replace Metric APIs:
-    
-    For example, replace:
-    
-    ```java
-    Counter requestCounter = metrics.counter("requests");
-    requestCounter.increment();
-    ```
-    
-    With OpenTelemetry’s Counter API:
-    
-    ```java
-    LongCounter requestCounter = openTelemetry.getMeter("example").counterBuilder("requests").build();
-    requestCounter.add(1);
-    ```
-    
+
+   For example, replace:
+
+   ```java
+   Counter requestCounter = metrics.counter("requests");
+   requestCounter.increment();
+   ```
+
+   With OpenTelemetry’s Counter API:
+
+   ```java
+   LongCounter requestCounter = openTelemetry.getMeter("example").counterBuilder("requests").build();
+   requestCounter.add(1);
+   ```
+
 3. Update your code to use OpenTelemetry's tracing and metrics APIs.
 
 Example:
@@ -315,11 +306,11 @@ When `performTask` is called, it creates a new trace span and increments the `ta
 ### 4. Performance Implications for Spring-Based Microservices
 
 - Micrometer:
-    - Low Overhead: Lightweight and optimized for metrics collection in Spring Boot.
-    - Minimal Performance Impact: Metrics collection with Micrometer is efficient, using dimensional tagging and asynchronous data export.
+  - Low Overhead: Lightweight and optimized for metrics collection in Spring Boot.
+  - Minimal Performance Impact: Metrics collection with Micrometer is efficient, using dimensional tagging and asynchronous data export.
 - OpenTelemetry:
-    - Slightly Higher Overhead: Due to the combined handling of traces, metrics, and logs.
-    - Scalability Impact: Requires more resources for large-scale applications due to richer data capture (e.g., distributed traces).
+  - Slightly Higher Overhead: Due to the combined handling of traces, metrics, and logs.
+  - Scalability Impact: Requires more resources for large-scale applications due to richer data capture (e.g., distributed traces).
 
 Recommendation:
 
@@ -469,4 +460,4 @@ Both OpenTelemetry and Micrometer provide mechanisms for handling sensitive data
 - OpenTelemetry offers configuration options to redact or obfuscate sensitive information in traces and logs. It also supports the secure transmission of telemetry data through encrypted protocols.
 - Micrometer allows for fine-grained control over what metrics are collected and exported, enabling you to exclude sensitive data from your metrics.
 
-In both cases, it's crucial to carefully configure your [observability pipeline](https://signoz.io/guides/observability-pipeline/) to ensure compliance with data privacy regulations and security best practices.
\ No newline at end of file
+In both cases, it's crucial to carefully configure your [observability pipeline](https://signoz.io/guides/observability-pipeline/) to ensure compliance with data privacy regulations and security best practices.
diff --git a/data/comparisons/opentelemetry-vs-newrelic.mdx b/data/comparisons/opentelemetry-vs-newrelic.mdx
index 6a29fef1d..2ff465b1b 100644
--- a/data/comparisons/opentelemetry-vs-newrelic.mdx
+++ b/data/comparisons/opentelemetry-vs-newrelic.mdx
@@ -1,11 +1,12 @@
 ---
 title: OpenTelemetry vs. New Relic - Which Monitoring Tool Fits You?
-slug: opentelemetry-vs-newrelic
+
 date: 2025-01-22
 tags: [opentelemetry, tools-comparisons]
 authors: [soumya_gupta]
 description: Discover the key differences between OpenTelemetry and New Relic for observability. Learn which tool best suits your monitoring needs and strategy.
-keywords: [OpenTelemetry, New Relic, observability, monitoring, APM, open-source, commercial tools, SigNoz]
+keywords:
+  [OpenTelemetry, New Relic, observability, monitoring, APM, open-source, commercial tools, SigNoz]
 ---
 
 OpenTelemetry and New Relic represent two distinct approaches to observability. OpenTelemetry is an open-source framework for collecting and standardizing telemetry data, while New Relic is a commercial observability platform that provides [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) capabilities.
@@ -20,7 +21,11 @@ OpenTelemetry is an open-source observability framework that standardizes teleme
 
 ### OpenTelemetry Key Features
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image.webp" alt="OpenTelemetry Key Features" caption="OpenTelemetry Key Features" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image.webp"
+  alt="OpenTelemetry Key Features"
+  caption="OpenTelemetry Key Features"
+/>
 
 - **Vendor-agnostic instrumentation**: An open standard that ensures flexibility and avoids vendor lock-in
 - **Multi-language support**: Unified toolkit for seamless instrumentation across different programming languages
@@ -39,6 +44,7 @@ New Relic takes a different approach as a commercial observability platform. It
 - **AI-powered anomaly detection**: Uses machine learning to identify critical performance issues before they impact customers.
 
 ### Can They Be Used Together?
+
 Yes, OpenTelemetry can complement New Relic by:
 
 - Instrumentation: Using OpenTelemetry for collecting telemetry data.
@@ -60,14 +66,14 @@ As software systems grew more complex, observability tools evolved beyond basic
 
 The fundamental distinction between OpenTelemetry and New Relic lies in their approaches to data collection and analysis:
 
-| Core Differences | OpenTelemetry | New Relic |
-| --- | --- | --- |
-| Type | Open-source framework | Proprietary SaaS platform |
-| Data Collection Methods | It uses a vendor-agnostic approach, allowing you to instrument your code once and send data to multiple backends. | It relies on proprietary agents and SDKs, optimized for its platform but potentially limiting portability. |
-| Customization and Flexibility | It offers high extensibility, enabling you to create custom exporters and integrations. | It provides out-of-the-box solutions with less flexibility but faster time-to-value. |
-| Pricing Models | It's open-source and free to use but requires infrastructure for data storage and visualization. | It offers a commercial licensing model with various tiers based on data ingestion and retention. |
-| Community Support and Ecosystem | It benefits from a large, collaborative open-source community. | It provides enterprise-grade support and a curated marketplace of integrations. |
-| Advanced Analytics | Depends on backend integration | Built-in with AI-powered insights |
+| Core Differences                | OpenTelemetry                                                                                                     | New Relic                                                                                                  |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| Type                            | Open-source framework                                                                                             | Proprietary SaaS platform                                                                                  |
+| Data Collection Methods         | It uses a vendor-agnostic approach, allowing you to instrument your code once and send data to multiple backends. | It relies on proprietary agents and SDKs, optimized for its platform but potentially limiting portability. |
+| Customization and Flexibility   | It offers high extensibility, enabling you to create custom exporters and integrations.                           | It provides out-of-the-box solutions with less flexibility but faster time-to-value.                       |
+| Pricing Models                  | It's open-source and free to use but requires infrastructure for data storage and visualization.                  | It offers a commercial licensing model with various tiers based on data ingestion and retention.           |
+| Community Support and Ecosystem | It benefits from a large, collaborative open-source community.                                                    | It provides enterprise-grade support and a curated marketplace of integrations.                            |
+| Advanced Analytics              | Depends on backend integration                                                                                    | Built-in with AI-powered insights                                                                          |
 
 ## Integration and Compatibility
 
@@ -75,17 +81,19 @@ Before OpenTelemetry (OTEL) came along, tools like New Relic relied on their own
 
 When you integrate OpenTelemetry with New Relic, OpenTelemetry provides a standardized way to collect telemetry data, while New Relic offers a robust platform to analyze and derive insights from that data, giving you a complete view of your software stack.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image%201.webp" alt="Reference architecture of OpenTelemetry with New Relic (Picture from: New Relic)" caption="Reference architecture of OpenTelemetry with New Relic (Picture from: New Relic)" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image%201.webp"
+  alt="Reference architecture of OpenTelemetry with New Relic (Picture from: New Relic)"
+  caption="Reference architecture of OpenTelemetry with New Relic (Picture from: New Relic)"
+/>
 
 New Relic has recognized the growing importance of OpenTelemetry and now supports data ingestion from OpenTelemetry-instrumented applications. This integration allows you to:
 
-**Send [OpenTelemetry traces](https://signoz.io/blog/opentelemetry-spans/) and metrics to New Relic**: 
+**Send [OpenTelemetry traces](https://signoz.io/blog/opentelemetry-spans/) and metrics to New Relic**:
 
-Typically, you start by configuring the Collector with a processor that enhances the [APM telemetry](https://signoz.io/blog/opentelemetry-apm/) by adding extra context through resource attributes before exporting the data to New Relic using OTLP. New Relic then identifies this correlation data and builds relationships between APM and infrastructure entities based on those resources. While the specifics of the configuration can differ depending on requirements, collectors that send data to New Relic should have certain things in common such as
-    - OTLP Exporter: The [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) can export data using the OTLP/HTTP exporter, so it's important to configure it according to New Relic's OTLP requirements.
-    - Batch Processor: It sets up the Collector to utilise the batch processor for exporting records in batches, provided you adjust the batch size and frequency to comply with New Relic's OTLP requirements.
+Typically, you start by configuring the Collector with a processor that enhances the [APM telemetry](https://signoz.io/blog/opentelemetry-apm/) by adding extra context through resource attributes before exporting the data to New Relic using OTLP. New Relic then identifies this correlation data and builds relationships between APM and infrastructure entities based on those resources. While the specifics of the configuration can differ depending on requirements, collectors that send data to New Relic should have certain things in common such as - OTLP Exporter: The [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) can export data using the OTLP/HTTP exporter, so it's important to configure it according to New Relic's OTLP requirements. - Batch Processor: It sets up the Collector to utilise the batch processor for exporting records in batches, provided you adjust the batch size and frequency to comply with New Relic's OTLP requirements.
 
-**Visualize OpenTelemetry data alongside New Relic's native telemetry** 
+**Visualize OpenTelemetry data alongside New Relic's native telemetry**
 
 Once OTEL data is ingested by New Relic, you can view and analyze both OTEL and New Relic's native telemetry concurrently. This feature is particularly useful in environments where deploying New Relic's native agents may not be feasible, such as certain cloud or serverless setups—OpenTelemetry effectively bridges that gap. You still benefit from New Relic's robust platform capabilities, including dashboards, alerts, analytics, and [distributed tracing](https://signoz.io/blog/distributed-tracing/) for both data types.
 
@@ -108,6 +116,7 @@ By integrating this data with New Relic's powerful analytics, you can gain valua
 New Relic's roadmap includes deeper OpenTelemetry integration, aiming to provide seamless support for the standard while maintaining its value-added features.
 
 ## When to Choose OpenTelemetry
+
 OpenTelemetry with a suitable backend is ideal when:
 
 - **Vendor-agnostic instrumentation is crucial**: You want the flexibility to switch observability backends without re-instrumenting your code and your organization has a multi-vendor strategy for observability tools.
@@ -132,30 +141,34 @@ New Relic is better suited when:
 
 When evaluating OpenTelemetry and New Relic, consider these performance and scalability factors:
 
-| Factors | OpenTelemetry | New Relic |
-| --- | --- | --- |
-| Data Ingestion and Processing | Highly efficient data collection, but backend performance depends on your chosen storage and analysis tools. | Optimized for high-volume data ingestion with automatic scaling. |
-| Query Performance | Query performance varies based on your backend (e.g., Prometheus, Jaeger). | Offers fast query response times, especially for pre-aggregated metrics. |
-| Data Retention | Flexible retention policies based on your storage solution. | Tiered retention policies with options for long-term storage. |
-| Scalability in Distributed Systems | Designed for large-scale distributed systems with minimal overhead. | Proven scalability for enterprise-grade deployments. |
-| Resource Overhead | Generally lightweight, with configurable sampling to reduce overhead. | Low overhead for most applications but may impact performance in resource-constrained environments. |
+| Factors                            | OpenTelemetry                                                                                                | New Relic                                                                                           |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------- |
+| Data Ingestion and Processing      | Highly efficient data collection, but backend performance depends on your chosen storage and analysis tools. | Optimized for high-volume data ingestion with automatic scaling.                                    |
+| Query Performance                  | Query performance varies based on your backend (e.g., Prometheus, Jaeger).                                   | Offers fast query response times, especially for pre-aggregated metrics.                            |
+| Data Retention                     | Flexible retention policies based on your storage solution.                                                  | Tiered retention policies with options for long-term storage.                                       |
+| Scalability in Distributed Systems | Designed for large-scale distributed systems with minimal overhead.                                          | Proven scalability for enterprise-grade deployments.                                                |
+| Resource Overhead                  | Generally lightweight, with configurable sampling to reduce overhead.                                        | Low overhead for most applications but may impact performance in resource-constrained environments. |
 
 ## Cost Considerations: OpenTelemetry vs. New Relic
 
 Understanding the total cost of ownership (TCO) is crucial when choosing between OpenTelemetry and New Relic:
 
-| Cost Considerations | OpenTelemetry | New Relic |
-| --- | --- | --- |
-| Initial Implementation Costs | It provides lower upfront costs but requires investment in setup and configuration. This often includes the need for skilled developers or DevOps resources to ensure a proper implementation, which can increase initial costs if expertise isn't already available. | Higher initial costs due to licensing but offers faster time-to-value. The pre-built integrations and dashboards can significantly reduce the learning curve, allowing teams to start gaining insights almost immediately, which can offset initial expenditures. |
-| Long-term Operational Expenses | Costs primarily relate to infrastructure for data storage and visualization. As usage grows, organizations may need to invest in more robust storage solutions or additional tools for data analysis, which can add to ongoing expenses. | Ongoing licensing fees based on data ingestion and user access. It's essential to project future growth accurately, as scaling can lead to increasing costs; however, the predictable pricing model can help in budgeting. |
-| Hidden Costs in Self-managed Deployments | Consider expenses for maintenance, upgrades, and scaling of your observability stack. Organizations should also factor in the potential costs of troubleshooting and the need for additional resources as complexity increases. | Fewer hidden costs due to managed service, but potential for unexpected charges from high data volume. Understanding the pricing tiers and potential spikes in usage is critical to avoid surprises on monthly bills. |
-| ROI Analysis | For small organizations, OpenTelemetry may offer better ROI due to lower costs, if in-house expertise is available. These organizations can leverage their technical resources effectively, turning the initial investment into long-term savings. | For Large enterprises, New Relic's comprehensive features and support may justify the higher costs through improved productivity and faster issue resolution. The ability to streamline operations and reduce downtime can lead to significant cost savings over time.  |
+| Cost Considerations                      | OpenTelemetry                                                                                                                                                                                                                                                         | New Relic                                                                                                                                                                                                                                                              |
+| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Initial Implementation Costs             | It provides lower upfront costs but requires investment in setup and configuration. This often includes the need for skilled developers or DevOps resources to ensure a proper implementation, which can increase initial costs if expertise isn't already available. | Higher initial costs due to licensing but offers faster time-to-value. The pre-built integrations and dashboards can significantly reduce the learning curve, allowing teams to start gaining insights almost immediately, which can offset initial expenditures.      |
+| Long-term Operational Expenses           | Costs primarily relate to infrastructure for data storage and visualization. As usage grows, organizations may need to invest in more robust storage solutions or additional tools for data analysis, which can add to ongoing expenses.                              | Ongoing licensing fees based on data ingestion and user access. It's essential to project future growth accurately, as scaling can lead to increasing costs; however, the predictable pricing model can help in budgeting.                                             |
+| Hidden Costs in Self-managed Deployments | Consider expenses for maintenance, upgrades, and scaling of your observability stack. Organizations should also factor in the potential costs of troubleshooting and the need for additional resources as complexity increases.                                       | Fewer hidden costs due to managed service, but potential for unexpected charges from high data volume. Understanding the pricing tiers and potential spikes in usage is critical to avoid surprises on monthly bills.                                                  |
+| ROI Analysis                             | For small organizations, OpenTelemetry may offer better ROI due to lower costs, if in-house expertise is available. These organizations can leverage their technical resources effectively, turning the initial investment into long-term savings.                    | For Large enterprises, New Relic's comprehensive features and support may justify the higher costs through improved productivity and faster issue resolution. The ability to streamline operations and reduce downtime can lead to significant cost savings over time. |
 
 ## The Role of SigNoz in the OpenTelemetry Ecosystem
 
-SigNoz emerges as an [open-source alternative to New Relic](https://signoz.io/blog/open-source-newrelic-alternative/), leveraging OpenTelemetry for data collection. 
+SigNoz emerges as an [open-source alternative to New Relic](https://signoz.io/blog/open-source-newrelic-alternative/), leveraging OpenTelemetry for data collection.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image%202.webp" alt="Signoz architecture with OpenTelemetry (Picture from: SigNoz)" caption="Signoz architecture with OpenTelemetry (Picture from: SigNoz)" />
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-newrelic-image%202.webp"
+  alt="Signoz architecture with OpenTelemetry (Picture from: SigNoz)"
+  caption="Signoz architecture with OpenTelemetry (Picture from: SigNoz)"
+/>
 
 Key features of SigNoz include:
 
@@ -167,7 +180,7 @@ Key features of SigNoz include:
 SigNoz offers several benefits when used with OpenTelemetry:
 
 1. Open-source flexibility with a turnkey solution being one. SigNoz provides the flexibility of open-source software, meaning it can be customized to fit your needs without the limitations imposed by commercial [APM tools](https://signoz.io/blog/open-source-apm-tools/).
-2. As SigNoz is open source, it offers a far more cost-effective option compared to expensive proprietary APM tools like New Relic. 
+2. As SigNoz is open source, it offers a far more cost-effective option compared to expensive proprietary APM tools like New Relic.
 3. It provided full control over your observability data. This level of data ownership is important for companies that are concerned about privacy, compliance, or simply prefer to manage their telemetry data in-house, rather than relying on external vendors who may store data in different regions or under varying security protocols.
 4. It has an active community support and provides updates on a regular basis. This approach ensures that SigNoz evolves in line with user needs, while also providing a support network where users can share best practices and get help with implementation challenges.
 
@@ -178,19 +191,19 @@ SigNoz offers several benefits when used with OpenTelemetry:
 The observability landscape continues to evolve, with several trends shaping the future:
 
 1. OpenTelemetry Adoption:
-    - Prediction: Widespread adoption of OpenTelemetry as the de facto standard for instrumentation. As more organizations recognize its advantages, adoption will grow exponentially.
-    - Impact: This widespread acceptance will facilitate greater interoperability between different observability tools, allowing for seamless integration and data sharing. As a result, organizations will experience reduced vendor lock-in, empowering them to switch tools or use multiple platforms without losing their investment in instrumentation.
+   - Prediction: Widespread adoption of OpenTelemetry as the de facto standard for instrumentation. As more organizations recognize its advantages, adoption will grow exponentially.
+   - Impact: This widespread acceptance will facilitate greater interoperability between different observability tools, allowing for seamless integration and data sharing. As a result, organizations will experience reduced vendor lock-in, empowering them to switch tools or use multiple platforms without losing their investment in instrumentation.
 2. Commercial Tool Adaptation:
-    - Trend: Commercial tools like New Relic are likely to enhance their integration with OpenTelemetry, providing users with more options for data collection and analysis.
-    - Outcome: As these tools adopt OpenTelemetry standards, the lines between open-source and commercial observability solutions will blur. Users will benefit from the strengths of both worlds—flexible, customisable open-source options alongside the robust features and support of commercial products.
+   - Trend: Commercial tools like New Relic are likely to enhance their integration with OpenTelemetry, providing users with more options for data collection and analysis.
+   - Outcome: As these tools adopt OpenTelemetry standards, the lines between open-source and commercial observability solutions will blur. Users will benefit from the strengths of both worlds—flexible, customisable open-source options alongside the robust features and support of commercial products.
 3. Emerging Observability Patterns:
-    - Focus on eBPF: The rise of extended Berkeley Packet Filter (eBPF) technology is revolutionizing low-overhead instrumentation. eBPF runs custom code within the Linux kernel ("kernel space"), making it faster than traditional "user space" operations. It minimizes resource usage and system crash risks by running in a sandboxed environment. Plus, eBPF allows code execution without changing kernel source code or loading new modules, streamlining OS updates while ensuring efficient data collection with minimal performance impact.
-    - Real-time, Streaming Analytics: The demand for real-time analytics will grow, enabling organizations to derive insights from their data as it streams in, enhancing decision-making and response times.
-    - Importance in Edge Computing and IoT: With the rise of edge computing and IoT devices, observability solutions will need to adapt to monitor distributed environments effectively, ensuring visibility across diverse systems and locations.
+   - Focus on eBPF: The rise of extended Berkeley Packet Filter (eBPF) technology is revolutionizing low-overhead instrumentation. eBPF runs custom code within the Linux kernel ("kernel space"), making it faster than traditional "user space" operations. It minimizes resource usage and system crash risks by running in a sandboxed environment. Plus, eBPF allows code execution without changing kernel source code or loading new modules, streamlining OS updates while ensuring efficient data collection with minimal performance impact.
+   - Real-time, Streaming Analytics: The demand for real-time analytics will grow, enabling organizations to derive insights from their data as it streams in, enhancing decision-making and response times.
+   - Importance in Edge Computing and IoT: With the rise of edge computing and IoT devices, observability solutions will need to adapt to monitor distributed environments effectively, ensuring visibility across diverse systems and locations.
 4. AI and Machine Learning in Observability:
-    - Advanced Anomaly Detection: The integration of AI and machine learning will enable advanced anomaly detection, allowing observability tools to identify unusual patterns and behaviors in real-time, thereby reducing response times to potential issues.
-    - Automated Root Cause Analysis: AI-driven solutions facilitate automated root cause analysis, providing insights and remediation suggestions based on historical data and machine learning models, streamlining the troubleshooting process.
-    - AI-assisted Query Building: As the complexity of data grows, AI-assisted query building and data exploration will help users navigate their telemetry data more effectively, making it easier to extract valuable insights without needing deep technical expertise.
+   - Advanced Anomaly Detection: The integration of AI and machine learning will enable advanced anomaly detection, allowing observability tools to identify unusual patterns and behaviors in real-time, thereby reducing response times to potential issues.
+   - Automated Root Cause Analysis: AI-driven solutions facilitate automated root cause analysis, providing insights and remediation suggestions based on historical data and machine learning models, streamlining the troubleshooting process.
+   - AI-assisted Query Building: As the complexity of data grows, AI-assisted query building and data exploration will help users navigate their telemetry data more effectively, making it easier to extract valuable insights without needing deep technical expertise.
 
 ## Key Takeaways
 
@@ -222,4 +235,4 @@ Common challenges in OpenTelemetry adoption include:
 2. Choosing and integrating appropriate backend systems
 3. Ensuring consistent instrumentation across diverse technology stacks
 4. Managing the performance impact of data collection at scale
-5. Keeping up with the rapidly evolving OpenTelemetry ecosystem
\ No newline at end of file
+5. Keeping up with the rapidly evolving OpenTelemetry ecosystem
diff --git a/data/comparisons/opentelemetry-vs-opencensus.mdx b/data/comparisons/opentelemetry-vs-opencensus.mdx
index 9308e8524..678bd248e 100644
--- a/data/comparisons/opentelemetry-vs-opencensus.mdx
+++ b/data/comparisons/opentelemetry-vs-opencensus.mdx
@@ -1,22 +1,29 @@
 ---
-
 title: OpenTelemetry vs OpenCensus - Key Differences Explained
-slug: opentelemetry-vs-opencensus
+
 date: 2024-11-07
 tags: [OpenTelemetry]
 authors: [manjunath_irukulla]
 description: Discover the key differences between OpenTelemetry and OpenCensus. Learn about features, migration strategies, and why OpenTelemetry is the future of observability.
-keywords: [opentelemetry, opencensus, observability, distributed tracing, metrics collection, migration, sigNoz]
-
+keywords:
+  [
+    opentelemetry,
+    opencensus,
+    observability,
+    distributed tracing,
+    metrics collection,
+    migration,
+    sigNoz,
+  ]
 ---
 
-Observability is essential for maintaining system health and performance in distributed systems and cloud-native applications. OpenTelemetry and OpenCensus are tools that enhance observability, each offering distinct features and approaches. 
+Observability is essential for maintaining system health and performance in distributed systems and cloud-native applications. OpenTelemetry and OpenCensus are tools that enhance observability, each offering distinct features and approaches.
 
-This article provides an in-depth comparison of OpenTelemetry and OpenCensus, examining their features, capabilities, and the driving factors behind the industry’s shift towards OpenTelemetry. 
+This article provides an in-depth comparison of OpenTelemetry and OpenCensus, examining their features, capabilities, and the driving factors behind the industry’s shift towards OpenTelemetry.
 
 ## What Are OpenTelemetry and OpenCensus?
 
-OpenTelemetry is an open-source framework that aims to standardize telemetry data collection and transmission, making it easier to integrate with various backends and analysis tools. It offers a unified API to collect metrics, traces, and logs from your applications and infrastructure.  
+OpenTelemetry is an open-source framework that aims to standardize telemetry data collection and transmission, making it easier to integrate with various backends and analysis tools. It offers a unified API to collect metrics, traces, and logs from your applications and infrastructure.
 
 OpenCensus, developed by Google, is an open-source library that focuses primarily on metrics collection and [distributed tracing](https://signoz.io/blog/distributed-tracing/). While it gained popularity for its simplicity and performance, OpenCensus had limitations that ultimately led to the evolution of OpenTelemetry.
 
@@ -33,13 +40,17 @@ OpenTelemetry and OpenCensus play a vital role in modern software development, p
 
 ## Key Features of OpenTelemetry
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-opencensus-napkin-selection_(10).webp" alt="Key Features of OpenTelemetry" caption="Key Features of OpenTelemetry" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-opencensus-napkin-selection_(10).webp"
+  alt="Key Features of OpenTelemetry"
+  caption="Key Features of OpenTelemetry"
+/>
 
-OpenTelemetry boasts several advantages that make it a powerful choice for observability: 
+OpenTelemetry boasts several advantages that make it a powerful choice for observability:
 
 1. Unified API: OpenTelemetry consolidates metrics, traces, and logs under a single API, simplifying the instrumentation and data collection process across your entire stack. This unified approach reduces complexity and improves consistency.
-2. Multi-Language Support: OpenTelemetry supports a wide array of programming languages and frameworks, including Java, Python, Go, and .NET. This broad compatibility facilitates widespread adoption across diverse environments, making it suitable for various projects. 
-3. Extensible Architecture: Its pluggable component design allows for easy integration with different backends and customization of its behavior, ensuring that it can cater to specific application needs. This flexibility enables developers to adapt OpenTelemetry to fit their unique requirements. 
+2. Multi-Language Support: OpenTelemetry supports a wide array of programming languages and frameworks, including Java, Python, Go, and .NET. This broad compatibility facilitates widespread adoption across diverse environments, making it suitable for various projects.
+3. Extensible Architecture: Its pluggable component design allows for easy integration with different backends and customization of its behavior, ensuring that it can cater to specific application needs. This flexibility enables developers to adapt OpenTelemetry to fit their unique requirements.
 4. Built-in [Context Propagation](https://signoz.io/blog/opentelemetry-context-propagation/) across Service Boundaries: OpenTelemetry includes mechanisms for context propagation, which allow for the seamless tracking of requests as they flow through different services in a distributed system. This feature enables developers to maintain contextual information (like trace IDs) across service boundaries, which is essential for correlating logs and traces effectively.
 
 ## OpenCensus Capabilities and Limitations
@@ -80,15 +91,15 @@ Despite its strengths, OpenCensus has limitations that prompted the rise of Open
 
 When comparing OpenTelemetry and OpenCensus, several key differences become apparent:
 
-| Feature | OpenTelemetry | OpenCensus |
-| --- | --- | --- |
-| Data Types | Metrics, Traces, Logs | Metrics, Traces |
-| Protocol | OTLP (standard protocol) | Multiple formats |
-| Instrumentation API | Comprehensive with significant auto-instrumentation capabilities and stability across languages | Less consistent across telemetry signal types |
-| Sampling Strategies | More flexible sampling decisions through its trace provider | Per-span sampling approach |
-| Backend Support | Extensive, standardized | Limited |
-| Community Support | Large, active community | Limited, decreasing |
-| Interoperability | Highly interoperable with a wide range of monitoring backends and tools due to its adherence to open standards.  | Limited interoperability and fewer integrations compared to OpenTelemetry.  |
+| Feature             | OpenTelemetry                                                                                                   | OpenCensus                                                                 |
+| ------------------- | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| Data Types          | Metrics, Traces, Logs                                                                                           | Metrics, Traces                                                            |
+| Protocol            | OTLP (standard protocol)                                                                                        | Multiple formats                                                           |
+| Instrumentation API | Comprehensive with significant auto-instrumentation capabilities and stability across languages                 | Less consistent across telemetry signal types                              |
+| Sampling Strategies | More flexible sampling decisions through its trace provider                                                     | Per-span sampling approach                                                 |
+| Backend Support     | Extensive, standardized                                                                                         | Limited                                                                    |
+| Community Support   | Large, active community                                                                                         | Limited, decreasing                                                        |
+| Interoperability    | Highly interoperable with a wide range of monitoring backends and tools due to its adherence to open standards. | Limited interoperability and fewer integrations compared to OpenTelemetry. |
 
 ### Data Model
 
@@ -112,45 +123,49 @@ When comparing OpenTelemetry and OpenCensus, several key differences become appa
 
 ## Migration Considerations from OpenCensus to OpenTelemetry
 
-If you’re contemplating a migration from OpenCensus to OpenTelemetry, consider the following: 
+If you’re contemplating a migration from OpenCensus to OpenTelemetry, consider the following:
 
-1. Breaking Changes: OpenTelemetry introduces significant changes in both its API structure and core concepts compared to OpenCensus. This means you’ll need to update your instrumentation code to align with the new API, so be prepared for a more involved refactoring process. 
-2. Compatibility Layers: OpenTelemetry provides bridges or shim layers that allow you to continue using OpenCensus APIs while sending data to [OpenTelemetry backends](https://signoz.io/blog/opentelemetry-backend/). These layers help smooth the migration by letting you adopt OpenTelemetry incrementally without breaking existing functionality. 
-3. Gradual Migration: Consider adopting a gradual migration strategy where you introduce OpenTelmetry alongside OpenCensus. This lets you migrate components one by one, allowing both to run automatically until you fully transition to OpenTelemetry. 
-4. Through Testing: Extensive testing is essential to ensure the accuracy and reliability of your telemetry data throughout the migration. Conduct rigorous tests to validate that your traces and metrics are being captured correctly, both during and after the transition, to avoid data loss or misrepresentation. 
+1. Breaking Changes: OpenTelemetry introduces significant changes in both its API structure and core concepts compared to OpenCensus. This means you’ll need to update your instrumentation code to align with the new API, so be prepared for a more involved refactoring process.
+2. Compatibility Layers: OpenTelemetry provides bridges or shim layers that allow you to continue using OpenCensus APIs while sending data to [OpenTelemetry backends](https://signoz.io/blog/opentelemetry-backend/). These layers help smooth the migration by letting you adopt OpenTelemetry incrementally without breaking existing functionality.
+3. Gradual Migration: Consider adopting a gradual migration strategy where you introduce OpenTelmetry alongside OpenCensus. This lets you migrate components one by one, allowing both to run automatically until you fully transition to OpenTelemetry.
+4. Through Testing: Extensive testing is essential to ensure the accuracy and reliability of your telemetry data throughout the migration. Conduct rigorous tests to validate that your traces and metrics are being captured correctly, both during and after the transition, to avoid data loss or misrepresentation.
 
 ## Why Choose OpenTelemetry Over OpenCensus?
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-opencensus-image.webp" alt="Reasons to choose OpenTelemetry" caption="Reasons to choose OpenTelemetry" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-opencensus-image.webp"
+  alt="Reasons to choose OpenTelemetry"
+  caption="Reasons to choose OpenTelemetry"
+/>
 
-OpenTelemetry presents several advantages, making it the preferred choice for new projects. 
+OpenTelemetry presents several advantages, making it the preferred choice for new projects.
 
-1. Broader Community Support: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is the industry-standard observability framework, backend by a large and active community. This support translates to quicker updates, better resources, and more contributions, making it easier to find help and best practices. 
-2. Enhanced features: OpenTelemetry brings advanced functionality by providing native support for logs, metrics, and traces within a single framework. This holistic approach simplifies observability, ensuring you can track all relevant data types. 
-3. Better interoperability: OpenTelemetry’s adherence to open standards ensures seamless integration with a wide variety of backends, monitoring tools, and cloud services. This makes it easier to adopt, expand, and manage in any environment. 
-4. Future-proof: With strong industry support him major technology companies, OpenTelemetry is poised to evolve and stay relevant as observability requirements change, ensuring you’re investing in a framework that will continue to grow. 
+1. Broader Community Support: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is the industry-standard observability framework, backend by a large and active community. This support translates to quicker updates, better resources, and more contributions, making it easier to find help and best practices.
+2. Enhanced features: OpenTelemetry brings advanced functionality by providing native support for logs, metrics, and traces within a single framework. This holistic approach simplifies observability, ensuring you can track all relevant data types.
+3. Better interoperability: OpenTelemetry’s adherence to open standards ensures seamless integration with a wide variety of backends, monitoring tools, and cloud services. This makes it easier to adopt, expand, and manage in any environment.
+4. Future-proof: With strong industry support him major technology companies, OpenTelemetry is poised to evolve and stay relevant as observability requirements change, ensuring you’re investing in a framework that will continue to grow.
 
 ## How to Migrate from OpenCensus to OpenTelemetry
 
-To facilitate your migration from OpenCensus to OpenTelemetry, follow these steps: 
+To facilitate your migration from OpenCensus to OpenTelemetry, follow these steps:
 
 1. Update Dependencies: Replace OpenCensus libraries with their OpenTelemetry equivalents in your project.
-2. Adapt Instrumentation: Modify your code to utilize OpenTelemetry’s API, updating how you create and manage traces, spans, and metrics. 
-3. Handle Context Propagation: OpenTelemetry employs a different context propagation mechanism. Update your code accordingly. 
-4. Configure Exporters: Set up [OpenTelemetry exporters](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) to direct data to your chosen backends. OpenTelemetry supports many backends previously used with OpenCensus.  
-5. Test thoroughly: Validates that your telemetry data is accurately collected and exported following the migration. 
+2. Adapt Instrumentation: Modify your code to utilize OpenTelemetry’s API, updating how you create and manage traces, spans, and metrics.
+3. Handle Context Propagation: OpenTelemetry employs a different context propagation mechanism. Update your code accordingly.
+4. Configure Exporters: Set up [OpenTelemetry exporters](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) to direct data to your chosen backends. OpenTelemetry supports many backends previously used with OpenCensus.
+5. Test thoroughly: Validates that your telemetry data is accurately collected and exported following the migration.
 
 ### Migrating an Application Using Bridges
 
-If your application relies entirely on OpenCensus instrumentation for traces and metrics, consider the following steps: 
+If your application relies entirely on OpenCensus instrumentation for traces and metrics, consider the following steps:
 
-1. Migrate the Exporters (SDK): 
-    - Install the <a href="https://opentelemetry.io/docs/languages/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry SDK</a> along with an equivalent exporter.
-    - If using an OpenCensus exporter, switch to an OTLP exporter.
-    - Integrate OpenTelemetry resource detectors and the W3C TraceContext propagator.
-2. Install the Metrics and Trace Bridges: These bridges will help facilitate the migration process while keeping the existing OpenCensus instrumentation functional. 
-3. Migrate the instrumentation (API): Update OpenCensus instrumentation packages to their OpenTelemetry equivalents, ensuring the new implementation adheres to the latest OpenTelemetry standards. 
-4. Clean Up: Once migration is complete, remove any traces of the metrics and trace bridges. 
+1. Migrate the Exporters (SDK):
+   - Install the <a href="https://opentelemetry.io/docs/languages/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry SDK</a> along with an equivalent exporter.
+   - If using an OpenCensus exporter, switch to an OTLP exporter.
+   - Integrate OpenTelemetry resource detectors and the W3C TraceContext propagator.
+2. Install the Metrics and Trace Bridges: These bridges will help facilitate the migration process while keeping the existing OpenCensus instrumentation functional.
+3. Migrate the instrumentation (API): Update OpenCensus instrumentation packages to their OpenTelemetry equivalents, ensuring the new implementation adheres to the latest OpenTelemetry standards.
+4. Clean Up: Once migration is complete, remove any traces of the metrics and trace bridges.
 
 Here's an example of updating an OpenCensus-instrumented function to OpenTelemetry:
 
@@ -169,7 +184,7 @@ def process_request(request):
     return result
 ```
 
-This code demonstrates how to instrument a code with OpenCensus for distributed tracing. The key steps include: 
+This code demonstrates how to instrument a code with OpenCensus for distributed tracing. The key steps include:
 
 - Creating a Tracer,
 - Starting a span,
@@ -192,14 +207,14 @@ def process_request(request):
     return result
 ```
 
-This code uses OpenTelemetry to trace the process of handling a request. It performs 
+This code uses OpenTelemetry to trace the process of handling a request. It performs
 
 - Creating a Tracer,
 - Starting a Span,
 - Setting span attributes,
 - Automatically managing span lifestyle.
 
-This approach helps monitor and debug distributed systems. It automatically provides visibility into individual steps, making it easier to identify issues. 
+This approach helps monitor and debug distributed systems. It automatically provides visibility into individual steps, making it easier to identify issues.
 
 ## Implementing OpenTelemetry with SigNoz
 
@@ -207,7 +222,7 @@ This approach helps monitor and debug distributed systems. It automatically prov
 
 ### Getting Started with SigNoz
 
-<GetStartedSigNoz /> 
+<GetStartedSigNoz />
 
 ### Benefits of using SigNoz with OpenTelemetry for Full-Stack Observability
 
@@ -219,18 +234,18 @@ Using SigNoz with OpenTelemetry for full-stack observability offers numerous adv
 - Metrics Visualization: With customizable metrics and dashboards, you can monitor critical KPIs like latency, error rates, and resource utilization, visualize trends, and detect anomalies before they impact users.
 - Actionable Insights: With customizable metrics and dashboards, you can monitor critical KPIs like latency, error rates, and resource utilization, enabling proactive performance tuning.
 
-SigNoz’s comprehensive feature set and OpenTelemetry compatibility make it an ideal choice for developers who seek a scalable, flexible solution. 
+SigNoz’s comprehensive feature set and OpenTelemetry compatibility make it an ideal choice for developers who seek a scalable, flexible solution.
 
 ## Future of Observability
 
-The trajectory of observability is closely intertwined with OpenTelemetry’s development. Key areas of focus include: 
+The trajectory of observability is closely intertwined with OpenTelemetry’s development. Key areas of focus include:
 
-1. Enhanced Log Support: OpenTelemetry is enhancing the integration of logs with traces and metrics, enabling between correlation of data for faster root cause analysis. [Structured logging](https://signoz.io/blog/structured-logs/) will offer richer context, making it easier to filter and analyze logs.   
-2. Advanced Sampling Techniques: To handle the performance impact of large-scale data collection, OpenTelemetry is developing dynamic sampling techniques. These will intelligently decide which data to trace, balancing performancing with comprehensive observability.  
-3. AI/ML Integration: AI and ML will revolutionise observability by automating anomaly detection and providing predictive analytics. OpenTelemetry will help organizations proactively manage systems by identifying potential issues and optimizing resources before problems escalate. 
-4. Ecosystem Growth: OpenTelemetry aims to foster a growing ecosystem with support for various backends, frameworks, and protocols, ensuring interoperability and flexibility without vendor lock-in.  
+1. Enhanced Log Support: OpenTelemetry is enhancing the integration of logs with traces and metrics, enabling between correlation of data for faster root cause analysis. [Structured logging](https://signoz.io/blog/structured-logs/) will offer richer context, making it easier to filter and analyze logs.
+2. Advanced Sampling Techniques: To handle the performance impact of large-scale data collection, OpenTelemetry is developing dynamic sampling techniques. These will intelligently decide which data to trace, balancing performancing with comprehensive observability.
+3. AI/ML Integration: AI and ML will revolutionise observability by automating anomaly detection and providing predictive analytics. OpenTelemetry will help organizations proactively manage systems by identifying potential issues and optimizing resources before problems escalate.
+4. Ecosystem Growth: OpenTelemetry aims to foster a growing ecosystem with support for various backends, frameworks, and protocols, ensuring interoperability and flexibility without vendor lock-in.
 
-As OpenTelemetry evolves, it is set to become the standard for cloud-native observability, opening new opportunities for both developers and organizations. 
+As OpenTelemetry evolves, it is set to become the standard for cloud-native observability, opening new opportunities for both developers and organizations.
 
 ## Key Takeaways
 
@@ -250,12 +265,12 @@ As OpenTelemetry evolves, it is set to become the standard for cloud-native obse
 
 ### Is OpenTelemetry completely backwards compatible with OpenCensus?
 
-While OpenTelemetry includes some compatibility layers for OpenCensus, it is not entirely backwards compatible. When migrating from OpenCensus to OpenTelemetry, you will need to update your instrumentation code to accommodate the differences in API and data models. 
+While OpenTelemetry includes some compatibility layers for OpenCensus, it is not entirely backwards compatible. When migrating from OpenCensus to OpenTelemetry, you will need to update your instrumentation code to accommodate the differences in API and data models.
 
 ### How long will OpenCensus continue to be supported?
 
-OpenCensus is currently in maintenance mode, which means no new features will be developed. While critical bug fixes may still be addressed, the community primarily focuses on OpenTelemetry. Therefore, it is advisable to plan your migration to OpenTelemetry to ensure long-term support and access to new features. 
+OpenCensus is currently in maintenance mode, which means no new features will be developed. While critical bug fixes may still be addressed, the community primarily focuses on OpenTelemetry. Therefore, it is advisable to plan your migration to OpenTelemetry to ensure long-term support and access to new features.
 
 ### Can I use OpenTelemetry and OpenCensus side by side during migration?
 
-Yes, it is possible to run OpenTelemetry and OpenCensus together during your migration process. This approach allows for a gradual transition, enabling you to migrate different parts of your system incrementally. However, it is crucial to have a well-defined migration plan to avoid confusion and ensure consistent data collection throughout the process.
\ No newline at end of file
+Yes, it is possible to run OpenTelemetry and OpenCensus together during your migration process. This approach allows for a gradual transition, enabling you to migrate different parts of your system incrementally. However, it is crucial to have a well-defined migration plan to avoid confusion and ensure consistent data collection throughout the process.
diff --git a/data/comparisons/opentelemetry-vs-splunk.mdx b/data/comparisons/opentelemetry-vs-splunk.mdx
index 6611a588f..ee98f1427 100644
--- a/data/comparisons/opentelemetry-vs-splunk.mdx
+++ b/data/comparisons/opentelemetry-vs-splunk.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: OpenTelemetry vs Splunk - Which Monitoring Tool Is Right for You?
-slug: opentelemetry-vs-splunk
+
 date: 2024-11-20
 tags: [OpenTelemetry]
 authors: [niyati_thakkar]
 description: Compare OpenTelemetry and Splunk for monitoring - features, costs, and implementation. Learn which tool best fits your needs and how to use them together.
-keywords: [opentelemetry vs splunk, splunk alternative, opentelemetry monitoring, splunk monitoring, observability platforms, distributed tracing tools]
-
+keywords:
+  [
+    opentelemetry vs splunk,
+    splunk alternative,
+    opentelemetry monitoring,
+    splunk monitoring,
+    observability platforms,
+    distributed tracing tools,
+  ]
 ---
 
 Modern distributed systems are complex, often spanning multiple environments and technologies. This complexity requires robust, scalable monitoring solutions to ensure reliability, performance, and quick troubleshooting. OpenTelemetry offers a vendor-neutral, open-source framework, allowing companies to instrument their systems without vendor lock-in and providing flexibility in data collection. On the other hand, Splunk is a comprehensive commercial platform known for its analytics capabilities, built-in visualization tools, and advanced alerting, which are particularly valued in enterprise environments.
@@ -18,7 +24,12 @@ OpenTelemetry and Splunk represent two distinct approaches for managing and anal
 
 ### OpenTelemetry: The Open-Source Observability Framework
 
-<a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> is an open-source framework offering standardized tools for collecting telemetry data like traces, metrics, and logs. Its flexibility and vendor-neutral design are ideal for teams seeking a customizable observability solution.
+<a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">
+  OpenTelemetry
+</a>
+is an open-source framework offering standardized tools for collecting telemetry data like traces,
+metrics, and logs. Its flexibility and vendor-neutral design are ideal for teams seeking a
+customizable observability solution.
 
 - Vendor-Neutral: Instrumentation is backend-agnostic, allowing data to be sent to multiple tools without reconfiguration.
 - Free and Open-Source: OpenTelemetry’s zero licensing costs make it budget-friendly, especially for smaller teams or those exploring new telemetry strategies.
@@ -27,14 +38,22 @@ OpenTelemetry and Splunk represent two distinct approaches for managing and anal
 
 ### Splunk: The Enterprise-Grade Monitoring and Analytics Platform
 
-<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> is a mature, commercial platform for monitoring and analytics, widely used in enterprise settings where robust support and advanced capabilities are essential.
+<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is a mature, commercial platform for monitoring and analytics, widely used in enterprise settings
+where robust support and advanced capabilities are essential.
 
 - Advanced Analytics: Splunk offers powerful search, visualization, and AI-driven insights, making it a strong choice for organizations with complex data needs.
 - Built-In Machine Learning: Splunk’s ML features enable proactive issue detection and performance optimization.
 - Commercial Licensing: Splunk’s per-GB ingestion pricing is tailored for enterprise budgets but may be costly for high data volumes.
 - Comprehensive Support: Splunk provides extensive documentation and professional services, ensuring reliable observability for enterprises with demanding requirements.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-splunk-image.webp" alt="Splunk Dashboard" caption="Splunk Dashboard" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-splunk-image.webp"
+  alt="Splunk Dashboard"
+  caption="Splunk Dashboard"
+/>
 
 ### Core Differences in Approach and Philosophy
 
@@ -52,34 +71,34 @@ Splunk: Splunk operates on a commercial, per-GB ingestion pricing model, which c
 
 In this section, we compare the key features and monitoring capabilities of OpenTelemetry and Splunk to help you better understand their strengths and suitability for different use cases.
 
-| Feature | OpenTelemetry | Splunk |
-| --- | --- | --- |
-| Data Collection and Formats | Supports traces, metrics, and logs; adaptable to various data types | Handles structured and unstructured data; excels in ingesting and analyzing large datasets |
-| Integration Options | Vendor-neutral, integrates with multiple platforms and tools | Rich ecosystem of integrations, especially strong for enterprise IT and security |
+| Feature                     | OpenTelemetry                                                           | Splunk                                                                                           |
+| --------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| Data Collection and Formats | Supports traces, metrics, and logs; adaptable to various data types     | Handles structured and unstructured data; excels in ingesting and analyzing large datasets       |
+| Integration Options         | Vendor-neutral, integrates with multiple platforms and tools            | Rich ecosystem of integrations, especially strong for enterprise IT and security                 |
 | Scalability and Performance | Scalable with backend flexibility; performance depends on backend setup | Enterprise-ready with high performance, robust cloud support, ideal for large-scale data volumes |
-| Visualization and Analytics | Flexible visualization options (e.g., Grafana) but setup-dependent | Built-in analytics with dashboards, reports, and AI/ML insights |
+| Visualization and Analytics | Flexible visualization options (e.g., Grafana) but setup-dependent      | Built-in analytics with dashboards, reports, and AI/ML insights                                  |
 
 ### Monitoring Capabilities
 
-| Monitoring Capability | OpenTelemetry | Splunk |
-| --- | --- | --- |
-| Metrics Collection | Collects metrics via SDKs; integrates with tools like Prometheus for analysis | Strong metric analysis with detailed dashboards and alerts |
-| Distributed Tracing | Supports distributed tracing standards, sending to backends like Zipkin and Jaeger | Comprehensive tracing with AI-driven insights and end-to-end visibility |
-| Log Aggregation | Provides log instrumentation, integrates with multiple logging solutions | Advanced log aggregation and search; ideal for centralized log management |
-| Real-Time Monitoring | Backend-dependent real-time monitoring with customizable configurations | Built-in, real-time monitoring with instant alerting, suited for proactive incident management |
+| Monitoring Capability | OpenTelemetry                                                                      | Splunk                                                                                         |
+| --------------------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| Metrics Collection    | Collects metrics via SDKs; integrates with tools like Prometheus for analysis      | Strong metric analysis with detailed dashboards and alerts                                     |
+| Distributed Tracing   | Supports distributed tracing standards, sending to backends like Zipkin and Jaeger | Comprehensive tracing with AI-driven insights and end-to-end visibility                        |
+| Log Aggregation       | Provides log instrumentation, integrates with multiple logging solutions           | Advanced log aggregation and search; ideal for centralized log management                      |
+| Real-Time Monitoring  | Backend-dependent real-time monitoring with customizable configurations            | Built-in, real-time monitoring with instant alerting, suited for proactive incident management |
 
 ## Implementation Considerations
 
-| Factor | OpenTelemetry | Splunk |
-| --- | --- | --- |
-| Setup Complexity and Learning Curve | OpenTelemetry offers flexibility but may require a steeper learning curve, especially when configuring backends and custom instrumentation. Teams need to have familiarity with observability concepts and integration setups. | Splunk provides a more streamlined setup with pre-built solutions, but advanced configurations or large-scale setups can still be complex. It offers UI-based setup for easier onboarding, but full-feature deployment needs expertise. |
-| Resource Requirements and Overhead | OpenTelemetry is lightweight in data collection, but backend infrastructure (e.g., storage, processing) must be managed separately. Depending on the backend, resource overhead may increase, especially for large-scale environments. | Splunk requires substantial resources to handle high data ingestion and processing. While powerful analytics are offered, it demands higher compute, storage, and network resources for data processing at scale. |
-| Team Expertise Requirements | OpenTelemetry is ideal for teams with experience in observability frameworks and microservices. It may require dedicated time for configuration, integration, and updates. Additionally, maintaining and troubleshooting the framework is team-dependent. | Splunk is user-friendly for monitoring dashboards and basic analytics, but requires technical expertise for advanced use cases. Splunk provides support services, but complex scenarios and custom configurations demand skilled personnel. |
-| Maintenance and Operational Costs | Free to use with no licensing fees, but OpenTelemetry does not provide direct support, and maintenance depends on the internal team. Teams are responsible for updating, troubleshooting, and scaling the observability infrastructure. | Splunk incurs costs based on data ingestion, with predictable pricing models. It reduces operational overhead with enterprise-grade support, but ongoing license fees and operational overhead remain significant at scale. |
-| Customization & Flexibility | OpenTelemetry allows complete customization, making it adaptable for diverse environments. Teams can build their own telemetry systems and implement tailored observability strategies. | Splunk provides a feature-rich, integrated platform but offers less flexibility compared to OpenTelemetry. Customization is available but may require specialized knowledge and additional configuration efforts. |
-| Vendor Lock-In | Being open-source, OpenTelemetry is vendor-neutral, giving teams the freedom to switch backends and toolchains without being locked into a specific vendor. | Splunk is a proprietary platform, which can lead to vendor lock-in. Although it offers extensive capabilities, it ties teams to Splunk’s ecosystem and pricing model, making migrations more complex. |
-| Scalability | OpenTelemetry's scalability is determined by the chosen backend and infrastructure. It provides flexibility in scaling based on the needs of the system and can be integrated with various backend platforms that scale horizontally. | Splunk is highly scalable, especially for large enterprises with vast data volumes. However, scaling requires additional resources and careful management of licensing and infrastructure. |
-| Ecosystem & Integrations | OpenTelemetry offers broad community support and integrates with a variety of backends and systems. However, the integrations may require additional setup and customization, depending on the environment. | Splunk has a well-established ecosystem and offers ready-made integrations with many systems, applications, and services. However, certain custom integrations may require additional licensing or development efforts. |
+| Factor                              | OpenTelemetry                                                                                                                                                                                                                                             | Splunk                                                                                                                                                                                                                                      |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Setup Complexity and Learning Curve | OpenTelemetry offers flexibility but may require a steeper learning curve, especially when configuring backends and custom instrumentation. Teams need to have familiarity with observability concepts and integration setups.                            | Splunk provides a more streamlined setup with pre-built solutions, but advanced configurations or large-scale setups can still be complex. It offers UI-based setup for easier onboarding, but full-feature deployment needs expertise.     |
+| Resource Requirements and Overhead  | OpenTelemetry is lightweight in data collection, but backend infrastructure (e.g., storage, processing) must be managed separately. Depending on the backend, resource overhead may increase, especially for large-scale environments.                    | Splunk requires substantial resources to handle high data ingestion and processing. While powerful analytics are offered, it demands higher compute, storage, and network resources for data processing at scale.                           |
+| Team Expertise Requirements         | OpenTelemetry is ideal for teams with experience in observability frameworks and microservices. It may require dedicated time for configuration, integration, and updates. Additionally, maintaining and troubleshooting the framework is team-dependent. | Splunk is user-friendly for monitoring dashboards and basic analytics, but requires technical expertise for advanced use cases. Splunk provides support services, but complex scenarios and custom configurations demand skilled personnel. |
+| Maintenance and Operational Costs   | Free to use with no licensing fees, but OpenTelemetry does not provide direct support, and maintenance depends on the internal team. Teams are responsible for updating, troubleshooting, and scaling the observability infrastructure.                   | Splunk incurs costs based on data ingestion, with predictable pricing models. It reduces operational overhead with enterprise-grade support, but ongoing license fees and operational overhead remain significant at scale.                 |
+| Customization & Flexibility         | OpenTelemetry allows complete customization, making it adaptable for diverse environments. Teams can build their own telemetry systems and implement tailored observability strategies.                                                                   | Splunk provides a feature-rich, integrated platform but offers less flexibility compared to OpenTelemetry. Customization is available but may require specialized knowledge and additional configuration efforts.                           |
+| Vendor Lock-In                      | Being open-source, OpenTelemetry is vendor-neutral, giving teams the freedom to switch backends and toolchains without being locked into a specific vendor.                                                                                               | Splunk is a proprietary platform, which can lead to vendor lock-in. Although it offers extensive capabilities, it ties teams to Splunk’s ecosystem and pricing model, making migrations more complex.                                       |
+| Scalability                         | OpenTelemetry's scalability is determined by the chosen backend and infrastructure. It provides flexibility in scaling based on the needs of the system and can be integrated with various backend platforms that scale horizontally.                     | Splunk is highly scalable, especially for large enterprises with vast data volumes. However, scaling requires additional resources and careful management of licensing and infrastructure.                                                  |
+| Ecosystem & Integrations            | OpenTelemetry offers broad community support and integrates with a variety of backends and systems. However, the integrations may require additional setup and customization, depending on the environment.                                               | Splunk has a well-established ecosystem and offers ready-made integrations with many systems, applications, and services. However, certain custom integrations may require additional licensing or development efforts.                     |
 
 ## Using OpenTelemetry with Splunk
 
@@ -93,7 +112,11 @@ For those interested in understanding how Splunk and OpenTelemetry work together
 - OpenTelemetry Collector as a Middle Layer: In this pattern, the OpenTelemetry Collector acts as a mediator, collecting, processing, and routing data to Splunk. It’s well-suited for large or distributed systems, like cloud-native applications, that require data filtering, aggregation, or enrichment before sending it to Splunk. This provides more control, reduces the data load on Splunk, and improves scalability. However, it introduces complexity in setup and maintenance, as it adds an extra layer that needs to be managed.
 - Multi-Backend Integration: Multi-backend integration allows OpenTelemetry to send data to multiple platforms, such as Splunk and Prometheus, providing flexibility and avoiding vendor lock-in. This setup is useful for organizations that need the advanced analytics of Splunk alongside real-time metrics from Prometheus. It offers the advantage of leveraging the strengths of multiple tools and increasing fault tolerance. However, it can be complex to configure and manage and may incur higher infrastructure costs, especially with high data volumes.
 
-<Figure src="/img/comparisons/2024/11/opentelemetry-vs-splunk-dc988d9c-ca0f-45ea-be37-d18432a7b29a.webp" alt="Integration Architecture Patterns" caption="Integration Architecture Patterns" />
+<Figure
+  src="/img/comparisons/2024/11/opentelemetry-vs-splunk-dc988d9c-ca0f-45ea-be37-d18432a7b29a.webp"
+  alt="Integration Architecture Patterns"
+  caption="Integration Architecture Patterns"
+/>
 
 ### Benefits of Combined Implementation
 
@@ -119,7 +142,7 @@ For those interested in understanding how Splunk and OpenTelemetry work together
 
 ## Modern Alternatives: SigNoz
 
-[SigNoz](https://signoz.io/) is an open-source, full-stack observability platform built natively for OpenTelemetry. It offers [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) by integrating metrics, traces, and logs into a unified platform. With its native OpenTelemetry support, SigNoz ensures teams can easily capture telemetry data without vendor lock-in, making it a flexible solution for monitoring distributed systems. 
+[SigNoz](https://signoz.io/) is an open-source, full-stack observability platform built natively for OpenTelemetry. It offers [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/) by integrating metrics, traces, and logs into a unified platform. With its native OpenTelemetry support, SigNoz ensures teams can easily capture telemetry data without vendor lock-in, making it a flexible solution for monitoring distributed systems.
 
 This approach is ideal for organizations that want a cost-effective, customizable observability stack, without compromising on power or scalability. SigNoz’s architecture allows teams to seamlessly collect and analyze telemetry data while maintaining complete control over the platform.
 
@@ -169,4 +192,4 @@ Migration complexity depends on your current setup. Start with parallel implemen
 
 ### Can I use OpenTelemetry and Splunk together?
 
-Yes, OpenTelemetry can send data to Splunk through the OpenTelemetry Collector using the Splunk HEC exporter.
\ No newline at end of file
+Yes, OpenTelemetry can send data to Splunk through the OpenTelemetry Collector using the Splunk HEC exporter.
diff --git a/data/comparisons/opentelemetry-vs-telegraf.mdx b/data/comparisons/opentelemetry-vs-telegraf.mdx
index 0d2df408d..ecc7f8c32 100644
--- a/data/comparisons/opentelemetry-vs-telegraf.mdx
+++ b/data/comparisons/opentelemetry-vs-telegraf.mdx
@@ -1,14 +1,21 @@
 ---
-
 title: OpenTelemetry vs. Telegraf - Choosing the Right Monitoring Tool
-slug: opentelemetry-vs-telegraf
+
 date: 2024-10-23
 tags: [OpenTelemetry]
 authors: [bhavya_sachdeva]
 description: Compare OpenTelemetry and Telegraf to choose the best monitoring tool for your observability needs. Learn key differences, features, and use cases.
-keywords: [opentelemetry vs telegraf, monitoring tools, observability, metrics collection, distributed tracing, logs management]
-
+keywords:
+  [
+    opentelemetry vs telegraf,
+    monitoring tools,
+    observability,
+    metrics collection,
+    distributed tracing,
+    logs management,
+  ]
 ---
+
 OpenTelemetry and Telegraf are distinct monitoring tools for different observability needs. OpenTelemetry collects metrics, traces and logs across your entire system, while Telegraf focuses on metrics collection and reporting. This comparison examines their key differences to help you make an informed choice.
 
 ## Quick Guide: OpenTelemetry vs. Telegraf
@@ -43,7 +50,12 @@ The project is backed by the Cloud Native Computing Foundation (CNCF), ensuring
 
 With support for multiple programming languages and seamless integration capabilities, OpenTelemetry provides a flexible foundation for observability across diverse tech stacks.
 
-<Figure src="/img/comparisons/2024/10/opentelemetry-vs-telegraf-Screenshot_2024-10-18_at_7.06.17_PM.webp" alt="" caption="" />### Key Features of OpenTelemetry
+<Figure
+  src="/img/comparisons/2024/10/opentelemetry-vs-telegraf-Screenshot_2024-10-18_at_7.06.17_PM.webp"
+  alt=""
+  caption=""
+/>
+### Key Features of OpenTelemetry
 
 1. Vendor-neutral and open standard: OpenTelemetry's design allows you to switch between different observability backends without changing your instrumentation code.
 2. Auto-instrumentation: Many popular frameworks and libraries can be automatically instrumented, reducing the manual work required to collect telemetry data.
@@ -79,92 +91,89 @@ It also offers numerous output plugins to send metrics to different destinations
 Telegraf is great for collecting specific data in a quick and efficient way. Here are some simple examples of where it works best:
 
 1. Monitoring Server Health
-    
-    Telegraf can track important details like how much CPU, memory, or disk space a server is using. This helps you keep an eye on server performance and spot issues before they become problems.
-    
+
+   Telegraf can track important details like how much CPU, memory, or disk space a server is using. This helps you keep an eye on server performance and spot issues before they become problems.
+
 2. Tracking Database Performance
-    
-    It collects information from databases like MySQL and PostgreSQL. You can monitor things like how long queries take, how many connections are active, and how often data is being read or written.
-    
+
+   It collects information from databases like MySQL and PostgreSQL. You can monitor things like how long queries take, how many connections are active, and how often data is being read or written.
+
 3. Monitoring Applications
-    
-    Telegraf can gather metrics from APIs and tools like RabbitMQ. This helps you see how well your applications are running and if there are any slowdowns or issues.
-    
+
+   Telegraf can gather metrics from APIs and tools like RabbitMQ. This helps you see how well your applications are running and if there are any slowdowns or issues.
+
 4. Keeping an Eye on IoT Devices
-    
-    Since Telegraf is lightweight, it works well on small devices, like those used in IoT setups. It can collect data from sensors and send it to a central system for analysis.
-    
+
+   Since Telegraf is lightweight, it works well on small devices, like those used in IoT setups. It can collect data from sensors and send it to a central system for analysis.
+
 5. Cloud Monitoring
-    
-    Telegraf easily integrates with cloud platforms. You can use it to track how much cloud storage, computing power, or bandwidth you’re using, ensuring everything is running smoothly.
-    
+
+   Telegraf easily integrates with cloud platforms. You can use it to track how much cloud storage, computing power, or bandwidth you’re using, ensuring everything is running smoothly.
 
 ## OpenTelemetry vs. Telegraf: Key Differences
 
-| Feature | OpenTelemetry | Telegraf |
-| --- | --- | --- |
-| Scope | OpenTelemetry offers a comprehensive observability solution, collecting three core data types: metrics, traces, and logs. This makes it suitable for full-stack monitoring of complex systems, covering both performance and behavior across distributed systems. OpenTelemetry helps teams track the lifecycle of a request as it moves through various services. | Telegraf focuses on metrics collection and aggregation. It is designed primarily for collecting system and application performance metrics (like CPU usage, memory consumption, and network activity). Telegraf is efficient for gathering raw data but lacks built-in support for logs and traces, making it more limited compared to OpenTelemetry. |
-| Data Types | OpenTelemetry supports multiple types of telemetry data: - Metrics for tracking system and application performance, - Traces for following the flow of requests across distributed systems, - Logs for detailed error messages and event analysis. This diversity allows users to get a unified view of system health. | Telegraf primarily handles metrics. It collects data from various sources (e.g., servers, databases, message queues) and sends it to monitoring tools. While it can indirectly gather logs or traces through plugins and external integrations, its primary role is to aggregate metrics, lacking native support for the full range of telemetry data. |
-| Standardization | OpenTelemetry is an open standard created by the Cloud Native Computing Foundation (CNCF). It provides a consistent, vendor-neutral way of instrumenting applications for observability. This standard ensures interoperability between different tools and services. It allows developers to instrument their applications once and send the data to any backend that supports OpenTelemetry without making changes. | Telegraf is a specific tool created by InfluxData. While it supports common protocols like StatsD, Prometheus, and Graphite, it is not a universal standard like OpenTelemetry. This makes Telegraf less flexible when trying to integrate with diverse observability tools or industry-wide instrumentation efforts. |
-| Ecosystem | OpenTelemetry is vendor-neutral and has broad industry support. It's supported by many observability and monitoring platforms, making it easy to integrate with different backends (e.g., Prometheus, Jaeger, Zipkin, etc.). This flexibility allows teams to choose their preferred monitoring tools without vendor lock-in. | Telegraf is closely tied to the InfluxData ecosystem, particularly InfluxDB, which is a popular time-series database for storing metrics. However, Telegraf can also integrate with other monitoring systems like Prometheus, Elasticsearch, or Graphite. Though flexible, Telegraf's deepest integration and optimization come from working with InfluxDB, meaning there may be some limitations or less native support for other backends. |
+| Feature         | OpenTelemetry                                                                                                                                                                                                                                                                                                                                                                                                         | Telegraf                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Scope           | OpenTelemetry offers a comprehensive observability solution, collecting three core data types: metrics, traces, and logs. This makes it suitable for full-stack monitoring of complex systems, covering both performance and behavior across distributed systems. OpenTelemetry helps teams track the lifecycle of a request as it moves through various services.                                                    | Telegraf focuses on metrics collection and aggregation. It is designed primarily for collecting system and application performance metrics (like CPU usage, memory consumption, and network activity). Telegraf is efficient for gathering raw data but lacks built-in support for logs and traces, making it more limited compared to OpenTelemetry.                                                                                        |
+| Data Types      | OpenTelemetry supports multiple types of telemetry data: - Metrics for tracking system and application performance, - Traces for following the flow of requests across distributed systems, - Logs for detailed error messages and event analysis. This diversity allows users to get a unified view of system health.                                                                                                | Telegraf primarily handles metrics. It collects data from various sources (e.g., servers, databases, message queues) and sends it to monitoring tools. While it can indirectly gather logs or traces through plugins and external integrations, its primary role is to aggregate metrics, lacking native support for the full range of telemetry data.                                                                                       |
+| Standardization | OpenTelemetry is an open standard created by the Cloud Native Computing Foundation (CNCF). It provides a consistent, vendor-neutral way of instrumenting applications for observability. This standard ensures interoperability between different tools and services. It allows developers to instrument their applications once and send the data to any backend that supports OpenTelemetry without making changes. | Telegraf is a specific tool created by InfluxData. While it supports common protocols like StatsD, Prometheus, and Graphite, it is not a universal standard like OpenTelemetry. This makes Telegraf less flexible when trying to integrate with diverse observability tools or industry-wide instrumentation efforts.                                                                                                                        |
+| Ecosystem       | OpenTelemetry is vendor-neutral and has broad industry support. It's supported by many observability and monitoring platforms, making it easy to integrate with different backends (e.g., Prometheus, Jaeger, Zipkin, etc.). This flexibility allows teams to choose their preferred monitoring tools without vendor lock-in.                                                                                         | Telegraf is closely tied to the InfluxData ecosystem, particularly InfluxDB, which is a popular time-series database for storing metrics. However, Telegraf can also integrate with other monitoring systems like Prometheus, Elasticsearch, or Graphite. Though flexible, Telegraf's deepest integration and optimization come from working with InfluxDB, meaning there may be some limitations or less native support for other backends. |
 
 ## When to Choose OpenTelemetry
 
 OpenTelemetry is ideal for complex systems that require a full observability solution. Below are detailed scenarios where OpenTelemetry shines:
 
 1. Your system uses multiple services, and you need comprehensive monitoring.
-    
-    If your application or infrastructure consists of several interconnected services, it becomes difficult to track the health and performance of each one individually. In such a setup, you need to monitor metrics (like CPU usage or request latency), logs (to capture error messages and events), and traces (to follow requests as they travel across different services).
-    
-    Example: Imagine a cloud-native application where a single user action triggers multiple microservices across different environments. OpenTelemetry helps you track how the request flows through each service, providing insights into bottlenecks or failures.
-    
+
+   If your application or infrastructure consists of several interconnected services, it becomes difficult to track the health and performance of each one individually. In such a setup, you need to monitor metrics (like CPU usage or request latency), logs (to capture error messages and events), and traces (to follow requests as they travel across different services).
+
+   Example: Imagine a cloud-native application where a single user action triggers multiple microservices across different environments. OpenTelemetry helps you track how the request flows through each service, providing insights into bottlenecks or failures.
+
 2. You want a vendor-neutral and future-proof observability solution.
-    
-    Many monitoring and observability tools are tied to specific platforms or vendors, which can create problems if you decide to switch tools in the future. OpenTelemetry, being an open-source and vendor-neutral standard, allows you to avoid this issue. You can instrument your services once and then easily switch backends or visualization tools without having to rework your observability setup.
-    
-    Example: If your company is using a proprietary monitoring solution but wants the flexibility to switch to open-source tools like Prometheus or Jaeger in the future, OpenTelemetry ensures that your telemetry data will remain compatible across different platforms.
-    
+
+   Many monitoring and observability tools are tied to specific platforms or vendors, which can create problems if you decide to switch tools in the future. OpenTelemetry, being an open-source and vendor-neutral standard, allows you to avoid this issue. You can instrument your services once and then easily switch backends or visualization tools without having to rework your observability setup.
+
+   Example: If your company is using a proprietary monitoring solution but wants the flexibility to switch to open-source tools like Prometheus or Jaeger in the future, OpenTelemetry ensures that your telemetry data will remain compatible across different platforms.
+
 3. You need end-to-end tracing for distributed systems.
-    
-    In complex, distributed systems where multiple services interact to fulfill a single user request, having end-to-end tracing is crucial. OpenTelemetry lets you trace each request from its entry point to its exit, allowing you to pinpoint where slowdowns or failures occur.
-    
-    Example: Consider an e-commerce platform where a user’s order involves checking inventory, processing payments, and arranging shipping across different microservices. [OpenTelemetry traces](https://signoz.io/blog/opentelemetry-spans/) this entire flow, helping you quickly identify if the delay happened in the payment service, the inventory check, or the shipping process.
-    
+
+   In complex, distributed systems where multiple services interact to fulfill a single user request, having end-to-end tracing is crucial. OpenTelemetry lets you trace each request from its entry point to its exit, allowing you to pinpoint where slowdowns or failures occur.
+
+   Example: Consider an e-commerce platform where a user’s order involves checking inventory, processing payments, and arranging shipping across different microservices. [OpenTelemetry traces](https://signoz.io/blog/opentelemetry-spans/) this entire flow, helping you quickly identify if the delay happened in the payment service, the inventory check, or the shipping process.
+
 4. You have a multi-language stack and need consistent monitoring.
-    
-    Many organizations use services built in different programming languages, making it challenging to get consistent monitoring across the entire stack. OpenTelemetry provides instrumentation for various languages (such as Python, Java, Go, and more), allowing you to collect uniform metrics, logs, and traces across all services.
-    
-    Example: If your frontend is written in JavaScript, your backend in Python, and some microservices in Go, OpenTelemetry ensures that you can instrument all of them consistently, gathering insights across your stack without language-based discrepancies.
-    
+
+   Many organizations use services built in different programming languages, making it challenging to get consistent monitoring across the entire stack. OpenTelemetry provides instrumentation for various languages (such as Python, Java, Go, and more), allowing you to collect uniform metrics, logs, and traces across all services.
+
+   Example: If your frontend is written in JavaScript, your backend in Python, and some microservices in Go, OpenTelemetry ensures that you can instrument all of them consistently, gathering insights across your stack without language-based discrepancies.
 
 ## When to Choose Telegraf
 
 Telegraf is excellent for focused metrics collection, especially when you are working with systems that need lightweight, fast performance monitoring. Here’s when Telegraf is the right fit:
 
 1. Your primary focus is on collecting and aggregating performance metrics.
-    
-    If your main need is to gather metrics like CPU, memory, disk usage, or network activity, Telegraf’s design makes it perfect for this task. It doesn’t collect logs or traces by default, but it excels at collecting raw metrics from various sources quickly and efficiently.
-    
-    Example: If you’re managing a fleet of servers or virtual machines and need to monitor their health (e.g., CPU and memory usage), Telegraf can gather these metrics from each machine and send them to a central monitoring system without overwhelming the servers.
-    
+
+   If your main need is to gather metrics like CPU, memory, disk usage, or network activity, Telegraf’s design makes it perfect for this task. It doesn’t collect logs or traces by default, but it excels at collecting raw metrics from various sources quickly and efficiently.
+
+   Example: If you’re managing a fleet of servers or virtual machines and need to monitor their health (e.g., CPU and memory usage), Telegraf can gather these metrics from each machine and send them to a central monitoring system without overwhelming the servers.
+
 2. You’re using InfluxDB or other time-series databases for storing metrics.
-    
-    Telegraf integrates seamlessly with time-series databases like InfluxDB, making it an ideal choice if you’re already using InfluxData’s ecosystem for storage and monitoring. It can also connect to other time-series databases like Prometheus or Graphite, but it’s particularly optimized for InfluxDB.
-    
-    Example: If your company stores all system and application metrics in InfluxDB and uses InfluxDB’s visualization tools to analyze them, Telegraf is the most efficient and straightforward way to collect and send that data.
-    
+
+   Telegraf integrates seamlessly with time-series databases like InfluxDB, making it an ideal choice if you’re already using InfluxData’s ecosystem for storage and monitoring. It can also connect to other time-series databases like Prometheus or Graphite, but it’s particularly optimized for InfluxDB.
+
+   Example: If your company stores all system and application metrics in InfluxDB and uses InfluxDB’s visualization tools to analyze them, Telegraf is the most efficient and straightforward way to collect and send that data.
+
 3. You need specific plugins to collect or send data.
-    
-    Telegraf has a rich library of input and output plugins, making it easy to collect data from many sources (e.g., MySQL, Redis, RabbitMQ) and send it to various destinations (e.g., Elasticsearch, Kafka, or Prometheus). This flexibility is useful if you have specific data sources that aren’t supported by other tools.
-    
-    Example: If your monitoring setup requires collecting metrics from a specific hardware sensor or a database that isn’t supported by other agents, Telegraf’s plugin-based system likely has a solution. You can easily set it up to send those metrics to your preferred monitoring tool.
-    
+
+   Telegraf has a rich library of input and output plugins, making it easy to collect data from many sources (e.g., MySQL, Redis, RabbitMQ) and send it to various destinations (e.g., Elasticsearch, Kafka, or Prometheus). This flexibility is useful if you have specific data sources that aren’t supported by other tools.
+
+   Example: If your monitoring setup requires collecting metrics from a specific hardware sensor or a database that isn’t supported by other agents, Telegraf’s plugin-based system likely has a solution. You can easily set it up to send those metrics to your preferred monitoring tool.
+
 4. You’re working in environments with limited resources.
-    
-    Telegraf is designed to be lightweight, meaning it can run on systems with minimal processing power and memory. This makes it a good fit for resource-constrained environments, such as IoT devices, embedded systems, or servers with low overhead.
-    
-    Example: If you’re monitoring sensors on IoT devices deployed in remote locations, these devices often have limited resources (like CPU and memory). Telegraf’s small footprint allows it to run efficiently on such devices without draining their resources.
-    
+
+   Telegraf is designed to be lightweight, meaning it can run on systems with minimal processing power and memory. This makes it a good fit for resource-constrained environments, such as IoT devices, embedded systems, or servers with low overhead.
+
+   Example: If you’re monitoring sensors on IoT devices deployed in remote locations, these devices often have limited resources (like CPU and memory). Telegraf’s small footprint allows it to run efficiently on such devices without draining their resources.
 
 In summary, choose OpenTelemetry if you need broad observability, tracing, and logging for distributed systems or want a flexible, vendor-neutral solution. On the other hand, choose Telegraf if you’re focused on gathering performance metrics efficiently, especially in environments where resources are constrained or you’re working with time-series databases.
 
@@ -234,4 +243,4 @@ Yes, you can use OpenTelemetry with InfluxDB. The OpenTelemetry Collector has an
 
 ### What are the performance implications of using OpenTelemetry vs. Telegraf?
 
-Telegraf is generally more lightweight and efficient for pure metrics collection, making it suitable for resource-constrained environments. OpenTelemetry, while more comprehensive, may have a slightly higher resource overhead due to its broader scope. However, OpenTelemetry's performance is continually improving, and its benefits in providing full observability often outweigh the minor performance differences in most scenarios.
\ No newline at end of file
+Telegraf is generally more lightweight and efficient for pure metrics collection, making it suitable for resource-constrained environments. OpenTelemetry, while more comprehensive, may have a slightly higher resource overhead due to its broader scope. However, OpenTelemetry's performance is continually improving, and its benefits in providing full observability often outweigh the minor performance differences in most scenarios.
diff --git a/data/comparisons/opentelemetry-vs-tempo.mdx b/data/comparisons/opentelemetry-vs-tempo.mdx
index b346eea69..43432f623 100644
--- a/data/comparisons/opentelemetry-vs-tempo.mdx
+++ b/data/comparisons/opentelemetry-vs-tempo.mdx
@@ -1,13 +1,21 @@
 ---
-
 title: OpenTelemetry vs Tempo - Key Differences Explained
-slug: opentelemetry-vs-tempo
+
 date: 2025-01-22
 tags: [OpenTelemetry]
 authors: [nilesh_sinha]
 description: Discover the key differences between OpenTelemetry and Tempo for distributed tracing. Learn how to leverage these tools for optimal observability in modern software architectures.
-keywords: [OpenTelemetry, Tempo, distributed tracing, observability, microservices, Grafana, telemetry data, trace storage]
-
+keywords:
+  [
+    OpenTelemetry,
+    Tempo,
+    distributed tracing,
+    observability,
+    microservices,
+    Grafana,
+    telemetry data,
+    trace storage,
+  ]
 ---
 
 OpenTelemetry and Grafana Tempo serve different but complementary roles in application observability.
@@ -35,23 +43,24 @@ Alternatively, Grafana Tempo is a distributed tracing backend developed by Grafa
 - **Trace Visualization**: Tempo integrates with Grafana to visualize traces, giving users a detailed view of how data flows through their applications, enabling quick diagnosis of bottlenecks or failures.
 
 <KeyPointCallout>
-In short, OpenTelemetry provides a comprehensive framework for collecting observability data, while Grafana Tempo specializes in handling and visualizing trace data efficiently. 
+  In short, OpenTelemetry provides a comprehensive framework for collecting observability data,
+  while Grafana Tempo specializes in handling and visualizing trace data efficiently.
 </KeyPointCallout>
 
 Here's a table that highlights the key features and differences between OpenTelemetry and Grafana Tempo:
 
-| Feature/Functionality | OpenTelemetry | Grafana Tempo |
-| --- | --- | --- |
-| Type of Tool | Observability framework | Distributed tracing backend |
-| Data Collected | Traces, metrics, and logs | Trace data only |
-| Data Storage | Not a storage solution; exports data to backends | Efficient trace storage, optimized for cost |
-| Querying | Requires a compatible backend (e.g., Jaeger, Prometheus) | Direct querying of trace data based on IDs |
-| Integration with Visualization | Integrates with various backends for metrics and traces | Seamless integration with Grafana for trace visualization |
-| Multi-language Support | Yes (Java, Python, Go, JavaScript, etc.) | Primarily supports any system sending trace data |
-| Vendor-Agnostic | Yes, exports to any supported backend | Yes, but primarily used with Grafana |
-| Auto-instrumentation | Yes, available for multiple languages | Not applicable |
-| Custom Instrumentation | Yes, allows for manual instrumentation | Not applicable |
-| Use Cases | Comprehensive observability across applications | Focused on distributed tracing in large-scale systems |
+| Feature/Functionality          | OpenTelemetry                                            | Grafana Tempo                                             |
+| ------------------------------ | -------------------------------------------------------- | --------------------------------------------------------- |
+| Type of Tool                   | Observability framework                                  | Distributed tracing backend                               |
+| Data Collected                 | Traces, metrics, and logs                                | Trace data only                                           |
+| Data Storage                   | Not a storage solution; exports data to backends         | Efficient trace storage, optimized for cost               |
+| Querying                       | Requires a compatible backend (e.g., Jaeger, Prometheus) | Direct querying of trace data based on IDs                |
+| Integration with Visualization | Integrates with various backends for metrics and traces  | Seamless integration with Grafana for trace visualization |
+| Multi-language Support         | Yes (Java, Python, Go, JavaScript, etc.)                 | Primarily supports any system sending trace data          |
+| Vendor-Agnostic                | Yes, exports to any supported backend                    | Yes, but primarily used with Grafana                      |
+| Auto-instrumentation           | Yes, available for multiple languages                    | Not applicable                                            |
+| Custom Instrumentation         | Yes, allows for manual instrumentation                   | Not applicable                                            |
+| Use Cases                      | Comprehensive observability across applications          | Focused on distributed tracing in large-scale systems     |
 
 Together, they offer a robust solution for monitoring distributed systems. With OpenTelemetry's support for multiple telemetry types and Tempo's focus on scalable trace storage, you can achieve full-stack observability with a cost-efficient backend for traces.
 
@@ -107,7 +116,7 @@ public class OrderService {
     public static void main(String[] args) {
         // Start a span for the overall "PlaceOrder" operation
         Span orderSpan = orderTracer.spanBuilder("PlaceOrder").startSpan();
-        
+
         try {
             // Step 1: Process the order
             processOrder();
@@ -128,7 +137,7 @@ public class OrderService {
         try {
             System.out.println("Processing order...");
             // Simulating order processing delay
-            Thread.sleep(200); 
+            Thread.sleep(200);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
@@ -147,7 +156,7 @@ class PaymentService {
         try {
             System.out.println("Processing payment...");
             // Simulating payment processing delay
-            Thread.sleep(300); 
+            Thread.sleep(300);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
@@ -167,7 +176,7 @@ class InventoryService {
         try {
             System.out.println("Updating inventory...");
             // Simulating inventory update delay
-            Thread.sleep(150); 
+            Thread.sleep(150);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
@@ -187,9 +196,9 @@ class InventoryService {
 When integrated with a tracing backend like Jaeger or Grafana Tempo, you would see the following trace structure:
 
 - Span 1: `PlaceOrder` (Total Time: 650ms)
-    - Span 1.1: `ProcessOrder` (200ms)
-    - Span 1.2: `ProcessPayment` (300ms)
-    - Span 1.3: `UpdateInventory` (150ms)
+  - Span 1.1: `ProcessOrder` (200ms)
+  - Span 1.2: `ProcessPayment` (300ms)
+  - Span 1.3: `UpdateInventory` (150ms)
 
 This trace allows you to visualize the entire flow of the request and see how long each step took. If there is a delay or issue in the `PaymentService`, for instance, you can directly pinpoint that the payment processing is taking longer than expected.
 
@@ -252,68 +261,66 @@ When deploying the OpenTelemetry Collector, consider the following best practice
 2. Batching and Filtering: Use batching and filtering processors to reduce the volume of data, minimize network traffic, and optimize resource usage.
 3. Resource Allocation: Ensure that you allocate sufficient CPU and memory to your Collector instances, especially when dealing with large volumes of telemetry data.
 4. Security: Set up TLS encryption and authentication where needed to secure the transmission of sensitive telemetry data.
-    
-    Configuration for TLS with OpenTelemetry Collector
-    
-    ```yaml
-    receivers:
-      otlp:
-        protocols:
-          grpc:
-            tls:
-    	        # Path to the Certificate Authority (CA) certificate
-              ca_file: "/path/to/ca.crt"  
-              # Path to the server's public certificate
-              cert_file: "/path/to/server.crt"
-              # Path to the server's private key
-              key_file: "/path/to/server.key"
-          http:
-            tls:
-              ca_file: "/path/to/ca.crt" 
-              cert_file: "/path/to/server.crt" 
-              key_file: "/path/to/server.key" 
-    
-    exporters:
-      otlp:
-    	  # Secure endpoint for SigNoz
-        endpoint: "https://<signoz-endpoint>:4317"
-        tls:
-    	    # CA certificate for validating SigNoz's certificate
-          ca_file: "/path/to/ca.crt"   
-          # Client certificate for mutual TLS authentication              
-          cert_file: "/path/to/client.crt" 
-          # Client private key for mutual TLS            
-          key_file: "/path/to/client.key"            
-    
-    service:
-      pipelines:
-        traces:
-          receivers: [otlp]
-          exporters: [otlp]
-    ```
-    
-    - Receivers:
-        - otlp: This defines the OTLP receiver that can accept telemetry data over gRPC and HTTP protocols. The `tls` configuration specifies the settings for secure communication.
-        
-        > gRPC (Google Remote Procedure Call) is a high-performance, open-source framework that enables remote communication between services using protocol buffers (Protobuf) for data serialization. It allows client and server applications to communicate seamlessly, supporting multiple programming languages
-        > 
-        - protocols: Specifies the protocols supported by the receiver.
-        - grpc: A protocol for high-performance remote procedure calls.
-        - tls: This section configures TLS for secure communication.
-            - ca_file: Path to the Certificate Authority (CA) certificate used to verify the server's identity.
-            - cert_file: Path to the server’s public certificate, which is shared with clients.
-            - key_file: Path to the server’s private key, which is used to establish a secure connection.
-        - http: Similar to gRPC, but for HTTP communication.
-    - Exporters:
-        - otlp: This defines the OTLP exporter, which sends telemetry data to a specified endpoint (in this case, SigNoz).
-            - endpoint: The URL of the SigNoz instance where the telemetry data will be sent. It uses `https` to indicate a secure connection.
-            - tls: Configures TLS for secure communication with SigNoz.
-                - ca_file: Path to the CA certificate used to verify the identity of SigNoz.
-                - cert_file: Path to the client’s public certificate for mutual authentication.
-                - key_file: Path to the client’s private key required for mutual authentication.
-    - Service:
-        - pipelines: This section defines the data flow through the Collector.
-            - traces: Specifies the pipeline for trace data. It includes receivers that collect the data and exporters that send it to the configured endpoint.
+
+   Configuration for TLS with OpenTelemetry Collector
+
+   ```yaml
+   receivers:
+     otlp:
+       protocols:
+         grpc:
+           tls:
+   	        # Path to the Certificate Authority (CA) certificate
+             ca_file: "/path/to/ca.crt"
+             # Path to the server's public certificate
+             cert_file: "/path/to/server.crt"
+             # Path to the server's private key
+             key_file: "/path/to/server.key"
+         http:
+           tls:
+             ca_file: "/path/to/ca.crt"
+             cert_file: "/path/to/server.crt"
+             key_file: "/path/to/server.key"
+
+   exporters:
+     otlp:
+   	  # Secure endpoint for SigNoz
+       endpoint: "https://<signoz-endpoint>:4317"
+       tls:
+   	    # CA certificate for validating SigNoz's certificate
+         ca_file: "/path/to/ca.crt"
+         # Client certificate for mutual TLS authentication
+         cert_file: "/path/to/client.crt"
+         # Client private key for mutual TLS
+         key_file: "/path/to/client.key"
+
+   service:
+     pipelines:
+       traces:
+         receivers: [otlp]
+         exporters: [otlp]
+   ```
+
+   - Receivers:
+     - otlp: This defines the OTLP receiver that can accept telemetry data over gRPC and HTTP protocols. The `tls` configuration specifies the settings for secure communication.
+       > gRPC (Google Remote Procedure Call) is a high-performance, open-source framework that enables remote communication between services using protocol buffers (Protobuf) for data serialization. It allows client and server applications to communicate seamlessly, supporting multiple programming languages
+     - protocols: Specifies the protocols supported by the receiver.
+     - grpc: A protocol for high-performance remote procedure calls.
+     - tls: This section configures TLS for secure communication.
+       - ca_file: Path to the Certificate Authority (CA) certificate used to verify the server's identity.
+       - cert_file: Path to the server’s public certificate, which is shared with clients.
+       - key_file: Path to the server’s private key, which is used to establish a secure connection.
+     - http: Similar to gRPC, but for HTTP communication.
+   - Exporters:
+     - otlp: This defines the OTLP exporter, which sends telemetry data to a specified endpoint (in this case, SigNoz).
+       - endpoint: The URL of the SigNoz instance where the telemetry data will be sent. It uses `https` to indicate a secure connection.
+       - tls: Configures TLS for secure communication with SigNoz.
+         - ca_file: Path to the CA certificate used to verify the identity of SigNoz.
+         - cert_file: Path to the client’s public certificate for mutual authentication.
+         - key_file: Path to the client’s private key required for mutual authentication.
+   - Service:
+     - pipelines: This section defines the data flow through the Collector.
+       - traces: Specifies the pipeline for trace data. It includes receivers that collect the data and exporters that send it to the configured endpoint.
 
 ## Grafana Tempo: Exploring the Tracing Backend
 
@@ -356,7 +363,7 @@ Example: Configuring Grafana Tempo
 ```yaml
 server:
 # HTTP port for the Tempo server
-  http_listen_port: 3100  
+  http_listen_port: 3100
 
 distributor:
   receivers:
@@ -364,39 +371,39 @@ distributor:
       protocols:
         grpc:
 	        # GRPC endpoint for OpenTelemetry
-          endpoint: 0.0.0.0:4317  
+          endpoint: 0.0.0.0:4317
 
 ingester:
   lifecycler:
     ring:
       kvstore:
 	      # Simple setup using in-memory KV store
-        store: inmemory  
+        store: inmemory
 
 storage:
   trace:
 	  # Using AWS S3 for object storage
-    backend: s3  
+    backend: s3
     s3:
       bucket: my-tempo-bucket
       endpoint: s3.amazonaws.com
       access_key: "<AWS_ACCESS_KEY>"
       secret_key: "<AWS_SECRET_KEY>"
 	    # AWS region where the bucket is located
-      region: "us-west-2"  
+      region: "us-west-2"
 
 compactor:
   compaction:
 	  # Enable trace compaction to optimize storage
-    enabled: true  
+    enabled: true
 
 query_frontend:
 	# Enable query result caching
-  cache_results: true  
+  cache_results: true
 
 querier:
 	# Set query timeout limi
-  query_timeout: 2m 
+  query_timeout: 2m
 ```
 
 - server: Defines the server settings, such as the port on which Tempo will listen.
@@ -408,7 +415,7 @@ querier:
 
 ### Tempo's Query and Visualization Features
 
-Tempo's query capabilities are tightly integrated with Grafana, providing a powerful interface for trace analysis. 
+Tempo's query capabilities are tightly integrated with Grafana, providing a powerful interface for trace analysis.
 
 Overview of Tempo's Query Language and Capabilities
 
@@ -460,7 +467,7 @@ By leveraging these optimizations, Tempo ensures efficient trace storage and ret
 
 ## OpenTelemetry vs Tempo: Comparative Analysis
 
-While OpenTelemetry and Tempo serve different purposes, they can complement each other effectively in an observability stack. 
+While OpenTelemetry and Tempo serve different purposes, they can complement each other effectively in an observability stack.
 
 ### Scope Comparison: OpenTelemetry as a Framework vs Tempo as a Backend
 
@@ -480,26 +487,26 @@ While OpenTelemetry and Tempo serve different purposes, they can complement each
 ### Use Case Scenarios: When to Use OpenTelemetry, Tempo, or Both Together
 
 - When to Use OpenTelemetry:
-    - In polyglot (multi-language) environments needing vendor-neutral telemetry collection.
-    - When you need to collect traces, metrics, and logs from different services.
-    - If you want to integrate with multiple backends or plan to switch observability platforms.
+  - In polyglot (multi-language) environments needing vendor-neutral telemetry collection.
+  - When you need to collect traces, metrics, and logs from different services.
+  - If you want to integrate with multiple backends or plan to switch observability platforms.
 - When to Use Tempo:
-    - If you’re primarily focused on trace data storage and are already using Grafana for monitoring and visualization.
-    - When you need a cost-effective solution to store large volumes of traces for the long term.
+  - If you’re primarily focused on trace data storage and are already using Grafana for monitoring and visualization.
+  - When you need a cost-effective solution to store large volumes of traces for the long term.
 - When to Use Both:
-    - If you need a comprehensive tracing solution: use OpenTelemetry to collect and instrument traces and export them to Tempo for long-term storage and querying. This combination provides both flexibility in data collection (OpenTelemetry) and scalability in trace storage (Tempo).
+  - If you need a comprehensive tracing solution: use OpenTelemetry to collect and instrument traces and export them to Tempo for long-term storage and querying. This combination provides both flexibility in data collection (OpenTelemetry) and scalability in trace storage (Tempo).
 
 Here's a table summarizing the key differences between OpenTelemetry and Tempo:
 
-| Category | OpenTelemetry | Tempo |
-| --- | --- | --- |
-| Scope | Framework for collecting telemetry data (traces, metrics, logs) | Backend for storing and querying trace data |
-| Focus | Data collection and instrumentation across services | Trace storage and retrieval for distributed systems |
-| Data Handling | Collection and export of telemetry data to different backends | Storage and indexing of trace data for efficient querying |
-| Ecosystem Integration | Vendor-agnostic; integrates with multiple backends (Jaeger, Prometheus, etc.) | Grafana-centric; optimized for the Grafana stack |
-| Supported Telemetry | Traces, metrics, and logs | Traces only |
-| Instrumentation | Instrumentation via API, SDK, and Collector | No instrumentation, focuses solely on trace data storage |
-| Integration Use Case | Best for polyglot environments needing broad telemetry support | Best for Grafana users needing scalable, cost-effective trace storage |
+| Category              | OpenTelemetry                                                                 | Tempo                                                                 |
+| --------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| Scope                 | Framework for collecting telemetry data (traces, metrics, logs)               | Backend for storing and querying trace data                           |
+| Focus                 | Data collection and instrumentation across services                           | Trace storage and retrieval for distributed systems                   |
+| Data Handling         | Collection and export of telemetry data to different backends                 | Storage and indexing of trace data for efficient querying             |
+| Ecosystem Integration | Vendor-agnostic; integrates with multiple backends (Jaeger, Prometheus, etc.) | Grafana-centric; optimized for the Grafana stack                      |
+| Supported Telemetry   | Traces, metrics, and logs                                                     | Traces only                                                           |
+| Instrumentation       | Instrumentation via API, SDK, and Collector                                   | No instrumentation, focuses solely on trace data storage              |
+| Integration Use Case  | Best for polyglot environments needing broad telemetry support                | Best for Grafana users needing scalable, cost-effective trace storage |
 
 ## Implementing OpenTelemetry with Tempo
 
@@ -556,7 +563,7 @@ processors:
 exporters:
   otlp:
 	  # Replace with your Tempo URL
-    endpoint: "http://tempo-backend:4317" 
+    endpoint: "http://tempo-backend:4317"
 
 service:
   pipelines:
@@ -583,29 +590,27 @@ To avoid overwhelming your tracing backend and optimize performance, implement s
 - AlwaysOn Sampling: Captures all traces (not recommended for high-throughput apps).
 - AlwaysOff Sampling: Captures no traces (used for debugging purposes).
 - Probability Sampling: Capture a percentage of traces (useful for reducing trace volume).
-    
-    ```yaml
-    processors:
-      batch:
-        timeout: 5s
-      probabilistic_sampler:
-        sampling_percentage: 10.0 # Capture 10% of traces
-    ```
-    
+  ```yaml
+  processors:
+    batch:
+      timeout: 5s
+    probabilistic_sampler:
+      sampling_percentage: 10.0 # Capture 10% of traces
+  ```
 - Reduce unnecessary spans: Only instrument critical parts of your code to avoid clutter in trace data.
 - Limit trace retention: Set up TTLs for trace data in Tempo to control storage costs.
 
 ### 4. Troubleshooting Common Integration Issues and Performance Bottlenecks
 
 - Traces not showing up in Tempo:
-    - Check if the Collector is running and configured correctly.
-    - Ensure that the OTLP receiver and exporter endpoints are correctly set.
+  - Check if the Collector is running and configured correctly.
+  - Ensure that the OTLP receiver and exporter endpoints are correctly set.
 - High latency or missing spans:
-    - Review batch processor settings. Increasing the batch timeout can reduce missed traces.
-    - Check your network and ensure that the Tempo backend can handle the load.
+  - Review batch processor settings. Increasing the batch timeout can reduce missed traces.
+  - Check your network and ensure that the Tempo backend can handle the load.
 - Overwhelming data volume:
-    - Use probabilistic sampling to control the number of traces exported.
-    - Ensure that trace retention settings in Tempo are optimized to avoid storage overload.
+  - Use probabilistic sampling to control the number of traces exported.
+  - Ensure that trace retention settings in Tempo are optimized to avoid storage overload.
 
 ## Enhancing Observability with SigNoz
 
@@ -640,13 +645,13 @@ To get started with SigNoz, follow these steps:
 
 1. Install SigNoz: You can install [SigNoz](https://signoz.io/docs/install/) on your local machine or in a cloud environment.
 2. Configure [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) in your application to send traces and metrics to SigNoz:
-    
-    ```yaml
-    exporters:
-      otlp:
-        endpoint: "http://<your-signoz-endpoint>:4317"
-    ```
-    
+
+   ```yaml
+   exporters:
+     otlp:
+       endpoint: 'http://<your-signoz-endpoint>:4317'
+   ```
+
 3. Monitor Your Application: Once you instrument your app, you can visualize traces, logs, and metrics in the SigNoz UI.
 
 ## Future Trends in Distributed Tracing
@@ -683,4 +688,4 @@ Tempo distinguishes itself through its cost-effective approach to trace storage,
 
 ### What are the performance implications of using OpenTelemetry?
 
-While OpenTelemetry adds some overhead due to instrumentation, it's designed to be lightweight and configurable. You can adjust sampling rates and use the OpenTelemetry Collector to batch and process data efficiently, minimizing the performance impact on your applications. The benefits of comprehensive observability often outweigh the minimal performance cost.
\ No newline at end of file
+While OpenTelemetry adds some overhead due to instrumentation, it's designed to be lightweight and configurable. You can adjust sampling rates and use the OpenTelemetry Collector to batch and process data efficiently, minimizing the performance impact on your applications. The benefits of comprehensive observability often outweigh the minimal performance cost.
diff --git a/data/comparisons/opentelemetry-vs-xray.mdx b/data/comparisons/opentelemetry-vs-xray.mdx
index 31c9ca4a8..4aa99bae4 100644
--- a/data/comparisons/opentelemetry-vs-xray.mdx
+++ b/data/comparisons/opentelemetry-vs-xray.mdx
@@ -1,13 +1,12 @@
 ---
-
 title: OpenTelemetry vs. X-Ray - Choosing the Right Tracing Tool
-slug: opentelemetry-vs-xray
+
 date: 2025-01-22
 tags: [opentelemetry, tools-comparison]
 authors: [sushant_gaurav]
 description: Compare OpenTelemetry and AWS X-Ray for distributed tracing. Learn their strengths, use cases, and how to choose the right tool for your needs.
-keywords: [opentelemetry vs xray, distributed tracing, observability, AWS, cloud-native, monitoring, SigNoz]
-
+keywords:
+  [opentelemetry vs xray, distributed tracing, observability, AWS, cloud-native, monitoring, SigNoz]
 ---
 
 Distributed tracing helps teams monitor and debug microservices applications by tracking requests as they flow through different services. OpenTelemetry and AWS X-Ray are two popular options for implementing distributed tracing.
@@ -37,6 +36,7 @@ OpenTelemetry's key features include its vendor-agnostic approach, which allows
 - Active community: X-Ray provides continuous development and support from a constantly expanding open-source community.
 
 ### Can They Be Used Together?
+
 Yes! OpenTelemetry can work alongside AWS X-Ray:
 
 You can instrument your application with OpenTelemetry and [export telemetry data to AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-services-adot.html) using the AWS Distro for OpenTelemetry (ADOT).
@@ -59,54 +59,51 @@ OpenTelemetry excels in areas that make it especially useful to enterprises that
 OpenTelemetry excels in cloud-native systems by offering critical capabilities that meet the particular problems of current application architectures:
 
 - **Kubernetes Integration**: OpenTelemetry has native support for Kubernetes, making it simple to instrument containerized systems. You can use the OpenTelemetry Collector as a DaemonSet to gather traces from your pods. This is an example configuration:
-    
-    ```yaml
-    apiVersion: apps/v1
-    kind: DaemonSet
-    metadata:
-      name: otel-collector
-    spec:
-      selector:
-        matchLabels:
+  ```yaml
+  apiVersion: apps/v1
+  kind: DaemonSet
+  metadata:
+    name: otel-collector
+  spec:
+    selector:
+      matchLabels:
+        app: otel-collector
+    template:
+      metadata:
+        labels:
           app: otel-collector
-      template:
-        metadata:
-          labels:
-            app: otel-collector
-        spec:
-          containers:
+      spec:
+        containers:
           - name: otel-collector
             image: otel/opentelemetry-collector:latest
             ports:
-            - containerPort: 4317
+              - containerPort: 4317
             volumeMounts:
-            - name: otel-config
-              mountPath: /etc/otel/config.yaml
-          volumes:
+              - name: otel-config
+                mountPath: /etc/otel/config.yaml
+        volumes:
           - name: otel-config
             configMap:
               name: otel-config
-    ```
-    
+  ```
 - **Microservices Support**: OpenTelemetry is intended to manage the complexity of distributed, microservices-based systems. Its versatility enables smooth tracking of service interactions.
 - **Cloud Service Compatibility**: OpenTelemetry is interoperable with popular cloud services from various providers, making it suitable for hybrid cloud configurations.
 - **Custom Instrumentation**: OpenTelemetry supports custom instrumentation, allowing you to tailor tracing capabilities to meet your individual needs. Here's an example of instrumenting an HTTP server.
-    
-    ```python
-    from opentelemetry import trace
-    from opentelemetry.instrumentation.flask import FlaskInstrumentor
-    
-    app = Flask(__name__)
-    FlaskInstrumentor().instrument_app(app)
-    
-    @app.route('/example')
-    def example():
-        return 'Hello, OpenTelemetry!'
-    
-    if __name__ == '__main__':
-        app.run()
-    ```
-    
+
+  ```python
+  from opentelemetry import trace
+  from opentelemetry.instrumentation.flask import FlaskInstrumentor
+
+  app = Flask(__name__)
+  FlaskInstrumentor().instrument_app(app)
+
+  @app.route('/example')
+  def example():
+      return 'Hello, OpenTelemetry!'
+
+  if __name__ == '__main__':
+      app.run()
+  ```
 
 ## When to Opt for AWS X-Ray?
 
@@ -124,20 +121,20 @@ If your application primarily uses the AWS services, X-Ray offers various advant
 - **Seamless Lambda Integration**: X-Ray integrates seamlessly with AWS Lambda and serverless architectures, enabling real-time tracing of serverless function invocations.
 - **AWS SDK Instrumentation**: The built-in capability for tracing AWS SDK calls streamlines the instrumentation process by eliminating the requirement for manual trace management.
 - **CloudWatch Integration**: X-Ray allows you to easily correlate traces with CloudWatch logs and metrics, providing complete observability throughout your AWS stack. Here's an example of enabling X-Ray tracing in a Lambda function:
-    
-    ```python
-    import boto3
-    
-    def lambda_handler(event, context):
-        xray_client = boto3.client('xray')
-        xray_client.put_trace_segments(
-            TraceSegmentDocuments=[
-                # Include your trace segments here
-            ]
-        )
-        return 'Lambda function executed successfully!'
-    ```
-    
+
+  ```python
+  import boto3
+
+  def lambda_handler(event, context):
+      xray_client = boto3.client('xray')
+      xray_client.put_trace_segments(
+          TraceSegmentDocuments=[
+              Include your trace segments here
+          ]
+      )
+      return 'Lambda function executed successfully!'
+  ```
+
 - **Reduced Operational Overhead**: X-Ray's broad AWS connection can greatly reduce the operational strain by automating many parts of trace management and visualization.
 
 ## Comparing OpenTelemetry and X-Ray Performance
@@ -154,54 +151,54 @@ When evaluating OpenTelemetry vs. X-Ray, performance is a crucial factor to cons
 To implement OpenTelemetry tracing in your application, follow these steps:
 
 1. Set Up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/):
-    - Deploy the collector as a sidecar, daemon, or standalone service.
-    - Configure receivers, processors, and exporters. Let's look at a basic configuration example for the collector:
-        
-        ```yaml
-        receivers:
-          otlp:
-            protocols:
-              grpc:
-              http:
-        
-        processors:
-          batch:
-        
-        exporters:
-          debug:
-            verbosity: detailed
-          jaeger:
-            endpoint: "<http://localhost:14268/api/traces>"
-        
-        service:
-          pipelines:
-            traces:
-              receivers: [otlp]
-              processors: [batch]
-              exporters: [debug, jaeger]
-        ```
-        
+   - Deploy the collector as a sidecar, daemon, or standalone service.
+   - Configure receivers, processors, and exporters. Let's look at a basic configuration example for the collector:
+
+     ```yaml
+     receivers:
+       otlp:
+         protocols:
+           grpc:
+           http:
+
+     processors:
+       batch:
+
+     exporters:
+       debug:
+         verbosity: detailed
+       jaeger:
+         endpoint: '<http://localhost:14268/api/traces>'
+
+     service:
+       pipelines:
+         traces:
+           receivers: [otlp]
+           processors: [batch]
+           exporters: [debug, jaeger]
+     ```
+
 2. Instrument Your Application:
-    - Set up the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) for your programming language.
-    - Enable automated instrumentation of compatible frameworks and libraries.
-    - Enable manual instrumentation for custom code paths.
-    - Example:
-        
-        ```python
-        from opentelemetry import trace
-        
-        tracer = trace.get_tracer(__name__)
-        
-        @app.route('/api/data')
-        def get_data():
-            with tracer.start_as_current_span("fetch-data"):
-                # Simulate data fetching
-                return "Data fetched!"
-        
-        ```
-        
+   - Set up the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) for your programming language.
+   - Enable automated instrumentation of compatible frameworks and libraries.
+   - Enable manual instrumentation for custom code paths.
+   - Example:
+
+     ```python
+     from opentelemetry import trace
+
+     tracer = trace.get_tracer(__name__)
+
+     @app.route('/api/data')
+     def get_data():
+         with tracer.start_as_current_span("fetch-data"):
+             Simulate data fetching
+             return "Data fetched!"
+
+     ```
+
 3. Configure Exporters:
-    - Choose and set up exporters for your preferred backends (e.g., Jaeger, Zipkin, or cloud-native solutions).
+   - Choose and set up exporters for your preferred backends (e.g., Jaeger, Zipkin, or cloud-native solutions).
 
 ### Best Practices
 
@@ -215,18 +212,16 @@ If you want to integrate AWS X-Ray tracing into your apps, follow these steps:
 
 1. To enable X-Ray Tracing for AWS Services, activate it in the AWS Console for services such as API Gateway, Lambda, and ECS.
 2. Instrument Your Applications:
-    - Install the X-Ray SDK based on your programming language. For example, with Python:
-        
-        ```bash
-        pip install aws-xray-sdk
-        ```
-        
-    - Integrate the X-Ray daemon into your EC2 instances or containers.
+   - Install the X-Ray SDK based on your programming language. For example, with Python:
+     ```bash
+     pip install aws-xray-sdk
+     ```
+   - Integrate the X-Ray daemon into your EC2 instances or containers.
 3. Configure Sampling Rules:
-    - Create sampling rules in the X-Ray interface to govern data collection.
+   - Create sampling rules in the X-Ray interface to govern data collection.
 4. Analyze Traces:
-    - Use the X-Ray console to explore service maps and trace data.
-    - Create X-Ray groups to organize and filter traces for improved insights.
+   - Use the X-Ray console to explore service maps and trace data.
+   - Create X-Ray groups to organize and filter traces for improved insights.
 
 ## Hybrid Approach: Using OpenTelemetry with AWS X-Ray
 
@@ -254,13 +249,13 @@ To configure ADOT to integrate X-Ray, follow these steps:
 To set up ADOT for X-Ray integration, follow these steps:
 
 1. Install the ADOT Collector:
-    - Follow the instructions in the <a href="https://aws-otel.github.io/docs/getting-started/x-ray" rel="noopener noreferrer nofollow" target="_blank">ADOT manual</a>.
+   - Follow the instructions in the <a href="https://aws-otel.github.io/docs/getting-started/x-ray" rel="noopener noreferrer nofollow" target="_blank">ADOT manual</a>.
 2. Configure the X-Ray Exporter:
-    - Configure the X-Ray exporter in the collector's configuration file.
+   - Configure the X-Ray exporter in the collector's configuration file.
 3. Use OpenTelemetry SDKs:
-    - Use the SDKs to instrument your apps, as previously mentioned.
+   - Use the SDKs to instrument your apps, as previously mentioned.
 4. Examine and Analyze Traces:
-    - Use the X-Ray console to examine and analyze application performance traces.
+   - Use the X-Ray console to examine and analyze application performance traces.
 
 ### OpenTelemetry's Advantages for Cloud-Native Environments
 
@@ -300,23 +295,23 @@ In the above code, you set up OpenTelemetry for a Flask application, enabling au
 This snippet demonstrates how to set up AWS X-Ray in an Express application:
 
 ```jsx
-const express = require('express');
-const AWSXRay = require('aws-xray-sdk');
+const express = require('express')
+const AWSXRay = require('aws-xray-sdk')
 
-const app = express();
-AWSXRay.config([AWSXRay.plugins.EC2Plugin]);
+const app = express()
+AWSXRay.config([AWSXRay.plugins.EC2Plugin])
 
-app.use(AWSXRay.express.openSegment('MyApp'));
+app.use(AWSXRay.express.openSegment('MyApp'))
 
 app.get('/hello', (req, res) => {
-    res.send('Hello, World!');
-});
+  res.send('Hello, World!')
+})
 
-app.use(AWSXRay.express.closeSegment());
+app.use(AWSXRay.express.closeSegment())
 
 app.listen(3000, () => {
-    console.log('Server running on <http://localhost:3000>');
-});
+  console.log('Server running on <http://localhost:3000>')
+})
 ```
 
 In the above code, you integrate AWS X-Ray with an Express application for tracing.
@@ -356,17 +351,17 @@ When choosing between OpenTelemetry and X-Ray (or alternatives such as SigNoz),
 
 ### Comparison Matrix
 
-| Feature / Criteria | OpenTelemetry | AWS X-Ray | SigNoz |
-| --- | --- | --- | --- |
-| Type | Open-source observability standard | Managed distributed tracing tool | Full-stack observability platform |
-| Vendor Lock-In | No | Yes (AWS proprietary) | No |
-| Flexibility | High (supports multiple backends) | Moderate (AWS services only) | High (OpenTelemetry-based) |
-| Ease of Setup | Moderate (requires configuration) | Easy (especially in AWS) | Easy (self-hosted with guided setup) |
-| Multi-Language Support | Extensive (multiple languages) | Limited (mainly Java, Node.js, Python) | Extensive (through OpenTelemetry) |
-| Data Ownership | Full control | Limited (AWS controls data) | Full control |
-| Out-of-the-Box Solution | No (requires additional tooling) | Yes (integrated with AWS services) | Yes (comprehensive observability) |
-| Analytics and Visualization | Depends on backend | Basic (service maps, insights) | Advanced (powerful analytics features) |
-| Cost | Varies (depending on backend) | Based on AWS usage | Lower TCO for self-hosted setups |
+| Feature / Criteria          | OpenTelemetry                      | AWS X-Ray                              | SigNoz                                 |
+| --------------------------- | ---------------------------------- | -------------------------------------- | -------------------------------------- |
+| Type                        | Open-source observability standard | Managed distributed tracing tool       | Full-stack observability platform      |
+| Vendor Lock-In              | No                                 | Yes (AWS proprietary)                  | No                                     |
+| Flexibility                 | High (supports multiple backends)  | Moderate (AWS services only)           | High (OpenTelemetry-based)             |
+| Ease of Setup               | Moderate (requires configuration)  | Easy (especially in AWS)               | Easy (self-hosted with guided setup)   |
+| Multi-Language Support      | Extensive (multiple languages)     | Limited (mainly Java, Node.js, Python) | Extensive (through OpenTelemetry)      |
+| Data Ownership              | Full control                       | Limited (AWS controls data)            | Full control                           |
+| Out-of-the-Box Solution     | No (requires additional tooling)   | Yes (integrated with AWS services)     | Yes (comprehensive observability)      |
+| Analytics and Visualization | Depends on backend                 | Basic (service maps, insights)         | Advanced (powerful analytics features) |
+| Cost                        | Varies (depending on backend)      | Based on AWS usage                     | Lower TCO for self-hosted setups       |
 
 ## Key Takeaways
 
@@ -392,4 +387,4 @@ While X-Ray is primarily utilised for the AWS environment, it can track calls to
 
 ### How does SigNoz compare with OpenTelemetry and X-Ray?
 
-SigNoz extends OpenTelemetry, providing a comprehensive observability platform with enhanced analytics and visualization. Unlike X-Ray, it is not limited to a single cloud provider and gives you more control over your data. SigNoz blends the freedom of OpenTelemetry with the extensive capabilities commonly seen in commercial observability solutions.
\ No newline at end of file
+SigNoz extends OpenTelemetry, providing a comprehensive observability platform with enhanced analytics and visualization. Unlike X-Ray, it is not limited to a single cloud provider and gives you more control over your data. SigNoz blends the freedom of OpenTelemetry with the extensive capabilities commonly seen in commercial observability solutions.
diff --git a/data/comparisons/pagerduty-alternatives.mdx b/data/comparisons/pagerduty-alternatives.mdx
index 59d19f1ec..ef76a5702 100644
--- a/data/comparisons/pagerduty-alternatives.mdx
+++ b/data/comparisons/pagerduty-alternatives.mdx
@@ -1,13 +1,12 @@
 ---
-
 title: Top 10 PagerDuty Alternatives for IT Incident Management
-slug: pagerduty-alternatives
+
 date: 2024-11-07
 tags: [tools-comparisons]
 authors: [niyati_thakkar]
 description: Discover the best PagerDuty alternatives for IT incident management. Compare features, pricing, and integration capabilities of top tools in 2024.
-keywords: [pagerduty alternatives, incident management, it alerting, devops tools, on-call management]
-
+keywords:
+  [pagerduty alternatives, incident management, it alerting, devops tools, on-call management]
 ---
 
 In today's fast-paced IT landscape, efficient incident management is crucial for maintaining system reliability and minimizing downtime. While PagerDuty has long been a go-to solution for many organizations, the market now offers a variety of alternatives that may better suit your specific needs and budget. This article explores the top 10 PagerDuty alternatives for IT incident management in 2024, helping you make an informed decision for your team.
@@ -34,7 +33,12 @@ Despite its popularity, some organizations find that PagerDuty’s high costs, c
 
 The incident management landscape has expanded, with numerous tools addressing these concerns, providing viable alternatives for companies looking to optimize their IT operations.
 
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-qBsSwRFWASRgO_g99wcly.webp" alt="" caption="" />### A Brief Look at the Incident Management Landscape
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-qBsSwRFWASRgO_g99wcly.webp"
+  alt=""
+  caption=""
+/>
+### A Brief Look at the Incident Management Landscape
 
 Incident management and alerting tools play a crucial role in maintaining IT service reliability. These platforms help organizations efficiently detect, respond to, and resolve incidents, minimizing downtime and improving overall IT operations.
 
@@ -52,9 +56,25 @@ We've evaluated numerous incident management tools based on their features, pric
 
 ### 1. Opsgenie
 
-<a href="https://www.atlassian.com/software/opsgenie" rel="noopener noreferrer nofollow" target="_blank">Opsgenie</a> is an established incident management platform launched in 2012 and acquired by Atlassian in 2018. Though its development and support have slowed since its acquisition, Opsgenie still stands as a strong alternative to PagerDuty, offering a centralized platform for handling alerts, escalations, on-call schedules, and team communications at a competitive price. While some users have reported occasional downtimes, Opsgenie’s features and reliability make it a useful solution for organizations focused on streamlined incident management.
-
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-image.webp" alt="Opsgenie Dashboard" caption="Opsgenie Dashboard" />
+<a
+  href="https://www.atlassian.com/software/opsgenie"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Opsgenie
+</a>
+is an established incident management platform launched in 2012 and acquired by Atlassian in 2018.
+Though its development and support have slowed since its acquisition, Opsgenie still stands as a
+strong alternative to PagerDuty, offering a centralized platform for handling alerts, escalations,
+on-call schedules, and team communications at a competitive price. While some users have reported
+occasional downtimes, Opsgenie’s features and reliability make it a useful solution for
+organizations focused on streamlined incident management.
+
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-image.webp"
+  alt="Opsgenie Dashboard"
+  caption="Opsgenie Dashboard"
+/>
 
 Opsgenie Features
 
@@ -76,40 +96,51 @@ Opsgenie supports over 200 integrations, including Jira, Slack, and other monito
 User Reviews and Ratings of Opsgenie
 
 - Pros:
-    - Easy setup with an intuitive interface.
-    - Extensive integration options, including Python support for customizable alerts.
-    - Reliable, with positive user reviews citing Opsgenie as a cost-effective alternative to other tools.
-    - Mobile app provides flexibility for incident management on the go.
+  - Easy setup with an intuitive interface.
+  - Extensive integration options, including Python support for customizable alerts.
+  - Reliable, with positive user reviews citing Opsgenie as a cost-effective alternative to other tools.
+  - Mobile app provides flexibility for incident management on the go.
 - Cons:
-    - Limited scheduling integration with Outlook and Google Calendar.
-    - The dashboard lacks advanced filtering and customization options.
-    - Post-acquisition support has occasionally led to downtime and fewer feature updates.
+  - Limited scheduling integration with Outlook and Google Calendar.
+  - The dashboard lacks advanced filtering and customization options.
+  - Post-acquisition support has occasionally led to downtime and fewer feature updates.
 
 ### 2. Squadcast
 
-<a href="https://www.squadcast.com/" rel="noopener noreferrer nofollow" target="_blank">Squadcast</a> is a modern incident management platform specifically designed for Site Reliability Engineering (SRE) and DevOps teams, offering an integrated suite of tools for On-Call Management, Incident Response, and Reliability Workflows. Known for its affordable pricing, intuitive design, and AI-powered features, Squadcast is a popular choice among organizations looking for a PagerDuty alternative.
-
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-Squadcast_Dashboard_0-11_screenshot.webp" alt="Squadcast Dashboard" caption="Squadcast Dashboard" />
+<a href="https://www.squadcast.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Squadcast
+</a>
+is a modern incident management platform specifically designed for Site Reliability Engineering
+(SRE) and DevOps teams, offering an integrated suite of tools for On-Call Management, Incident
+Response, and Reliability Workflows. Known for its affordable pricing, intuitive design, and
+AI-powered features, Squadcast is a popular choice among organizations looking for a PagerDuty
+alternative.
+
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-Squadcast_Dashboard_0-11_screenshot.webp"
+  alt="Squadcast Dashboard"
+  caption="Squadcast Dashboard"
+/>
 
 Unique Selling Points
 
 1. On-Call Management:
-    - Customizable Schedules: Teams can create flexible on-call schedules and escalation policies to ensure prompt incident handling.
-    - Intelligent Alert Routing: Alerts are routed based on priority and team member availability, ensuring that critical issues reach the right person quickly.
-    - Multi-Channel Notifications: Notifications are sent through SMS, email, and push notifications to maximize response efficiency.
+   - Customizable Schedules: Teams can create flexible on-call schedules and escalation policies to ensure prompt incident handling.
+   - Intelligent Alert Routing: Alerts are routed based on priority and team member availability, ensuring that critical issues reach the right person quickly.
+   - Multi-Channel Notifications: Notifications are sent through SMS, email, and push notifications to maximize response efficiency.
 2. Incident Response Capabilities:
-    - Built-In Communication: Integrated communication tools keep team members aligned and updated.
-    - Supportive Runbooks: Pre-configured runbooks guide incident resolution, helping to streamline response times.
-    - Custom APIs and Webhooks: Seamless integration with other platforms ensures Squadcast fits into your existing workflows.
+   - Built-In Communication: Integrated communication tools keep team members aligned and updated.
+   - Supportive Runbooks: Pre-configured runbooks guide incident resolution, helping to streamline response times.
+   - Custom APIs and Webhooks: Seamless integration with other platforms ensures Squadcast fits into your existing workflows.
 3. Automated Workflows:
-    - Automated Tasks: Routine incident tasks can be automated, reducing manual efforts and expediting issue resolution.
-    - Lifecycle Management: Squadcast offers end-to-end incident lifecycle management, from alert generation to postmortem analysis.
+   - Automated Tasks: Routine incident tasks can be automated, reducing manual efforts and expediting issue resolution.
+   - Lifecycle Management: Squadcast offers end-to-end incident lifecycle management, from alert generation to postmortem analysis.
 4. Reliability and AI-Powered Features:
-    - Noise Reduction with AI: AI-powered noise reduction filters out irrelevant alerts, keeping the focus on high-priority incidents.
-    - SLO Tracking: Service Level Objective (SLO) tracking helps ensure reliability by monitoring service performance against set benchmarks.
-    - Customizable Status Pages: Internal and external status pages keep stakeholders informed during incidents.
+   - Noise Reduction with AI: AI-powered noise reduction filters out irrelevant alerts, keeping the focus on high-priority incidents.
+   - SLO Tracking: Service Level Objective (SLO) tracking helps ensure reliability by monitoring service performance against set benchmarks.
+   - Customizable Status Pages: Internal and external status pages keep stakeholders informed during incidents.
 5. PagerDuty Migration Tool:
-    - Seamless Transition: Squadcast provides a proprietary migration tool for smooth data and configuration transfer from PagerDuty, simplifying the switch.
+   - Seamless Transition: Squadcast provides a proprietary migration tool for smooth data and configuration transfer from PagerDuty, simplifying the switch.
 
 Pricing Model
 
@@ -134,9 +165,18 @@ Many customers highlight these key advantages of Squadcast:
 
 ### 3. Zenduty
 
-<a href="https://www.zenduty.com/" rel="noopener noreferrer nofollow" target="_blank">Zenduty</a> provides a robust incident management platform focused on automation, collaborative response, and seamless integrations. With its competitive pricing and user-friendly interface, Zenduty is a solid choice for organizations looking to streamline incident response processes.
+<a href="https://www.zenduty.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Zenduty
+</a>
+provides a robust incident management platform focused on automation, collaborative response, and
+seamless integrations. With its competitive pricing and user-friendly interface, Zenduty is a solid
+choice for organizations looking to streamline incident response processes.
 
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-image%201.webp" alt="Zenduty Dashboard" caption="Zenduty Dashboard" />
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-image%201.webp"
+  alt="Zenduty Dashboard"
+  caption="Zenduty Dashboard"
+/>
 
 Standout Features
 
@@ -159,9 +199,17 @@ Users consistently praise Zenduty’s intuitive interface and responsive support
 
 ### 4. xMatters
 
-<a href="https://www.xmatters.com/" rel="noopener noreferrer nofollow" target="_blank">xMatters</a> is a robust incident management platform with a focus on intelligent communication and workflow automation, catering to teams that need reliable alerting and customizable workflows.
+<a href="https://www.xmatters.com/" rel="noopener noreferrer nofollow" target="_blank">
+  xMatters
+</a>
+is a robust incident management platform with a focus on intelligent communication and workflow
+automation, catering to teams that need reliable alerting and customizable workflows.
 
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-fb6a1b2b-f0a2-47ae-83e8-172672960274.webp" alt="xMatters Dashboard" caption="xMatters Dashboard" />
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-fb6a1b2b-f0a2-47ae-83e8-172672960274.webp"
+  alt="xMatters Dashboard"
+  caption="xMatters Dashboard"
+/>
 
 Core Functionalities
 
@@ -187,7 +235,11 @@ xMatters provides comprehensive customer support, including robust documentation
 
 ### 5. AlertOps
 
-<a href="https://alertops.com/" rel="noopener noreferrer nofollow" target="_blank">AlertOps</a> provides a customizable and scalable incident management platform designed to handle complex alerting scenarios, with a strong emphasis on real-time collaboration.
+<a href="https://alertops.com/" rel="noopener noreferrer nofollow" target="_blank">
+  AlertOps
+</a>
+provides a customizable and scalable incident management platform designed to handle complex
+alerting scenarios, with a strong emphasis on real-time collaboration.
 
 Key Capabilities
 
@@ -217,9 +269,21 @@ Users appreciate AlertOps' flexible integration and customization features, maki
 
 ### 6. Splunk On-Call (Formerly VictorOps)
 
-<a href="https://www.splunk.com/en_us/products/on-call.html" rel="noopener noreferrer nofollow" target="_blank">Splunk On-Call</a>, previously VictorOps, is an incident management platform closely integrated with Splunk’s observability suite, offering streamlined on-call management and incident resolution.
-
-<Figure src="/img/comparisons/2024/11/pagerduty-alternatives-34013ebe-0d5a-4899-af0d-a19e44a6982b.webp" alt="Splunk On-Call Dashboard" caption="Splunk On-Call Dashboard" />
+<a
+  href="https://www.splunk.com/en_us/products/on-call.html"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Splunk On-Call
+</a>
+, previously VictorOps, is an incident management platform closely integrated with Splunk’s
+observability suite, offering streamlined on-call management and incident resolution.
+
+<Figure
+  src="/img/comparisons/2024/11/pagerduty-alternatives-34013ebe-0d5a-4899-af0d-a19e44a6982b.webp"
+  alt="Splunk On-Call Dashboard"
+  caption="Splunk On-Call Dashboard"
+/>
 
 Notable Features
 
@@ -244,7 +308,11 @@ While Splunk On-Call is powerful and highly customizable, some users report a st
 
 ### 7. FireHydrant
 
-<a href="https://firehydrant.com/" rel="noopener noreferrer nofollow" target="_blank">FireHydrant</a> is an incident management platform designed to streamline the entire lifecycle of incidents, from detection to resolution and post-incident analysis.
+<a href="https://firehydrant.com/" rel="noopener noreferrer nofollow" target="_blank">
+  FireHydrant
+</a>
+is an incident management platform designed to streamline the entire lifecycle of incidents, from
+detection to resolution and post-incident analysis.
 
 Unique Approach to Incident Management
 
@@ -270,7 +338,13 @@ Many customers report that FireHydrant helps improve post-incident learning and
 
 ### 8. Moogsoft
 
-<a href="https://www.moogsoft.com/" rel="noopener noreferrer nofollow" target="_blank">Moogsoft</a> is an AIOps (Artificial Intelligence for IT Operations) platform that provides automated incident detection and response solutions for IT teams. Founded in 2011 and acquired by Dell in August 2023, Moogsoft is designed to improve the efficiency and accuracy of IT operations through machine learning and anomaly detection.
+<a href="https://www.moogsoft.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Moogsoft
+</a>
+is an AIOps (Artificial Intelligence for IT Operations) platform that provides automated incident
+detection and response solutions for IT teams. Founded in 2011 and acquired by Dell in August 2023,
+Moogsoft is designed to improve the efficiency and accuracy of IT operations through machine
+learning and anomaly detection.
 
 Key Features
 
@@ -289,7 +363,12 @@ Pros and Cons
 
 ### 9. BigPanda
 
-<a href="https://www.bigpanda.io/" rel="noopener noreferrer nofollow" target="_blank">BigPanda</a> is an AIOps platform focused on event correlation and automation for IT operations teams in large-scale environments. Founded in 2012, it is known for its innovative approach to streamlining incident management.
+<a href="https://www.bigpanda.io/" rel="noopener noreferrer nofollow" target="_blank">
+  BigPanda
+</a>
+is an AIOps platform focused on event correlation and automation for IT operations teams in
+large-scale environments. Founded in 2012, it is known for its innovative approach to streamlining
+incident management.
 
 Key Differentiators in the Market
 
@@ -313,7 +392,12 @@ Case Studies and Success Metrics:
 
 ### 10. Uptime (Formerly Better Uptime)
 
-<a href="https://uptime.com/" rel="noopener noreferrer nofollow" target="_blank">Uptime</a>, originally known as Better Uptime, is a newcomer in the incident management space, founded in 2021. It is recognized for its straightforward and user-friendly approach, making it particularly suitable for smaller teams or those new to formal incident management.
+<a href="https://uptime.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Uptime
+</a>
+, originally known as Better Uptime, is a newcomer in the incident management space, founded in
+2021. It is recognized for its straightforward and user-friendly approach, making it particularly
+suitable for smaller teams or those new to formal incident management.
 
 Core Features for Incident Management:
 
@@ -339,44 +423,44 @@ Users frequently praise Uptime for its ease of use and quick setup process, noti
 
 ### Comparison of Top PagerDuty Alternatives: Key Features and Capabilities
 
-| Features | Opsgenie | Squadcast | Zenduty | xMatters | AlertOps | Splunk On-Call | FireHydrant | Moogsoft | BigPanda | Uptime |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| Incident Management | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Pricing | Mid-tier | Lower-cost | Cost-effective | Enterprise-focused | Affordable | Enterprise-focused | Mid-tier | Premium | Premium | Budget-friendly |
-| Automated Escalation | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | No |
-| Customizable Alert Rules | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Limited | Yes | Limited |
-| AI-Driven Incident Response | No | No | No | No | No | No | No | Yes | Yes | No |
-| Integrations (Slack, MS Teams) | Wide | Wide | Wide | Wide | Extensive | Splunk Integration | Basic | Extensive | Extensive | Basic |
-| User Adoption & Learning Curve | Moderate | Easy | Easy | Higher complexity | Moderate | Moderate | Easy | High | Moderate | Easy |
-| Reporting & Analytics | Basic Analytics | Moderate | Moderate | Extensive | Moderate | Extensive | Limited | Extensive | Advanced | Basic |
-| Mobile App Support | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes |
-| Customer Support | 24/7 Support | 24/7 Support | 24/7 Support | 24/7 Support | Standard Support | 24/7 Support | Standard Support | Priority Support | Premium Support | Basic Support |
-| Ease of Adoption | Moderate | High | High | Moderate | Moderate | Moderate | High | Low | Moderate | High |
-| Target Users | DevOps, SMEs | SMEs, Startups | IT teams, SMEs | Enterprises, IT teams | SMEs, Startups | Enterprise IT Teams | Small to Mid Companies | Enterprises | Enterprises | Startups, SMEs |
+| Features                       | Opsgenie        | Squadcast      | Zenduty        | xMatters              | AlertOps         | Splunk On-Call      | FireHydrant            | Moogsoft         | BigPanda        | Uptime          |
+| ------------------------------ | --------------- | -------------- | -------------- | --------------------- | ---------------- | ------------------- | ---------------------- | ---------------- | --------------- | --------------- |
+| Incident Management            | Yes             | Yes            | Yes            | Yes                   | Yes              | Yes                 | Yes                    | Yes              | Yes             | Yes             |
+| Pricing                        | Mid-tier        | Lower-cost     | Cost-effective | Enterprise-focused    | Affordable       | Enterprise-focused  | Mid-tier               | Premium          | Premium         | Budget-friendly |
+| Automated Escalation           | Yes             | Yes            | Yes            | Yes                   | Yes              | Yes                 | Yes                    | No               | Yes             | No              |
+| Customizable Alert Rules       | Yes             | Yes            | Yes            | Yes                   | Yes              | Yes                 | Yes                    | Limited          | Yes             | Limited         |
+| AI-Driven Incident Response    | No              | No             | No             | No                    | No               | No                  | No                     | Yes              | Yes             | No              |
+| Integrations (Slack, MS Teams) | Wide            | Wide           | Wide           | Wide                  | Extensive        | Splunk Integration  | Basic                  | Extensive        | Extensive       | Basic           |
+| User Adoption & Learning Curve | Moderate        | Easy           | Easy           | Higher complexity     | Moderate         | Moderate            | Easy                   | High             | Moderate        | Easy            |
+| Reporting & Analytics          | Basic Analytics | Moderate       | Moderate       | Extensive             | Moderate         | Extensive           | Limited                | Extensive        | Advanced        | Basic           |
+| Mobile App Support             | Yes             | Yes            | Yes            | Yes                   | Yes              | Yes                 | Yes                    | No               | Yes             | Yes             |
+| Customer Support               | 24/7 Support    | 24/7 Support   | 24/7 Support   | 24/7 Support          | Standard Support | 24/7 Support        | Standard Support       | Priority Support | Premium Support | Basic Support   |
+| Ease of Adoption               | Moderate        | High           | High           | Moderate              | Moderate         | Moderate            | High                   | Low              | Moderate        | High            |
+| Target Users                   | DevOps, SMEs    | SMEs, Startups | IT teams, SMEs | Enterprises, IT teams | SMEs, Startups   | Enterprise IT Teams | Small to Mid Companies | Enterprises      | Enterprises     | Startups, SMEs  |
 
 ## How to Choose the Right PagerDuty Alternative
 
 Selecting the ideal incident management tool requires careful consideration of your organization's specific needs and constraints. Here's a framework to guide your decision-making process:
 
 1. Assess your organization's specific needs:
-    - Team size and structure
-    - The complexity of your IT infrastructure
-    - Current pain points in incident management
+   - Team size and structure
+   - The complexity of your IT infrastructure
+   - Current pain points in incident management
 2. Evaluate feature sets against your requirements:
-    - Alert routing and escalation capabilities
-    - On-call scheduling flexibility
-    - Reporting and analytics depth
+   - Alert routing and escalation capabilities
+   - On-call scheduling flexibility
+   - Reporting and analytics depth
 3. Consider scalability and growth potential:
-    - How well will the tool accommodate team growth?
-    - Can it handle increasing alert volumes?
+   - How well will the tool accommodate team growth?
+   - Can it handle increasing alert volumes?
 4. Analyze pricing models and total cost of ownership:
-    - Per-user vs. per-incident pricing
-    - Additional costs for advanced features or integrations
-    - Long-term cost projections
+   - Per-user vs. per-incident pricing
+   - Additional costs for advanced features or integrations
+   - Long-term cost projections
 5. Test integration capabilities with your existing stack:
-    - Compatibility with current monitoring tools
-    - Ease of integration with communication platforms
-    - Support for custom integrations if needed
+   - Compatibility with current monitoring tools
+   - Ease of integration with communication platforms
+   - Support for custom integrations if needed
 
 By methodically evaluating these factors, you can identify the PagerDuty alternative that best aligns with your organization's incident management strategy and operational needs.
 
@@ -443,21 +527,21 @@ SigNoz also offers an open-source version, allowing teams to leverage its capabi
 The landscape of IT incident management continues to evolve, driven by technological advancements and changing operational needs:
 
 1. AI and Machine Learning Integration:
-    - Predictive alerting to identify potential issues before they occur
-    - Automated root cause analysis to speed up incident resolution
-    - Intelligent alert routing based on historical data and team expertise
+   - Predictive alerting to identify potential issues before they occur
+   - Automated root cause analysis to speed up incident resolution
+   - Intelligent alert routing based on historical data and team expertise
 2. Shift Towards Proactive Incident Prevention:
-    - Increased focus on anomaly detection and trend analysis
-    - Integration of chaos engineering practices into incident management workflows
-    - Emphasis on continuous improvement through detailed incident postmortems
+   - Increased focus on anomaly detection and trend analysis
+   - Integration of chaos engineering practices into incident management workflows
+   - Emphasis on continuous improvement through detailed incident postmortems
 3. Tighter Integration with Observability Platforms:
-    - Unified dashboards combining metrics, logs, and traces with alerting
-    - Seamless correlation between incidents and underlying system behavior
-    - Real-time collaboration tools embedded within observability interfaces
+   - Unified dashboards combining metrics, logs, and traces with alerting
+   - Seamless correlation between incidents and underlying system behavior
+   - Real-time collaboration tools embedded within observability interfaces
 4. Evolution of Incident Management Tools:
-    - More customizable and flexible platforms to adapt to diverse team structures
-    - Enhanced support for remote and distributed teams
-    - Improved stakeholder communication features for transparent incident updates
+   - More customizable and flexible platforms to adapt to diverse team structures
+   - Enhanced support for remote and distributed teams
+   - Improved stakeholder communication features for transparent incident updates
 
 As these trends shape the future of incident management, tools will likely become more intelligent, proactive, and deeply integrated with the broader IT operations ecosystem.
 
@@ -525,4 +609,4 @@ When assessing the total cost of ownership (TCO) for incident management tools,
 6. Support costs: Fees for premium support levels
 7. Scalability impact: How costs change as your team or alert volume grows
 
-Remember to factor in potential cost savings from improved efficiency and reduced downtime when calculating the overall value of the solution.
\ No newline at end of file
+Remember to factor in potential cost savings from improved efficiency and reduced downtime when calculating the overall value of the solution.
diff --git a/data/comparisons/platform-engineering-tools.mdx b/data/comparisons/platform-engineering-tools.mdx
index d5dfa623c..aa7d03c37 100644
--- a/data/comparisons/platform-engineering-tools.mdx
+++ b/data/comparisons/platform-engineering-tools.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Top 10 Platform Engineering Tools for Efficient DevOps
-slug: platform-engineering-tools
+
 date: 2024-08-27
 tags: [tools-comparision]
 authors: [bhavya_sachdeva]
 description: Discover the top 10 platform engineering tools that streamline DevOps processes, enhance productivity, and drive efficient software delivery.
-keywords: [platform engineering tools, DevOps efficiency, infrastructure automation, continuous integration, deployment tools, observability platforms]
-
+keywords:
+  [
+    platform engineering tools,
+    DevOps efficiency,
+    infrastructure automation,
+    continuous integration,
+    deployment tools,
+    observability platforms,
+  ]
 ---
 
 Platform engineering tools have become essential for organizations aiming to streamline their DevOps processes and boost developer productivity. As the complexity of modern software systems grows, these tools provide the foundation for efficient, scalable, and reliable application development and deployment. But which tools should you choose for your platform engineering stack? Let's explore the top 10 platform engineering tools that are shaping the DevOps landscape in 2024.
@@ -47,9 +53,18 @@ Balancing customization and standardization is crucial in platform engineering.
 
 ### 1. Kubernetes: The Foundation of Container Orchestration
 
-<a href="https://kubernetes.io/" rel="noopener noreferrer nofollow" target="_blank">Kubernetes</a> has become the de facto standard for container orchestration in platform engineering. It provides a powerful system for automating the deployment, scaling, and management of containerized applications. 
+<a href="https://kubernetes.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Kubernetes
+</a>
+has become the de facto standard for container orchestration in platform engineering. It provides a
+powerful system for automating the deployment, scaling, and management of containerized
+applications.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-tools-Screenshot_2024-08-23_at_3.14.57_PM.webp" alt="Kubernetes" caption="Kubernetes" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-tools-Screenshot_2024-08-23_at_3.14.57_PM.webp"
+  alt="Kubernetes"
+  caption="Kubernetes"
+/>
 
 Key features of Kubernetes include:
 
@@ -69,7 +84,12 @@ How to get the most out of it?
 
 ### 2. Docker: Streamlining Application Containerization
 
-<a href="https://www.docker.com/" rel="noopener noreferrer nofollow" target="_blank">Docker</a> simplifies the process of creating, deploying, and running applications by using containers. It packages an application and its dependencies into a standardized unit for software development and deployment.
+<a href="https://www.docker.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Docker
+</a>
+simplifies the process of creating, deploying, and running applications by using containers. It
+packages an application and its dependencies into a standardized unit for software development and
+deployment.
 
 Key Docker concepts include:
 
@@ -86,7 +106,11 @@ Best practices for using Docker in platform engineering:
 
 ### 3. Terraform: Infrastructure as Code Made Easy
 
-<a href="https://www.terraform.io/" rel="noopener noreferrer nofollow" target="_blank">Terraform</a> is an open-source Infrastructure as Code (IaC) tool that enables you to define and provision infrastructure resources across multiple cloud providers and services.
+<a href="https://www.terraform.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Terraform
+</a>
+is an open-source Infrastructure as Code (IaC) tool that enables you to define and provision
+infrastructure resources across multiple cloud providers and services.
 
 Key features of Terraform include:
 
@@ -104,7 +128,11 @@ Best practices for using Terraform in platform engineering:
 
 ### 4. GitLab CI: Continuous Integration for Seamless Development
 
-<a href="https://docs.gitlab.com/ee/ci/" rel="noopener noreferrer nofollow" target="_blank">GitLab CI</a> is a powerful continuous integration tool that integrates seamlessly with GitLab's version control system. It allows you to automate building, testing, and deploying your applications.
+<a href="https://docs.gitlab.com/ee/ci/" rel="noopener noreferrer nofollow" target="_blank">
+  GitLab CI
+</a>
+is a powerful continuous integration tool that integrates seamlessly with GitLab's version control
+system. It allows you to automate building, testing, and deploying your applications.
 
 Key features of GitLab CI include:
 
@@ -122,7 +150,15 @@ Best practices for setting up GitLab CI workflows:
 
 ### 5. ArgoCD: Streamlining Continuous Deployment
 
-<a href="https://argo-cd.readthedocs.io/en/stable/" rel="noopener noreferrer nofollow" target="_blank">ArgoCD</a> is a declarative, GitOps continuous delivery tool for Kubernetes. It automates the deployment of applications to Kubernetes clusters by monitoring changes in Git repositories.
+<a
+  href="https://argo-cd.readthedocs.io/en/stable/"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  ArgoCD
+</a>
+is a declarative, GitOps continuous delivery tool for Kubernetes. It automates the deployment of
+applications to Kubernetes clusters by monitoring changes in Git repositories.
 
 Key features of ArgoCD include:
 
@@ -140,7 +176,11 @@ How to get the most out of it?
 
 ### 6. Crossplane: Unified Cloud Resource Management
 
-<a href="https://www.crossplane.io/" rel="noopener noreferrer nofollow" target="_blank">Crossplane</a> extends Kubernetes with the ability to provision and manage cloud infrastructure resources using Kubernetes-style declarative configurations.
+<a href="https://www.crossplane.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Crossplane
+</a>
+extends Kubernetes with the ability to provision and manage cloud infrastructure resources using
+Kubernetes-style declarative configurations.
 
 Key features of Crossplane include:
 
@@ -158,7 +198,11 @@ How to get the most out of it?
 
 ### 7. Backstage: Building Developer Portals with Ease
 
-<a href="https://backstage.io/" rel="noopener noreferrer nofollow" target="_blank">Backstage</a> is an open platform for building developer portals. It provides a centralized place for managing services, tools, and documentation.
+<a href="https://backstage.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Backstage
+</a>
+is an open platform for building developer portals. It provides a centralized place for managing
+services, tools, and documentation.
 
 Key features of Backstage include:
 
@@ -176,7 +220,11 @@ How to get the most out of it?
 
 ### 8. Prometheus: Powerful Monitoring for Platform Engineers
 
-<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">Prometheus</a> is an open-source monitoring and alerting toolkit designed for reliability and scalability. It's particularly well-suited for monitoring dynamic container environments.
+<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Prometheus
+</a>
+is an open-source monitoring and alerting toolkit designed for reliability and scalability. It's
+particularly well-suited for monitoring dynamic container environments.
 
 Key features of Prometheus include:
 
@@ -194,7 +242,11 @@ How to get the most out of it?
 
 ### 9. Grafana: Visualizing Platform Metrics and Logs
 
-<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> is a multi-platform open-source analytics and interactive visualization web application. It provides charts, graphs, and alerts for the web when connected to supported data sources.
+<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a>
+is a multi-platform open-source analytics and interactive visualization web application. It provides
+charts, graphs, and alerts for the web when connected to supported data sources.
 
 Key features of Grafana include:
 
@@ -214,7 +266,11 @@ How to get the most out of it?
 
 [SigNoz](https://signoz.io/) is an open-source Application Performance Monitoring (APM) and observability tool. It provides end-to-end tracing, metrics, and logs for applications, making it an excellent choice for platform engineers focused on performance and reliability.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-tools-image.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-tools-image.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 Key features of SigNoz include:
 
@@ -230,7 +286,11 @@ Steps to set up [SigNoz](https://signoz.io/docs/introduction/) for your platform
 3. Configure data ingestion to send telemetry data to SigNoz.
 4. Set up dashboards and alerts to monitor your applications.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-tools-image%201.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-tools-image%201.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 <GetStartedSigNoz />
 
@@ -238,17 +298,17 @@ Steps to set up [SigNoz](https://signoz.io/docs/introduction/) for your platform
 
 ### 1. KusionStack
 
-It is a technology stack for building cloud-native IDPs.  It helps the developers create applications with an app-centric approach. In this, Developers only need to write a single application specification AppConfiguration. AppConfiguration defines the workload and all resource dependencies without needing to supply environment-specific values and Kusion ensures it provides everything needed for the application to run.
+It is a technology stack for building cloud-native IDPs. It helps the developers create applications with an app-centric approach. In this, Developers only need to write a single application specification AppConfiguration. AppConfiguration defines the workload and all resource dependencies without needing to supply environment-specific values and Kusion ensures it provides everything needed for the application to run.
 
 ### 2. Capsule
 
-Capsule is an open-source framework designed for Platform Engineers to create secure, multi-tenant Internal Developer Platforms on any Kubernetes infrastructure. It supports the sharing of a single Kubernetes cluster among multiple teams or departments, improving efficiency and preventing cluster sprawl by grouping namespaces into a construct called a Tenant. 
+Capsule is an open-source framework designed for Platform Engineers to create secure, multi-tenant Internal Developer Platforms on any Kubernetes infrastructure. It supports the sharing of a single Kubernetes cluster among multiple teams or departments, improving efficiency and preventing cluster sprawl by grouping namespaces into a construct called a Tenant.
 
-Capsule integrates seamlessly with the  Cloud Native ecosystem which helps in enhancing the Platform Engineers' ability to build tailored and secure environments. It aims to simplify operational management and enhance resource utilization across organizations.
+Capsule integrates seamlessly with the Cloud Native ecosystem which helps in enhancing the Platform Engineers' ability to build tailored and secure environments. It aims to simplify operational management and enhance resource utilization across organizations.
 
 ### 3. Spacelift
 
-Spacelift is a CI/CD platform for Infrastructure as Code (IaC). It supports tools like Terraform, Pulumi, and AWS CloudFormation. It also integrates role-based security, custom workflows, and drift detection to manage between the desired and actual infrastructure states. It is designed for scalability. This platform offers visualization tools and automated workflows. 
+Spacelift is a CI/CD platform for Infrastructure as Code (IaC). It supports tools like Terraform, Pulumi, and AWS CloudFormation. It also integrates role-based security, custom workflows, and drift detection to manage between the desired and actual infrastructure states. It is designed for scalability. This platform offers visualization tools and automated workflows.
 
 ### 4. Cloudsmith
 
@@ -307,7 +367,7 @@ As platform engineering continues to evolve, keep an eye on these emerging trend
 - AI-powered operations: Machine learning algorithms will increasingly assist in anomaly detection, capacity planning, and automated remediation.
 - Serverless platforms: As serverless architectures, such as AWS Lambda and Azure Functions, become more widespread, platform engineering tools will need to adapt. Serverless reduces infrastructure management but introduces new challenges in observability, deployment strategies, and scaling, which tools will need to address.
 - GitOps expansion:More tools will adopt GitOps principles for managing infrastructure and applications, using Git as the single source of truth. For example, tools like Argo CD allow teams to automatically deploy updates to Kubernetes clusters based on changes committed to a Git repository.
-- Low-code/no-code platforms: Expect to see more tools that enable non-technical users to contribute to platform engineering efforts.  For example, platforms like <a href="https://www.microsoft.com/en-us/power-platform" rel="noopener noreferrer nofollow" target="_blank">Microsoft Power Platform</a> let users automate workflows and manage resources without writing code, broadening the scope of who can participate in development processes.
+- Low-code/no-code platforms: Expect to see more tools that enable non-technical users to contribute to platform engineering efforts. For example, platforms like <a href="https://www.microsoft.com/en-us/power-platform" rel="noopener noreferrer nofollow" target="_blank">Microsoft Power Platform</a> let users automate workflows and manage resources without writing code, broadening the scope of who can participate in development processes.
 
 To stay updated with the latest developments:
 
@@ -354,4 +414,4 @@ Platform engineering tools impact the software development lifecycle by:
 - Improving collaboration between development and operations teams.
 - Enabling faster and more reliable deployments.
 - Providing better visibility into application performance and issues.
-- Facilitating continuous improvement through feedback loops and metrics.
\ No newline at end of file
+- Facilitating continuous improvement through feedback loops and metrics.
diff --git a/data/comparisons/platform-engineering-vs-DevOps.mdx b/data/comparisons/platform-engineering-vs-DevOps.mdx
index 3a314978c..8b68754e3 100644
--- a/data/comparisons/platform-engineering-vs-DevOps.mdx
+++ b/data/comparisons/platform-engineering-vs-DevOps.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Platform Engineering vs DevOps - Key Differences Explained
-slug: platform-engineering-vs-DevOps
+
 date: 2024-08-14
 tags: [devops, infra]
 authors: [bhavya_sachdeva]
 description: Discover the key differences between platform engineering and DevOps, their roles in modern software development, and how they complement each other.
-keywords: [platform engineering, DevOps, software development, CI/CD, infrastructure as code, developer productivity]
-
+keywords:
+  [
+    platform engineering,
+    DevOps,
+    software development,
+    CI/CD,
+    infrastructure as code,
+    developer productivity,
+  ]
 ---
 
 In the ever-evolving landscape of software development, two approaches have gained significant traction: DevOps and platform engineering. While both aim to improve the software delivery process, they have distinct focuses and methodologies. This article explores the key differences between platform engineering and DevOps, their roles in modern software development, and how they complement each other to drive innovation and efficiency.
@@ -18,9 +24,13 @@ In the ever-evolving landscape of software development, two approaches have gain
 
 Before we discuss DevOps, let's look at the typical steps involved in creating software, like building a website for an NGO. This includes planning, analysis, design, implementation, testing, integration, and maintenance. This process becomes more complex when dealing with larger software products. The Two Departments In most organizations, two main departments handle software delivery: - Development Team: Focuses on writing code and creating new features. - Operations Team: Handles deployment, traffic, and security maintenance.
 
-There's often a gap between these two teams, leading to delays in product releases. So to bridge the gap between development and operation teams there is a term that came to the picture “DevOps”. DevOps is not just about learning tools; it's a cultural practice that emphasizes teamwork, communication, and collaboration between the development and operations teams. The goal is to enhance security, speed up processes, ensure quality, and automate as much as possible to reduce manual work and bugs in production. 
+There's often a gap between these two teams, leading to delays in product releases. So to bridge the gap between development and operation teams there is a term that came to the picture “DevOps”. DevOps is not just about learning tools; it's a cultural practice that emphasizes teamwork, communication, and collaboration between the development and operations teams. The goal is to enhance security, speed up processes, ensure quality, and automate as much as possible to reduce manual work and bugs in production.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-06_at_10.42.49_AM.webp" alt="Developers and Operations" caption="Developers and Operations" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-06_at_10.42.49_AM.webp"
+  alt="Developers and Operations"
+  caption="Developers and Operations"
+/>
 
 DevOps came into existence in order to solve above problem. Let’s discuss about DevOps.
 
@@ -52,9 +62,13 @@ Imagine a software organization with multiple DevOps teams, each specializing in
 
 Let’s take an example where the Core Web Application Team (Team A) utilizes Kubernetes for orchestration, Ansible for infrastructure provisioning, and Jenkins for continuous integration and deployment. The Mobile Application Team (Team B) employs Docker Swarm for orchestration, Puppet for infrastructure provisioning, and Buildbot for continuous integration and deployment. Meanwhile, the Data Science Team (Team C) leverages Apache Airflow for orchestration, Terraform for infrastructure provisioning, and Prometheus for monitoring and logging.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-06_at_11.27.13_AM.webp" alt="Limitations of DevOps" caption="Limitations of DevOps" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-06_at_11.27.13_AM.webp"
+  alt="Limitations of DevOps"
+  caption="Limitations of DevOps"
+/>
 
-There are challenges raised by using different tools in the same organization. Like, Integrating various tools across teams can be tough, leading to inconsistent practices and making it hard to enforce standards. The mix of tools also demands more training, raising the learning curve and complicating knowledge sharing. Managing these tools increases operational costs and can cause delays, especially when developers, who are also handling operational tasks, face bottlenecks. The "You Build It, You Run It" approach adds to the pressure, stretching developers too thin and potentially impacting the quality of their work. 
+There are challenges raised by using different tools in the same organization. Like, Integrating various tools across teams can be tough, leading to inconsistent practices and making it hard to enforce standards. The mix of tools also demands more training, raising the learning curve and complicating knowledge sharing. Managing these tools increases operational costs and can cause delays, especially when developers, who are also handling operational tasks, face bottlenecks. The "You Build It, You Run It" approach adds to the pressure, stretching developers too thin and potentially impacting the quality of their work.
 
 As DevOps continues to struggle with the increasing complexity of software systems and diverse technological ecosystems, the necessity for an evolved strategy is clear. So there is a need for a “Platform” raise where we can combine these tools. The term "platform" typically refers to a combination of tools, services, and technologies designed to enable developers to build, deploy, and manage applications more efficiently and effectively. So, Platform engineering emerges as this necessary evolution, specifically designed to address the challenges that DevOps alone cannot solve.
 
@@ -70,7 +84,11 @@ Key components of platform engineering include:
 
 Platform engineering addresses the growing complexity of modern software development by providing a structured, efficient environment for developers to work in.
 
-<Figure src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-07_at_12.39.32_AM.webp" alt="Platform Engineering" caption="Platform Engineering" />
+<Figure
+  src="/img/comparisons/2024/08/platform-engineering-vs-DevOps-Screenshot_2024-08-07_at_12.39.32_AM.webp"
+  alt="Platform Engineering"
+  caption="Platform Engineering"
+/>
 
 ### The Role of Platform Engineers
 
@@ -81,7 +99,7 @@ Platform engineers play a crucial role in optimizing the software development li
 - Optimize workflows to reduce cognitive load for development teams.
 - Balance standardization with flexibility to meet diverse team needs.
 
-By focusing on these areas, platform engineers enable development teams to focus on creating business value rather than managing complex infrastructure and tooling. 
+By focusing on these areas, platform engineers enable development teams to focus on creating business value rather than managing complex infrastructure and tooling.
 
 ## Platform Engineering vs DevOps: Key Differences Explained
 
@@ -138,7 +156,7 @@ Measure the success of your platform engineering initiatives through metrics suc
 
 ## Monitoring and Observability in Platform Engineering and DevOps
 
-Effective monitoring is crucial for both DevOps and platform engineering practices. It enables teams to detect and  and resolve issues quickly with performance optimization. It also helps to make data-driven decisions about infrastructure and application design.
+Effective monitoring is crucial for both DevOps and platform engineering practices. It enables teams to detect and and resolve issues quickly with performance optimization. It also helps to make data-driven decisions about infrastructure and application design.
 
 SigNoz, an open-source application performance monitoring (APM) and observability tool can enhance monitoring capabilities for modern software architectures. It provides, end-to-end [distributed tracing](https://signoz.io/blog/distributed-tracing/), detailed performance metrics and also real-time alerts and notifications
 
@@ -177,4 +195,4 @@ Platform engineering improves productivity by providing self-service platforms,
 
 ### What skills are needed for platform engineering compared to DevOps?
 
-Platform engineering requires deep technical knowledge of infrastructure, APIs, and tooling, as well as a strong understanding of developer workflows. DevOps skills often encompass a broader range of areas, including collaboration, process optimization, and cultural change management.
\ No newline at end of file
+Platform engineering requires deep technical knowledge of infrastructure, APIs, and tooling, as well as a strong understanding of developer workflows. DevOps skills often encompass a broader range of areas, including collaboration, process optimization, and cultural change management.
diff --git a/data/comparisons/postgresql-monitoring-tools.mdx b/data/comparisons/postgresql-monitoring-tools.mdx
index cdfa4d815..40b94e768 100644
--- a/data/comparisons/postgresql-monitoring-tools.mdx
+++ b/data/comparisons/postgresql-monitoring-tools.mdx
@@ -1,43 +1,44 @@
 ---
 title: Top 10 PostgreSQL Monitoring Tools [2025 Guide]
-slug: postgresql-monitoring-tools
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: PostgreSQL is a powerful, open-source object-relational database system used by various organizations due to its robust features and flexibility. Top 10 Postgresql monitoring tools - 1.SigNoz 2.Datadog 3.Grafana+Prometheus 4.Sematext...
 image: /img/blog/2024/04/postgresql-monitoring-tools-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [postgresql-monitoring-tools,postgres,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [postgresql-monitoring-tools, postgres, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Are you looking for a PostgreSQL database monitoring tool? Then you’re at the right place. PostgreSQL is a powerful, open-source object-relational database system used by various organizations due to its robust features and flexibility.
-
 
+Are you looking for a PostgreSQL database monitoring tool? Then you’re at the right place. PostgreSQL is a powerful, open-source object-relational database system used by various organizations due to its robust features and flexibility.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-cover.webp"
+    alt=""
+  />
 </figure>
 
-
-For databases to operate efficiently, it's essential to monitor them. This provides insights into their health, enables early detection of potential issues, and aids in effective resource allocation. 
+For databases to operate efficiently, it's essential to monitor them. This provides insights into their health, enables early detection of potential issues, and aids in effective resource allocation.
 
 It is just as important to select the right tool to monitor your databases effectively. This article discusses various monitoring tools you can consider adopting for monitoring your PostgreSQL databases.
 
 ## Top PostgreSQL monitoring tools at a glance
 
-|  | Best For | Standout Feature | Pricing |
-| --- | --- | --- | --- |
-| SigNoz (open-source) | OpenTelemetry native monitoring, and creating a wide range of PostgreSQL metric visualizations. | Open-source. Lets you track MELT under a single pane of glass. | Free community edition. Starts at \$49/month for cloud. Custom price for enterprises. |
-| Datadog | Full-stack visibility of metrics, logs, and events from 450+ technologies. | Managing downtime with responsive customer service. | Free edition for core collection and visualization, Pro edition starts at \$15 per host per month. |
-| Grafana + Prometheus | Grafana is best for visualizing data, whereas Prometheus is ideal for collecting metrics data. | Both are open-source. Pre-built dashboards of Grafana and robust and customizable alerting features of Prometheus. | Grafana has a free edition with cloud features, and the advanced premium bundle starts at \$299. Prometheus is free. |
-| Sematext | Comprehensive monitoring and observability for cloud-native applications. | Unified platform for logs, metrics, and traces. | Free 14-day trial with prices starting at — log management at \$40/month, monitoring at \$3.24/month, and synthetics at \$4.5/month annually. |
-| AppDynamics | Application and business performance monitoring. | Real-time analytics and insights into application performance. | Free edition, \$39 for a standard edition, and customized premium edition. |
-| New Relic | Full-stack observability for cloud-native environments. | Proactive performance optimization and anomaly detection. | Free edition for free clusters, serverless edition from \$0.10/million reads, and dedicated from \$57/month. |
-| pganalyze | PostgreSQL database performance monitoring. | Intelligent tuning advisors and continuous database profiling. | Free edition with 30+ capabilities and custom pricing for standard, pro, and enterprise. |
-| SolarWinds Database Performance Monitor | Database performance monitoring and optimization. | Cross-platform support for databases and cloud-native environments. | Free trial for 30 days with customized pricing. |
-| Middleware | Application performance monitoring (APM). | Real-time monitoring and alerting for applications. | Free forever plan, pay-as-you-go plan, and custom price for enterprise plan. |
-| Nagios | Network and infrastructure monitoring. | Comprehensive monitoring of servers, networks, and services. | Free edition, with customized enterprise solutions. |
+|                                         | Best For                                                                                        | Standout Feature                                                                                                   | Pricing                                                                                                                                       |
+| --------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| SigNoz (open-source)                    | OpenTelemetry native monitoring, and creating a wide range of PostgreSQL metric visualizations. | Open-source. Lets you track MELT under a single pane of glass.                                                     | Free community edition. Starts at \$49/month for cloud. Custom price for enterprises.                                                         |
+| Datadog                                 | Full-stack visibility of metrics, logs, and events from 450+ technologies.                      | Managing downtime with responsive customer service.                                                                | Free edition for core collection and visualization, Pro edition starts at \$15 per host per month.                                            |
+| Grafana + Prometheus                    | Grafana is best for visualizing data, whereas Prometheus is ideal for collecting metrics data.  | Both are open-source. Pre-built dashboards of Grafana and robust and customizable alerting features of Prometheus. | Grafana has a free edition with cloud features, and the advanced premium bundle starts at \$299. Prometheus is free.                          |
+| Sematext                                | Comprehensive monitoring and observability for cloud-native applications.                       | Unified platform for logs, metrics, and traces.                                                                    | Free 14-day trial with prices starting at — log management at \$40/month, monitoring at \$3.24/month, and synthetics at \$4.5/month annually. |
+| AppDynamics                             | Application and business performance monitoring.                                                | Real-time analytics and insights into application performance.                                                     | Free edition, \$39 for a standard edition, and customized premium edition.                                                                    |
+| New Relic                               | Full-stack observability for cloud-native environments.                                         | Proactive performance optimization and anomaly detection.                                                          | Free edition for free clusters, serverless edition from \$0.10/million reads, and dedicated from \$57/month.                                  |
+| pganalyze                               | PostgreSQL database performance monitoring.                                                     | Intelligent tuning advisors and continuous database profiling.                                                     | Free edition with 30+ capabilities and custom pricing for standard, pro, and enterprise.                                                      |
+| SolarWinds Database Performance Monitor | Database performance monitoring and optimization.                                               | Cross-platform support for databases and cloud-native environments.                                                | Free trial for 30 days with customized pricing.                                                                                               |
+| Middleware                              | Application performance monitoring (APM).                                                       | Real-time monitoring and alerting for applications.                                                                | Free forever plan, pay-as-you-go plan, and custom price for enterprise plan.                                                                  |
+| Nagios                                  | Network and infrastructure monitoring.                                                          | Comprehensive monitoring of servers, networks, and services.                                                       | Free edition, with customized enterprise solutions.                                                                                           |
 
 ### Why is PostgreSQL monitoring important?
 
@@ -51,12 +52,17 @@ Monitoring your PostgreSQL database is important for different reasons. Here are
 
 ## SigNoz
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-signoz.webp" alt="PostgreSQL Monitoring Dashboard Overview"/>
-    <figcaption><i>PostgreSQL Monitoring Dashboard Overview</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-signoz.webp"
+    alt="PostgreSQL Monitoring Dashboard Overview"
+  />
+  <figcaption>
+    <i>PostgreSQL Monitoring Dashboard Overview</i>
+  </figcaption>
 </figure>
 
-
 SigNoz is an open-source [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/) tool built on OpenTelemetry, an emerging standard for observability.
 
 Monitoring of PostgreSQL databases in [SigNoz](https://signoz.io/docs/introduction/) is done through OpenTelemetry. It collects PostgreSQL metrics using the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) and visualizes this data effectively. SigNoz allows users to monitor key database metrics, enabling a comprehensive analysis of database performance. It allows for the creation of customized dashboards and alerts for tracking and managing the health and performance of PostgreSQL instances.
@@ -72,24 +78,29 @@ If you are interested in monitoring your PostgreSQL database instances with SigN
 5. Easy to set alerts with DIY [query builder](https://signoz.io/blog/query-builder-v5/).
 6. Logs management.
 
-| Pros | Cons |
-| --- | --- |
+| Pros                                           | Cons                                                    |
+| ---------------------------------------------- | ------------------------------------------------------- |
 | It has an open-source and cloud-based version. | Manual setup and management of the open-source version. |
-| It is built on OpenTelemetry. |  |
-| It has an active and growing Slack community. |  |
-| It is a very cost-effective tool. |  |
+| It is built on OpenTelemetry.                  |                                                         |
+| It has an active and growing Slack community.  |                                                         |
+| It is a very cost-effective tool.              |                                                         |
 
 ## Datadog
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-datadog.webp" alt="PostgreSQL performance monitoring in Datadog"/>
-    <figcaption><i>PostgreSQL performance monitoring in Datadog</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-datadog.webp"
+    alt="PostgreSQL performance monitoring in Datadog"
+  />
+  <figcaption>
+    <i>PostgreSQL performance monitoring in Datadog</i>
+  </figcaption>
 </figure>
 
-
 Datadog is a cloud-based monitoring and analytics platform that provides full-stack observability, allowing users to monitor their applications, infrastructure, and logs in real time.
 
-Datadog provides a PostgreSQL integration that enables the automatic collection of PostgreSQL data from the statistics collector. This feature allows you to monitor all your PostgreSQL metrics in one centralized location. The Datadog agent is responsible for collecting PostgreSQL metrics so instead of querying PostgreSQL metrics manually, the agent automatically aggregates the metrics and presents them for visualization in a dashboard. 
+Datadog provides a PostgreSQL integration that enables the automatic collection of PostgreSQL data from the statistics collector. This feature allows you to monitor all your PostgreSQL metrics in one centralized location. The Datadog agent is responsible for collecting PostgreSQL metrics so instead of querying PostgreSQL metrics manually, the agent automatically aggregates the metrics and presents them for visualization in a dashboard.
 
 ### Features of Datadog
 
@@ -97,20 +108,25 @@ Datadog provides a PostgreSQL integration that enables the automatic collection
 2. It supports query and host metric correlation for insights into resource constraints' impact.
 3. Users can create custom dashboards to monitor specific PostgreSQL metrics and performance indicators.
 
-| Pros | Cons |
-| --- | --- |
-| PostgreSQL integration. | Datadog is quite expensive to use. |
-| Centralized database with easy customization. | Charges for monitoring individual custom metrics. |
-| Managing downtime is easy with responsive customer support. | No self-hosted option. |
+| Pros                                                        | Cons                                              |
+| ----------------------------------------------------------- | ------------------------------------------------- |
+| PostgreSQL integration.                                     | Datadog is quite expensive to use.                |
+| Centralized database with easy customization.               | Charges for monitoring individual custom metrics. |
+| Managing downtime is easy with responsive customer support. | No self-hosted option.                            |
 
 ## Grafana + Prometheus
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-grafana-prometheus.webp" alt="PostgreSQL metrics displayed on a custom dashboard in Grafana"/>
-    <figcaption><i>PostgreSQL metrics displayed on a custom dashboard in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-grafana-prometheus.webp"
+    alt="PostgreSQL metrics displayed on a custom dashboard in Grafana"
+  />
+  <figcaption>
+    <i>PostgreSQL metrics displayed on a custom dashboard in Grafana</i>
+  </figcaption>
 </figure>
 
-
 Prometheus and Grafana are open-source tools that, when used together, provide a comprehensive monitoring solution. This combination can be used in monitoring PostgreSQL databases. Prometheus functions as a metrics collector, and Grafana as the visualization tool.
 
 To gain insights into the health and performance of PostgreSQL databases, Prometheus collects metrics from PostgreSQL database instances and stores them in its time-series database. These metrics are then visualized through Grafana, which is configured to use Prometheus as a data source.
@@ -122,44 +138,54 @@ To gain insights into the health and performance of PostgreSQL databases, Promet
 3. Robust Querying Language.
 4. Variety of visualization options.
 
-| Pros | Cons |
-| --- | --- |
+| Pros                                                           | Cons                                               |
+| -------------------------------------------------------------- | -------------------------------------------------- |
 | Grafana has nice visualization features for interpreting data. | Prometheus is limited to metrics collection alone. |
-| Prometheus is a powerful monitoring system. | Prometheus requires manual setup and maintenance. |
-| Both tools have strong community support. | Setup can be complex. |
+| Prometheus is a powerful monitoring system.                    | Prometheus requires manual setup and maintenance.  |
+| Both tools have strong community support.                      | Setup can be complex.                              |
 
 ## Sematext
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-sematext.webp" alt="PostgreSQL custom dashboard overview"/>
-    <figcaption><i>PostgreSQL custom dashboard overview</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-sematext.webp"
+    alt="PostgreSQL custom dashboard overview"
+  />
+  <figcaption>
+    <i>PostgreSQL custom dashboard overview</i>
+  </figcaption>
 </figure>
 
-
-Sematext is a comprehensive monitoring tool that supports PostgreSQL and various other databases, focusing on logs, infrastructure, tracing, and performance monitoring. It offers an easy-to-set-up PostgreSQL agent for seamless installation via the UI or terminal. 
+Sematext is a comprehensive monitoring tool that supports PostgreSQL and various other databases, focusing on logs, infrastructure, tracing, and performance monitoring. It offers an easy-to-set-up PostgreSQL agent for seamless installation via the UI or terminal.
 
 With Sematext, users can ship PostgreSQL metrics to the control plane for visualization, optimization, and alerting. Additionally, it includes a built-in PostgreSQL Log integration for identifying slow queries and errors, facilitating root-cause analysis.
 
 ### Features of Sematext
 
-1. Sematext provides a powerful feature for correlating PostgreSQL logs with performance metrics. 
+1. Sematext provides a powerful feature for correlating PostgreSQL logs with performance metrics.
 2. It offers pre-built PostgreSQL dashboards that display both host-specific metrics and container metrics.
 3. Monitors the database's performance including the underlying infrastructure's health.
 
-| Pros | Cons |
-| --- | --- |
+| Pros                                          | Cons                                                               |
+| --------------------------------------------- | ------------------------------------------------------------------ |
 | Real-time monitoring of database performance. | Doesn't support custom PostgreSQL metrics from certain extensions. |
-| Slow query analysis. | Limited support for transaction tracing. |
-| Metrics correlation for troubleshooting. |  |
+| Slow query analysis.                          | Limited support for transaction tracing.                           |
+| Metrics correlation for troubleshooting.      |                                                                    |
 
 ## AppDynamics
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-appdynamics.webp" alt="PostgreSQL dashboard in AppDynamics"/>
-    <figcaption><i>PostgreSQL dashboard in AppDynamics</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-appdynamics.webp"
+    alt="PostgreSQL dashboard in AppDynamics"
+  />
+  <figcaption>
+    <i>PostgreSQL dashboard in AppDynamics</i>
+  </figcaption>
 </figure>
 
-
 AppDynamics is an application performance monitoring and management solution that helps organizations monitor, troubleshoot, and optimize their software applications in real-time.
 
 AppDynamics can monitor PostgreSQL databases through its dedicated PostgreSQL Database Monitoring Extension. It provides real-time visibility into transaction activity, cache hit rates, tuple access types, and other performance counters in any PostgreSQL server for quickly identifying the root cause of issues and resolving costly performance problems.
@@ -169,20 +195,38 @@ AppDynamics can monitor PostgreSQL databases through its dedicated PostgreSQL Da
 1. AppDynamics provides comprehensive database monitoring dashboards that offer insights into the performance and health of PostgreSQL databases.
 2. It provides out-of-the-box features such as logical data storage with tablespaces and table partitioning for efficient data management and performance optimization.
 
-| Pros | Cons |
-| --- | --- |
-| Deep visibility into PostgreSQL performance. | No self-hosted option. |
-| Provides historical performance trends and comprehensive PostgreSQL performance reports. |  |
+| Pros                                                                                     | Cons                   |
+| ---------------------------------------------------------------------------------------- | ---------------------- |
+| Deep visibility into PostgreSQL performance.                                             | No self-hosted option. |
+| Provides historical performance trends and comprehensive PostgreSQL performance reports. |                        |
 
 ## New Relic
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-new-relic.webp" alt="PostgreSQL key metrics monitoring"/>
-    <figcaption><i>PostgreSQL key metrics monitoring</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-new-relic.webp"
+    alt="PostgreSQL key metrics monitoring"
+  />
+  <figcaption>
+    <i>PostgreSQL key metrics monitoring</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank" >New Relic</a> is a cloud-based observability platform that offers an <a href = "https://docs.newrelic.com/docs/infrastructure/host-integrations/host-integrations-list/postgresql/postgresql-integration" rel="noopener noreferrer nofollow" target="_blank" >on-host PostgreSQL monitoring integration</a> designed for monitoring PostgreSQL databases. This integration facilitates the transmission of inventory metrics from PostgreSQL instances to the New Relic platform, enabling the aggregation and visualization of key performance metrics.
+<a href="https://newrelic.com" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a>
+is a cloud-based observability platform that offers an 
+<a
+  href="https://docs.newrelic.com/docs/infrastructure/host-integrations/host-integrations-list/postgresql/postgresql-integration"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  on-host PostgreSQL monitoring integration
+</a>
+ designed for monitoring PostgreSQL databases. This integration facilitates the transmission of
+inventory metrics from PostgreSQL instances to the New Relic platform, enabling the aggregation and
+visualization of key performance metrics.
 
 New Relic provides comprehensive insights into database performance, including detailed analysis of queries, throughput, and response times. It also provides an alerting system that can notify users of performance anomalies within their PostgreSQL databases.
 
@@ -195,21 +239,26 @@ New Relic provides comprehensive insights into database performance, including d
 5. Long-term data retention period.
 6. Complete visibility across your entire stack.
 
-| Pros | Cons |
-| --- | --- |
-| Supports a wide range of integrations. | Charges based on data ingested
-and user seats which can be expensive. |
-| Comprehensive monitoring. |  |
-| Clean and intuitive UI. |  |
+| Pros                                   | Cons                           |
+| -------------------------------------- | ------------------------------ |
+| Supports a wide range of integrations. | Charges based on data ingested |
+| and user seats which can be expensive. |
+| Comprehensive monitoring.              |                                |
+| Clean and intuitive UI.                |                                |
 
 ## pganalyze
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-pganalyze.webp" alt="SQL Queries from the PostgreSQL database"/>
-    <figcaption><i>SQL Queries from the PostgreSQL database</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-pganalyze.webp"
+    alt="SQL Queries from the PostgreSQL database"
+  />
+  <figcaption>
+    <i>SQL Queries from the PostgreSQL database</i>
+  </figcaption>
 </figure>
 
-
 Pganalyze is a comprehensive monitoring tool designed specifically for PostgreSQL databases, providing deep insights into the performance of PostgreSQL databases. It enhances database performance and availability by leveraging intelligent tuning advisors and continuous database profiling. This approach ensures that your PostgreSQL database operates at optimal efficiency and is always accessible, even under varying workloads.
 
 ### Features of pganalyze
@@ -217,20 +266,25 @@ Pganalyze is a comprehensive monitoring tool designed specifically for PostgreSQ
 1. An Indexing Engine that automatically identifies the optimal indexes for your database, enhancing query performance and reducing load times.
 2. An Index Advisor that provides recommendations for creating or dropping indexes based on real-time database usage patterns, helping to optimize database performance.
 
-| Pros | Cons |
-| --- | --- |
-| In-depth Postgres observability. | Limited extension support. |
-| Built for PostgreSQL database monitoring. | Temporary tables are not supported. |
-| Allows easy access to historical data. | PostGIS is only partially supported. |
+| Pros                                      | Cons                                 |
+| ----------------------------------------- | ------------------------------------ |
+| In-depth Postgres observability.          | Limited extension support.           |
+| Built for PostgreSQL database monitoring. | Temporary tables are not supported.  |
+| Allows easy access to historical data.    | PostGIS is only partially supported. |
 
 ## SolarWinds Database Performance Monitor (DPM)
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-dpm.webp" alt="PostgreSQL monitoring dashboard"/>
-    <figcaption><i>PostgreSQL monitoring dashboard</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-dpm.webp"
+    alt="PostgreSQL monitoring dashboard"
+  />
+  <figcaption>
+    <i>PostgreSQL monitoring dashboard</i>
+  </figcaption>
 </figure>
 
-
 SolarWinds DPM is a SaaS-based platform designed to monitor various databases' performance, including PostgreSQL, MongoDB, Microsoft SQL, and more. It offers a Profiler feature that provides detailed information about the most time-consuming and frequently executed queries within a PostgreSQL database. This allows for organizing and managing database queries.
 
 In addition, SolarWinds also offers a Database Performance Analyzer (DPA) product. This tool is specifically designed to assist in monitoring, diagnosing, and resolving performance issues for PostgreSQL database instances, regardless of whether they are self-managed or hosted in the cloud.
@@ -242,20 +296,29 @@ In addition, SolarWinds also offers a Database Performance Analyzer (DPA) produc
 3. Analyzes queries in detail to understand performance.
 4. Configurable alerts for immediate issue detection.
 
-| Pros | Cons |
-| --- | --- |
-| Supports monitoring of different databases. | The pricing may not be very affordable for smaller companies. |
-| Provides a wide range of monitoring products. | Doesn’t have an open-source version. |
+| Pros                                          | Cons                                                          |
+| --------------------------------------------- | ------------------------------------------------------------- |
+| Supports monitoring of different databases.   | The pricing may not be very affordable for smaller companies. |
+| Provides a wide range of monitoring products. | Doesn’t have an open-source version.                          |
 
 ## Middleware
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-middleware.webp" alt="Overview dashboard of PostgreSQL database information"/>
-    <figcaption><i>Overview dashboard of PostgreSQL database information</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-middleware.webp"
+    alt="Overview dashboard of PostgreSQL database information"
+  />
+  <figcaption>
+    <i>Overview dashboard of PostgreSQL database information</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://middleware.io" rel="noopener noreferrer nofollow" target="_blank" >Middleware</a> is a comprehensive cloud observability platform that provides detailed insights and into systems and applications. 
+<a href="https://middleware.io" rel="noopener noreferrer nofollow" target="_blank">
+  Middleware
+</a>
+is a comprehensive cloud observability platform that provides detailed insights and into systems and
+applications.
 
 Middleware provides a PostgreSQL integration which is designed to efficiently monitor PostgreSQL, helping you quickly detect and resolve issues across your PostgreSQL instances. It seamlessly integrates with your PostgreSQL instance, automatically collecting key PostgreSQL metrics which can be visualized in a custom dashboard.
 
@@ -265,21 +328,32 @@ Middleware provides a PostgreSQL integration which is designed to efficiently mo
 2. Seamless correlation of metrics, logs, and traces for enhanced performance analysis and troubleshooting.
 3. Centralized monitoring of application performance.
 
-| Pros | Cons |
-| --- | --- |
-| Creation of custom dashboards. | No open-source version. |
-| Real-time monitoring of services. |  |
-| 24/7 technical support. |  |
+| Pros                              | Cons                    |
+| --------------------------------- | ----------------------- |
+| Creation of custom dashboards.    | No open-source version. |
+| Real-time monitoring of services. |                         |
+| 24/7 technical support.           |                         |
 
 ## Nagios
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/04/postgresql-monitoring-tools-nagios.webp" alt="PostgreSQL database information visualization"/>
-    <figcaption><i>PostgreSQL database information visualization</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/04/postgresql-monitoring-tools-nagios.webp"
+    alt="PostgreSQL database information visualization"
+  />
+  <figcaption>
+    <i>PostgreSQL database information visualization</i>
+  </figcaption>
 </figure>
 
-
-<a href = "https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank" >Nagios</a> is an open-source monitoring tool used to monitor their IT infrastructure, networks, and applications. Nagios provides different wizards for monitoring databases including PostgreSQL. Its built-in Postgres Database Wizard monitors key metrics like connection Status, database size, table sizes, relation sizes, and sequences
+<a href="https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank">
+  Nagios
+</a>
+is an open-source monitoring tool used to monitor their IT infrastructure, networks, and
+applications. Nagios provides different wizards for monitoring databases including PostgreSQL. Its
+built-in Postgres Database Wizard monitors key metrics like connection Status, database size, table
+sizes, relation sizes, and sequences
 
 Nagios also for configuration of alerts with different states and thresholds in case of downtime or performance issues.
 
@@ -289,10 +363,10 @@ Nagios also for configuration of alerts with different states and thresholds in
 2. Comprehensive monitoring.
 3. Multi-Tenant capabilities.
 
-| Pros | Cons |
-| --- | --- |
-| It can integrate with third-party solutions. | It has an operation overhead. |
-| Supports system-level metrics. | It is not PostgreSQL-specific. |
+| Pros                                         | Cons                           |
+| -------------------------------------------- | ------------------------------ |
+| It can integrate with third-party solutions. | It has an operation overhead.  |
+| Supports system-level metrics.               | It is not PostgreSQL-specific. |
 
 ## Factors to consider in selecting the right PostgreSQL monitoring tool
 
@@ -321,4 +395,4 @@ If you’re looking for an all-in-one solution, easy-to-use, open-source tool, c
 
 [Decoding PostgreSQL Monitoring | 101 Guide](https://signoz.io/blog/postgresql-monitoring/)
 
-[How to Monitor PostgreSQL metrics with OpenTelemetry](https://signoz.io/blog/opentelemetry-postgresql-metrics-monitoring/)
\ No newline at end of file
+[How to Monitor PostgreSQL metrics with OpenTelemetry](https://signoz.io/blog/opentelemetry-postgresql-metrics-monitoring/)
diff --git a/data/comparisons/prometheus-alternatives.mdx b/data/comparisons/prometheus-alternatives.mdx
index 41fb98836..c40e5772a 100644
--- a/data/comparisons/prometheus-alternatives.mdx
+++ b/data/comparisons/prometheus-alternatives.mdx
@@ -1,25 +1,26 @@
 ---
 title: Top 11 Prometheus Alternatives in 2025 [Includes Open-Source]
-slug: prometheus-alternatives
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [debanjan]
 description: Prometheus is a popular metrics monitoring tool. But there are many use cases where it might not be the best fit. Here are top 11 Prometheus alternatives - 1.SigNoz(open-source) 2.InfluxDB 3.Zabbix 4.Nagios...
 image: /img/blog/2024/03/prometheus-alternatives-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 3
-keywords: [prometheus-alternatives,prometheus,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [prometheus-alternatives, prometheus, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Prometheus has been one of the most popular open-source monitoring tools for the last few years. However, as systems become more complex, Prometheus looks like a monolithic application that just can’t match performance needs anymore. In fact, it also lacks high availability and easy scalability. In this article, we will go through the top 11 Prometheus alternatives that you can consider using.
-
 
+Prometheus has been one of the most popular open-source monitoring tools for the last few years. However, as systems become more complex, Prometheus looks like a monolithic application that just can’t match performance needs anymore. In fact, it also lacks high availability and easy scalability. In this article, we will go through the top 11 Prometheus alternatives that you can consider using.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 That calls for searching for Prometheus alternatives. While your options are many, you can narrow down your search by focusing on the ones that deliver superior performance, data ingestion, compression with high availability, and scalability. Let’s take a look at the top 11 tools.
 
 ## Why Look for Prometheus Alternatives?
@@ -27,11 +28,11 @@ That calls for searching for Prometheus alternatives. While your options are man
 Prometheus is a popular metrics monitoring tool. But there are many use cases where it might not be the best fit. Some scenarios where people look for [Prometheus alternatives](https://signoz.io/comparisons/prometheus-alternatives/#8-victoriametrics) are:
 
 - **Complex set up and issues in scaling** <br />
-Some people find it complex to set up. Also, managing its scalability for very large and dynamic environments can become complex.
+  Some people find it complex to set up. Also, managing its scalability for very large and dynamic environments can become complex.
 - **Not a fan of PromQL** <br />
-Some users just don’t like PromQL, the query language of Prometheus for querying metrics.
+  Some users just don’t like PromQL, the query language of Prometheus for querying metrics.
 - **More use cases than just Metrics monitoring** <br />
-Prometheus is limited to metrics monitoring. Some users want to do more than metrics and don’t want to use multiple tools for their monitoring set up. SigNoz, an open-source Prometheus alternative can do logs, metrics, and traces under a single pane of glass.
+  Prometheus is limited to metrics monitoring. Some users want to do more than metrics and don’t want to use multiple tools for their monitoring set up. SigNoz, an open-source Prometheus alternative can do logs, metrics, and traces under a single pane of glass.
 
 We have created a list of 11 Prometheus alternatives that you can consider for your use-cases.
 
@@ -39,250 +40,323 @@ We have created a list of 11 Prometheus alternatives that you can consider for y
 
 ### 1. SigNoz (Open-Source)
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/common/hostmetrics-dashboard-overview.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/common/hostmetrics-dashboard-overview.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 [SigNoz](https://signoz.io/) is a full-stack OpenTelemetry native monitoring tool. It’s effective not only as a Prometheus alternative but also for monitoring any application that generates different types of telemetry data. It offers logs, metrics and traces under a single pane of glass, and has other exceptional features like root cause analysis, live tailing, anomaly detection, and detailed trace filtering.
 
 Not only that, but it uses columnar ClickHouse-based storage to generate analytics quickly. Moreover, when it comes to metrics and dashboards, you can enable a [Prometheus receiver](https://signoz.io/blog/opentelemetry-collector-prometheus-receiver/) to receive any metrics exposed in a running Prometheus instance. It has a strong community that’s proactive, extensive documentation, and a user-friendly journey. Additionally, there are no licensing costs if you self-host it as it is open source.
 
 It also provides a [cloud version](https://signoz.io/teams/) where you can just sign-up and start sending your monitoring data.
 
-**Pros:** 
+**Pros:**
 
 1. Support for PromQL to help you set up trigger-based alerts with the DIY [query builder](https://signoz.io/blog/query-builder-v5/)
 2. Ingest, process, and analyze data at highly scalable levels while reducing costs
 3. Easy to migrate out of Prometheus to SigNoz as it supports [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/)
 
-**Cons:** 
+**Cons:**
 
-1. Live support is unavailable 
+1. Live support is unavailable
 2. More visualization types needed
 
 ### 2. InfluxDB + Chronograf
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-influxdb.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-influxdb.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://docs.influxdata.com/chronograf/v1/guides/create-a-dashboard" rel="noopener noreferrer nofollow" target="_blank" >Influxdata documentation</a>
 
-<a href = "https://www.influxdata.com" rel="noopener noreferrer nofollow" target="_blank" >InfluxDB</a> is a database for collecting and storing time-series data, whereas Chronograf is for visualizing that data and deriving metrics and real-time analytics. In fact, Chronograf can also help you build queries, alerts, and dashboards. 
+<a href="https://www.influxdata.com" rel="noopener noreferrer nofollow" target="_blank">
+  InfluxDB
+</a>
+is a database for collecting and storing time-series data, whereas Chronograf is for visualizing
+that data and deriving metrics and real-time analytics. In fact, Chronograf can also help you build
+queries, alerts, and dashboards.
 
 You can use 20+ pre-built dashboards, templates, and libraries to not build everything from scratch, and save yourself time. It’s ideal for all your Influx deployments. Now back to InfluxDB, it’s perfect for handling telemetry data and comes with a straightforward query language that is easy and quick to learn.
 
-Its powerful integrations can make aggregating large data sets a breeze! It’s extremely resource-efficient, sometimes more than Prometheus, and when backed by Chronograf’s simple interface and customizable dashboards, it can be effective for infrastructure and alert management. 
+Its powerful integrations can make aggregating large data sets a breeze! It’s extremely resource-efficient, sometimes more than Prometheus, and when backed by Chronograf’s simple interface and customizable dashboards, it can be effective for infrastructure and alert management.
 
-**Pros:** 
+**Pros:**
 
 1. InfluxDB is known for fast bulk queries, low latency, and resource efficiency, and its retention policies are top-tier for scalability
 2. Chronograf’s best at visualizing time-series data with better redundancy storage, customizable dashboards, and a user-friendly interface
 
-**Cons:** 
+**Cons:**
 
 1. InfluxDB has certain operations which are difficult to execute, and its open-source version lacks support for certain deployments
 2. Chronograf has limited data support and is less powerful than visualization alternatives
 
 ### 3. Zabbix
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-zabbix.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-zabbix.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.zabbix.com/documentation/6.0/en/manual/web_interface/frontend_sections/monitoring/dashboard" rel="noopener noreferrer nofollow" target="_blank" >Zabbix</a>
 
 An enterprise-class network monitoring solution, <a href = "https://www.zabbix.com" rel="noopener noreferrer nofollow" target="_blank" >Zabbix</a> is an excellent Prometheus alternative that’s also open-source. In fact, Zabbix is a Prometheus predecessor which provides high-performance monitoring, low resource usage, and streamlined data processing.
 
-Zabbix is known for its reliability in production environments. You can take advantage of its advanced alerting features or self-healing capabilities. 
+Zabbix is known for its reliability in production environments. You can take advantage of its advanced alerting features or self-healing capabilities.
 
 Zabbix offers flexibility of deployment options along with a ‘single pane of glass’ view of your entire infrastructure. It has a web interface for smooth real-time monitoring, alerting, and visualization of infrastructure performance. You can also use its APIs to integrate them into your applications and enjoy integration with numerous services like Grafana, Prometheus, Elasticsearch, and AWS.
 
-**Pros:** 
+**Pros:**
 
 1. More ready-to-use solutions with easy-to-understand performance graphs, severity charts, and customizable options
 2. Can process unstructured data, and can collect data from numerous sources like SNMP and JMX
 
-**Cons:** 
+**Cons:**
 
 1. There’s no built-in machine-learning support within the application
-2. Lack of pre-built integration options, especially for specific platforms or cloud applications 
+2. Lack of pre-built integration options, especially for specific platforms or cloud applications
 
 ### 4. Nagios
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-nagios.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-nagios.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://support.nagios.com/kb/article/log-server-dashboard-overview-898.html" rel="noopener noreferrer nofollow" target="_blank" >Nagios</a>
 
-Supported by a powerful community, <a href = "https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank" >Nagios</a> is an open-source monitoring solution perfect for your entire infrastructure. As a Prometheus alternative, it gets the job done when you’re focusing on application network traffic and security. It’s known for its centralized visual operational status that enables speedy resolutions and a commercial-grade netflow data analysis solution for checking data dips and spikes. 
+Supported by a powerful community, <a href = "https://www.nagios.org" rel="noopener noreferrer nofollow" target="_blank" >Nagios</a> is an open-source monitoring solution perfect for your entire infrastructure. As a Prometheus alternative, it gets the job done when you’re focusing on application network traffic and security. It’s known for its centralized visual operational status that enables speedy resolutions and a commercial-grade netflow data analysis solution for checking data dips and spikes.
 
-It has a log server for easy visualization, analysis, and archival of logs. You can use the multiple available add-ons for cross-platform monitoring, flexible data transport mechanisms, or integrating passive alerts. You can rely on Nagios for server performance monitoring, capacity planning, and snapshot configurations in addition to server, network, and application monitoring. 
+It has a log server for easy visualization, analysis, and archival of logs. You can use the multiple available add-ons for cross-platform monitoring, flexible data transport mechanisms, or integrating passive alerts. You can rely on Nagios for server performance monitoring, capacity planning, and snapshot configurations in addition to server, network, and application monitoring.
 
-**Pros:** 
+**Pros:**
 
 1. Facilitates high availability of applications with a web-based interface and a vast library of plugins
-2. Multitude of graphical reports, dashboards for visualizing multiple end points with community support 
+2. Multitude of graphical reports, dashboards for visualizing multiple end points with community support
 
-**Cons:** 
+**Cons:**
 
-1. It can be costly, despite being an open-source solution 
+1. It can be costly, despite being an open-source solution
 2. The UI can be better in comparison to modern monitoring alternatives
 
 ### 5. Icinga
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-icinga.webp" alt="Icinga Monitoring Tool"/>
-    <figcaption><i>Icinga Monitoring Tool</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-icinga.webp"
+    alt="Icinga Monitoring Tool"
+  />
+  <figcaption>
+    <i>Icinga Monitoring Tool</i>
+  </figcaption>
 </figure>
 
+<a href="https://icinga.com" rel="noopener noreferrer nofollow" target="_blank">
+  Icinga
+</a>
+is a popular Prometheus alternative that has six core areas of focus: infrastructure monitoring,
+monitoring automation, cloud monitoring, outstanding integrations, meaningful visualizations, and
+triggered-based alerts or notifications.
 
-<a href = "https://icinga.com" rel="noopener noreferrer nofollow" target="_blank" >Icinga</a> is a popular Prometheus alternative that has six core areas of focus: infrastructure monitoring, monitoring automation, cloud monitoring, outstanding integrations, meaningful visualizations, and triggered-based alerts or notifications. 
-
-You can check availability, performance, and trends or combine and visualize metrics. You can also create reports, automate and synchronize monitoring objects with ease. It’s highly configurable and relies on active checks to monitor a system, as opposed to Prometheus’s pull-based model. 
+You can check availability, performance, and trends or combine and visualize metrics. You can also create reports, automate and synchronize monitoring objects with ease. It’s highly configurable and relies on active checks to monitor a system, as opposed to Prometheus’s pull-based model.
 
 It stores data in external databases like MySQL or PostgreSQL and doesn’t have a dedicated query language like Prometheus. However, Icinga doesn’t have great visualization options. Prometheus, often used with Grafana, has better in-built visualization capabilities. What’s special about Icinga is its advanced alerting system with flexible notification options like email or SMS.
 
-**Pros:** 
+**Pros:**
 
 1. It actively collects data, thereby facilitating more real-time alerts for faster troubleshooting
-2. Compatible with a wide range of systems with multiple integrations and plugins 
+2. Compatible with a wide range of systems with multiple integrations and plugins
 
-**Cons:** 
+**Cons:**
 
-1. High scalability depends on manual configuration entirely 
+1. High scalability depends on manual configuration entirely
 2. It can be a steep learning curve with complicated configuration options
 
 ### 6. Splunk
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-splunk.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-splunk.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://www.splunk.com/en_us/blog/platform/dashboard-studio-level-up-your-app-with-dashboard-studio.html" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a>
 
-<a href = "https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank" >Splunk</a> is a proprietary commercial-grade data management software with a built-in AI that can improve detection, investigation, and response. It can collect data accurately and efficiently from various sources and allow for real-time visualization, allowing enterprises to restore mission-critical services in seconds. 
+<a href="https://www.splunk.com" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a>
+is a proprietary commercial-grade data management software with a built-in AI that can improve
+detection, investigation, and response. It can collect data accurately and efficiently from various
+sources and allow for real-time visualization, allowing enterprises to restore mission-critical
+services in seconds.
 
-Splunk is also adept at [distributed tracing](https://signoz.io/blog/distributed-tracing/), which is ideal for troubleshooting microservices-based architectures. This is a bonus for highly scalable production environments with complex systems. It’s an SIEM with enormous searching and reporting facilities. 
+Splunk is also adept at [distributed tracing](https://signoz.io/blog/distributed-tracing/), which is ideal for troubleshooting microservices-based architectures. This is a bonus for highly scalable production environments with complex systems. It’s an SIEM with enormous searching and reporting facilities.
 
 Moreover, it can create a data source from any type of data generation. It has its own search processing language (SPL) with advanced functionalities like data search, correlation, and visualization and also more plugins and integrations than Prometheus!
 
-**Pros:** 
+**Pros:**
 
-1. Effective at automating workflows and [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) in real-time 
-2. Better scalability options with a push model that stores data in a centralized database 
+1. Effective at automating workflows and [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) in real-time
+2. Better scalability options with a push model that stores data in a centralized database
 
-**Cons:** 
+**Cons:**
 
 1. It is pricier with licensing costs, and deployment size considerations
 2. It requires a higher network overhead as it’s constantly pulling data
 
 ### 7. Logz.io
 
-<a href = "http://Logz.io" rel="noopener noreferrer nofollow" target="_blank" >Logz.io</a> isn’t a Prometheus alternative, it’s more of a wrapper that offers Prometheus as a service so that you can track logs and traces within a single platform. This implies that you’ll be able to scrape metrics using Prometheus but won’t be limited by its management, scalability, or storage, as Logz.io will take care of it.
+<a href="http://Logz.io" rel="noopener noreferrer nofollow" target="_blank">
+  Logz.io
+</a>
+isn’t a Prometheus alternative, it’s more of a wrapper that offers Prometheus as a service so that
+you can track logs and traces within a single platform. This implies that you’ll be able to scrape
+metrics using Prometheus but won’t be limited by its management, scalability, or storage, as Logz.io
+will take care of it.
 
-Perfect for cloud, hybrid, or on-premise environments, <a href = "http://Logz.io" rel="noopener noreferrer nofollow" target="_blank" >Logz.io</a> can centralize your metrics once you create an account and add a remote write to your config files. If you’re not an existing Prometheus user,you can use the Telemetry [Collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/), which will help collect metrics for further storage and analysis.  
+Perfect for cloud, hybrid, or on-premise environments, <a href = "http://Logz.io" rel="noopener noreferrer nofollow" target="_blank" >Logz.io</a> can centralize your metrics once you create an account and add a remote write to your config files. If you’re not an existing Prometheus user,you can use the Telemetry [Collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/), which will help collect metrics for further storage and analysis.
 
-With log management, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), and distributed tracing as its main areas of strength, <a href = "http://Logz.io" rel="noopener noreferrer nofollow" target="_blank" >Logz.io</a> is replacing traditional APM as a cloud-based SIEM. You can use pre-built dashboards, create newer ones, or migrate older dashboards to correlate data easily. In fact, its data optimization hub can help you filter out low-priority data. 
+With log management, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), and distributed tracing as its main areas of strength, <a href = "http://Logz.io" rel="noopener noreferrer nofollow" target="_blank" >Logz.io</a> is replacing traditional APM as a cloud-based SIEM. You can use pre-built dashboards, create newer ones, or migrate older dashboards to correlate data easily. In fact, its data optimization hub can help you filter out low-priority data.
 
-**Pros:** 
+**Pros:**
 
 1. Faster troubleshooting with reduced costs to improve system health, performance, and security
 2. 300+ integrations to monitor any stack, and quick and easy onboarding functionalities
 
-**Cons:** 
+**Cons:**
 
-1. Customer service isn’t exceptional 
+1. Customer service isn’t exceptional
 2. You can process a limited number of logs daily, and bypassing this requires expensive add-on purchases
 
 ### 8. VictoriaMetrics
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-victoriametrics.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-victoriametrics.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://docs.victoriametrics.com/operator/monitoring" rel="noopener noreferrer nofollow" target="_blank" >VictoriaMetrics</a>
 
-VictoriaMetrics is a superior Prometheus alternative that’s known for being more resource-efficient. It’s an open-source observability solution that is easy to configure and operate, ideal for long-term metrics storage and multi-tenancy support. 
+VictoriaMetrics is a superior Prometheus alternative that’s known for being more resource-efficient. It’s an open-source observability solution that is easy to configure and operate, ideal for long-term metrics storage and multi-tenancy support.
 
-It offers the same features as Prometheus does, but has additional benefits like high performance, high scalability, and anomaly detection for troubleshooting. While scraping data, Prometheus uses more resources in comparison to VictoriaMetrics. Its query language MetricsQL allows you to do more than PromQL. You can use Remotewrite to configure VictoriaMetrics to read data from Prometheus. 
+It offers the same features as Prometheus does, but has additional benefits like high performance, high scalability, and anomaly detection for troubleshooting. While scraping data, Prometheus uses more resources in comparison to VictoriaMetrics. Its query language MetricsQL allows you to do more than PromQL. You can use Remotewrite to configure VictoriaMetrics to read data from Prometheus.
 
-**Pros:** 
+**Pros:**
 
 1. More effective data compression capabilities than other alternatives
 2. It can be used as a long-term storage solution for Prometheus with fast backups, and advanced data ingestion and querying
 
-**Cons:** 
+**Cons:**
 
 1. It can be pricier, especially while dealing with large volumes of data
 2. The graphical user interface can be enhanced
 
 ### 9. TimescaleDB + Telegraf + Grafana
 
-TimescaleDB, Telegraf, and Grafana come together to make a powerful application monitoring stack. TimescaleDB helps you store time-series data in a highly scalable platform for real-time and historical analysis. 
+TimescaleDB, Telegraf, and Grafana come together to make a powerful application monitoring stack. TimescaleDB helps you store time-series data in a highly scalable platform for real-time and historical analysis.
 
 Telegraf collects, aggregates, and sends metrics and events, which get stored in TimescaleDB. Then, Grafana helps you visualize this data. When you have a TimescaleDB instance running, you’ll be able to query the data and build real-time dashboards. Furthermore, TimescaleDB makes it exceptionally easy to get the data out, thereby reducing time and lessening the learning curve.
 
-Telegraf, with its data collection, is here to evaluate database performance and application response time. Grafana can help you set up alert rules and dispatch timely notifications for faster troubleshooting. 
+Telegraf, with its data collection, is here to evaluate database performance and application response time. Grafana can help you set up alert rules and dispatch timely notifications for faster troubleshooting.
 
-**Pros:** 
+**Pros:**
 
 1. Purpose-built tools allow you more flexibility to collect data and visualize metrics
-2. You’re able to have an eye on all application layers to ensure a seamless and optimized user experience 
+2. You’re able to have an eye on all application layers to ensure a seamless and optimized user experience
 
-**Cons:** 
+**Cons:**
 
-1. You have to use three separate tools 
+1. You have to use three separate tools
 2. It might require more manual intervention to manage them
 
 ### 10. Sensu
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-sensu.webp" alt=""/>
-    <figcaption><i></i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-sensu.webp"
+    alt=""
+  />
+  <figcaption>
+    <i></i>
+  </figcaption>
 </figure>
 
-
 Source: <a href = "https://sensu.io/blog/sensu-metrics-collection-beafdebf28bc" rel="noopener noreferrer nofollow" target="_blank" >Sensu</a>
 
-<a href = "https://sensu.io" rel="noopener noreferrer nofollow" target="_blank" >Sensu</a> is an observability platform that offers monitoring-as-code for DevOps and SRE teams. It’s designed for the cloud and open-source and lets you visualize every protocol across a single dashboard view. This Prometheus alternative has different functionalities than Prometheus but lets you automate workflows, enjoy instant visibility, and integrate tools and plugins for a seamless experience.
+<a href="https://sensu.io" rel="noopener noreferrer nofollow" target="_blank">
+  Sensu
+</a>
+is an observability platform that offers monitoring-as-code for DevOps and SRE teams. It’s designed
+for the cloud and open-source and lets you visualize every protocol across a single dashboard view.
+This Prometheus alternative has different functionalities than Prometheus but lets you automate
+workflows, enjoy instant visibility, and integrate tools and plugins for a seamless experience.
 
-It’s known for its flexible, API-rich [observability pipeline](https://signoz.io/guides/observability-pipeline/), but it doesn’t have a data storage backend. In fact, it relies on time-series databases like Prometheus or Graphite. It’s not that efficient at alerting like Prometheus. However, it’s effective for monitoring data. 
+It’s known for its flexible, API-rich [observability pipeline](https://signoz.io/guides/observability-pipeline/), but it doesn’t have a data storage backend. In fact, it relies on time-series databases like Prometheus or Graphite. It’s not that efficient at alerting like Prometheus. However, it’s effective for monitoring data.
 
-**Pros:** 
+**Pros:**
 
 1. Perfect for multi-cloud monitoring, with container monitoring being the best
-2. Easy to set up this centralized monitoring management platform, and push and pull models make it flexible 
+2. Easy to set up this centralized monitoring management platform, and push and pull models make it flexible
 
-**Cons:** 
+**Cons:**
 
-1. Built-in alerting and notification triggers could be more advanced 
+1. Built-in alerting and notification triggers could be more advanced
 2. Scalability can be difficult as it doesn’t have a native federated architecture
 
 ### 11. Mimir by Grafana (open-source)
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/prometheus-alternatives-mimir.webp" alt="Mimir + Grafana metrics monitoring"/>
-    <figcaption><i>Mimir + Grafana metrics monitoring</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/prometheus-alternatives-mimir.webp"
+    alt="Mimir + Grafana metrics monitoring"
+  />
+  <figcaption>
+    <i>Mimir + Grafana metrics monitoring</i>
+  </figcaption>
 </figure>
 
-
 Mimir is an open-source, horizontally scalable time-series database provided by Grafana.
 
-It extends the Prometheus ecosystem with a focus on horizontal scalability and long-term storage. Designed to be API-compatible with Prometheus, Mimir allows for seamless integration with existing Prometheus setups but distinguishes itself by enabling massive scale across multiple nodes and clusters. 
+It extends the Prometheus ecosystem with a focus on horizontal scalability and long-term storage. Designed to be API-compatible with Prometheus, Mimir allows for seamless integration with existing Prometheus setups but distinguishes itself by enabling massive scale across multiple nodes and clusters.
 
 It offers durable, long-term storage capabilities and is built to handle billions of metrics across many tenants, addressing the scalability and multi-tenancy limitations of Prometheus. Mimir's architecture facilitates easier management of large-scale monitoring environments, providing robustness and resilience without sacrificing Prometheus's core strengths.
 
@@ -320,4 +394,4 @@ SigNoz can be a great [Prometheus alternative](https://signoz.io/comparisons/pro
 
 [Datadog vs Prometheus - Key Differences](https://signoz.io/blog/datadog-vs-prometheus/)
 
-[OpenTelemetry vs Prometheus Detailed Comparison](https://signoz.io/blog/opentelemetry-vs-prometheus/)
\ No newline at end of file
+[OpenTelemetry vs Prometheus Detailed Comparison](https://signoz.io/blog/opentelemetry-vs-prometheus/)
diff --git a/data/comparisons/prometheus-vs-grafana.mdx b/data/comparisons/prometheus-vs-grafana.mdx
index fe63f7208..9d5c08e7a 100644
--- a/data/comparisons/prometheus-vs-grafana.mdx
+++ b/data/comparisons/prometheus-vs-grafana.mdx
@@ -1,26 +1,31 @@
 ---
 title: Prometheus vs Grafana - Which Tool is Right for You?
-slug: prometheus-vs-grafana
+
 date: 2024-06-11
 tags: [tools-comparison]
 authors: [daniel]
 description: Prometheus specializes in robust metric collection, monitoring, and alerting, while Grafana excels in data visualization and dashboarding. We have compared Prometheus and Grafana on important features like data collection, visualization capabilities...
 image: /img/blog/2024/02/prometheus-vs-grafana-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [prometheus,grafana,opentelemetry,open-source,monitoring-tools,signoz]
+keywords: [prometheus, grafana, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Prometheus and Grafana are popularly used tools for monitoring applications and systems. Prometheus specializes in robust metric collection, monitoring, and alerting, while Grafana excels in data visualization and dashboarding. 
+
+Prometheus and Grafana are popularly used tools for monitoring applications and systems. Prometheus specializes in robust metric collection, monitoring, and alerting, while Grafana excels in data visualization and dashboarding.
 
 Together, they form a powerful duo, allowing users to monitor their systems effectively, [analyze metrics](https://signoz.io/blog/metrics-explorer/) comprehensively, and visualize insights intuitively, but how well do these tools perform individually in the [Prometheus vs](https://signoz.io/comparisons/prometheus-alternatives/) Grafana comparison?
 
 <Admonition type="info">
-💡 I configured a sample PHP application alongside a MySQL database and sent their data to Prometheus and Grafana for evaluation. Some takeaways are subjective and based on personal preference.
+  💡 I configured a sample PHP application alongside a MySQL database and sent their data to
+  Prometheus and Grafana for evaluation. Some takeaways are subjective and based on personal
+  preference.
 </Admonition>
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-cover.webp"
+    alt=""
+  />
 </figure>
 
 In this article, I have discussed the differences between Prometheus and Grafana regarding important features like data collection, visualization capabilities, data query, and data storage.
@@ -28,19 +33,19 @@ Finally, I have discussed common use cases to help you decide which tool is best
 
 ## Prometheus vs Grafana: Overview
 
-| Features | Prometheus | Grafana |
-| --- | --- | --- |
-| Data Collection | 🟡 Limited | ✅ Available |
-| Visualization Capabilities | 🟡 Limited | ✅ Available |
-| Data Query | ✅ Available | ✅ Available |
-| Log management | ❌ Does not exist | ✅ Available |
-| APM | 🟡 Limited | ✅ Available |
-| Data Storage | 🟡 Limited | ✅ Available |
-| Alerting | ✅ Available | ✅ Available |
-| UI/UX | 🟡 Limited | ✅ Available |
-| Cloud Option | ❌ Does not exist | ✅ Available |
-| Pricing | ✅ Free | 🟡 Freemium |
-| Documentation & Community Support | 🟡 Limited | ✅ Available |
+| Features                          | Prometheus        | Grafana      |
+| --------------------------------- | ----------------- | ------------ |
+| Data Collection                   | 🟡 Limited        | ✅ Available |
+| Visualization Capabilities        | 🟡 Limited        | ✅ Available |
+| Data Query                        | ✅ Available      | ✅ Available |
+| Log management                    | ❌ Does not exist | ✅ Available |
+| APM                               | 🟡 Limited        | ✅ Available |
+| Data Storage                      | 🟡 Limited        | ✅ Available |
+| Alerting                          | ✅ Available      | ✅ Available |
+| UI/UX                             | 🟡 Limited        | ✅ Available |
+| Cloud Option                      | ❌ Does not exist | ✅ Available |
+| Pricing                           | ✅ Free           | 🟡 Freemium  |
+| Documentation & Community Support | 🟡 Limited        | ✅ Available |
 
 Prometheus and Grafana are powerful tools with distinct strengths:
 
@@ -51,8 +56,6 @@ For comprehensive monitoring and observability, Grafana, with its integrated sta
 
 **Let's dive deep into each parameter mentioned above for a better understanding.**
 
-
-
 ## Ease of Deployment: Tie
 
 ### Prometheus
@@ -70,6 +73,7 @@ I deployed Grafana using Docker; the time this would take will depend on your in
 Grafana also has a cloud version known as Grafana Cloud. This version doesn’t require management of Grafana as it is hosted in the cloud, all it takes is for users to sign up and use.
 
 ### Verdict
+
 **Which is easier to deploy between Prometheus vs Grafana?**
 
 Both Prometheus and Grafana offer straightforward deployment options with Docker, making them equally easy to deploy.
@@ -80,9 +84,15 @@ Both Prometheus and Grafana offer straightforward deployment options with Docker
 
 Prometheus excels at collecting data from a diverse range of sources. It uses client libraries to expose metrics via HTTP endpoints, which are then scraped and sent to the Prometheus server.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-http-endpoints.webp" alt="HTTP endpoints Prometheus is scraping metrics from"/>
-<figcaption><i>HTTP endpoints Prometheus is scraping metrics from</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-http-endpoints.webp"
+    alt="HTTP endpoints Prometheus is scraping metrics from"
+  />
+  <figcaption>
+    <i>HTTP endpoints Prometheus is scraping metrics from</i>
+  </figcaption>
 </figure>
 
 Additionally, it utilizes exporters to transform metrics from third-party systems into a format that Prometheus can process. For dynamic monitoring, Prometheus leverages file-based service discovery to identify and track targets. It also supports remote endpoints for flexible data collection. This approach allows Prometheus to effectively collect metrics from various sources.
@@ -91,12 +101,19 @@ Additionally, it utilizes exporters to transform metrics from third-party system
 
 Grafana has built-in support for many data sources. For additional data sources that are not natively supported, Grafana offers a robust ecosystem of data source plugins. These plugins extend Grafana's capabilities, allowing users to integrate a variety of data sources into their dashboards. If a required data source plugin is not available, Grafana's open-source nature enables the development of custom plugins.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-datasources.webp" alt="Data sources in Grafana"/>
-<figcaption><i>Data sources in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-datasources.webp"
+    alt="Data sources in Grafana"
+  />
+  <figcaption>
+    <i>Data sources in Grafana</i>
+  </figcaption>
 </figure>
 
 ### Verdict
+
 **Which tool has better data collection capabilities between Prometheus vs Grafana?**
 
 Prometheus and Grafana both have great data collection capabilities, but Grafana can collect data from a wider range of data sources, making it more versatile.
@@ -109,14 +126,26 @@ Prometheus and Grafana both have great data collection capabilities, but Grafana
 
 Prometheus has limited visualization capabilities. The built-in expression browser is the primary tool for querying and visualizing data within Prometheus. It offers two main visualization options: a table and a graph. These visualizations are useful for understanding the trends and patterns in the data over time. The expression browser is not as comprehensive or user-friendly as other visualization tools; it’s very basic.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-table-visualization.webp" alt="Table visualization in Prometheus"/>
-<figcaption><i>Table visualization</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-table-visualization.webp"
+    alt="Table visualization in Prometheus"
+  />
+  <figcaption>
+    <i>Table visualization</i>
+  </figcaption>
 </figure>
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-graph-visualisation.webp" alt="Graph visualization in Prometheus"/>
-<figcaption><i>Graph visualization</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-graph-visualisation.webp"
+    alt="Graph visualization in Prometheus"
+  />
+  <figcaption>
+    <i>Graph visualization</i>
+  </figcaption>
 </figure>
 
 ### Grafana
@@ -125,19 +154,32 @@ Grafana is known for its excellent visualization capabilities. It offers a wide
 
 It can also suggest visualization types based on the queries or data available. This feature presents a preview to users, aiding them in making an informed choice about the type of visualization that best represents their data.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-visualization-suggestion.webp" alt="Visualization suggestion in Grafana"/>
-<figcaption><i>Visualization suggestion</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-visualization-suggestion.webp"
+    alt="Visualization suggestion in Grafana"
+  />
+  <figcaption>
+    <i>Visualization suggestion</i>
+  </figcaption>
 </figure>
 
 Grafana has highly customizable dashboards, allowing users to fine-tune their visualizations through panel options. Users have the flexibility to add and configure panels, define metrics, and customize the appearance of visual elements to suit their specific needs. These dashboards can also be shared with others, facilitating collaboration for teams.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-mysql-dashboard.webp" alt="MySQL database dashboard in Grafana"/>
-<figcaption><i>MySQL database dashboard in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-mysql-dashboard.webp"
+    alt="MySQL database dashboard in Grafana"
+  />
+  <figcaption>
+    <i>MySQL database dashboard in Grafana</i>
+  </figcaption>
 </figure>
 
 ### Verdict
+
 **Which tool offers better visualization capabilities between Prometheus vs Grafana?**
 
 When comparing Prometheus vs Grafana in terms of visualization capabilities, Grafana is the preferred choice for users seeking robust and versatile visualizations.
@@ -154,12 +196,19 @@ Grafana, in conjunction with Loki, offers a robust solution for log management.
 
 Loki allows you to store and query logs from all your applications and infrastructure, without worrying about log volumes, costs, or storage limits.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-log.webp" alt="Log management with Loki in Grafana"/>
-<figcaption><i>Log management with Loki in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-log.webp"
+    alt="Log management with Loki in Grafana"
+  />
+  <figcaption>
+    <i>Log management with Loki in Grafana</i>
+  </figcaption>
 </figure>
 
 ### Verdict
+
 **Which tool offers better log management between Prometheus vs Grafana?**
 
 When it comes to log management in the [Prometheus vs Grafana](https://signoz.io/comparisons/prometheus-vs-grafana/#prometheus-vs-grafana-overview) comparison, Grafana, with Loki, provides a comprehensive and scalable solution for aggregating and querying logs.
@@ -185,40 +234,58 @@ Here's a streamlined overview of how the Grafana stack supports Application Perf
 - **Grafana**: Provides customizable dashboards for visualizing key performance indicators (KPIs) from applications, trace data, and log data to identify patterns, trends, and anomalies in your application's performance.
 
 ### Verdict
+
 **Which tool offers better APM capabilities between Prometheus vs Grafana?**
 
 When comparing Prometheus vs Grafana for APM capabilities, Grafana, with its integrated stack, offers a more comprehensive solution for detailed application performance monitoring.
 
-
-
 ## Data Query: Tie
 
 ### Prometheus
 
 Prometheus provides a powerful and flexible querying language known as PromQL ([Prometheus Query Language](https://signoz.io/blog/prometheus-query/)) for querying and analyzing time-series data. PromQL allows users to perform a wide range of operations, including filtering, aggregation, and mathematical transformations, on the collected metrics data. Users can write expressive queries to extract valuable insights and monitor system performance effectively. With support for functions like rate, sum, and histogram_quantile, PromQL enables advanced analysis and visualization of metrics data.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-promql.webp" alt="Query in Prometheus using PromQL"/>
-<figcaption><i>Query in Prometheus using PromQL</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-promql.webp"
+    alt="Query in Prometheus using PromQL"
+  />
+  <figcaption>
+    <i>Query in Prometheus using PromQL</i>
+  </figcaption>
 </figure>
 
 ### Grafana
 
 Grafana's data query functionality is specific to the data source in use. For instance, if you have configured Prometheus with a MySQLD exporter to collect metrics from a MySQL database and you subsequently select Prometheus as the data source within Grafana, your data queries will be executed using PromQL. You can see an example, as shown in the image below.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-promql-in-grafana.webp" alt="PromQL queries in Grafana with Prometheus as datasource"/>
-<figcaption><i>PromQL queries in Grafana with Prometheus as datasource</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-promql-in-grafana.webp"
+    alt="PromQL queries in Grafana with Prometheus as datasource"
+  />
+  <figcaption>
+    <i>PromQL queries in Grafana with Prometheus as datasource</i>
+  </figcaption>
 </figure>
 
 Similarly, if MySQL is configured as the direct data source in Grafana, the queries executed will be SQL queries, which are native to the MySQL database system.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-sql-in-grafana.webp" alt="SQL query in Grafana with MySQL as data source"/>
-<figcaption><i>SQL query in Grafana with MySQL as data source</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-sql-in-grafana.webp"
+    alt="SQL query in Grafana with MySQL as data source"
+  />
+  <figcaption>
+    <i>SQL query in Grafana with MySQL as data source</i>
+  </figcaption>
 </figure>
 
 ### Verdict
+
 **Which tool offers better data query capabilities between Prometheus vs Grafana?**
 
 Overall, both Prometheus and Grafana have good data query capabilities, each excelling in different areas depending on the data source and use case.
@@ -238,6 +305,7 @@ Grafana uses Mimir, a part of the Grafana stack for metrics storage. Mimir is an
 Mimir's architecture is structured to support up to 1 billion metrics, enabling it to offer rapid query performance. It ensures high availability, durable storage, and is capable of scaling horizontally to meet the demands of large-scale deployments.
 
 ### Verdict
+
 **Which tool offers better data storage capabilities between Prometheus vs Grafana?**
 
 When we compare Prometheus vs Grafana in terms of data storage, Grafana’s Mimir provides a more scalable and robust solution for long-term storage of metrics.
@@ -250,25 +318,43 @@ Prometheus does not provide a built-in feature for configuring alert rules direc
 
 Users define alerting rules using PromQL, setting conditions based on the collected metrics. When these conditions are met, Prometheus generates alert instances.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-alerts.webp" alt="Alerts in Prometheus"/>
-<figcaption><i>Alerts in Prometheus</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-alerts.webp"
+    alt="Alerts in Prometheus"
+  />
+  <figcaption>
+    <i>Alerts in Prometheus</i>
+  </figcaption>
 </figure>
 
 These instances are then forwarded to Alertmanager, which handles deduplication, grouping, and routing for prompt notification to email, Slack, PagerDuty, OpsGenie, etc.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-alertmanager.webp" alt="Triggered alerts sent to Alertmanager from Prometheus"/>
-<figcaption><i>Triggered alerts sent to Alertmanager</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-alertmanager.webp"
+    alt="Triggered alerts sent to Alertmanager from Prometheus"
+  />
+  <figcaption>
+    <i>Triggered alerts sent to Alertmanager</i>
+  </figcaption>
 </figure>
 
 ### Grafana
 
 Grafana allows users to create alerts based on queries and expressions from multiple data sources. Alerting rules are configured through the UI, providing a visually intuitive approach. Users can set up alert rules, add labels, and define notification policies to specify where, when, and how notifications are routed.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-alert-rules.webp" alt="Alert rules in Grafana"/>
-<figcaption><i>Alert rules in Grafana</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-alert-rules.webp"
+    alt="Alert rules in Grafana"
+  />
+  <figcaption>
+    <i>Alert rules in Grafana</i>
+  </figcaption>
 </figure>
 
 If you want to keep your alerting system separate from your visualization layer, Prometheus's Alertmanager is an excellent choice, as it is a dedicated component offering enhanced flexibility and customization for managing alerts.
@@ -276,6 +362,7 @@ If you want to keep your alerting system separate from your visualization layer,
 If you are already utilizing Grafana for visualization and require a comprehensive, integrated alerting solution, then Grafana's alerting features would be the appropriate choice for your needs.
 
 ### Verdict
+
 **Which tool offers better alerting capabilities between Prometheus vs Grafana?**
 
 In the Prometheus vs Grafana comparison, each tool provides unique advantages for alerting, depending on your specific requirements and setup.
@@ -291,6 +378,7 @@ Prometheus does not offer a cloud service or option. This means users are respon
 Grafana, on the other hand, offers a fully managed cloud service known as  <a href = "https://grafana.com/products/cloud" rel="noopener noreferrer nofollow" target="_blank" >Grafana Cloud</a>. This service provides a seamless experience for deploying, managing, and scaling Grafana dashboards and data sources. Grafana Cloud eliminates the need for manual setup and maintenance, allowing teams to focus on creating and sharing insights from their data. It's an excellent choice for organizations looking for a hassle-free monitoring solution that requires minimal operational overhead.
 
 ### Verdict
+
 **Which tool offers better cloud options between Prometheus vs Grafana?**
 
 In the Prometheus vs Grafana comparison for cloud options, Grafana stands out with its managed cloud service, offering ease of use and reduced operational overhead.
@@ -301,28 +389,40 @@ In the Prometheus vs Grafana comparison for cloud options, Grafana stands out wi
 
 Prometheus provides a basic web interface, primarily focused on querying and visualizing time series data. The UI is functional but relatively minimalistic, with options for executing PromQL queries, viewing graphs, and exploring metrics. The user experience in Prometheus is straightforward and intuitive.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-prometheus-ui.webp" alt="Prometheus UI"/>
-<figcaption><i>Prometheus UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-prometheus-ui.webp"
+    alt="Prometheus UI"
+  />
+  <figcaption>
+    <i>Prometheus UI</i>
+  </figcaption>
 </figure>
 
 ### Grafana
 
 Grafana offers a visually appealing and robust UI, compared to Prometheus. It has a user-friendly interface for easy navigation and interaction. The user experience in Grafana is designed to be intuitive and accessible.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/02/prometheus-vs-grafana-ui-grafana.webp" alt="Grafana UI"/>
-<figcaption><i>Grafana UI</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/02/prometheus-vs-grafana-ui-grafana.webp"
+    alt="Grafana UI"
+  />
+  <figcaption>
+    <i>Grafana UI</i>
+  </figcaption>
 </figure>
 
 Both tools offer satisfactory user experiences, but Grafana has richer UI functionality compared to Prometheus. Grafana not only provides a visually appealing interface but also offers a broader range of features and customization options.
 
 ### Verdict
+
 **Which tool offers better UI/UX between Prometheus vs Grafana?**
 
 Both tools offer satisfactory user experiences, but Grafana has richer UI functionality compared to Prometheus. Grafana not only provides a visually appealing interface but also offers a broader range of features and customization options.
 
-
 ## Pricing: Prometheus Wins
 
 ### Prometheus
@@ -336,6 +436,7 @@ Grafana's open-source offering is available at no cost, making it accessible to
 Grafana’s paid cloud option, Grafana Cloud, provides a range of pricing options to cater to various user requirements. The free forever plan includes a set of limited resources, encompassing metrics, visualizations, logs, traces, and profiles. Users looking to scale monitoring and visualization can opt for the pay-as-you-go model with no upfront costs, starting at \$0, or the advanced premium bundle starting at \$299 per month.
 
 ### Verdict
+
 Which tool offers better pricing options between Prometheus vs Grafana?
 
 Prometheus, being completely open-source and free, offers a cost-effective solution for organizations of all sizes. Grafana also provides an open-source version for free, but its paid cloud option, Grafana Cloud, caters to users looking for more advanced features and scalability, starting at $0 with a pay-as-you-go model.
@@ -351,6 +452,7 @@ Prometheus has very comprehensive and easy-to-understand documentation. The  <a
 Grafana also provides comprehensive documentation that is accessible and easy to navigate. The  <a href = "https://grafana.com/community/?plcmt=learn-nav" rel="noopener noreferrer nofollow" target="_blank" >Grafana community</a> is vibrant and supportive, with a variety of channels for engagement, including online forums, social media groups, official community events like webinars and workshops, and a comprehensive library of educational videos and materials.
 
 ### Verdict
+
 **Which tool offers better documentation and community support between Prometheus vs Grafana?**
 
 Overall, both Prometheus and Grafana have excellent documentation and active communities for support. However, Grafana, being a self-hosted and managed service, provides more extensive support channels and resources for users.
@@ -371,31 +473,35 @@ For effective monitoring and observability of your applications, all your teleme
 
 ## A better Prometheus and Grafana Alternative: SigNoz
 
-SigNoz is a full-stack open-source application performance monitoring and observability tool that serves as an excellent Prometheus and Grafana alternative. 
+SigNoz is a full-stack open-source application performance monitoring and observability tool that serves as an excellent Prometheus and Grafana alternative.
 
 **Why SigNoz?** <br />
 Because it consolidates logs, metrics, and traces under a single pane of glass, providing complete telemetry signals simplifying your workflows as compared to Grafana. SigNoz is also cost-effective, as you are charged only for the amount of telemetry data sent.
 
-<figure data-zoomable align='center'>
-<img className="box-shadowed-image" src="/img/blog/2024/06/signoz-thumbnail.webp" alt="SigNoz Thumbnail"/>
-<figcaption><i>SigNoz</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/06/signoz-thumbnail.webp"
+    alt="SigNoz Thumbnail"
+  />
+  <figcaption>
+    <i>SigNoz</i>
+  </figcaption>
 </figure>
 
-
 Some of the key features of SigNoz are:
 
-* **Comprehensive Monitoring**: Out-of-the-box charts for application metrics such as request latency, and custom dashboards for monitoring infrastructure.
-* **Effortless Correlation**: Easily correlate metrics and traces with a single click, simplifying root cause analysis and performance troubleshooting.
-* **Built-in Alerting**: In-built alerting feature that ensures you are promptly notified of any anomalies or performance issues.
-* **Seamless Integration**: Support for Prometheus remote read, facilitating a smooth transition from Prometheus to SigNoz for metrics monitoring.
-* **Advanced Log Management**: Excellent log management capabilities with features like a log [query builder](https://signoz.io/blog/query-builder-v5/), multi-field search, structured table views, and JSON views.
-* **Native [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Support**: Native integration with OpenTelemetry, aligning with the industry standard for telemetry data.
-* **End-to-End Tracing**: End-to-end distributed tracing to gain complete visibility of your services.
-* **High-Performance Database**: Utilizes Clickhouse, a high-performance OLAP database, for efficient data ingestion and aggregation.
+- **Comprehensive Monitoring**: Out-of-the-box charts for application metrics such as request latency, and custom dashboards for monitoring infrastructure.
+- **Effortless Correlation**: Easily correlate metrics and traces with a single click, simplifying root cause analysis and performance troubleshooting.
+- **Built-in Alerting**: In-built alerting feature that ensures you are promptly notified of any anomalies or performance issues.
+- **Seamless Integration**: Support for Prometheus remote read, facilitating a smooth transition from Prometheus to SigNoz for metrics monitoring.
+- **Advanced Log Management**: Excellent log management capabilities with features like a log [query builder](https://signoz.io/blog/query-builder-v5/), multi-field search, structured table views, and JSON views.
+- **Native [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Support**: Native integration with OpenTelemetry, aligning with the industry standard for telemetry data.
+- **End-to-End Tracing**: End-to-end distributed tracing to gain complete visibility of your services.
+- **High-Performance Database**: Utilizes Clickhouse, a high-performance OLAP database, for efficient data ingestion and aggregation.
 
 For a detailed comparison between Grafana and SigNoz, check out [this comprehensive article.](https://signoz.io/product-comparison/signoz-vs-grafana/)
 
-
 ## Getting Started with SigNoz
 
 <GetStartedSigNoz />
@@ -405,33 +511,43 @@ For a detailed comparison between Grafana and SigNoz, check out [this comprehens
 We have answered a few common questions that developers often have around Prometheus and Grafana below:
 
 ### Is Prometheus the same as Grafana?
+
 No, Prometheus and Grafana serve different purposes. Prometheus is used for metrics collection and monitoring, while Grafana excels in data visualization and dashboarding.
 
 ### Is it possible to use Grafana without Prometheus?
+
 Yes, Grafana supports a wide range of data sources and can be used without Prometheus.
 
 ### What is the difference between Grafana and Prometheus and Kibana?
+
 Prometheus is a monitoring tool for metrics, Grafana is a visualization tool for various data sources, and Kibana is a visualization tool specifically for Elasticsearch data.
 
 ### What is Prometheus and Grafana in DevOps?
+
 Prometheus and Grafana are used in DevOps for monitoring and visualizing application and system metrics, aiding in performance analysis and alerting.
 
 ### What is Prometheus used for?
+
 Prometheus is used for collecting and storing metrics data, which helps in monitoring the performance and health of applications and infrastructure.
 
 ### Is Prometheus better than CloudWatch?
+
 Prometheus and CloudWatch have different strengths. Prometheus is open-source and customizable, while CloudWatch is a managed service integrated with AWS.
 
 ### What is better than Grafana?
+
 The choice depends on specific needs. SigNoz offers integrated monitoring and observability in a single pane, which might be better for some use cases.
 
 ### What are the disadvantages of Prometheus?
+
 Prometheus lacks long-term storage and native log management, requiring integration with other tools for comprehensive monitoring.
 
 ### Is Grafana better than Kibana?
+
 Grafana and Kibana serve different purposes. Grafana supports multiple data sources and is highly customizable, while Kibana is tailored for Elasticsearch.
 
 ### Is Prometheus and Grafana free?
+
 Yes, both Prometheus and Grafana have open-source versions available for free.
 
 ---
@@ -441,5 +557,3 @@ Yes, both Prometheus and Grafana have open-source versions available for free.
 [SigNoz vs Grafana](https://signoz.io/product-comparison/signoz-vs-grafana/)
 
 [An open source OpenTelemetry APM](https://signoz.io/blog/opentelemetry-apm/)
-
-
diff --git a/data/comparisons/sentry-alternatives.mdx b/data/comparisons/sentry-alternatives.mdx
index 3a1f074fc..d9653629c 100644
--- a/data/comparisons/sentry-alternatives.mdx
+++ b/data/comparisons/sentry-alternatives.mdx
@@ -1,6 +1,6 @@
 ---
 title: Top 10 Sentry Alternatives for Error Tracking in 2025
-slug: sentry-alternatives
+
 date: 2025-01-09
 tags: [sentry, observability]
 authors: [soumya_gupta]
@@ -247,7 +247,8 @@ To get started with SigNoz cloud:
 3. Start monitoring your application errors and performance in real-time
 
 <KeyPointCallout>
-SigNoz stands out as a comprehensive open-source alternative to Sentry, offering full-stack observability with complete data ownership and native OpenTelemetry support.
+  SigNoz stands out as a comprehensive open-source alternative to Sentry, offering full-stack
+  observability with complete data ownership and native OpenTelemetry support.
 </KeyPointCallout>
 
 ## 2. Better Stack
@@ -377,7 +378,8 @@ Better Stack excels in log management and error tracking, making it ideal for te
 | **Compliance** | SOC 2 Type II-compliant, GDPR-compliant, provides audit logs, and offers SSO integrations.             | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     |
 
 <KeyPointCallout>
-Better Stack excels in log management and real-time monitoring, with a focus on intuitive error tracking and transparent, usage-based pricing.
+  Better Stack excels in log management and real-time monitoring, with a focus on intuitive error
+  tracking and transparent, usage-based pricing.
 </KeyPointCallout>
 
 ## 3. LogRocket
@@ -478,7 +480,8 @@ For mobile sessions, **LogRocket tracks real-time network throughput, memory usa
 | **Compliance** | SOC II compliance, GDPR & CCPA compliance, PII audit, Data erasure                                                                                        | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     |
 
 <KeyPointCallout>
-LogRocket differentiates itself with powerful session replay capabilities and detailed user interaction tracking, making it ideal for customer-facing applications.
+  LogRocket differentiates itself with powerful session replay capabilities and detailed user
+  interaction tracking, making it ideal for customer-facing applications.
 </KeyPointCallout>
 
 ## 4. Dynatrace
@@ -504,17 +507,17 @@ It's a feature-packed, enterprise-ready monitoring solution, which often makes i
     caption="Automated Discovery with Dynatrace"
   />
 
-  Here's how it works: 
+  Here's how it works:
   - **Install OneAgent:** <br/>
-    Install Dynatrace's OneAgent once per host. This is a single binary file containing specialized services tailored for your monitoring environment. 
+    Install Dynatrace's OneAgent once per host. This is a single binary file containing specialized services tailored for your monitoring environment.
   - **Automatic Discovery:** <br/>
-    Within minutes, Dynatrace's Smartscape technology automatically detects all components and dependencies in your technology stack, including applications, services, processes, hosts, networks, and infrastructure. It gathers metrics on hardware, OS, and application processes. 
+    Within minutes, Dynatrace's Smartscape technology automatically detects all components and dependencies in your technology stack, including applications, services, processes, hosts, networks, and infrastructure. It gathers metrics on hardware, OS, and application processes.
   - **Process Detection:** <br/>
-    OneAgent detects all running processes on the host, including specific technologies like Java, Node.js, and .NET. It injects itself into these processes for detailed, code-level monitoring. 
+    OneAgent detects all running processes on the host, including specific technologies like Java, Node.js, and .NET. It injects itself into these processes for detailed, code-level monitoring.
   - **Automatic Instrumentation:** <br/>
-    Based on the detected processes, OneAgent automatically activates instrumentation specifically for your stack. It injects tags into web application pages for real-user monitoring, tracking response times and performance in mobile and desktop browsers. 
+    Based on the detected processes, OneAgent automatically activates instrumentation specifically for your stack. It injects tags into web application pages for real-user monitoring, tracking response times and performance in mobile and desktop browsers.
   - **On-the-Fly Updates:** <br/>
-    As new components are introduced, Dynatrace automatically instruments them in real-time, ensuring that all dependencies are continuously tracked and monitored. 
+    As new components are introduced, Dynatrace automatically instruments them in real-time, ensuring that all dependencies are continuously tracked and monitored.
   - **Dynamic Topology:** <br/>
     The entire application topology, including relationships between components, is displayed visually in a dynamic and interactive way, providing full visibility into your environment.
 
@@ -596,7 +599,8 @@ Dynatrace offers a more comprehensive monitoring solution but may be overkill fo
 | **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | SOC 2, GDPR, HIPAA,                                                   |
 
 <KeyPointCallout>
-Dynatrace provides enterprise-grade monitoring with AI-powered insights, ideal for complex infrastructures requiring comprehensive observability.
+  Dynatrace provides enterprise-grade monitoring with AI-powered insights, ideal for complex
+  infrastructures requiring comprehensive observability.
 </KeyPointCallout>
 
 ## 5. AppSignal
@@ -665,29 +669,30 @@ and JavaScript environments, offering deep integrations that enhance workflow.
 
 #### Customizations and integrations
 
-   - **Framework-Specific Integrations**
-     AppSignal specializes in **Ruby on Rails** and **Elixir/Phoenix** integrations, offering tailored performance insights and error tracking. It also supports custom metrics via APIs.
-     Sentry supports a broader range of platforms but lacks the same framework-specific customization that AppSignal provides for Ruby on Rails and Elixir/Phoenix.
-   - **Security and Access Management**
-     AppSignal integrates with **SAML SSO** for secure enterprise-level access. Sentry supports SSO but may require more configuration, and its external security system integration is not as seamless as AppSignal's.
-   - **Anomaly Detection**
-     AppSignal includes **host monitoring** and **anomaly detection** by default, helping teams track performance issues easily. Sentry offers **change alerts** for anomaly detection, but these are limited to higher-tier plans (Business and Enterprise).
-   - **Setup and Configuration**
-     AppSignal features a simplified setup with automatic metric dashboards, background job monitoring, and easy namespace configuration, streamlining the process.
-     Sentry requires more integrations and configurations for performance monitoring, making the setup process more complex compared to AppSignal.
+- **Framework-Specific Integrations**
+  AppSignal specializes in **Ruby on Rails** and **Elixir/Phoenix** integrations, offering tailored performance insights and error tracking. It also supports custom metrics via APIs.
+  Sentry supports a broader range of platforms but lacks the same framework-specific customization that AppSignal provides for Ruby on Rails and Elixir/Phoenix.
+- **Security and Access Management**
+  AppSignal integrates with **SAML SSO** for secure enterprise-level access. Sentry supports SSO but may require more configuration, and its external security system integration is not as seamless as AppSignal's.
+- **Anomaly Detection**
+  AppSignal includes **host monitoring** and **anomaly detection** by default, helping teams track performance issues easily. Sentry offers **change alerts** for anomaly detection, but these are limited to higher-tier plans (Business and Enterprise).
+- **Setup and Configuration**
+  AppSignal features a simplified setup with automatic metric dashboards, background job monitoring, and easy namespace configuration, streamlining the process.
+  Sentry requires more integrations and configurations for performance monitoring, making the setup process more complex compared to AppSignal.
 
 #### Security and compliance
 
-   | **Aspect**     | **Sentry**                                                                          | **AppSignal**                    |
-   | -------------- | ----------------------------------------------------------------------------------- | -------------------------------- |
-   | **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | End-to-end encryption            |
-   | **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Basic RBAC                       |
-   | **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | GDPR, HIPAA, ISO:27001, ISO:9001 |
+| **Aspect**     | **Sentry**                                                                          | **AppSignal**                    |
+| -------------- | ----------------------------------------------------------------------------------- | -------------------------------- |
+| **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | End-to-end encryption            |
+| **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Basic RBAC                       |
+| **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | GDPR, HIPAA, ISO:27001, ISO:9001 |
 
-   While AppSignal offers end-to-end encryption and GDPR compliance, it may not meet the specific security or compliance needs of larger enterprises requiring more granular controls, such as detailed role-based access (RBAC) or compliance certifications like SOC 2.
+While AppSignal offers end-to-end encryption and GDPR compliance, it may not meet the specific security or compliance needs of larger enterprises requiring more granular controls, such as detailed role-based access (RBAC) or compliance certifications like SOC 2.
 
 <KeyPointCallout>
-AppSignal shines in Ruby and Elixir environments, offering streamlined performance monitoring with clear, actionable insights for developers.
+  AppSignal shines in Ruby and Elixir environments, offering streamlined performance monitoring with
+  clear, actionable insights for developers.
 </KeyPointCallout>
 
 ## 6. BugSnag
@@ -727,69 +732,70 @@ BugSnag offers similar core functionality to Sentry, particularly for error trac
 - **Pricing Model**
   BugSnag offers a **flexible pricing model**, allowing users to manage daily event quotas and apply rate limiting to avoid unexpected charges.
   Sentry uses a **tiered pricing** structure, where costs increase with event volume, leading to potential overage fees or mandatory upgrades.
-   - **Trial and Flexibility**
-     BugSnag offers a **14-day free trial** with full access to all features, giving businesses a risk-free opportunity to explore its offerings.
-     Sentry provides free trials for certain tiers, but its pricing can escalate with higher event counts or premium features.
-   - **Cost Transparency**
-     BugSnag is known for **transparent invoicing** and flexible payment options, with discounts for annual plans.
-     Sentry's tiered pricing and overage policies can lead to complex billing, resulting in unforeseen additional costs.
-   - **Customer-Focused Benefits**
-     BugSnag prioritizes customer-friendly features like **customizable event handling** and quota management.
-     Sentry's tiered pricing and overage charges may be less favorable for teams with fluctuating event volumes.
+  - **Trial and Flexibility**
+    BugSnag offers a **14-day free trial** with full access to all features, giving businesses a risk-free opportunity to explore its offerings.
+    Sentry provides free trials for certain tiers, but its pricing can escalate with higher event counts or premium features.
+  - **Cost Transparency**
+    BugSnag is known for **transparent invoicing** and flexible payment options, with discounts for annual plans.
+    Sentry's tiered pricing and overage policies can lead to complex billing, resulting in unforeseen additional costs.
+  - **Customer-Focused Benefits**
+    BugSnag prioritizes customer-friendly features like **customizable event handling** and quota management.
+    Sentry's tiered pricing and overage charges may be less favorable for teams with fluctuating event volumes.
 
 #### Instrumentation and performance overhead
 
-   - **Performance Data Management**
-     BugSnag uses an efficient system with **managed** and **unmanaged spans**. Managed spans adjust dynamically for smooth performance monitoring, while unmanaged spans provide control over sampling rates.
-     Sentry's dynamic sampling can lead to **trace incompleteness** and dropped events, especially under high traffic or frequent sampling adjustments.
-   - **Sampling Strategy**
-     BugSnag offers **precise control** over sampling rates, ensuring **optimal performance** with minimal latency.
-     Sentry's dynamic sampling strategy aims to maintain **trace completeness** but can introduce additional overhead, affecting efficiency.
-   - **Latency and Efficiency**
-     BugSnag prioritizes **minimal setup** and **efficiency**, designed for teams needing low-latency performance without complexity.
-     Sentry's reliance on **stored events** and dynamic sampling can increase **overhead**, making it less efficient in low-latency environments.
-   - **Trace Completeness**
-     BugSnag's simplified sampling strategies help maintain **consistent and complete performance data**.
-     Sentry aims for **trace completeness**, but **rate limiting** and **dropped events** can impact data integrity.
+- **Performance Data Management**
+  BugSnag uses an efficient system with **managed** and **unmanaged spans**. Managed spans adjust dynamically for smooth performance monitoring, while unmanaged spans provide control over sampling rates.
+  Sentry's dynamic sampling can lead to **trace incompleteness** and dropped events, especially under high traffic or frequent sampling adjustments.
+- **Sampling Strategy**
+  BugSnag offers **precise control** over sampling rates, ensuring **optimal performance** with minimal latency.
+  Sentry's dynamic sampling strategy aims to maintain **trace completeness** but can introduce additional overhead, affecting efficiency.
+- **Latency and Efficiency**
+  BugSnag prioritizes **minimal setup** and **efficiency**, designed for teams needing low-latency performance without complexity.
+  Sentry's reliance on **stored events** and dynamic sampling can increase **overhead**, making it less efficient in low-latency environments.
+- **Trace Completeness**
+  BugSnag's simplified sampling strategies help maintain **consistent and complete performance data**.
+  Sentry aims for **trace completeness**, but **rate limiting** and **dropped events** can impact data integrity.
 
 #### Data Architecture
 
-   - **Data Sampling and Performance**
-     BugSnag uses **sampled data**, like percentiles (e.g., **P90**), balancing **performance insights** with system efficiency. It optimizes **error tracking** without overwhelming the system.
-     Sentry relies on **unsampled** and **stored events**, offering granular analysis but at the cost of increased **system overhead** and potential inefficiency with large datasets.
-   - **Efficiency and Resource Management**
-     BugSnag's **focused architecture** uses **quotas and sampling strategies** to manage resources efficiently, keeping the system streamlined.
-     Sentry's reliance on **stored events** for deep queries can lead to **greater resource consumption**, which may affect performance, particularly in large-scale environments.
-   - **Complexity and Flexibility**
-     BugSnag's simpler, **efficient architecture** provides more **flexibility** and reduces data management complexity.
-     Sentry offers detailed analysis but may become more **complex** due to its need for **storage** and increased resource demands, limiting flexibility.
-   - **Scalability and Data Management**
-     BugSnag's **sampled data** approach ensures **scalability** without overloading the system, keeping performance analysis efficient.
-     Sentry may face scalability challenges as data volume increases, requiring more resources to maintain performance.
+- **Data Sampling and Performance**
+  BugSnag uses **sampled data**, like percentiles (e.g., **P90**), balancing **performance insights** with system efficiency. It optimizes **error tracking** without overwhelming the system.
+  Sentry relies on **unsampled** and **stored events**, offering granular analysis but at the cost of increased **system overhead** and potential inefficiency with large datasets.
+- **Efficiency and Resource Management**
+  BugSnag's **focused architecture** uses **quotas and sampling strategies** to manage resources efficiently, keeping the system streamlined.
+  Sentry's reliance on **stored events** for deep queries can lead to **greater resource consumption**, which may affect performance, particularly in large-scale environments.
+- **Complexity and Flexibility**
+  BugSnag's simpler, **efficient architecture** provides more **flexibility** and reduces data management complexity.
+  Sentry offers detailed analysis but may become more **complex** due to its need for **storage** and increased resource demands, limiting flexibility.
+- **Scalability and Data Management**
+  BugSnag's **sampled data** approach ensures **scalability** without overloading the system, keeping performance analysis efficient.
+  Sentry may face scalability challenges as data volume increases, requiring more resources to maintain performance.
 
 #### Customizations and integrations
 
-   - **Integration Options**
-     Sentry provides a **wide range of integrations** with platforms like **Jira**, **GitHub**, and **Slack**, making it ideal for **full-stack monitoring** and seamless workflows.
-     BugSnag offers **simpler integrations** via a **JSON-based API**, focusing on streamlined error tracking but with fewer integration options compared to Sentry.
-   - **Customization Options**
-     Sentry allows for extensive customization, such as **custom tags** and detailed trace visibility, enabling teams to tailor monitoring to their needs.
-     BugSnag offers basic customization, including filters for **user behavior** and **device type**, but lacks the extensive flexibility of Sentry.
-   - **Setup Complexity**
-     Sentry's setup is more **complex** due to its wide array of features and customization options. BugSnag is known for its **simplicity**, offering a **quick and easy setup** for teams that prefer a straightforward solution.
+- **Integration Options**
+  Sentry provides a **wide range of integrations** with platforms like **Jira**, **GitHub**, and **Slack**, making it ideal for **full-stack monitoring** and seamless workflows.
+  BugSnag offers **simpler integrations** via a **JSON-based API**, focusing on streamlined error tracking but with fewer integration options compared to Sentry.
+- **Customization Options**
+  Sentry allows for extensive customization, such as **custom tags** and detailed trace visibility, enabling teams to tailor monitoring to their needs.
+  BugSnag offers basic customization, including filters for **user behavior** and **device type**, but lacks the extensive flexibility of Sentry.
+- **Setup Complexity**
+  Sentry's setup is more **complex** due to its wide array of features and customization options. BugSnag is known for its **simplicity**, offering a **quick and easy setup** for teams that prefer a straightforward solution.
 
 #### Security and compliance
 
-   | **Aspect**     | Sentry                                                                              | **Bugsnag**                                                                                                                                                                                                                  |
-   | -------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-   | **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | uses HTTPS and Transport Layer Security (TLS) to encrypt all communications between users and servers by default. Customer data is also encrypted at rest, with automatic encryption applied before data is written to disk. |
-   | **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Supports role-based access control with customizable roles available in higher-tier plans.                                                                                                                                   |
-   | **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | ISO 27001, ISO 27017, ISO 27018, EU GDPR, CCPA, SOC 1, SOC 2 and SOC 3                                                                                                                                                       |
+| **Aspect**     | Sentry                                                                              | **Bugsnag**                                                                                                                                                                                                                  |
+| -------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | uses HTTPS and Transport Layer Security (TLS) to encrypt all communications between users and servers by default. Customer data is also encrypted at rest, with automatic encryption applied before data is written to disk. |
+| **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Supports role-based access control with customizable roles available in higher-tier plans.                                                                                                                                   |
+| **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | ISO 27001, ISO 27017, ISO 27018, EU GDPR, CCPA, SOC 1, SOC 2 and SOC 3                                                                                                                                                       |
 
-   Bugsnag offers strong data encryption and compliance with GDPR, though its RBAC features are more limited, which may be a consideration for larger teams or those with stricter security requirements.
+Bugsnag offers strong data encryption and compliance with GDPR, though its RBAC features are more limited, which may be a consideration for larger teams or those with stricter security requirements.
 
 <KeyPointCallout>
-BugSnag excels in mobile app error tracking with powerful stability scoring and diagnostics features, making it ideal for mobile-first development teams.
+  BugSnag excels in mobile app error tracking with powerful stability scoring and diagnostics
+  features, making it ideal for mobile-first development teams.
 </KeyPointCallout>
 
 ## 7. New Relic
@@ -821,72 +827,73 @@ New Relic provides a more comprehensive observability solution than Sentry, with
 
 #### Pricing
 
-   - **Pricing Model**
-     New Relic offers **100 GB of free data ingestion** per month, charging **$0.35 per GB** for additional data. Paid plans start at **$49 per month** with a predictable pricing structure. Sentry uses an **event-based pricing model**, charging separately for features like errors, spans, replays, and attachments, leading to potential complexity in cost estimation.
-   - **Cost Predictability**
-     New Relic's pricing is **straightforward**, based on data usage, making it ideal for large-scale ingestion and easier to scale.
-     Sentry's pricing is **unpredictable**, as it charges for each event and feature, potentially increasing costs as usage grows.
-   - **Plan Flexibility and Scaling**
-     New Relic offers **unlimited platform users** on the **Pro plan** for **$349 per year per user**, making it attractive for teams needing more users without additional costs.
-     Sentry's pricing is based on **usage volume**, leading to **unpredictable costs** for teams with fluctuating data or events.
+- **Pricing Model**
+  New Relic offers **100 GB of free data ingestion** per month, charging **$0.35 per GB** for additional data. Paid plans start at **$49 per month** with a predictable pricing structure. Sentry uses an **event-based pricing model**, charging separately for features like errors, spans, replays, and attachments, leading to potential complexity in cost estimation.
+- **Cost Predictability**
+  New Relic's pricing is **straightforward**, based on data usage, making it ideal for large-scale ingestion and easier to scale.
+  Sentry's pricing is **unpredictable**, as it charges for each event and feature, potentially increasing costs as usage grows.
+- **Plan Flexibility and Scaling**
+  New Relic offers **unlimited platform users** on the **Pro plan** for **$349 per year per user**, making it attractive for teams needing more users without additional costs.
+  Sentry's pricing is based on **usage volume**, leading to **unpredictable costs** for teams with fluctuating data or events.
 
 #### Instrumentation and performance overhead
 
-   - **Performance Overhead**
-     New Relic offers **detailed APM capabilities** with extensive monitoring, but this can introduce **performance overhead**, especially in **resource-constrained environments**. It is more suitable for scenarios where in-depth monitoring is prioritized.
-     Sentry, focused on **error tracking**, has a **lower performance impact**, making it ideal for environments where error management is the primary concern.
-   - **Setup Complexity**
-     New Relic requires a **longer setup** due to its complex and comprehensive monitoring features, which may be challenging for teams with limited resources.
-     Sentry offers a **simpler setup** process, with a focus on error tracking, allowing quick implementation without complex integrations.
-   - **Error Grouping**
-     New Relic automatically **groups errors** based on factors like **stack traces** and **HTTP requests**, providing a comprehensive view of errors in the context of the application's performance.
-     Sentry offers **custom grouping rules**, providing greater flexibility for teams to tailor error management based on their specific application needs.
+- **Performance Overhead**
+  New Relic offers **detailed APM capabilities** with extensive monitoring, but this can introduce **performance overhead**, especially in **resource-constrained environments**. It is more suitable for scenarios where in-depth monitoring is prioritized.
+  Sentry, focused on **error tracking**, has a **lower performance impact**, making it ideal for environments where error management is the primary concern.
+- **Setup Complexity**
+  New Relic requires a **longer setup** due to its complex and comprehensive monitoring features, which may be challenging for teams with limited resources.
+  Sentry offers a **simpler setup** process, with a focus on error tracking, allowing quick implementation without complex integrations.
+- **Error Grouping**
+  New Relic automatically **groups errors** based on factors like **stack traces** and **HTTP requests**, providing a comprehensive view of errors in the context of the application's performance.
+  Sentry offers **custom grouping rules**, providing greater flexibility for teams to tailor error management based on their specific application needs.
 
 #### Data Architecture
 
-  <Figure
-     src="/img/comparisons/2025/01/sentry-alternatives-image%2012.webp"
-     alt="New Relic Data Architecture (credits: new relic docs)"
-     caption="New Relic Data Architecture (credits: new relic docs)"
-   />
+<Figure
+  src="/img/comparisons/2025/01/sentry-alternatives-image%2012.webp"
+  alt="New Relic Data Architecture (credits: new relic docs)"
+  caption="New Relic Data Architecture (credits: new relic docs)"
+/>
 
-   - **Event Sampling and Data Integrity**
-     New Relic uses **event limits** and **sampling** to optimize data ingestion and ensure data integrity, especially when agents can't connect or reporting limits are reached. It includes tools like **`EXTRAPOLATE`** to maintain accuracy during limited data availability.
-     Sentry applies **dynamic sampling** to preserve trace completeness, but under **rate limits**, partial traces may result, affecting full trace analysis accuracy.
-   - **Control and Flexibility**
-     New Relic provides **precise control** over agent configurations, offering flexibility to handle large volumes of telemetry data in complex, high-traffic systems.
-     Sentry, with its reliance on dynamic sampling and client-side filtering, offers **less flexibility** and control compared to New Relic, especially in large-scale environments.
-   - **Scalability and Flexibility in Handling Volumes**
-     New Relic handles large volumes of telemetry data with **high scalability**, integrating traces, metrics, logs, and events for comprehensive observability.
-     Sentry, focused mainly on error tracking, is scalable for error and performance monitoring but lacks broader telemetry capabilities.
-   - **Full-Stack Observability**
-     New Relic excels at **full-stack observability**, integrating multiple data sources for unified insights across the application stack, making it ideal for monitoring complex systems.
-     Sentry focuses on **error tracking and event monitoring**, with less emphasis on full-stack observability and broader telemetry analysis.
+- **Event Sampling and Data Integrity**
+  New Relic uses **event limits** and **sampling** to optimize data ingestion and ensure data integrity, especially when agents can't connect or reporting limits are reached. It includes tools like **`EXTRAPOLATE`** to maintain accuracy during limited data availability.
+  Sentry applies **dynamic sampling** to preserve trace completeness, but under **rate limits**, partial traces may result, affecting full trace analysis accuracy.
+- **Control and Flexibility**
+  New Relic provides **precise control** over agent configurations, offering flexibility to handle large volumes of telemetry data in complex, high-traffic systems.
+  Sentry, with its reliance on dynamic sampling and client-side filtering, offers **less flexibility** and control compared to New Relic, especially in large-scale environments.
+- **Scalability and Flexibility in Handling Volumes**
+  New Relic handles large volumes of telemetry data with **high scalability**, integrating traces, metrics, logs, and events for comprehensive observability.
+  Sentry, focused mainly on error tracking, is scalable for error and performance monitoring but lacks broader telemetry capabilities.
+- **Full-Stack Observability**
+  New Relic excels at **full-stack observability**, integrating multiple data sources for unified insights across the application stack, making it ideal for monitoring complex systems.
+  Sentry focuses on **error tracking and event monitoring**, with less emphasis on full-stack observability and broader telemetry analysis.
 
 #### Customizations and integration
 
-   - **Range of Integrations**
-     New Relic supports a wide range of integrations with cloud services, DevOps tools, and third-party applications, offering comprehensive insights across the system.
-     Sentry, while offering some integrations, focuses mainly on error tracking and performance monitoring, lacking the variety seen in New Relic.
-   - **Customization Capabilities**
-     New Relic offers deep customization through **NRQL** (New Relic Query Language), enabling tailored dashboards and alerts, though it can be complex for beginners.
-     Sentry provides a simpler approach with fewer customization options, focusing on easy error tracking and monitoring.
-   - **Custom Dashboards and Alerts**
-     New Relic allows advanced customization for dashboards and alerts, providing flexibility for teams needing detailed system insights.
-     Sentry offers predefined dashboards and alerts with limited customization, focusing more on error tracking.
+- **Range of Integrations**
+  New Relic supports a wide range of integrations with cloud services, DevOps tools, and third-party applications, offering comprehensive insights across the system.
+  Sentry, while offering some integrations, focuses mainly on error tracking and performance monitoring, lacking the variety seen in New Relic.
+- **Customization Capabilities**
+  New Relic offers deep customization through **NRQL** (New Relic Query Language), enabling tailored dashboards and alerts, though it can be complex for beginners.
+  Sentry provides a simpler approach with fewer customization options, focusing on easy error tracking and monitoring.
+- **Custom Dashboards and Alerts**
+  New Relic allows advanced customization for dashboards and alerts, providing flexibility for teams needing detailed system insights.
+  Sentry offers predefined dashboards and alerts with limited customization, focusing more on error tracking.
 
 #### Security and compliance
 
-   | **Aspect**     | Sentry                                                                              | New Relic                                                                                                                                                                                                                                                                |
-   | -------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-   | **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | New Relic secures data with TLS 1.3 encryption in transit for all customers and automatically encrypts data at rest using AES-256 in AWS and Azure. FIPS 140-2 compliance is available upon request, with unique encryption keys that are destroyed when instances stop. |
-   | **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Advanced RBAC with built-in base roles (Admin, User, Restricted User) and easy-to-manage, fine-grained permissions through custom and New Relic-managed add-on roles.                                                                                                    |
-   | **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | FedRAMP, HIPAA, HITRUST, ISO 27001, PCI DSS, SOC 2, TISAX                                                                                                                                                                                                                |
+| **Aspect**     | Sentry                                                                              | New Relic                                                                                                                                                                                                                                                                |
+| -------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | New Relic secures data with TLS 1.3 encryption in transit for all customers and automatically encrypts data at rest using AES-256 in AWS and Azure. FIPS 140-2 compliance is available upon request, with unique encryption keys that are destroyed when instances stop. |
+| **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Advanced RBAC with built-in base roles (Admin, User, Restricted User) and easy-to-manage, fine-grained permissions through custom and New Relic-managed add-on roles.                                                                                                    |
+| **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | FedRAMP, HIPAA, HITRUST, ISO 27001, PCI DSS, SOC 2, TISAX                                                                                                                                                                                                                |
 
-   Learn more about [new relic vs sentry](https://signoz.io/comparisons/newrelic-vs-sentry/#new-relic-vs-sentry-at-a-glance).
+Learn more about [new relic vs sentry](https://signoz.io/comparisons/newrelic-vs-sentry/#new-relic-vs-sentry-at-a-glance).
 
 <KeyPointCallout>
-New Relic offers comprehensive observability with powerful querying capabilities and extensive integrations, suited for organizations needing full-stack monitoring.
+  New Relic offers comprehensive observability with powerful querying capabilities and extensive
+  integrations, suited for organizations needing full-stack monitoring.
 </KeyPointCallout>
 
 ## 8. Raygun
@@ -918,70 +925,71 @@ Raygun and Sentry provide similar core functionality, focusing on error tracking
 
 #### Pricing
 
-   - **Pricing Model**
-     Raygun uses a **tiered pricing model** based on error/exception events tracked per month, allowing flexibility based on event volume.
-     Sentry follows a **user seat-based pricing model**, with costs increasing based on users and events tracked. It offers a free tier, but costs can escalate as applications grow.
-   - **Cost Predictability**
-     Raygun's tiered model provides more control over costs, especially for high-traffic applications, though it can still get expensive.
-     Sentry's pricing can be **unpredictable** as it scales with users and events.
-   - **Scalability**
-     Raygun is better suited for teams focusing on **user session tracking** and **crash reporting at scale**, benefiting from its tiered system.
-     Sentry's pricing may rise rapidly as the number of users and events increases.
+- **Pricing Model**
+  Raygun uses a **tiered pricing model** based on error/exception events tracked per month, allowing flexibility based on event volume.
+  Sentry follows a **user seat-based pricing model**, with costs increasing based on users and events tracked. It offers a free tier, but costs can escalate as applications grow.
+- **Cost Predictability**
+  Raygun's tiered model provides more control over costs, especially for high-traffic applications, though it can still get expensive.
+  Sentry's pricing can be **unpredictable** as it scales with users and events.
+- **Scalability**
+  Raygun is better suited for teams focusing on **user session tracking** and **crash reporting at scale**, benefiting from its tiered system.
+  Sentry's pricing may rise rapidly as the number of users and events increases.
 
 #### Instrumentation and performance overhead
 
-   - **Lightweight and Non-Intrusive Instrumentation**
-     Raygun is designed to be lightweight and non-intrusive, minimizing performance impact while tracking errors and performance.
-     Sentry provides lightweight instrumentation but places more emphasis on backend performance, which may result in slightly higher overhead than Raygun's frontend-focused approach.
-   - **Performance Overhead**
-     Raygun has low overhead, especially in real user monitoring (RUM) and frontend applications, allowing real-time performance tracking with minimal impact.
-     Sentry's comprehensive APM for backend monitoring can introduce higher performance overhead, particularly in environments prioritizing frontend performance.
-   - **Frontend and Mobile Monitoring**
-     Raygun offers browser and mobile monitoring, providing insights into performance issues on both web and mobile platforms.
-     Sentry focuses more on backend monitoring and error tracking, with less emphasis on frontend or mobile-specific tracking.
-   - **Real-Time Tracking and Performance Bottlenecks**
-     Raygun excels at real-time tracking of performance bottlenecks, using RUM for insights into frontend issues.
-     Sentry also monitors performance but is more focused on server-side and backend performance, rather than frontend tracking.
+- **Lightweight and Non-Intrusive Instrumentation**
+  Raygun is designed to be lightweight and non-intrusive, minimizing performance impact while tracking errors and performance.
+  Sentry provides lightweight instrumentation but places more emphasis on backend performance, which may result in slightly higher overhead than Raygun's frontend-focused approach.
+- **Performance Overhead**
+  Raygun has low overhead, especially in real user monitoring (RUM) and frontend applications, allowing real-time performance tracking with minimal impact.
+  Sentry's comprehensive APM for backend monitoring can introduce higher performance overhead, particularly in environments prioritizing frontend performance.
+- **Frontend and Mobile Monitoring**
+  Raygun offers browser and mobile monitoring, providing insights into performance issues on both web and mobile platforms.
+  Sentry focuses more on backend monitoring and error tracking, with less emphasis on frontend or mobile-specific tracking.
+- **Real-Time Tracking and Performance Bottlenecks**
+  Raygun excels at real-time tracking of performance bottlenecks, using RUM for insights into frontend issues.
+  Sentry also monitors performance but is more focused on server-side and backend performance, rather than frontend tracking.
 
 #### Data Architecture
 
-   - **Real-Time Data Collection and Storage**
-     Raygun offers real-time data collection and storage, providing instant feedback on issues for faster troubleshooting and resolution.
-     Sentry also tracks errors in real-time but focuses more on event data and error management, lacking the depth of performance metrics for frontend applications that Raygun provides.
-   - **Error Grouping and Prioritization**
-     Raygun features automatic error grouping and prioritization, helping teams quickly identify and resolve critical issues, especially those impacting user experience.
-     Sentry offers error grouping but has less focus on prioritization and frontend performance, making Raygun more specialized for managing user experience-related issues.
-   - **Real User Monitoring (RUM) and Session Tracking**
-     Raygun includes RUM and session tracking, providing deep insights into the user experience and performance, ideal for optimizing the frontend and tracking user interactions.
-     Sentry is more focused on error tracking and event data, with less emphasis on RUM and session tracking, making it less integrated for user experience metrics than Raygun.
+- **Real-Time Data Collection and Storage**
+  Raygun offers real-time data collection and storage, providing instant feedback on issues for faster troubleshooting and resolution.
+  Sentry also tracks errors in real-time but focuses more on event data and error management, lacking the depth of performance metrics for frontend applications that Raygun provides.
+- **Error Grouping and Prioritization**
+  Raygun features automatic error grouping and prioritization, helping teams quickly identify and resolve critical issues, especially those impacting user experience.
+  Sentry offers error grouping but has less focus on prioritization and frontend performance, making Raygun more specialized for managing user experience-related issues.
+- **Real User Monitoring (RUM) and Session Tracking**
+  Raygun includes RUM and session tracking, providing deep insights into the user experience and performance, ideal for optimizing the frontend and tracking user interactions.
+  Sentry is more focused on error tracking and event data, with less emphasis on RUM and session tracking, making it less integrated for user experience metrics than Raygun.
 
 #### Customizations and integrations
 
-   - **Integrations with Tools**
-     Raygun integrates with tools like Slack, Jira, and GitHub, enhancing its functionality for teams using multiple platforms for project management.
-     Sentry also integrates with similar tools but doesn't focus as much on frontend performance or real user monitoring (RUM), making its integrations less specialized in these areas.
-   - **Customization in Error and Performance Tracking**
-     Raygun offers detailed tracking for frontend performance and RUM, providing a more tailored approach to error analysis and insights into user interactions.
-     Sentry supports performance monitoring but doesn't offer the same level of customization for frontend performance or user experience as Raygun.
-   - **Deployment Tracking and Release Correlation**
-     Raygun includes deployment tracking, allowing teams to correlate errors with specific releases and identify issues introduced by new deployments.
-     Sentry lacks dedicated deployment tracking, making it less optimized for release correlation compared to Raygun.
-   - **Data Retention and Privacy**
-     Raygun retains error event data for 180 days by default, with the option to extend retention as needed.
-     Sentry offers self-hosting options, giving organizations full control over data retention and privacy, which is ideal for strict data governance requirements.
+- **Integrations with Tools**
+  Raygun integrates with tools like Slack, Jira, and GitHub, enhancing its functionality for teams using multiple platforms for project management.
+  Sentry also integrates with similar tools but doesn't focus as much on frontend performance or real user monitoring (RUM), making its integrations less specialized in these areas.
+- **Customization in Error and Performance Tracking**
+  Raygun offers detailed tracking for frontend performance and RUM, providing a more tailored approach to error analysis and insights into user interactions.
+  Sentry supports performance monitoring but doesn't offer the same level of customization for frontend performance or user experience as Raygun.
+- **Deployment Tracking and Release Correlation**
+  Raygun includes deployment tracking, allowing teams to correlate errors with specific releases and identify issues introduced by new deployments.
+  Sentry lacks dedicated deployment tracking, making it less optimized for release correlation compared to Raygun.
+- **Data Retention and Privacy**
+  Raygun retains error event data for 180 days by default, with the option to extend retention as needed.
+  Sentry offers self-hosting options, giving organizations full control over data retention and privacy, which is ideal for strict data governance requirements.
 
 #### Security and compliance
 
-   | **Aspect**     | **Sentry**                                                                          | **Raygun**                                                     |
-   | -------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------- |
-   | **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | Provides 256-bit data encryption and private source maps       |
-   | **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Supports role-based access control (RBAC) in higher-tier plans |
-   | **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | HIPAA, GDPR, CCPA, and PCI                                     |
+| **Aspect**     | **Sentry**                                                                          | **Raygun**                                                     |
+| -------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------- |
+| **Encryption** | AES-256bit encryption at rest; HTTPS TLS connections for data transmission.         | Provides 256-bit data encryption and private source maps       |
+| **RBAC**       | Basic RBAC with roles like Billing, Member, Admin, Manager, and Organization Owner. | Supports role-based access control (RBAC) in higher-tier plans |
+| **Compliance** | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     | HIPAA, GDPR, CCPA, and PCI                                     |
 
-   While Raygun offers end-to-end encryption and GDPR compliance, it may not meet the specific security or compliance needs of larger enterprises requiring more granular controls, such as detailed role-based access (RBAC) or compliance certifications like SOC 2.
+While Raygun offers end-to-end encryption and GDPR compliance, it may not meet the specific security or compliance needs of larger enterprises requiring more granular controls, such as detailed role-based access (RBAC) or compliance certifications like SOC 2.
 
 <KeyPointCallout>
-Raygun combines powerful error tracking with real user monitoring, providing deep insights into user experience and application performance.
+  Raygun combines powerful error tracking with real user monitoring, providing deep insights into
+  user experience and application performance.
 </KeyPointCallout>
 
 ## 9. Jaeger
@@ -1015,78 +1023,76 @@ Jaeger and Sentry both provide monitoring and observability tools, but they serv
 
 #### Pricing
 
-   - **Pricing Model**
-     Jaeger is open-source and free to use, but costs come from infrastructure, deployment, and maintenance (e.g., storage with Cassandra or Elasticsearch).
-     Sentry follows a subscription-based model, where costs are based on the number of seats or events processed, offering a fully managed service.
-    - **Cost Predictability**
-      Jaeger has flexible costs tied to infrastructure and maintenance, but scaling and data retention add complexity.
-      Sentry offers more predictable and scalable pricing, tied directly to users or events processed.
-    - **Operational Overhead**
-      Jaeger requires teams to handle deployment, maintenance, and storage, leading to higher operational overhead.
-      Sentry is a fully managed service, reducing operational complexity but potentially increasing costs as usage grows.
+- **Pricing Model**
+  Jaeger is open-source and free to use, but costs come from infrastructure, deployment, and maintenance (e.g., storage with Cassandra or Elasticsearch).
+  Sentry follows a subscription-based model, where costs are based on the number of seats or events processed, offering a fully managed service.
+- **Cost Predictability**
+  Jaeger has flexible costs tied to infrastructure and maintenance, but scaling and data retention add complexity.
+  Sentry offers more predictable and scalable pricing, tied directly to users or events processed.
+- **Operational Overhead**
+  Jaeger requires teams to handle deployment, maintenance, and storage, leading to higher operational overhead.
+  Sentry is a fully managed service, reducing operational complexity but potentially increasing costs as usage grows.
 
 #### Instrumentation and performance overhead
 
-  - **Sampling and Data Collection**
-     Jaeger offers advanced sampling options like head-based and tail-based sampling with sharding, allowing for fine-tuned control over trace data in high-throughput environments. Sentry uses event-based sampling, ideal for error tracking, but lacks the advanced sampling features of Jaeger.
-  - **Performance Optimization and Storage Costs**
-      Jaeger optimizes performance and reduces storage costs through its sampling and configuration options, especially in large-scale distributed systems.
-      Sentry focuses on resource efficiency for error tracking but lacks the same optimization features for storage costs as Jaeger.
-  - **Instrumentation and Architecture**
-    Jaeger uses client libraries for instrumentation, with a well-structured architecture (Agent, Collector, Storage, Query, UI) for high-throughput distributed systems.
-    Sentry is designed primarily for error tracking and performance monitoring but is not built for managing complex trace data in distributed systems.
-  - **Sharding and Overhead**
-    Jaeger offers sharding for remote clusters, managing high-throughput environments but can experience marshaling/unmarshaling overhead.
-    Sentry lacks sharding and advanced sampling, making it less suited for large-scale distributed systems.
+- **Sampling and Data Collection**
+  Jaeger offers advanced sampling options like head-based and tail-based sampling with sharding, allowing for fine-tuned control over trace data in high-throughput environments. Sentry uses event-based sampling, ideal for error tracking, but lacks the advanced sampling features of Jaeger.
+- **Performance Optimization and Storage Costs**
+  Jaeger optimizes performance and reduces storage costs through its sampling and configuration options, especially in large-scale distributed systems.
+  Sentry focuses on resource efficiency for error tracking but lacks the same optimization features for storage costs as Jaeger.
+- **Instrumentation and Architecture**
+  Jaeger uses client libraries for instrumentation, with a well-structured architecture (Agent, Collector, Storage, Query, UI) for high-throughput distributed systems.
+  Sentry is designed primarily for error tracking and performance monitoring but is not built for managing complex trace data in distributed systems.
+- **Sharding and Overhead**
+  Jaeger offers sharding for remote clusters, managing high-throughput environments but can experience marshaling/unmarshaling overhead.
+  Sentry lacks sharding and advanced sampling, making it less suited for large-scale distributed systems.
 
 #### Data Architecture
 
-   - **Data Architecture**
-     Jaeger's architecture consists of several key components: - **Client Libraries:** Instrument the application code, create spans, and send them to the Jaeger Agent. - **Agent:** A network daemon that collects spans and forwards them to the Collector. - **Collector:** Processes the spans and stores them in a backend storage system like Cassandra or Elasticsearch. - **Query:** Retrieves traces from storage and presents them via the [Jaeger UI](https://signoz.io/guides/how-to-implement-jaeger/). - **UI:** A web interface to search, analyze, and visualize trace data.
-
-    {' '}
-
-    <Figure
-      src="/img/comparisons/2025/01/sentry-alternatives-image%2015.webp"
-      alt="Data architecture: Jaeger (credits: Jaeger docs)"
-      caption="Data architecture: Jaeger (credits: Jaeger docs)"
-    />
+- **Data Architecture**
+  Jaeger's architecture consists of several key components: - **Client Libraries:** Instrument the application code, create spans, and send them to the Jaeger Agent. - **Agent:** A network daemon that collects spans and forwards them to the Collector. - **Collector:** Processes the spans and stores them in a backend storage system like Cassandra or Elasticsearch. - **Query:** Retrieves traces from storage and presents them via the [Jaeger UI](https://signoz.io/guides/how-to-implement-jaeger/). - **UI:** A web interface to search, analyze, and visualize trace data.
 
-    - **Data Collection and Traffic Handling**
+  {' '}
 
-        Jaeger uses collectors with an in-memory queue to manage short-term traffic spikes, but sustained spikes may cause data loss if storage can't keep up.
+  <Figure
+    src="/img/comparisons/2025/01/sentry-alternatives-image%2015.webp"
+    alt="Data architecture: Jaeger (credits: Jaeger docs)"
+    caption="Data architecture: Jaeger (credits: Jaeger docs)"
+  />
+  - **Data Collection and Traffic Handling**
 
-        Sentry focuses on error tracking and performance monitoring, capturing events and organizing them into issues, without the same emphasis on traffic management as Jaeger.
+  Jaeger uses collectors with an in-memory queue to manage short-term traffic spikes, but sustained spikes may cause data loss if storage can't keep up.
 
-    - **Sampling and Data Capture**
+  Sentry focuses on error tracking and performance monitoring, capturing events and organizing them into issues, without the same emphasis on traffic management as Jaeger.
+  - **Sampling and Data Capture**
 
-        Jaeger employs a configurable sampling algorithm, with 0.1% of requests sampled by default, balancing data capture with system performance.
+    Jaeger employs a configurable sampling algorithm, with 0.1% of requests sampled by default, balancing data capture with system performance.
 
-        Sentry captures real-time errors and performance issues during user interactions but does not mention sampling explicitly.
+    Sentry captures real-time errors and performance issues during user interactions but does not mention sampling explicitly.
 
-    - **Scalability and Flexibility**
+  - **Scalability and Flexibility**
 
-        Jaeger's architecture is built to scale efficiently, especially for large volumes of trace data in microservices environments.
+    Jaeger's architecture is built to scale efficiently, especially for large volumes of trace data in microservices environments.
 
-        Sentry is designed for error tracking and performance monitoring, with less emphasis on handling massive trace volumes compared to Jaeger.
+    Sentry is designed for error tracking and performance monitoring, with less emphasis on handling massive trace volumes compared to Jaeger.
 
 #### Customizations and integrations
 
-   - **Customizability**
-      Jaeger offers a highly customizable and extensible platform, allowing developers to configure the system according to their specific needs. One of its key strengths is the ability to adjust the sampling rate, enabling developers to control the amount of data captured.
-      On the other hand, Sentry provides a simpler configuration that focuses primarily on error tracking, with fewer customization options for distributed tracing. While Sentry supports custom error grouping and basic issue tracking, it lacks the deep configurability Jaeger offers for handling tracing data at scale, especially in complex environments like Kubernetes.
-    - **Integration with [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)**
-      Jaeger operates independently but can be integrated with the OpenTelemetry Collector, which can run as a sidecar, host agent/daemon, or central cluster. The OpenTelemetry Collector supports Jaeger's Remote Sampling protocol, which allows it to either serve static configurations directly from config files or proxy requests to the Jaeger backend for adaptive sampling.
-      This integration simplifies SDK configuration by pointing both trace export and sampling endpoints to a local host, eliminating the need for remote service discovery. It also enables data enrichment, such as adding Kubernetes pod names, and distributes the resource load for enrichment across all application hosts, though it introduces overhead due to marshaling and unmarshaling data.
-      In contrast, Sentry integrates with external tools for alerts and notifications but lacks the same level of flexibility and integration with OpenTelemetry. Sentry does not support the advanced data enrichment capabilities or intricate integration features that Jaeger offers, especially when dealing with distributed systems.
-      <Figure
-        src="/img/comparisons/2025/01/sentry-alternatives-image%2016.webp"
-        alt="Jaeger's integration with OpenTelemetry Collector"
-        caption="Jaeger's integration with OpenTelemetry Collector"
-      />
-    - **Distributed Tracing**
-      Jaeger excels with its advanced configurability, particularly in large-scale and complex environments like Kubernetes. It offers features such as remote and adaptive sampling, which can fine-tune the tracing process to ensure that only relevant data is collected. This flexibility makes it suitable for teams that need detailed control over their tracing data.
-      On the other hand, Sentry is focused mainly on error tracking and grouping based on error patterns. While it provides basic performance monitoring and release tracking, it does not offer the same in-depth distributed tracing features as Jaeger, limiting its capabilities for complex tracing scenarios.
+- **Customizability**
+  Jaeger offers a highly customizable and extensible platform, allowing developers to configure the system according to their specific needs. One of its key strengths is the ability to adjust the sampling rate, enabling developers to control the amount of data captured.
+  On the other hand, Sentry provides a simpler configuration that focuses primarily on error tracking, with fewer customization options for distributed tracing. While Sentry supports custom error grouping and basic issue tracking, it lacks the deep configurability Jaeger offers for handling tracing data at scale, especially in complex environments like Kubernetes.
+- **Integration with [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)**
+  Jaeger operates independently but can be integrated with the OpenTelemetry Collector, which can run as a sidecar, host agent/daemon, or central cluster. The OpenTelemetry Collector supports Jaeger's Remote Sampling protocol, which allows it to either serve static configurations directly from config files or proxy requests to the Jaeger backend for adaptive sampling.
+  This integration simplifies SDK configuration by pointing both trace export and sampling endpoints to a local host, eliminating the need for remote service discovery. It also enables data enrichment, such as adding Kubernetes pod names, and distributes the resource load for enrichment across all application hosts, though it introduces overhead due to marshaling and unmarshaling data.
+  In contrast, Sentry integrates with external tools for alerts and notifications but lacks the same level of flexibility and integration with OpenTelemetry. Sentry does not support the advanced data enrichment capabilities or intricate integration features that Jaeger offers, especially when dealing with distributed systems.
+  <Figure
+    src="/img/comparisons/2025/01/sentry-alternatives-image%2016.webp"
+    alt="Jaeger's integration with OpenTelemetry Collector"
+    caption="Jaeger's integration with OpenTelemetry Collector"
+  />
+- **Distributed Tracing**
+  Jaeger excels with its advanced configurability, particularly in large-scale and complex environments like Kubernetes. It offers features such as remote and adaptive sampling, which can fine-tune the tracing process to ensure that only relevant data is collected. This flexibility makes it suitable for teams that need detailed control over their tracing data.
+  On the other hand, Sentry is focused mainly on error tracking and grouping based on error patterns. While it provides basic performance monitoring and release tracking, it does not offer the same in-depth distributed tracing features as Jaeger, limiting its capabilities for complex tracing scenarios.
 
 #### Security and compliance
 
@@ -1099,7 +1105,8 @@ Jaeger and Sentry both provide monitoring and observability tools, but they serv
     Jaeger is an excellent choice for teams focused on [distributed tracing in microservices](https://signoz.io/blog/distributed-tracing-in-microservices/), while Sentry serves as a great complement for tracking errors, performance anomalies, and overall application health. Together, they can provide a comprehensive observability solution for modern applications.
 
 <KeyPointCallout>
-Jaeger specializes in distributed tracing for microservices architectures, offering deep insights into service dependencies and performance bottlenecks.
+  Jaeger specializes in distributed tracing for microservices architectures, offering deep insights
+  into service dependencies and performance bottlenecks.
 </KeyPointCallout>
 
 ## 10. DataDog
@@ -1131,15 +1138,16 @@ Datadog provides a more extensive monitoring solution compared to Sentry, potent
 
 #### Pricing
 
-   - **Pricing Model**
-     Datadog uses a **per-host pricing model**, which can get **expensive** quickly, especially with additional features like APM, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), RUM, and extended data retention.
-     Sentry charges based on **event volume** and **user seats**, making it **more affordable** for smaller-scale use but requiring extra integrations for full observability.
-    - **Cost Predictability**
-      Datadog's **per-host model** can result in **scalable costs**, making it harder to budget as infrastructure grows.
-      Sentry offers **more predictable pricing** based on events and users but can become costly with increased event volume and additional features.
-    - **Coverage and Integrations**
-      Datadog provides **comprehensive features** with broad coverage, including APM, infrastructure monitoring, and RUM, but at a higher cost.
-      Sentry offers basic **event monitoring**, requiring **additional integrations** to match Datadog's level of observability, potentially increasing complexity and cost at scale.
+- **Pricing Model**
+  Datadog uses a **per-host pricing model**, which can get **expensive** quickly, especially with additional features like APM, [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), RUM, and extended data retention.
+  Sentry charges based on **event volume** and **user seats**, making it **more affordable** for smaller-scale use but requiring extra integrations for full observability.
+- **Cost Predictability**
+  Datadog's **per-host model** can result in **scalable costs**, making it harder to budget as infrastructure grows.
+  Sentry offers **more predictable pricing** based on events and users but can become costly with increased event volume and additional features.
+- **Coverage and Integrations**
+  Datadog provides **comprehensive features** with broad coverage, including APM, infrastructure monitoring, and RUM, but at a higher cost.
+  Sentry offers basic **event monitoring**, requiring **additional integrations** to match Datadog's level of observability, potentially increasing complexity and cost at scale.
+
 #### Instrumentation and performance overhead
 
     - **Resource Overhead**
@@ -1151,6 +1159,7 @@ Datadog provides a more extensive monitoring solution compared to Sentry, potent
     - **Proactive Debugging**
       Datadog's synthetic monitoring allows it to identify and address potential performance problems before they impact end users.
       Sentry, by comparison, excels in diagnosing issues after they occur but doesn't provide the same level of early-stage performance tuning.
+
 #### Data Architecture
 
     - **Backend Architecture**
@@ -1162,6 +1171,7 @@ Datadog provides a more extensive monitoring solution compared to Sentry, potent
     - **Flexibility and Control**
       Datadog offers a **fully managed solution**, providing ease of use and automatic scalability but less control over backend configurations.
       Sentry provides the option for **self-hosting**, offering greater control over storage and scaling strategies, though this adds management complexity
+
 #### Customizations and integrations
 
     - **Incident Management**:
@@ -1173,6 +1183,7 @@ Datadog provides a more extensive monitoring solution compared to Sentry, potent
     - **CI/CD Integration**:
       **Datadog p**rovides extensive CI/CD integrations, such as deployment tracking, custom error grouping, and support for IaC tools like Terraform.
       **Sentry,** primarily focuses on error tracking and reporting within the development pipeline, offering advanced error grouping algorithms but fewer CI/CD hooks and APIs than Datadog.
+
 #### Security and compliance
 
     | **Aspect**     | **Datadog**                                                                                                  | **Sentry**                                                                          |
@@ -1182,7 +1193,8 @@ Datadog provides a more extensive monitoring solution compared to Sentry, potent
     | **Compliance** | SOC 2, GDPR, HIPAA, ISO 27001                                                                                | SOC2 Type I & II, HIPAA Attestation, ISO 27001.                                     |
 
 <KeyPointCallout>
-Datadog delivers comprehensive monitoring and observability features with extensive integrations, ideal for organizations requiring a complete DevOps monitoring solution.
+  Datadog delivers comprehensive monitoring and observability features with extensive integrations,
+  ideal for organizations requiring a complete DevOps monitoring solution.
 </KeyPointCallout>
 
 ## Additional Considerations for Choosing a Sentry Alternative
@@ -1198,33 +1210,33 @@ Datadog delivers comprehensive monitoring and observability features with extens
 Selecting an alternative to Sentry involves a thorough evaluation of technical, operational, and compliance aspects to ensure the chosen tool aligns with your needs. Below are key factors to consider in detail:
 
 1. **Project Size & Complexity**
-    - **Scalability**: Verify the tool can scale with your application, whether it's a microservices architecture, a monolithic system, or a serverless setup. Look for features like [distributed tracing](https://signoz.io/distributed-tracing/) and support for asynchronous workflows. Distributed tracing helps scalability by providing a comprehensive view of how requests flow through a system, making it easier to identify bottlenecks and optimize performance as the application grows.
-      Similarly, **support for** asynchronous workflows ensures accurate monitoring of background tasks and parallel processes, which are crucial in handling increased load efficiently.
-    - **Technology Stack**: Confirm the tool supports your tech stack, including programming languages, frameworks, and runtime environments.
-      For example, check if it has native integrations for Python, Java, Node.js, or other languages you use.
-      Additionally, ensure the tool aligns with your deployment strategy, whether it's cloud-based, on-premises, or hybrid, and supports containerized environments like Docker or orchestration tools like Kubernetes.
-    - **Event Throughput**: Ensure the solution can handle your expected volume of error events and traces without performance degradation. Look for features like rate limiting, batching, or load balancing to ensure efficient processing at scale.
-      Additionally, verify the tool's ability to handle peak traffic periods without slowing down or losing data.
+   - **Scalability**: Verify the tool can scale with your application, whether it's a microservices architecture, a monolithic system, or a serverless setup. Look for features like [distributed tracing](https://signoz.io/distributed-tracing/) and support for asynchronous workflows. Distributed tracing helps scalability by providing a comprehensive view of how requests flow through a system, making it easier to identify bottlenecks and optimize performance as the application grows.
+     Similarly, **support for** asynchronous workflows ensures accurate monitoring of background tasks and parallel processes, which are crucial in handling increased load efficiently.
+   - **Technology Stack**: Confirm the tool supports your tech stack, including programming languages, frameworks, and runtime environments.
+     For example, check if it has native integrations for Python, Java, Node.js, or other languages you use.
+     Additionally, ensure the tool aligns with your deployment strategy, whether it's cloud-based, on-premises, or hybrid, and supports containerized environments like Docker or orchestration tools like Kubernetes.
+   - **Event Throughput**: Ensure the solution can handle your expected volume of error events and traces without performance degradation. Look for features like rate limiting, batching, or load balancing to ensure efficient processing at scale.
+     Additionally, verify the tool's ability to handle peak traffic periods without slowing down or losing data.
 2. **Budget & Pricing Models**
-    - **Usage Metrics**: Assess pricing models based on key metrics such as the number of events, traces, or seats. For high-traffic applications, tools offering unlimited events with flat-rate pricing might be cost-effective. Consider whether the tool offers tiered pricing or pay-as-you-go plans that align with your usage patterns.
-    - **Hidden Costs**: Look for potential additional expenses, such as charges for data retention extensions, API usage, or integration with external tools like Slack or PagerDuty.
-      Be mindful of potential "gotchas" like fees for advanced features, historical data access, or additional storage beyond the basic plan.
-    - **Trial Period**: Try to opt for tools that provide a free trial or tier, allowing you to evaluate their features without commitment. This can help you test scalability, usability, and integration capabilities before fully committing.
+   - **Usage Metrics**: Assess pricing models based on key metrics such as the number of events, traces, or seats. For high-traffic applications, tools offering unlimited events with flat-rate pricing might be cost-effective. Consider whether the tool offers tiered pricing or pay-as-you-go plans that align with your usage patterns.
+   - **Hidden Costs**: Look for potential additional expenses, such as charges for data retention extensions, API usage, or integration with external tools like Slack or PagerDuty.
+     Be mindful of potential "gotchas" like fees for advanced features, historical data access, or additional storage beyond the basic plan.
+   - **Trial Period**: Try to opt for tools that provide a free trial or tier, allowing you to evaluate their features without commitment. This can help you test scalability, usability, and integration capabilities before fully committing.
 3. **Integration & Ecosystem Fit**
-    - **CI/CD Integration**: Ensure the tool integrates seamlessly with your continuous integration and deployment pipelines. For example, check compatibility with GitHub Actions, Jenkins, or GitLab CI/CD for tracking deployment-specific issues.
-      Also, verify whether the tool supports version control systems for automatic release tracking and issue linking.
-    - **Observability Suite**: Verify that the error tracker can complement your existing observability stack. Look for out-of-the-box support for metrics and logging correlation, and check if the tool integrates well with monitoring platforms like Prometheus, Grafana, or Datadog.
-    - **Automation Support**: Ensure the tool provides robust APIs or SDKs for automating workflows, such as custom alerts or automated ticket creation in systems like Jira or Trello.
-      Additionally, check whether the tool supports webhooks to integrate with other alerting or notification systems.
+   - **CI/CD Integration**: Ensure the tool integrates seamlessly with your continuous integration and deployment pipelines. For example, check compatibility with GitHub Actions, Jenkins, or GitLab CI/CD for tracking deployment-specific issues.
+     Also, verify whether the tool supports version control systems for automatic release tracking and issue linking.
+   - **Observability Suite**: Verify that the error tracker can complement your existing observability stack. Look for out-of-the-box support for metrics and logging correlation, and check if the tool integrates well with monitoring platforms like Prometheus, Grafana, or Datadog.
+   - **Automation Support**: Ensure the tool provides robust APIs or SDKs for automating workflows, such as custom alerts or automated ticket creation in systems like Jira or Trello.
+     Additionally, check whether the tool supports webhooks to integrate with other alerting or notification systems.
 4. **Data Privacy & Compliance**
-    - **Regulatory Adherence**: Verify the solution complies with regulatory frameworks like GDPR, HIPAA, or CCPA. This is especially crucial if your application handles sensitive user data. Ensure the vendor provides details about their compliance certifications and regularly updated audit reports.
-    - **Data Residency**: Check if the tool allows you to specify data storage locations to meet local data residency requirements. Confirm if the solution supports multiple regions or cloud providers for better control over data sovereignty.
-    - **Anonymization Features**: Ensure it provides capabilities to redact or mask sensitive data from logs and error traces. Look for configurable settings that can automatically remove or obfuscate personally identifiable information (PII) or other sensitive data points.
+   - **Regulatory Adherence**: Verify the solution complies with regulatory frameworks like GDPR, HIPAA, or CCPA. This is especially crucial if your application handles sensitive user data. Ensure the vendor provides details about their compliance certifications and regularly updated audit reports.
+   - **Data Residency**: Check if the tool allows you to specify data storage locations to meet local data residency requirements. Confirm if the solution supports multiple regions or cloud providers for better control over data sovereignty.
+   - **Anonymization Features**: Ensure it provides capabilities to redact or mask sensitive data from logs and error traces. Look for configurable settings that can automatically remove or obfuscate personally identifiable information (PII) or other sensitive data points.
 5. **Support & Community**
-    - **Documentation Quality**: Evaluate the depth and clarity of the documentation. Look for comprehensive guides, API references, and troubleshooting sections. Ideally, documentation should be frequently updated with examples and real-world use cases.
-    - **Support Channels**: Check the availability of support through live chat, email, or dedicated account managers for enterprise-level plans. Also, assess the availability of service-level agreements (SLAs) for support response times, especially for critical issues.
-    - **Community Engagement**: Look for an active user community or forums where you can get quick resolutions for common issues. Open-source tools often have strong GitHub communities for reporting bugs and sharing plugins.
-      You should also assess the vendor's involvement in online communities or forums, as this can indicate the level of investment in customer satisfaction.
+   - **Documentation Quality**: Evaluate the depth and clarity of the documentation. Look for comprehensive guides, API references, and troubleshooting sections. Ideally, documentation should be frequently updated with examples and real-world use cases.
+   - **Support Channels**: Check the availability of support through live chat, email, or dedicated account managers for enterprise-level plans. Also, assess the availability of service-level agreements (SLAs) for support response times, especially for critical issues.
+   - **Community Engagement**: Look for an active user community or forums where you can get quick resolutions for common issues. Open-source tools often have strong GitHub communities for reporting bugs and sharing plugins.
+     You should also assess the vendor's involvement in online communities or forums, as this can indicate the level of investment in customer satisfaction.
 
 ## Comparing Scalability and Pricing Models
 
@@ -1362,7 +1374,7 @@ Transitioning from Sentry to a new error-tracking solution involves technical co
 
 ### Migrating from Sentry to SigNoz
 
-  <Figure
+<Figure
   src="/img/comparisons/2025/01/sentry-alternatives-image%2024.webp"
   alt="Exception Monitoring with SigNoz"
   caption="Exception Monitoring with SigNoz"
@@ -1372,69 +1384,68 @@ If you've chosen SigNoz as your Sentry alternative, follow these steps:
 
 1. **Set Up SigNoz**
 
-    Begin by choosing the appropriate deployment model for SigNoz. If you opt for the **cloud offering**, simply create an account and follow the onboarding process.
+   Begin by choosing the appropriate deployment model for SigNoz. If you opt for the **cloud offering**, simply create an account and follow the onboarding process.
 
-    For the **self-hosted option**, ensure you have the required infrastructure and install SigNoz using its Docker Compose or Helm chart setup. Verify that the platform is running correctly by checking its user interface and initial metrics.
+   For the **self-hosted option**, ensure you have the required infrastructure and install SigNoz using its Docker Compose or Helm chart setup. Verify that the platform is running correctly by checking its user interface and initial metrics.
 
 2. **Integrate OpenTelemetry SDK**
 
-    OpenTelemetry serves as the backbone for SigNoz. Select the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) for your application's programming language and integrate it following SigNoz's language-specific documentation.
-
-    This involves configuring the SDK to send trace and error data to SigNoz. Include instrumentation for critical application components such as HTTP requests, database queries, and custom spans to ensure comprehensive monitoring.
+   OpenTelemetry serves as the backbone for SigNoz. Select the [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) for your application's programming language and integrate it following SigNoz's language-specific documentation.
 
-    Here are some popular language-specific OpenTelemetry instrumentation guides to help you get started:
+   This involves configuring the SDK to send trace and error data to SigNoz. Include instrumentation for critical application components such as HTTP requests, database queries, and custom spans to ensure comprehensive monitoring.
 
-    1. [**OpenTelemetry Python Instrumentation**](https://signoz.io/docs/instrumentation/python/)
-    2. [**OpenTelemetry Javascript Instrumentation**](https://signoz.io/docs/instrumentation/javascript/)
-    3. [**OpenTelemetry Java Instrumentation**](https://signoz.io/docs/instrumentation/java/)
-    4. [**OpenTelemetry Go Instrumentation**](https://signoz.io/docs/instrumentation/golang/)
-    5. [**OpenTelemetry PHP Instrumentation**](https://signoz.io/docs/instrumentation/php/)
+   Here are some popular language-specific OpenTelemetry instrumentation guides to help you get started:
+   1. [**OpenTelemetry Python Instrumentation**](https://signoz.io/docs/instrumentation/python/)
+   2. [**OpenTelemetry Javascript Instrumentation**](https://signoz.io/docs/instrumentation/javascript/)
+   3. [**OpenTelemetry Java Instrumentation**](https://signoz.io/docs/instrumentation/java/)
+   4. [**OpenTelemetry Go Instrumentation**](https://signoz.io/docs/instrumentation/golang/)
+   5. [**OpenTelemetry PHP Instrumentation**](https://signoz.io/docs/instrumentation/php/)
 
-    and many [more](https://signoz.io/docs/instrumentation/overview/).
+   and many [more](https://signoz.io/docs/instrumentation/overview/).
 
 3. **Match Error Capturing**
 
-    When migrating from **Sentry** to **SigNoz**, it's important to match errors correctly. **SigNoz** ties errors to [traces and spans](https://signoz.io/comparisons/opentelemetry-trace-vs-span/), so you need to ensure that error events from **Sentry** align with the new tracing context in **SigNoz** for accurate tracking.
+   When migrating from **Sentry** to **SigNoz**, it's important to match errors correctly. **SigNoz** ties errors to [traces and spans](https://signoz.io/comparisons/opentelemetry-trace-vs-span/), so you need to ensure that error events from **Sentry** align with the new tracing context in **SigNoz** for accurate tracking.
 
-    When comparing error capturing between **Sentry** and **SigNoz**, the key difference lies in their integration and focus areas. Sentry captures errors using its SDK through the `capture_exception` method, which either accepts a caught exception directly or relies on the current exception from `sys.exc_info()`. This method sends exceptions as events to Sentry's backend for analysis and storage, offering rich debugging information like stack traces and breadcrumbs.
+   When comparing error capturing between **Sentry** and **SigNoz**, the key difference lies in their integration and focus areas. Sentry captures errors using its SDK through the `capture_exception` method, which either accepts a caught exception directly or relies on the current exception from `sys.exc_info()`. This method sends exceptions as events to Sentry's backend for analysis and storage, offering rich debugging information like stack traces and breadcrumbs.
 
-    On the other hand, **SigNoz**, built on OpenTelemetry, captures errors within the context of traces. It uses the `record_exception` method to convert exceptions into span events, associating errors directly with a specific trace.
+   On the other hand, **SigNoz**, built on OpenTelemetry, captures errors within the context of traces. It uses the `record_exception` method to convert exceptions into span events, associating errors directly with a specific trace.
 
-    <Figure
-      src="/img/comparisons/2025/01/sentry-alternatives-image%2025.webp"
-      alt="SigNoz vs Sentry exception handling"
-      caption="SigNoz vs Sentry exception handling"
-    />
+   <Figure
+     src="/img/comparisons/2025/01/sentry-alternatives-image%2025.webp"
+     alt="SigNoz vs Sentry exception handling"
+     caption="SigNoz vs Sentry exception handling"
+   />
 
-    Additionally, SigNoz updates the span status to reflect the failure, providing a more comprehensive context for observability that includes not only error reporting but also tracing and metrics.
+   Additionally, SigNoz updates the span status to reflect the failure, providing a more comprehensive context for observability that includes not only error reporting but also tracing and metrics.
 
-    While **Sentry** is primarily geared towards error monitoring and debugging with minimal setup, **SigNoz** provides a [unified observability](https://signoz.io/unified-observability/) framework that combines error capturing, tracing, and metrics for deeper insights into application performance and failure.
+   While **Sentry** is primarily geared towards error monitoring and debugging with minimal setup, **SigNoz** provides a [unified observability](https://signoz.io/unified-observability/) framework that combines error capturing, tracing, and metrics for deeper insights into application performance and failure.
 
 4. **Create Custom Dashboards**
 
-    Recreate your most-used Sentry views in SigNoz. Use its dashboarding tools to design custom panels that provide insights into error frequency, response times, and affected users. Tailor these dashboards to align with your team's workflows, ensuring minimal disruption during the transition.
+   Recreate your most-used Sentry views in SigNoz. Use its dashboarding tools to design custom panels that provide insights into error frequency, response times, and affected users. Tailor these dashboards to align with your team's workflows, ensuring minimal disruption during the transition.
 
 5. **Set Up Alerts**
 
-    Replicate critical notifications from Sentry in SigNoz by setting up alerts. Define thresholds for error rates, latency, and other key metrics, and configure alerting channels such as email, Slack, or PagerDuty. Test the alerts to ensure they trigger correctly and provide actionable information.
+   Replicate critical notifications from Sentry in SigNoz by setting up alerts. Define thresholds for error rates, latency, and other key metrics, and configure alerting channels such as email, Slack, or PagerDuty. Test the alerts to ensure they trigger correctly and provide actionable information.
 
 6. **Staged Migration**
 
-    Gradually shift your team's focus to SigNoz for error analysis. Start by monitoring both platforms in parallel, allowing your team to familiarize themselves with SigNoz while keeping Sentry as a fallback.
+   Gradually shift your team's focus to SigNoz for error analysis. Start by monitoring both platforms in parallel, allowing your team to familiarize themselves with SigNoz while keeping Sentry as a fallback.
 
-    Compare the data captured by both tools to identify gaps or discrepancies. Once confident, fully transition to SigNoz and decommission Sentry.
+   Compare the data captured by both tools to identify gaps or discrepancies. Once confident, fully transition to SigNoz and decommission Sentry.
 
 7. **Train Your Team**
 
-    Provide your team with tutorials and training sessions on using SigNoz. Focus on navigating the interface, interpreting metrics, and leveraging OpenTelemetry for custom tracing.
+   Provide your team with tutorials and training sessions on using SigNoz. Focus on navigating the interface, interpreting metrics, and leveraging OpenTelemetry for custom tracing.
 
-    Create internal documentation to ensure new team members can quickly adapt to the new system.
+   Create internal documentation to ensure new team members can quickly adapt to the new system.
 
 8. **Monitor and Optimize**
 
-    Post-migration, regularly review your SigNoz setup to optimize its performance. [Analyze metrics](https://signoz.io/blog/metrics-explorer/) and feedback to fine-tune dashboards, alerts, and instrumentation.
+   Post-migration, regularly review your SigNoz setup to optimize its performance. [Analyze metrics](https://signoz.io/blog/metrics-explorer/) and feedback to fine-tune dashboards, alerts, and instrumentation.
 
-    Stay updated on SigNoz's latest features to continuously enhance your monitoring capabilities.
+   Stay updated on SigNoz's latest features to continuously enhance your monitoring capabilities.
 
 ## Key Takeaways
 
diff --git a/data/comparisons/solarwinds-alternatives.mdx b/data/comparisons/solarwinds-alternatives.mdx
index 8d8b3a785..ea809fae2 100644
--- a/data/comparisons/solarwinds-alternatives.mdx
+++ b/data/comparisons/solarwinds-alternatives.mdx
@@ -1,13 +1,22 @@
 ---
-
 title: Top 7 SolarWinds Alternatives for Network Monitoring in 2025
-slug: solarwinds-alternatives
+
 date: 2025-01-02
 tags: [tools-comparision]
 authors: [soumya_gupta]
 description: Discover the top 7 SolarWinds alternatives for network monitoring in 2024. Compare features, pricing, and find the best solution for your organization.
-keywords: [solarwinds alternatives, network monitoring, PRTG, Zabbix, Datadog, ManageEngine OpManager, Nagios, LogicMonitor, Netreo]
-
+keywords:
+  [
+    solarwinds alternatives,
+    network monitoring,
+    PRTG,
+    Zabbix,
+    Datadog,
+    ManageEngine OpManager,
+    Nagios,
+    LogicMonitor,
+    Netreo,
+  ]
 ---
 
 Network monitoring is crucial for maintaining a robust IT infrastructure. As organizations seek alternatives to SolarWinds, the market offers a range of powerful solutions. This article explores the top 7 SolarWinds alternatives for network monitoring in 2024, helping you make an informed decision for your organization's needs.
@@ -30,7 +39,11 @@ Here are the top 7 [SolarWinds alternatives](https://signoz.io/comparisons/solar
 
 PRTG simplifies monitoring your entire IT infrastructure, such as network, cloud apps, databases, and storage systems, all within a single application. Unlike SolarWinds, which charges extra for various features like flow or server monitoring, forcing you to buy multiple modules, PRTG offers a comprehensive set of features in one package. This approach saves you from juggling multiple specialized tools and reduces costs, time, and effort.
 
-<Figure src="/img/comparisons/2024/08/solarwinds-alternatives-image.webp" alt="PRTG Network Monitor" caption="PRTG Network Monitor" /> 
+<Figure
+  src="/img/comparisons/2024/08/solarwinds-alternatives-image.webp"
+  alt="PRTG Network Monitor"
+  caption="PRTG Network Monitor"
+/>
 
 PRTG Network Monitor stands out for its user-friendly approach to comprehensive network monitoring:
 
@@ -44,23 +57,33 @@ PRTG Network Monitor stands out for its user-friendly approach to comprehensive
 
 SolarWinds comes with a wide range of built-in features and predefined templates, but its customization options can be more limited compared to Zabbix. Zabbix, on the other hand, offers great flexibility and allows you to tailor the monitoring system to your exact needs. While SolarWinds provides scalability and a user-friendly interface, it tends to be more expensive. Zabbix is more budget-friendly, supports multiple platforms, and gives you extensive customization options.
 
-<Figure src="/img/comparisons/2024/08/solarwinds-alternatives-image%201.webp" alt="Zabbix Dashboard" caption="Zabbix Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/solarwinds-alternatives-image%201.webp"
+  alt="Zabbix Dashboard"
+  caption="Zabbix Dashboard"
+/>
 
 Zabbix offers an open-source alternative with enterprise-grade capabilities:
 
 - Highly customizable: Adapt the tool to your specific monitoring needs with extensive configuration options. Zabbix can help you enhance the frontend by creating custom widgets and modules, allowing you to tailor how you view and visualize your data. You can easily add new features, make adjustments, and even perform internal audits to ensure it meets your security requirements.
 - Large community: Benefit from regular updates and a wealth of community-contributed resources, including social media channels, lively discussion forums, insightful blog posts, and extensive developer tools. They encourage users to actively engage with experts and enhance their experience through shared knowledge.
-    
-    <Figure src="/img/comparisons/2024/08/solarwinds-alternatives-image%202.webp" alt="Zabbix Community Tab" caption="Zabbix Community Tab" />
-    
+  <Figure
+    src="/img/comparisons/2024/08/solarwinds-alternatives-image%202.webp"
+    alt="Zabbix Community Tab"
+    caption="Zabbix Community Tab"
+  />
 - Scalability: Suitable for both small networks and large-scale enterprise deployments. Zabbix offers proxies, that are easily deployable, for adding an extra layer of scalability. You can scale up to collect millions of metrics from thousands of devices, services, applications, etc.
 - No licensing costs: As an open-source solution, Zabbix can significantly reduce your monitoring expenses, making it cost-effective for businesses on constrained budgets. A paid enterprise version with additional features and support is also available. Unlike proprietary software, Zabbix helps you avoid vendor lock-in since there are no initial costs.
 
 ### 3. Datadog
 
-Unlike SolarWinds, Datadog has an extensive integration ecosystem, making it simple for users to connect and gather data from a wide variety of tools, services, and platforms. It contains built-in integrations for popular cloud providers, container technologies, monitoring agents, databases, etc. 
+Unlike SolarWinds, Datadog has an extensive integration ecosystem, making it simple for users to connect and gather data from a wide variety of tools, services, and platforms. It contains built-in integrations for popular cloud providers, container technologies, monitoring agents, databases, etc.
 
-<Figure src="/img/comparisons/2024/08/solarwinds-alternatives-image%203.webp" alt="DataDog Monitoring Solution" caption="DataDog Monitoring Solution" />
+<Figure
+  src="/img/comparisons/2024/08/solarwinds-alternatives-image%203.webp"
+  alt="DataDog Monitoring Solution"
+  caption="DataDog Monitoring Solution"
+/>
 
 For organizations embracing cloud technologies, Datadog provides a modern monitoring solution:
 
@@ -73,7 +96,11 @@ For organizations embracing cloud technologies, Datadog provides a modern monito
 
 ManageEngine OpManager is a user-friendly and cost-effective network monitoring solution that covers a wide range of devices. It can keep an eye on everything from routers and switches to firewalls, load balancers, wireless LAN controllers, servers, VMs, printers, and storage devices, essentially, any network-connected device with an IP address.
 
-<Figure src="/img/comparisons/2024/08/solarwinds-alternatives-image%204.webp" alt="ManageEngine OpManager Dashboard" caption="ManageEngine OpManager Dashboard" />
+<Figure
+  src="/img/comparisons/2024/08/solarwinds-alternatives-image%204.webp"
+  alt="ManageEngine OpManager Dashboard"
+  caption="ManageEngine OpManager Dashboard"
+/>
 
 ManageEngine OpManager caters to small and medium-sized businesses with a comprehensive yet affordable solution:
 
@@ -89,7 +116,7 @@ Nagios is a robust open-source monitoring system that helps companies detect and
 Nagios remains a powerful option for organizations with technical expertise:
 
 - Robust open-source core: As an open-source tool, Nagios is free to use and offers extensive customization options, making it adaptable to various applications and network infrastructures. Its flexibility allows for tailored solutions to meet specific needs.
-- Extensive plugin ecosystem:  Nagios supports a wide range of plugins—compiled executables or scripts—that monitor everything from databases and operating systems to applications and network equipment. These plugins enable detailed status checks of services and hosts.
+- Extensive plugin ecosystem: Nagios supports a wide range of plugins—compiled executables or scripts—that monitor everything from databases and operating systems to applications and network equipment. These plugins enable detailed status checks of services and hosts.
 - Detailed documentation: Nagios benefits from a vibrant and engaged user community that provides a wealth of resources, plugins, and community-developed extensions. This active support network makes it easier to troubleshoot problems and find solutions to common issues.
 - Scalability: Nagios is well-regarded for its scalability, making it easy to keep an eye on a huge number of devices and systems all at once. It’s capable of handling thousands of checks per second, so it’s a great fit for larger organizations with sprawling networks.
 - Operating System: Another area where SolarWinds falls short is its operating system compatibility. It only works with Windows systems and doesn't support other operating systems. In contrast, Nagios offers broad support for monitoring across various platforms, including Windows, Linux, Unix, Solaris, AIX, HP-UX, and Mac OS/X.
@@ -105,7 +132,7 @@ LogicMonitor leverages its Edwin AI to deliver [proactive monitoring](https://si
 
 ### 7. Netreo
 
-Netreo streamlines onboarding with automation, a user-friendly interface, and customizable dashboards, reducing training time and speeding up device discovery. It enables IT teams to quickly enhance performance through real-time monitoring, polling, and synthetic transactions, providing full visibility into your cloud environment. 
+Netreo streamlines onboarding with automation, a user-friendly interface, and customizable dashboards, reducing training time and speeding up device discovery. It enables IT teams to quickly enhance performance through real-time monitoring, polling, and synthetic transactions, providing full visibility into your cloud environment.
 
 Netreo focuses on providing end-to-end visibility across complex IT environments:
 
@@ -159,4 +186,3 @@ Yes, most modern monitoring solutions, including the alternatives listed, suppor
 ### What features should I prioritize when choosing a network monitoring tool?
 
 Focus on comprehensive coverage of your IT assets, real-time alerting, customizable dashboards, scalability, and integration capabilities with your existing tools and workflows.
-
diff --git a/data/comparisons/splunk-vs-dynatrace.mdx b/data/comparisons/splunk-vs-dynatrace.mdx
index 796636cdc..0718a9185 100644
--- a/data/comparisons/splunk-vs-dynatrace.mdx
+++ b/data/comparisons/splunk-vs-dynatrace.mdx
@@ -1,44 +1,45 @@
 ---
 title: Splunk vs Dynatrace - Which Tool To Choose? [2025 Guide]
-slug: splunk-vs-dynatrace
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: We have compared Splunk and Dynatrace by sending data from a sample application to both platforms and comparing our experience. Check out Splunk vs Dynatrace across key aspects like APM, log management, application security, pricing...
 image: /img/blog/2024/03/splunk-vs-dynatrace-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [splunk-vs-dynatrace,splunk,dynatrace,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [splunk-vs-dynatrace, splunk, dynatrace, opentelemetry, open-source, monitoring-tools, signoz]
 ---
 
 Splunk and Dynatrace are monitoring tools that provide a wide range of products and services for monitoring. In this post, I have compared Splunk and Dynatrace on important features like APM, log management, application security, etc.
 
 <Admonition type="info">
-💡 I instrumented a sample application and sent data to Splunk and Dynatrace to evaluate my experience. Some takeaways are subjective and based on personal preference.
+  💡 I instrumented a sample application and sent data to Splunk and Dynatrace to evaluate my
+  experience. Some takeaways are subjective and based on personal preference.
 </Admonition>
 
-
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 ## Splunk vs Dynatrace: A Quick Overview
 
-| Features | Splunk | Dynatrace |
-| --- | --- | --- |
-| APM | ✅ | ✅ |
-| Log Management | ✅ | ✅ |
-| Application Security | ✅ | ✅ |
-| Real User Monitoring | ✅ | 🟡 |
-| Infrastructure Monitoring | ✅ | ✅  |
-| Network Monitoring | ✅ | ✅  |
-| AI-Driven Analytics | ✅ | ✅ |
-| Security Information and Event Management (SIEM) | ✅ | ❌ |
-| Synthetic Monitoring | ✅ | ✅ |
-| 15-day free trial | ✅ | ✅ |
+| Features                                         | Splunk | Dynatrace |
+| ------------------------------------------------ | ------ | --------- |
+| APM                                              | ✅     | ✅        |
+| Log Management                                   | ✅     | ✅        |
+| Application Security                             | ✅     | ✅        |
+| Real User Monitoring                             | ✅     | 🟡        |
+| Infrastructure Monitoring                        | ✅     | ✅        |
+| Network Monitoring                               | ✅     | ✅        |
+| AI-Driven Analytics                              | ✅     | ✅        |
+| Security Information and Event Management (SIEM) | ✅     | ❌        |
+| Synthetic Monitoring                             | ✅     | ✅        |
+| 15-day free trial                                | ✅     | ✅        |
 
 ✅ - Available
 
@@ -58,26 +59,36 @@ Splunk APM provides different visualization options to further understand your a
 
 For detecting and alerting customer issues, Splunk APM uses a streaming analytics engine that analyzes data in real-time, allowing for immediate detection and alerting of any customer issues.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-tracing-splunk.webp" alt="Tag-based grouping of traces"/>
-    <figcaption><i>Tag-based grouping of traces</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-tracing-splunk.webp"
+    alt="Tag-based grouping of traces"
+  />
+  <figcaption>
+    <i>Tag-based grouping of traces</i>
+  </figcaption>
 </figure>
 
-
 ### Dynatrace
 
-APM setup in Dynatrace wasn’t very clear as the APM feature is not immediately visible within the user interface. I was eventually able to carry out the APM setup by utilizing the One Agent SDK, which works with the Dynatrace One Agent. 
+APM setup in Dynatrace wasn’t very clear as the APM feature is not immediately visible within the user interface. I was eventually able to carry out the APM setup by utilizing the One Agent SDK, which works with the Dynatrace One Agent.
 
-Dynatrace provides end-to-end visibility into the entire application stack, including user experience, application code, dependencies, databases, and infrastructure components. It utilizes advanced AI algorithms to automatically identify anomalies and root causes, enabling proactive problem-solving before they impact end-users. 
+Dynatrace provides end-to-end visibility into the entire application stack, including user experience, application code, dependencies, databases, and infrastructure components. It utilizes advanced AI algorithms to automatically identify anomalies and root causes, enabling proactive problem-solving before they impact end-users.
 
 Its [distributed tracing](https://signoz.io/distributed-tracing/) capabilities provided me with detailed insights into relevant calls for each trace as well as the logs associated with them.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-traces-captured.webp" alt="Captured traces in Dynatrace"/>
-    <figcaption><i>Captured traces in Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-traces-captured.webp"
+    alt="Captured traces in Dynatrace"
+  />
+  <figcaption>
+    <i>Captured traces in Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 If you are looking for a comprehensive, AI-driven platform that provides real-time insights into the performance and health of applications, Dynatrace is the right tool.
 
 ## Log Management: Splunk for enterprise-level log management
@@ -88,24 +99,34 @@ Splunk is a powerful tool designed to handle large volumes of data, making it an
 
 For enhanced log management, Splunk utilizes the <a href = "https://www.splunk.com/en_us/products/log-observer-connect.html" rel="noopener noreferrer nofollow" target="_blank" >Log Observer Connect</a> feature which enables the correlation of logs with real-time metrics and traces. This allowed me to perform log-based analysis of my data through advanced search, filtering, and visualization capabilities. It was also very useful for monitoring and troubleshooting my application’s performance in cases of failures and downtime.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-log-observer.webp" alt="Log Observer in Splunk"/>
-    <figcaption><i>Log Observer in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-log-observer.webp"
+    alt="Log Observer in Splunk"
+  />
+  <figcaption>
+    <i>Log Observer in Splunk</i>
+  </figcaption>
 </figure>
 
-
 ### Dynatrace
 
 Log management in Dynatrace is being powered by <a href = "https://www.dynatrace.com/platform/grail" rel="noopener noreferrer nofollow" target="_blank" >Grail</a>, a powerful tool designed to manage log data efficiently without requiring schemas or indexing, which means that users can easily manage large amounts of log data, without the need for complex setup or manual intervention. Once I deployed the OneAgent on my host machine, it automatically ingested my log data into Dynatrace.
 
 Dyntrace allows users to define custom log ingestion rules with OneAgent and control the retention of log data by placing it into designated data retention buckets. Storing log data in buckets improves query performance by reducing query execution time and the scope of data read.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-log.webp" alt="Log management in Dynatrace"/>
-    <figcaption><i>Log management in Dynatrace</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-log.webp"
+    alt="Log management in Dynatrace"
+  />
+  <figcaption>
+    <i>Log management in Dynatrace</i>
+  </figcaption>
 </figure>
 
-
 If require a platform that can aggregate and analyze large log volumes from various sources, Splunk is the better choice. If you have less log management requirement, you can consider Dynatrace.
 
 ## Application Security: Splunk
@@ -120,12 +141,17 @@ Here’s what some of Splunk’s security products can do:
 - The Splunk Enterprise Security tool allows users to understand their organization's security posture. It also identifies potential security risks by analyzing diverse data sources and recognizing suspicious patterns indicative of attacks.
 - The Splunk attack analyzer helps to discover and investigate cyber-attacks and threats. It also provides information on how they can be rectified.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-dynatrace-security.webp" alt="Security monitoring in Splunk"/>
-    <figcaption><i>Security monitoring in Splunk</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-dynatrace-security.webp"
+    alt="Security monitoring in Splunk"
+  />
+  <figcaption>
+    <i>Security monitoring in Splunk</i>
+  </figcaption>
 </figure>
 
-
 ### Dynatrace
 
 Dyntrace uses its AI engine to protect applications and understand the security posture of your environment in real-time. This AI engine automatically assessed the risks in my application and provided me with remediation strategies. It can also detect and block threats, simplifying security analysis across all data in an environment.
@@ -136,7 +162,7 @@ If you require complete security of your entire environments and applications, S
 
 ### Splunk
 
-Splunk’s pricing model is complex and expensive. You get a 15-day free trial period after which you have to pay to keep using Splunk. 
+Splunk’s pricing model is complex and expensive. You get a 15-day free trial period after which you have to pay to keep using Splunk.
 
 Splunk provides several pricing options, including <a href = "https://www.splunk.com/en_us/products/pricing/workload-pricing.html" rel="noopener noreferrer nofollow" target="_blank" >workload Pricing</a>, entity Pricing, <a href = "https://www.splunk.com/en_us/products/pricing/ingest-pricing.html" rel="noopener noreferrer nofollow" target="_blank" >ingest Pricing</a>, and activity-based pricing, each tailored to different aspects of data usage and business requirements. The actual price of using Splunk is not explicitly stated on the Splunk website and so, users need to contact the sales team.
 
@@ -146,7 +172,7 @@ Dynatrace is also expensive to use but can be less expensive in contrast to Splu
 
 Dynatrace uses a consumption-based pricing approach where­ users are billed base­d on the number of monitored hosts, This is more predictable compared to Splunk's data ingest-based pricing where costs can escalate significantly with the volume of data ingested, leading to potentially higher costs for organizations with large volumes of log data.
 
-For organizations with smaller workloads or less extensive data management needs, Dynatrace offers a more cost-effective solution due to its all-in-one platform approach. 
+For organizations with smaller workloads or less extensive data management needs, Dynatrace offers a more cost-effective solution due to its all-in-one platform approach.
 
 ## AI-Driven Analytics: Dynatrace
 
@@ -194,4 +220,4 @@ Here are some notable features of SigNoz:
 
 [SigNoz vs Dynatrace](https://signoz.io/product-comparison/signoz-vs-dynatrace/)
 
-[Top 11 Splunk Alternatives in 2024 [Includes Free & Open-Source Tools]](https://signoz.io/blog/splunk-alternatives/)
\ No newline at end of file
+[Top 11 Splunk Alternatives in 2024 [Includes Free & Open-Source Tools]](https://signoz.io/blog/splunk-alternatives/)
diff --git a/data/comparisons/splunk-vs-prometheus.mdx b/data/comparisons/splunk-vs-prometheus.mdx
index 9034d63c1..4ca33b0f3 100644
--- a/data/comparisons/splunk-vs-prometheus.mdx
+++ b/data/comparisons/splunk-vs-prometheus.mdx
@@ -1,25 +1,26 @@
 ---
 title: Splunk vs Prometheus - In-depth Comparison for 2025
-slug: splunk-vs-prometheus
+
 date: 2025-01-02
 tags: [tools-comparison]
 authors: [daniel]
 description: Splunk is an enterprise monitoring tool popularly known for log monitoring, log analysis, and application security, while Prometheus is primarily for metrics monitoring...
 image: /img/blog/2024/03/splunk-vs-prometheus-cover.webp
 hide_table_of_contents: false
-toc_min_heading_level: 2
-toc_max_heading_level: 2
-keywords: [splunk-vs-prometheus,splunk,prometheus,opentelemetry,open-source,monitoring-tools,signoz]
+keywords:
+  [splunk-vs-prometheus, splunk, prometheus, opentelemetry, open-source, monitoring-tools, signoz]
 ---
-Splunk and Prometheus are popular monitoring tools used today by businesses and companies for monitoring data. Splunk is an enterprise monitoring tool that specializes in searching, monitoring, and analyzing machine-generated big data, while Prometheus is primarily for metrics monitoring. In this article, we will compare Splunk and Prometheus against their key features.
-
 
+Splunk and Prometheus are popular monitoring tools used today by businesses and companies for monitoring data. Splunk is an enterprise monitoring tool that specializes in searching, monitoring, and analyzing machine-generated big data, while Prometheus is primarily for metrics monitoring. In this article, we will compare Splunk and Prometheus against their key features.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-prometheus-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-prometheus-cover.webp"
+    alt=""
+  />
 </figure>
 
-
 Splunk is a powerful software platform used to search, analyze, and visualize machine-generated data and logs through a web interface in real-time. Beyond its core functionality in log analysis, Splunk offers a wide array of capabilities and features, including the monitoring of telemetry data, application performance monitoring (APM), application security, incident response, and more. This positions Splunk as a versatile solution for organizations seeking to delve deeply into the insights provided by their systems and applications.
 
 On the other hand, Prometheus is an open-source monitoring tool primarily used for monitoring metrics data. It collects and stores metrics as time-series data (metrics that change over time). Additionally, Prometheus includes robust alerting capabilities, allowing for [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and quick response to potential issues.
@@ -30,17 +31,17 @@ Monitoring is essential for maintaining the health and reliability of your appli
 
 Here’s a quick overview of the overall platform features and functionality of Splunk and Prometheus.
 
-| Features | Splunk | Prometheus |
-| --- | --- | --- |
-| Getting Started | 🟡 | ✅  |
-| Metrics Monitoring | ✅ | ✅ |
-| Log management | ✅ | ❌ |
-| Cloud SIEM | ✅ | ❌ |
-| Application Security | ✅ | ❌ |
-| Alerting | ✅ | 🟡 |
-| Visualization capabilities | ✅ | 🟡  |
-| UI/UX | 🟡 | 🟡  |
-| Free Tier | 🟡 | ✅  |
+| Features                   | Splunk | Prometheus |
+| -------------------------- | ------ | ---------- |
+| Getting Started            | 🟡     | ✅         |
+| Metrics Monitoring         | ✅     | ✅         |
+| Log management             | ✅     | ❌         |
+| Cloud SIEM                 | ✅     | ❌         |
+| Application Security       | ✅     | ❌         |
+| Alerting                   | ✅     | 🟡         |
+| Visualization capabilities | ✅     | 🟡         |
+| UI/UX                      | 🟡     | 🟡         |
+| Free Tier                  | 🟡     | ✅         |
 
 ✅ - Available
 
@@ -53,61 +54,53 @@ Here’s a quick overview of the overall platform features and functionality of
 Some of the key features of Splunk are:
 
 - **Security** <br />
-    
-    Splunk offers real-time monitoring and analysis of security events to detect and respond to threats effectively. 
-    
+  Splunk offers real-time monitoring and analysis of security events to detect and respond to threats effectively.
 - **Observability** <br />
-    
-    Splunk provides 360 visibility into your environment. It predicts and detects problems before customer impact and helps with the troubleshooting process.
-    
+  Splunk provides 360 visibility into your environment. It predicts and detects problems before customer impact and helps with the troubleshooting process.
 - **Incident management** <br />
-    
-    Splunk uses advanced analytics like anomaly detection and adaptive thresholding to predict and prevent issues before they impact performance.
-    
+  Splunk uses advanced analytics like anomaly detection and adaptive thresholding to predict and prevent issues before they impact performance.
 - **Query language** <br />
-    
-    Splunk uses a powerful query language called the Splunk "Search Processing Language” (SPL), a rich, expressive language for searching, filtering, and aggregating data machine data.
-    
+  Splunk uses a powerful query language called the Splunk "Search Processing Language” (SPL), a rich, expressive language for searching, filtering, and aggregating data machine data.
 - **Search and analysis** <br />
-    
-    Splunk has a powerful search engine designed to handle and analyze large volumes of data efficiently. It allows users to search, analyze, and get insights from massive datasets collected from various sources in real-time, using SPL. 
-    
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-prometheus-monitoring.webp" alt="Monitoring in Splunk"/>
-    <figcaption><i>Monitoring in Splunk</i></figcaption>
+  Splunk has a powerful search engine designed to handle and analyze large volumes of data efficiently. It allows users to search, analyze, and get insights from massive datasets collected from various sources in real-time, using SPL.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-prometheus-monitoring.webp"
+    alt="Monitoring in Splunk"
+  />
+  <figcaption>
+    <i>Monitoring in Splunk</i>
+  </figcaption>
 </figure>
 
-
 ## Key features of Prometheus
 
 Some of the key features of Prometheus are:
 
 - **Multi-dimensional data model**<br />
-    
-    It stores data as time series (data that is tracked at an increment in time). You can also store an optional set of key-value pairs called labels for those metrics. The multi-dimensional data model enables rich contextual metrics monitoring.
-    
+  It stores data as time series (data that is tracked at an increment in time). You can also store an optional set of key-value pairs called labels for those metrics. The multi-dimensional data model enables rich contextual metrics monitoring.
 - **Query language**<br />
-    
-    Prometheus uses a query language called “Prom QL” to query the metrics data collected.
-    
+  Prometheus uses a query language called “Prom QL” to query the metrics data collected.
 - **Pull model data collection over HTTP**<br />
-    
-    Data collection for Prometheus is pull-based. It pulls metrics from an application and exposes them in a format it understands on an HTTP endpoint.
-    
+  Data collection for Prometheus is pull-based. It pulls metrics from an application and exposes them in a format it understands on an HTTP endpoint.
 - **Alerting**<br />
-    
-    Prometheus uses Alert manager to create alerts on metrics. The alert manager also provides capabilities to group alerts in a single notification.
-    
+  Prometheus uses Alert manager to create alerts on metrics. The alert manager also provides capabilities to group alerts in a single notification.
 - **Visualization and dashboard**<br />
-    
-    Prometheus comes with a basic visualization layer and doesn’t allow for the creation of dashboards.
-    
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-prometheus-dashboards.webp" alt="Monitoring in Prometheus"/>
-    <figcaption><i>Monitoring in Prometheus</i></figcaption>
+  Prometheus comes with a basic visualization layer and doesn’t allow for the creation of dashboards.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-prometheus-dashboards.webp"
+    alt="Monitoring in Prometheus"
+  />
+  <figcaption>
+    <i>Monitoring in Prometheus</i>
+  </figcaption>
 </figure>
 
-
 ## Getting Started: Splunk vs Prometheus
 
 Splunk provides a cloud version, a fully managed service that doesn't require any installation. It comes with a 14-day free trial.
@@ -122,39 +115,49 @@ Metrics monitoring provides insights into system performance, resource utilizati
 
 ### Splunk
 
-Metrics monitoring in Splunk involves a comprehensive process that starts with the collection of metrics data from various sources. 
-
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-prometheus-data-sources.webp" alt="Splunk Data ingestion source"/>
-    <figcaption><i>Data sources Splunk  can ingest metrics from</i></figcaption>
+Metrics monitoring in Splunk involves a comprehensive process that starts with the collection of metrics data from various sources.
+
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-prometheus-data-sources.webp"
+    alt="Splunk Data ingestion source"
+  />
+  <figcaption>
+    <i>Data sources Splunk can ingest metrics from</i>
+  </figcaption>
 </figure>
 
-
 Other than ingesting metrics data, Splunk can automatically convert ingested log data into metrics and insert it into a specified metrics index.
 
 Once the metrics data is ingested, it is indexed and stored in Splunk's proprietary index format, for fast and efficient retrieval of metrics data during query and analysis.
 
-The metrics are then monitored in real-time using different visualizations.  Dashboards can be utilized for this as the <a href = "https://docs.splunk.com/observability/en/get-started/welcome.html" rel="noopener noreferrer nofollow" target="_blank" >Splunk Observability Cloud platform</a> comes with out-of-the-box dashboards. Custom dashboards can also be created to monitor custom or other specific metrics and alerts can be set up on the metrics.
+The metrics are then monitored in real-time using different visualizations. Dashboards can be utilized for this as the <a href = "https://docs.splunk.com/observability/en/get-started/welcome.html" rel="noopener noreferrer nofollow" target="_blank" >Splunk Observability Cloud platform</a> comes with out-of-the-box dashboards. Custom dashboards can also be created to monitor custom or other specific metrics and alerts can be set up on the metrics.
 
 Another way to monitor metrics in Splunk is through the use of the <a href = "https://docs.splunk.com/Documentation/Splunk/9.2.0/Analytics/About" rel="noopener noreferrer nofollow" target="_blank" >Analytics Workspace</a>. The Analytics Workspace provides a user interface that allows for monitoring and analysis of metrics and other time series without using SPL. It allows users to easily understand trends and patterns in their metrics data.
 
 ### Prometheus
 
-Prometheus is specifically designed for monitoring and alerting on metrics. Metrics monitoring in Prometheus starts with the collection of metric data from different data sources, by scraping metrics from HTTP endpoints exposed by monitored services at regular intervals. Once collected, Prometheus stores the metrics in a local database optimized for time-series data. 
+Prometheus is specifically designed for monitoring and alerting on metrics. Metrics monitoring in Prometheus starts with the collection of metric data from different data sources, by scraping metrics from HTTP endpoints exposed by monitored services at regular intervals. Once collected, Prometheus stores the metrics in a local database optimized for time-series data.
 
 This storage method allows for efficient querying and analysis of the metrics. These metrics can be queried using PromQL, a powerful query language, to analyze the collected metrics. Users can write queries to create temporary time series from the source data, allowing for real-[time aggregation](https://signoz.io/docs/metrics-management/types-and-aggregation/) and analysis. Alerts can then be set on these metrics for proactiveness in resolving issues before they escalate.
 
 The downside of metrics monitoring in Prometheus is its basic visualization, the expression browser, which doesn’t provide enough information to understand your metrics data. For better metrics visualization, users would have to send the metrics from Prometheus to a different visualization platform, like Grafana. Prometheus is usually used in combination with Grafana for visualization.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/03/splunk-vs-prometheus-browser.webp" alt="Prometheus expression browser"/>
-    <figcaption><i>Prometheus expression browser</i></figcaption>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/03/splunk-vs-prometheus-browser.webp"
+    alt="Prometheus expression browser"
+  />
+  <figcaption>
+    <i>Prometheus expression browser</i>
+  </figcaption>
 </figure>
 
-
 ## An alternative to Splunk and Prometheus - SigNoz
 
-While Splunk does offer good metrics monitoring capabilities, it's often not the first choice for organizations specifically looking for metric monitoring solutions, because of the costs that come with it. Splunk is more suited for enterprises and large-scale businesses, hence its robust features. 
+While Splunk does offer good metrics monitoring capabilities, it's often not the first choice for organizations specifically looking for metric monitoring solutions, because of the costs that come with it. Splunk is more suited for enterprises and large-scale businesses, hence its robust features.
 
 Prometheus, in contrast, is open-source and doesn’t require any license to install and use but you need to maintain it yourself which will require engineering bandwidth. However, its scope is limited to metrics alone. For a holistic understanding of your systems, metrics alone are insufficient. Logs and traces are equally crucial for comprehensive [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/) of services and infrastructure. In such cases, it is best to consider an alternative tool like [SigNoz](https://signoz.io/docs/introduction/).
 
@@ -172,4 +175,4 @@ Regarding cost, SigNoz is highly cost-effective. It is available both as an <a
 
 [Top 11 Splunk Alternatives in 2024 [Includes Free & Open-Source Tools]](https://signoz.io/blog/splunk-alternatives/#splunk-usecases)
 
-[New vs Splunk - Which Monitoring Tool Should You Choose?](https://signoz.io/comparisons/newrelic-vs-splunk/)
\ No newline at end of file
+[New vs Splunk - Which Monitoring Tool Should You Choose?](https://signoz.io/comparisons/newrelic-vs-splunk/)
diff --git a/data/comparisons/sre-tools.mdx b/data/comparisons/sre-tools.mdx
index 58521e659..c51dec402 100644
--- a/data/comparisons/sre-tools.mdx
+++ b/data/comparisons/sre-tools.mdx
@@ -1,20 +1,25 @@
 ---
-
 title: 10 Essential SRE Tools for Reliable Systems in 2023
-slug: sre-tools
 date: 2024-11-29
 tags: [SRE, DevOps]
 authors: [niyati_thakkar]
 description: Discover the top 10 SRE tools for 2023 to enhance system reliability, automate processes, and streamline operations in your organization.
-keywords: [SRE tools, site reliability engineering, monitoring, incident management, automation, observability]
-
+keywords:
+  [
+    SRE tools,
+    site reliability engineering,
+    monitoring,
+    incident management,
+    automation,
+    observability,
+  ]
 ---
 
 Site Reliability Engineering (SRE) has become essential for organizations striving to keep their systems both highly reliable and scalable. As modern software systems grow increasingly complex, SRE teams depend on a powerful suite of tools to automate tasks, monitor system health, and manage incidents quickly and precisely. In this article, we’ll dive into 10 essential SRE tools that are indispensable for building and sustaining reliable systems, helping teams enhance performance, streamline operations, and reduce downtime.
 
 ## What is Site Reliability Engineering (SRE) and Why Are Tools Important?
 
-Site Reliability Engineering (SRE) is a discipline that combines software engineering with IT operations, developed to ensure the reliability, scalability, and performance of complex software systems. Pioneered by Google, SRE introduces a unique approach to managing infrastructure and applications by applying engineering practices to solve operational problems. 
+Site Reliability Engineering (SRE) is a discipline that combines software engineering with IT operations, developed to ensure the reliability, scalability, and performance of complex software systems. Pioneered by Google, SRE introduces a unique approach to managing infrastructure and applications by applying engineering practices to solve operational problems.
 
 SRE teams are responsible for minimizing downtime, addressing incidents, and building automated solutions to manage and maintain systems at scale. SRE tools empower teams to automate processes such as monitoring, alerting, scaling, and incident response, making it easier to manage complex environments.
 
@@ -25,7 +30,7 @@ SRE tools play a vital role in this practice for several reasons:
 3. Incident Response: SRE tools help teams detect, diagnose, and resolve issues quickly.
 4. Scalability: These tools enable SRE teams to manage increasingly complex and distributed systems efficiently.
 
-SRE tools not only automate and simplify repetitive tasks but also provide the insights and control needed to proactively manage system reliability.  For organizations, this translates to reduced downtime, faster recovery, and a more reliable user experience—key benefits in today’s competitive, digital-first landscape.
+SRE tools not only automate and simplify repetitive tasks but also provide the insights and control needed to proactively manage system reliability. For organizations, this translates to reduced downtime, faster recovery, and a more reliable user experience—key benefits in today’s competitive, digital-first landscape.
 
 ## Top 10 SRE Tools for 2023: An Overview
 
@@ -35,7 +40,8 @@ Selecting the right SRE tools is crucial for building a robust reliability pract
 
 [SigNoz](https://signoz.io/) is an innovative open-source Application Performance Monitoring (APM) tool designed to provide comprehensive observability by combining [distributed tracing](https://signoz.io/blog/distributed-tracing/), metrics, and logs into a unified platform. Built on OpenTelemetry, SigNoz supports a wide array of instrumentation options, making it highly adaptable for modern SRE workflows.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image.webp" alt="" caption="" />### Key Features of SigNoz
+<Figure src="/img/comparisons/2024/11/sre-tools-image.webp" alt="" caption="" />
+### Key Features of SigNoz
 
 - Unified Observability: Offers distributed tracing, performance metrics, and logs in one place, reducing the need to switch between tools.
 - [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-Native: Leverages the power of OpenTelemetry for seamless instrumentation across multiple languages and frameworks.
@@ -66,9 +72,15 @@ Imagine an e-commerce application experiencing sporadic latency issues. With Sig
 
 ## 2. Prometheus: The Gold Standard for Monitoring
 
-<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">Prometheus</a> has established itself as a core tool for SRE monitoring due to its flexibility, scalability, and open-source nature. Designed specifically for complex, dynamic environments, Prometheus is a favorite in cloud-native setups for real-time metrics and alerting.
+<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Prometheus
+</a>
+has established itself as a core tool for SRE monitoring due to its flexibility, scalability, and
+open-source nature. Designed specifically for complex, dynamic environments, Prometheus is a
+favorite in cloud-native setups for real-time metrics and alerting.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%201.webp" alt="" caption="" />### Core Features:
+<Figure src="/img/comparisons/2024/11/sre-tools-image%201.webp" alt="" caption="" />
+### Core Features:
 
 - Powerful Query Language (PromQL): PromQL allows you to create sophisticated queries and insights, which are perfect for analyzing time series data and creating complex alerts.
 - Multi-dimensional Data Model: Prometheus organizes time series data by metric names and key/value labels, making it easy to slice and aggregate data.
@@ -85,26 +97,31 @@ With Prometheus, you gain more than just metrics; you gain a comprehensive view
 
 ## 3. Grafana: Visualizing Metrics and Logs
 
-<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> is an indispensable tool for Site Reliability Engineers, providing the ability to transform raw metrics and logs into intuitive, actionable visualizations. Its robust features and support for multiple data sources make it a favorite for monitoring dynamic and complex systems.
+<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a>
+is an indispensable tool for Site Reliability Engineers, providing the ability to transform raw
+metrics and logs into intuitive, actionable visualizations. Its robust features and support for
+multiple data sources make it a favorite for monitoring dynamic and complex systems.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%202.webp" alt="" caption="" />### Key Features of Grafana
+<Figure src="/img/comparisons/2024/11/sre-tools-image%202.webp" alt="" caption="" />
+### Key Features of Grafana
 
 1. Customizable Dashboards:
-    
-    Grafana offers various visualizations, including time-series graphs, heat maps, and tables. Dynamic, reusable dashboards can be built using templates to fit different use cases effortlessly.
-    
+
+   Grafana offers various visualizations, including time-series graphs, heat maps, and tables. Dynamic, reusable dashboards can be built using templates to fit different use cases effortlessly.
+
 2. Multi-source Integration:
-    
-    Grafana seamlessly integrates with diverse data sources such as Prometheus, Elasticsearch, InfluxDB, Azure Monitor, Application Insights, and even cloud-based platforms like AWS CloudWatch. This allows SRE teams to consolidate data from disparate parts of their infrastructure.
-    
+
+   Grafana seamlessly integrates with diverse data sources such as Prometheus, Elasticsearch, InfluxDB, Azure Monitor, Application Insights, and even cloud-based platforms like AWS CloudWatch. This allows SRE teams to consolidate data from disparate parts of their infrastructure.
+
 3. Alerting Capabilities:
-    
-    Grafana’s built-in alerting system allows teams to set up thresholds and notifications. It integrates with tools like Slack, PagerDuty, and Opsgenie to ensure timely responses to issues.
-    
+
+   Grafana’s built-in alerting system allows teams to set up thresholds and notifications. It integrates with tools like Slack, PagerDuty, and Opsgenie to ensure timely responses to issues.
+
 4. Plug-ins and Extendibility:
-    
-    Grafana's plug-ins ecosystem lets teams extend its functionality with specialized visualizations, data sources, and custom panels. 
-    
+
+   Grafana's plug-ins ecosystem lets teams extend its functionality with specialized visualizations, data sources, and custom panels.
 
 ### SRE teams use Grafana to:
 
@@ -115,7 +132,13 @@ With Prometheus, you gain more than just metrics; you gain a comprehensive view
 
 ## 4. Kubernetes: Orchestrating Containerized Applications
 
-<a href="https://kubernetes.io/" rel="noopener noreferrer nofollow" target="_blank">Kubernetes</a> has transformed SRE practices by simplifying the management of complex, containerized applications. As an open-source platform, it provides essential orchestration features to help scale, monitor, and heal applications seamlessly. This open-source container orchestration platform offers following features:
+<a href="https://kubernetes.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Kubernetes
+</a>
+has transformed SRE practices by simplifying the management of complex, containerized applications.
+As an open-source platform, it provides essential orchestration features to help scale, monitor, and
+heal applications seamlessly. This open-source container orchestration platform offers following
+features:
 
 ### Core Features:
 
@@ -123,18 +146,26 @@ With Prometheus, you gain more than just metrics; you gain a comprehensive view
 - Self-healing: It monitors container health, replacing or rescheduling failed containers to minimize downtime.
 - Rolling Updates and Rollbacks: Ensures smooth application updates with minimal user disruption.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%203.webp" alt="" caption="" />### Best Practices for SREs:
+<Figure src="/img/comparisons/2024/11/sre-tools-image%203.webp" alt="" caption="" />
+### Best Practices for SREs:
 
 1. Resource Management: Set clear resource requests and limits to optimize resource use and prevent overload.
 2. Auto-scaling: Use Horizontal Pod Autoscaler (HPA) to adjust resources based on load.
 3. Health Probes: Enable liveness and readiness probes to detect and respond to failures quickly.
-4. Logging and Monitoring: Implement logging and monitoring to track performance and troubleshoot issues efficiently. 
+4. Logging and Monitoring: Implement logging and monitoring to track performance and troubleshoot issues efficiently.
 
 ## 5. Terraform: Infrastructure as Code
 
-<a href="https://www.terraform.io/" rel="noopener noreferrer nofollow" target="_blank">Terraform</a> has become a cornerstone for SRE teams managing modern infrastructure. This Infrastructure as Code (IaC) tool enables teams to define, provision, and manage infrastructure efficiently using a declarative approach. By automating the provisioning process, Terraform reduces manual errors and ensures consistency across environments.
+<a href="https://www.terraform.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Terraform
+</a>
+has become a cornerstone for SRE teams managing modern infrastructure. This Infrastructure as Code
+(IaC) tool enables teams to define, provision, and manage infrastructure efficiently using a
+declarative approach. By automating the provisioning process, Terraform reduces manual errors and
+ensures consistency across environments.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%204.webp" alt="" caption="" />### Key Features of Terraform
+<Figure src="/img/comparisons/2024/11/sre-tools-image%204.webp" alt="" caption="" />
+### Key Features of Terraform
 
 1. Declarative Syntax: Define the desired state of your infrastructure using HashiCorp Configuration Language (HCL), and Terraform handles the steps to achieve it.
 2. Multi-cloud and Multi-provider Support: Terraform supports a wide range of providers, including AWS, Azure, GCP, and even on-premise systems, allowing you to manage hybrid and multi-cloud environments seamlessly.
@@ -166,7 +197,8 @@ The <a href="https://www.elastic.co/elastic-stack" rel="noopener noreferrer nofo
 - Logstash: A data pipeline that collects, processes, and ingests logs from various sources.
 - Kibana: A powerful dashboard tool to visualize data stored in Elasticsearch.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%205.webp" alt="" caption="" />### How SRE teams benefit from ELK:
+<Figure src="/img/comparisons/2024/11/sre-tools-image%205.webp" alt="" caption="" />
+### How SRE teams benefit from ELK:
 
 - Centralized Log Aggregation: Collect logs from different services and systems into a unified platform.
 - Real-Time Troubleshooting: Quickly analyze and resolve issues by examining logs in real-time.
@@ -182,12 +214,20 @@ The <a href="https://www.elastic.co/elastic-stack" rel="noopener noreferrer nofo
 
 ## 7. PagerDuty: Streamlining Incident Management
 
-<a href="https://www.pagerduty.com/" rel="noopener noreferrer nofollow" target="_blank">PagerDuty</a> is a premier platform designed to streamline incident management, enabling Site Reliability Engineering (SRE) teams to respond to critical issues effectively and maintain high service availability.
-
-<Figure src="/img/comparisons/2024/11/sre-tools-image%206.webp" alt="" caption="" />- On-Call Management: Automate on-call schedules and escalation workflows, ensuring the right team members are alerted promptly.
-- Seamless Integrations: Connect with monitoring tools like Prometheus and Datadog to centralize alerts, providing a unified incident detection system.
-- Real-Time Collaboration: Facilitate cross-team coordination during incidents, reducing response times and minimizing downtime.
-- Data-Driven Insights: Generate detailed post-mortem reports to analyze trends, optimize processes, and improve future incident responses.
+<a href="https://www.pagerduty.com/" rel="noopener noreferrer nofollow" target="_blank">
+  PagerDuty
+</a>
+is a premier platform designed to streamline incident management, enabling Site Reliability
+Engineering (SRE) teams to respond to critical issues effectively and maintain high service
+availability.
+
+<Figure src="/img/comparisons/2024/11/sre-tools-image%206.webp" alt="" caption="" />- On-Call
+Management: Automate on-call schedules and escalation workflows, ensuring the right team members are
+alerted promptly. - Seamless Integrations: Connect with monitoring tools like Prometheus and Datadog
+to centralize alerts, providing a unified incident detection system. - Real-Time Collaboration:
+Facilitate cross-team coordination during incidents, reducing response times and minimizing
+downtime. - Data-Driven Insights: Generate detailed post-mortem reports to analyze trends, optimize
+processes, and improve future incident responses.
 
 ### Best Practices for SRE Teams
 
@@ -198,14 +238,20 @@ The <a href="https://www.elastic.co/elastic-stack" rel="noopener noreferrer nofo
 
 ## 8. Ansible: Automating Configuration Management
 
-<a href="https://www.ansible.com/" rel="noopener noreferrer nofollow" target="_blank">Ansible</a> is a powerful open-source automation tool designed to simplify configuration management for Site Reliability Engineering (SRE) teams. By automating system configurations, deployments, and orchestration tasks, it boosts efficiency and consistency. Key features of Ansible include:
+<a href="https://www.ansible.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Ansible
+</a>
+is a powerful open-source automation tool designed to simplify configuration management for Site
+Reliability Engineering (SRE) teams. By automating system configurations, deployments, and
+orchestration tasks, it boosts efficiency and consistency. Key features of Ansible include:
 
 - Agentless Architecture: Operates via SSH, eliminating the need for additional agents on target systems, simplifying management and reducing overhead.
 - YAML-Based Playbooks: Automation tasks are defined using human-readable YAML syntax, making it easy to understand and maintain.
 - Comprehensive Module Support: Ansible offers an extensive library of modules for managing a variety of systems and services, from cloud platforms to network devices.
 - Idempotency: Ensures that tasks can be safely run multiple times without causing unintended changes, as long as the system is already in the desired state.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%207.webp" alt="" caption="" />### Best Practices for Writing Effective Ansible Playbooks
+<Figure src="/img/comparisons/2024/11/sre-tools-image%207.webp" alt="" caption="" />
+### Best Practices for Writing Effective Ansible Playbooks
 
 1. Modularize with Roles: Use roles to structure playbooks into reusable and maintainable components, enhancing code reusability and organization.
 2. Secure Sensitive Data: Leverage Ansible Vault to encrypt and securely manage sensitive data like passwords and API keys.
@@ -214,13 +260,19 @@ The <a href="https://www.elastic.co/elastic-stack" rel="noopener noreferrer nofo
 
 ## 9. GitLab CI/CD: Continuous Integration and Deployment
 
-<a href="https://docs.gitlab.com/ee/ci/" rel="noopener noreferrer nofollow" target="_blank">GitLab CI/CD</a> is a comprehensive platform that enables teams to automate and streamline software delivery workflows, encompassing version control, continuous integration, deployment, and issue tracking. It offers:
+<a href="https://docs.gitlab.com/ee/ci/" rel="noopener noreferrer nofollow" target="_blank">
+  GitLab CI/CD
+</a>
+is a comprehensive platform that enables teams to automate and streamline software delivery
+workflows, encompassing version control, continuous integration, deployment, and issue tracking. It
+offers:
 
 - YAML-Based Pipeline Definitions: Flexible and easily configurable pipelines that allow teams to define custom workflows based on their needs.
 - Integrated Container Registry and Artifact Management: Simplifies management and storage of build artifacts and Docker images within the GitLab environment.
 - Support for Advanced Deployment Strategies: Includes deployment options like canary and blue-green, which ensure safe, gradual releases to production.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%208.webp" alt="" caption="" />### Best Practices for CI/CD in SRE Workflows
+<Figure src="/img/comparisons/2024/11/sre-tools-image%208.webp" alt="" caption="" />
+### Best Practices for CI/CD in SRE Workflows
 
 1. Align Pipeline Stages with Workflow: Design pipeline stages to reflect the exact steps in your development and deployment workflow, ensuring efficient automation.
 2. Automate Tests Across Stages: Implement automated testing at multiple stages (unit, integration, and end-to-end) to ensure quality at every phase of the pipeline.
@@ -229,63 +281,68 @@ The <a href="https://www.elastic.co/elastic-stack" rel="noopener noreferrer nofo
 
 ## 10. Datadog: Unified Monitoring and Analytics
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> provides a powerful, all-in-one platform for monitoring and analytics, tailored to the needs of modern, distributed systems. Key capabilities include:
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+provides a powerful, all-in-one platform for monitoring and analytics, tailored to the needs of
+modern, distributed systems. Key capabilities include:
 
 - Real-Time Visibility: Comprehensive monitoring across infrastructure, applications, and logs in a single interface.
 - ML-Driven Insights: Leverage machine learning to detect anomalies and forecast potential issues before they escalate.
 - Customizable Dashboards: Create dynamic dashboards to visualize key metrics and gain actionable insights.
 - Broad Integrations: Seamlessly connect with various technologies, cloud providers, and services for end-to-end observability.
 
-<Figure src="/img/comparisons/2024/11/sre-tools-image%209.webp" alt="" caption="" />### How SRE Teams Benefit
+<Figure src="/img/comparisons/2024/11/sre-tools-image%209.webp" alt="" caption="" />
+### How SRE Teams Benefit
 
 1. System Performance Monitoring: Track performance metrics across complex, multi-cloud or hybrid environments.
 2. Root Cause Analysis: Correlate metrics, traces, and logs to quickly pinpoint and resolve issues.
 3. Proactive Alerts: Configure automated alerts based on thresholds or patterns, enabling swift responses to anomalies.
-4. Capacity Planning: Use generated reports and insights to optimize resources and plan for future growth. 
+4. Capacity Planning: Use generated reports and insights to optimize resources and plan for future growth.
 
 Here is the summary of the discussion made so far in the article:
 
-| Tool | Highlight | Key Features | Beneficial For |
-| --- | --- | --- | --- |
-| SigNoz (APM) | Open-source, unified observability with traces, metrics, and logs | - Cost-effective alternative to proprietary APM  - OpenTelemetry support for flexible instrumentation | Gaining comprehensive insights into application performance and user behavior for proactive problem solving. |
-| Prometheus (Monitoring) | Open-source, gold standard for monitoring complex environments | - Powerful PromQL for sophisticated queries  - Multi-dimensional data model for efficient querying  - Pull model for data collection from dynamic environments | Real-time metrics and alerting for faster troubleshooting and maintaining high service reliability. |
-| Grafana (Visualization) | Visualizing metrics and logs for actionable insights | - Customizable dashboards with various visualizations  - Multi-source integration for consolidating data  - Alerting capabilities with integrations for timely incident response | Building comprehensive system overviews, analyzing trends and patterns, and fostering team collaboration through clear communication of system metrics. |
-| Kubernetes (Orchestration) | Open-source container orchestration platform | - Automated deployment and scaling  - Self-healing capabilities to minimize downtime  - Rolling updates and rollbacks for smooth application updates | Simplifying management of complex containerized applications with features for scaling, monitoring, and healing. |
-| Terraform (IaC) | Infrastructure as Code for efficient infrastructure management | - Declarative syntax for defining desired infrastructure state - Multi-cloud and multi-provider support  - Version control & collaboration for tracking changes and rollback capabilities  - Plan and Apply workflow for transparency and risk reduction | Automating repetitive infrastructure tasks, ensuring consistency, scalability, collaboration, and minimizing risks through planning and previewing changes. |
-| ELK Stack (Logging) | Centralized logging and analysis with Elasticsearch, Logstash, and Kibana | - Centralized log aggregation for easy access - Real-time troubleshooting through log analysis - Custom visualizations for monitoring system health  - Alerting based on log patterns for proactive issue identification | Simplifying log management, enabling real-time troubleshooting, creating informative dashboards, and setting up proactive alerts. |
-| PagerDuty (Incident Management) | Streamlining incident management for effective response | - On-call management for efficient team notification - Seamless integrations for centralized alert detection - Real-time collaboration for faster incident resolution  - Data-driven insights for improving future responses | Ensuring timely response to critical issues through streamlined on-call management, collaboration tools, and data-driven post-mortem analysis. |
-| Ansible (Automation) | Powerful open-source tool for automating configuration management | - Agentless architecture for simplified management - YAML-based playbooks for easy understanding and maintenance - Comprehensive module support for managing diverse systems - Idempotent tasks for safe execution | Boosting efficiency and consistency by automating system configurations, deployments, and orchestration tasks. |
-| GitLab CI/CD | Comprehensive platform for automating software delivery workflows | - YAML-based pipeline definitions for flexible configuration - Integrated container registry and artifact management - Support for advanced deployment strategies | Streamlining software delivery through automated pipelines encompassing version control, CI, CD, and issue tracking. |
-| Datadog (Monitoring & Analytics) | Unified monitoring and analytics for modern, distributed systems | - Real-time visibility across infrastructure, applications, and logs - ML-driven insights for anomaly detection and forecasting - Customizable dashboards for actionable visualizations - Broad integrations for comprehensive observability | Gaining real-time visibility, performing root cause analysis, configuring proactive alerts, and optimizing resource allocation through data-driven insights. |
+| Tool                             | Highlight                                                                 | Key Features                                                                                                                                                                                                                                           | Beneficial For                                                                                                                                               |
+| -------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| SigNoz (APM)                     | Open-source, unified observability with traces, metrics, and logs         | - Cost-effective alternative to proprietary APM - OpenTelemetry support for flexible instrumentation                                                                                                                                                   | Gaining comprehensive insights into application performance and user behavior for proactive problem solving.                                                 |
+| Prometheus (Monitoring)          | Open-source, gold standard for monitoring complex environments            | - Powerful PromQL for sophisticated queries - Multi-dimensional data model for efficient querying - Pull model for data collection from dynamic environments                                                                                           | Real-time metrics and alerting for faster troubleshooting and maintaining high service reliability.                                                          |
+| Grafana (Visualization)          | Visualizing metrics and logs for actionable insights                      | - Customizable dashboards with various visualizations - Multi-source integration for consolidating data - Alerting capabilities with integrations for timely incident response                                                                         | Building comprehensive system overviews, analyzing trends and patterns, and fostering team collaboration through clear communication of system metrics.      |
+| Kubernetes (Orchestration)       | Open-source container orchestration platform                              | - Automated deployment and scaling - Self-healing capabilities to minimize downtime - Rolling updates and rollbacks for smooth application updates                                                                                                     | Simplifying management of complex containerized applications with features for scaling, monitoring, and healing.                                             |
+| Terraform (IaC)                  | Infrastructure as Code for efficient infrastructure management            | - Declarative syntax for defining desired infrastructure state - Multi-cloud and multi-provider support - Version control & collaboration for tracking changes and rollback capabilities - Plan and Apply workflow for transparency and risk reduction | Automating repetitive infrastructure tasks, ensuring consistency, scalability, collaboration, and minimizing risks through planning and previewing changes.  |
+| ELK Stack (Logging)              | Centralized logging and analysis with Elasticsearch, Logstash, and Kibana | - Centralized log aggregation for easy access - Real-time troubleshooting through log analysis - Custom visualizations for monitoring system health - Alerting based on log patterns for proactive issue identification                                | Simplifying log management, enabling real-time troubleshooting, creating informative dashboards, and setting up proactive alerts.                            |
+| PagerDuty (Incident Management)  | Streamlining incident management for effective response                   | - On-call management for efficient team notification - Seamless integrations for centralized alert detection - Real-time collaboration for faster incident resolution - Data-driven insights for improving future responses                            | Ensuring timely response to critical issues through streamlined on-call management, collaboration tools, and data-driven post-mortem analysis.               |
+| Ansible (Automation)             | Powerful open-source tool for automating configuration management         | - Agentless architecture for simplified management - YAML-based playbooks for easy understanding and maintenance - Comprehensive module support for managing diverse systems - Idempotent tasks for safe execution                                     | Boosting efficiency and consistency by automating system configurations, deployments, and orchestration tasks.                                               |
+| GitLab CI/CD                     | Comprehensive platform for automating software delivery workflows         | - YAML-based pipeline definitions for flexible configuration - Integrated container registry and artifact management - Support for advanced deployment strategies                                                                                      | Streamlining software delivery through automated pipelines encompassing version control, CI, CD, and issue tracking.                                         |
+| Datadog (Monitoring & Analytics) | Unified monitoring and analytics for modern, distributed systems          | - Real-time visibility across infrastructure, applications, and logs - ML-driven insights for anomaly detection and forecasting - Customizable dashboards for actionable visualizations - Broad integrations for comprehensive observability           | Gaining real-time visibility, performing root cause analysis, configuring proactive alerts, and optimizing resource allocation through data-driven insights. |
 
 ## Lesser-Known but Highly Useful Tools for SREs
 
 In the fast-evolving world of SRE, exploring lesser-known tools can provide unique benefits and address specific challenges that mainstream solutions might overlook. These tools often offer niche features, streamlined workflows, or cost-effective alternatives that can enhance an SRE team’s capabilities.
 
 1. Cabot:
-    - An open-source platform for incident management and monitoring.
-    - Combines uptime monitoring, customizable alerts, and a straightforward dashboard.
-    - Ideal for smaller teams looking for a lightweight solution.
+   - An open-source platform for incident management and monitoring.
+   - Combines uptime monitoring, customizable alerts, and a straightforward dashboard.
+   - Ideal for smaller teams looking for a lightweight solution.
 2. Netdata:
-    - A real-time performance monitoring tool.
-    - Features highly visual dashboards and efficient resource usage.
-    - Helps detect anomalies in system behavior quickly.
+   - A real-time performance monitoring tool.
+   - Features highly visual dashboards and efficient resource usage.
+   - Helps detect anomalies in system behavior quickly.
 3. OpsGenie:
-    - Incident management and notification tool with customizable workflows.
-    - Integrates well with monitoring tools like Prometheus and Datadog.
-    - Provides advanced on-call scheduling and routing options.
+   - Incident management and notification tool with customizable workflows.
+   - Integrates well with monitoring tools like Prometheus and Datadog.
+   - Provides advanced on-call scheduling and routing options.
 4. Silverback:
-    - A tool dedicated to tracking and managing Service Level Objectives (SLOs).
-    - Simplifies aligning reliability goals with operational metrics.
-    - Particularly useful for teams adopting [SRE best practices](https://signoz.io/guides/sre-best-practices/).
+   - A tool dedicated to tracking and managing Service Level Objectives (SLOs).
+   - Simplifies aligning reliability goals with operational metrics.
+   - Particularly useful for teams adopting [SRE best practices](https://signoz.io/guides/sre-best-practices/).
 5. Vector:
-    - A high-performance log and metric data pipeline.
-    - Offers efficient data transformation and routing with minimal overhead.
-    - Compatible with logging systems like ELK and Prometheus.
+   - A high-performance log and metric data pipeline.
+   - Offers efficient data transformation and routing with minimal overhead.
+   - Compatible with logging systems like ELK and Prometheus.
 6. BorgMon:
-    - Inspired by Google’s internal monitoring tools.
-    - Focuses on detailed alerting and monitoring configurations.
-    - Suited for advanced users requiring granular control over observability.
+   - Inspired by Google’s internal monitoring tools.
+   - Focuses on detailed alerting and monitoring configurations.
+   - Suited for advanced users requiring granular control over observability.
 
 These tools offer valuable functionality tailored for specific SRE workflows, providing alternatives or complements to more widely-used solutions.
 
@@ -350,4 +407,4 @@ Small teams can greatly benefit from SRE tools by starting with essential soluti
 
 ### How often should SRE tools be updated or replaced?
 
-SRE tools should be regularly updated to maintain security and access new features. An annual review of your toolset helps ensure it meets evolving needs. Tools should be replaced when they no longer scale, lack critical features, or if better alternatives become available. Balancing the benefits of migration against the costs of training and potential workflow disruptions is essential to making informed decisions.
\ No newline at end of file
+SRE tools should be regularly updated to maintain security and access new features. An annual review of your toolset helps ensure it meets evolving needs. Tools should be replaced when they no longer scale, lack critical features, or if better alternatives become available. Balancing the benefits of migration against the costs of training and potential workflow disruptions is essential to making informed decisions.
diff --git a/data/comparisons/sumo-logic-vs-datadog.mdx b/data/comparisons/sumo-logic-vs-datadog.mdx
index ef3223bdb..a9fe7c584 100644
--- a/data/comparisons/sumo-logic-vs-datadog.mdx
+++ b/data/comparisons/sumo-logic-vs-datadog.mdx
@@ -1,15 +1,24 @@
 ---
-title: "Sumo Logic vs. Datadog: The Definitive Comparison for 2025"
-slug: "sumo-logic-vs-datadog"
-date: "2025-10-14"
+title: 'Sumo Logic vs. Datadog: The Definitive Comparison for 2025'
+date: '2025-10-14'
 tags: [observability, comparison]
 authors: [yuvraj]
 description: "A definitive comparison of Sumo Logic and Datadog, covering features, pricing, data pipeline control, security, and a senior engineer's POC checklist."
-keywords: [Sumo Logic, Datadog, observability, APM, SIEM, data path control, trace sampling, agent overhead, metric cardinality, Datadog vs Sumo Logic]
+keywords:
+  [
+    Sumo Logic,
+    Datadog,
+    observability,
+    APM,
+    SIEM,
+    data path control,
+    trace sampling,
+    agent overhead,
+    metric cardinality,
+    Datadog vs Sumo Logic,
+  ]
 ---
 
-
-
 Datadog and Sumo Logic, both offer powerful tools to monitor applications. While they often appear in the same conversations, they were built with different core philosophies that shape their features, costs, and the day-to-day experience for engineers.
 
 Datadog is widely recognized as a market leader in infrastructure and application performance monitoring (APM). Sumo Logic, conversely, established its roots in log management and security analytics, positioning itself as a converged platform for both observability and security operations.
@@ -20,40 +29,47 @@ This article provides a definitive, deep-dive comparison of Sumo Logic vs. Datad
 
 Understanding the origins of each platform is key to grasping their current strengths.
 
-
-
 **Datadog's focus is on unified, real-time performance monitoring.** It began by providing deep visibility into infrastructure metrics and has since expanded into a comprehensive, all-in-one observability platform. It's designed for DevOps and SRE teams who need to quickly diagnose performance issues across a complex stack, from frontend user experience down to the underlying network.
 
-<Figure src="/img/comparisons/2025/10/sumologic-datadog-overview.webp" alt="Datadog's Request Flow Map Dashboard" caption="Datadog's Request Flow Map Dashboard (credits: Datadog)" />
-
-
+<Figure
+  src="/img/comparisons/2025/10/sumologic-datadog-overview.webp"
+  alt="Datadog's Request Flow Map Dashboard"
+  caption="Datadog's Request Flow Map Dashboard (credits: Datadog)"
+/>
 
 **Sumo Logic’s focus is on converged security and log analytics.** It's designed to ingest and analyze massive volumes of log data. This foundation makes it exceptionally strong for deep troubleshooting, compliance, and security investigations. Its key differentiator is the native integration of a Security Information and Event Management (SIEM) solution, creating a single source of truth for development, security, and operations teams.
 
-<Figure src="/img/comparisons/2025/10/sumo-logic-overview.webp" alt="Sumo Logic's Logs Dashboard" caption="Sumo Logic's Logs Dashboard (credits: Sumo Logic)" />
+<Figure
+  src="/img/comparisons/2025/10/sumo-logic-overview.webp"
+  alt="Sumo Logic's Logs Dashboard"
+  caption="Sumo Logic's Logs Dashboard (credits: Sumo Logic)"
+/>
 
 ## Feature Comparison
 
 While both platforms cover the three pillars of observability: logs, metrics, and traces. Their feature sets and depth vary significantly.
 
-| Feature / Capability                     | Datadog | Sumo Logic   |   
-| ---------------------------------------- | ------- | ------------ | 
-| Infrastructure Monitoring                | ✓✓      | ✓✓           |      
-| Log Management & Analytics               | ✓✓      | ✓✓           |   
-| APM (Tracing & Profiling)                | ✓✓      | ✓✓           |   
-| Real User & Synthetic Monitoring         | ✓✓      | ✓ (Limited)* |    
-| Cloud SIEM                               | ✓✓      | ✓✓           |
-| Cloud SOAR (Security Orchestration)      | ✓✓      | ✓✓           |
-| Cloud Security Posture Management (CSPM) | ✓✓      | ✗            |  
-| Built-in Incident Management             | ✓       | ✓            |   
-| Generous Free Tier                       | ✗       | ✓            |     
+| Feature / Capability                     | Datadog | Sumo Logic    |
+| ---------------------------------------- | ------- | ------------- |
+| Infrastructure Monitoring                | ✓✓      | ✓✓            |
+| Log Management & Analytics               | ✓✓      | ✓✓            |
+| APM (Tracing & Profiling)                | ✓✓      | ✓✓            |
+| Real User & Synthetic Monitoring         | ✓✓      | ✓ (Limited)\* |
+| Cloud SIEM                               | ✓✓      | ✓✓            |
+| Cloud SOAR (Security Orchestration)      | ✓✓      | ✓✓            |
+| Cloud Security Posture Management (CSPM) | ✓✓      | ✗             |
+| Built-in Incident Management             | ✓       | ✓             |
+| Generous Free Tier                       | ✗       | ✓             |
 
 ✓✓ - Feature is fully available
 ✓ - Partial or limited feature
 ✗ - Feature is not available
 
-<a href="https://help.sumologic.com/docs/apm/real-user-monitoring/" rel="nofollow noreferrer">Sumo provides native RUM</a>; synthetic tests are typically surfaced via provider integrations rather than a deep first-party suite.
-
+<a href="https://help.sumologic.com/docs/apm/real-user-monitoring/" rel="nofollow noreferrer">
+  Sumo provides native RUM
+</a>
+; synthetic tests are typically surfaced via provider integrations rather than a deep first-party
+suite.
 
 ## Under the Hood: Sumo Logic vs Datadog
 
@@ -79,9 +95,9 @@ Controlling telemetry before you pay for it is critical for managing costs at sc
 
 Both platforms allow you to archive logs to your own S3 bucket to save costs, but their retrieval mechanics differ.
 
-Datadog’s <a href="https://docs.datadoghq.com/logs/log_configuration/rehydrating/" rel="nofollow noreferrer"><strong>Log Rehydration</strong></a> reads archived objects from your bucket for the selected **time window**, then applies your query. Because the query is evaluated **after** the archive files for that time range are downloaded, **scan size and cloud data-transfer costs** depend primarily on the time window you choose, not just the query selectivity. Narrowing the time window is the best way to reduce scan size and retrieval cost. 
+Datadog’s <a href="https://docs.datadoghq.com/logs/log_configuration/rehydrating/" rel="nofollow noreferrer"><strong>Log Rehydration</strong></a> reads archived objects from your bucket for the selected **time window**, then applies your query. Because the query is evaluated **after** the archive files for that time range are downloaded, **scan size and cloud data-transfer costs** depend primarily on the time window you choose, not just the query selectivity. Narrowing the time window is the best way to reduce scan size and retrieval cost.
 
-Also, rehydration only supports specific **S3 storage classes**—**Standard**, **Standard-IA**, **One Zone-IA**, **Glacier Instant Retrieval**, and **Intelligent-Tiering** (only if the asynchronous archive tiers are disabled) as documented in <a href="https://docs.datadoghq.com/logs/log_configuration/archives" rel="nofollow noreferrer">Datadog's archive configuration guide</a>. 
+Also, rehydration only supports specific **S3 storage classes**—**Standard**, **Standard-IA**, **One Zone-IA**, **Glacier Instant Retrieval**, and **Intelligent-Tiering** (only if the asynchronous archive tiers are disabled) as documented in <a href="https://docs.datadoghq.com/logs/log_configuration/archives" rel="nofollow noreferrer">Datadog's archive configuration guide</a>.
 
 **The implication is** that if your S3 lifecycle policies automatically move logs to these colder, cheaper storage tiers to save money, you won't be able to rehydrate them in Datadog without first manually restoring them to a supported class. This adds extra steps and time during an incident or audit when you need urgent access to old logs.
 
@@ -93,12 +109,12 @@ The term "on-demand ingestion" means you can selectively re-ingest data from a s
 
 The resource footprint of the collector agent is a key planning consideration, especially on busy hosts.
 
-**Datadog Agent**: The APM path is CPU-bound and scales with spans per second. When CPU is constrained, the Agent buffers unprocessed payloads in memory, which can increase memory usage and risk drops. For sizing, Datadog publishes guidance by throughput—for example, ~70 MB at ~58k spans/s and ~130 MB at ~130k spans/s (Agent 7.39 benchmarks according to <a href="https://docs.datadoghq.com/tracing/troubleshooting/agent_apm_resource_usage/" rel="nofollow noreferrer">Datadog's agent resource guide</a>). 
+**Datadog Agent**: The APM path is CPU-bound and scales with spans per second. When CPU is constrained, the Agent buffers unprocessed payloads in memory, which can increase memory usage and risk drops. For sizing, Datadog publishes guidance by throughput—for example, ~70 MB at ~58k spans/s and ~130 MB at ~130k spans/s (Agent 7.39 benchmarks according to <a href="https://docs.datadoghq.com/tracing/troubleshooting/agent_apm_resource_usage/" rel="nofollow noreferrer">Datadog's agent resource guide</a>).
 
 **Sumo Logic Collector**: This is a Java process with a default heap of 128 MB; planning for 256–512 MB is common depending on sources and volume. It’s designed to handle up to ~15,000 events/sec per collector before you scale out.
 
 > **Which collector is this?**  
-   **Installed Collector** is Sumo’s **Java-based** collector (the one with a default **128 MB heap**, with guidance to plan **256–512 MB** depending on sources and volume). <a href="https://help.sumologic.com/docs/send-data/choose-collector-source/#installed-collectors-installed-agent" rel="nofollow noreferrer"><strong>Sumo Logic Distribution for OpenTelemetry</strong> is a separate OTel-based collector</a> with different packaging and management; choose it if you want OTel semantics and remote management at scale.
+>  **Installed Collector** is Sumo’s **Java-based** collector (the one with a default **128 MB heap**, with guidance to plan **256–512 MB** depending on sources and volume). <a href="https://help.sumologic.com/docs/send-data/choose-collector-source/#installed-collectors-installed-agent" rel="nofollow noreferrer"><strong>Sumo Logic Distribution for OpenTelemetry</strong> is a separate OTel-based collector</a> with different packaging and management; choose it if you want OTel semantics and remote management at scale.
 
 ### The "Life During an Incident" Experience
 
@@ -134,13 +150,13 @@ The day-to-day experience of using each platform is quite different.
 
 **Datadog** uses a modular, per-product model with several billing dimensions. At a minimum, you’ll size hosts for Infrastructure and/or APM, then layer on usage-based items like logs, RUM sessions, and custom metrics.
 
-### Core Datadog SKUs & Units — *list pricing as of Oct 2025*
+### Core Datadog SKUs & Units — _list pricing as of Oct 2025_
 
-* **Infrastructure Pro**: $15 per host/month.
-* **APM**: $31 per APM host/month, which also includes a monthly bundle of **1M indexed spans** and **150 GB ingested spans** per APM host.
-* **Logs**: Two levers—ingest and indexing. Ingest is **\$0.10/GB**; indexing is priced per 1M events and scales with retention (e.g., **7 days \$1.27**, **15 days \$1.70**, **30 days \$2.50** per 1M events). Flex Logs adds a cheaper storage tier with separate query compute.
-* **Custom metrics**: Billed per 100 custom metrics.
-* **RUM/Product Analytics**: Billed per 1,000 sessions. For example, **RUM – Measure** is **\$0.15 per 1K sessions** according to <a href="https://www.datadoghq.com/pricing/list/" rel="nofollow noreferrer">Datadog's list pricing</a>.
+- **Infrastructure Pro**: $15 per host/month.
+- **APM**: $31 per APM host/month, which also includes a monthly bundle of **1M indexed spans** and **150 GB ingested spans** per APM host.
+- **Logs**: Two levers—ingest and indexing. Ingest is **\$0.10/GB**; indexing is priced per 1M events and scales with retention (e.g., **7 days \$1.27**, **15 days \$1.70**, **30 days \$2.50** per 1M events). Flex Logs adds a cheaper storage tier with separate query compute.
+- **Custom metrics**: Billed per 100 custom metrics.
+- **RUM/Product Analytics**: Billed per 1,000 sessions. For example, **RUM – Measure** is **\$0.15 per 1K sessions** according to <a href="https://www.datadoghq.com/pricing/list/" rel="nofollow noreferrer">Datadog's list pricing</a>.
 
 For a deeper dive into datadog pricing, check out our article on [Datadog Pricing Main Caveats Explained](https://signoz.io/blog/datadog-pricing/).
 
@@ -161,7 +177,7 @@ Logs are often the biggest variable. Costs can be managed by trimming data at in
 
 Finally, costs for products like RUM and Synthetics are event and session-based, so it's wise to forecast traffic peaks. For custom metrics, costs can be controlled by reducing cardinality and using aggregations.
 
-With **Sumo Logic**, the main *driver of your bill is scan intensity*. The more you query, especially with wide time ranges or numerous dashboards, the more scan credits you will consume. This can be managed by right-sizing time ranges and using targeted filters.
+With **Sumo Logic**, the main _driver of your bill is scan intensity_. The more you query, especially with wide time ranges or numerous dashboards, the more scan credits you will consume. This can be managed by right-sizing time ranges and using targeted filters.
 
 Storage and retention are also key factors. You choose the retention period for each data source, and older data kept in "hot" storage costs more than data in cheaper tiers or S3.
 
@@ -184,11 +200,11 @@ If you are weighing Sumo Logic and Datadog, add **SigNoz Cloud** to your shortli
 **Why teams evaluating Sumo and Datadog choose SigNoz Cloud**
 
 - **One UI for incident work**  
-    Correlate a slow trace with related logs and service metrics in a click. No context switching, faster root cause.
+   Correlate a slow trace with related logs and service metrics in a click. No context switching, faster root cause.
 - **OpenTelemetry first**  
-    Keep the same OTel Collector you already run. Point it to SigNoz Cloud and ship OTLP without re-instrumenting.
+   Keep the same OTel Collector you already run. Point it to SigNoz Cloud and ship OTLP without re-instrumenting.
 - **Starts hosted, stays flexible**  
-    Begin on Cloud for speed. If policy changes, move to BYOC or self-host without changing your instrumentation.
+   Begin on Cloud for speed. If policy changes, move to BYOC or self-host without changing your instrumentation.
 - **Clear, predictable pricing:** Starts at **\$49/month**; then pay for what you use (**\$0.30/GB** for logs and traces, **\$0.10 per million** metric samples). Unlimited teammates. [See pricing](https://signoz.io/pricing/).
 
 ### Get Started with SigNoz
diff --git a/data/comparisons/zabbix-alternatives.mdx b/data/comparisons/zabbix-alternatives.mdx
index 7f6765204..8ece28358 100644
--- a/data/comparisons/zabbix-alternatives.mdx
+++ b/data/comparisons/zabbix-alternatives.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top 10 Zabbix Alternatives for IT Monitoring in 2025
-slug: zabbix-alternatives
 date: 2025-01-02
 tags: [tools-comparision]
 authors: [niyati_thakkar]
 description: Discover the best Zabbix alternatives for IT monitoring in 2024. Compare features, scalability, and ease of use to find the perfect solution for your organization.
-keywords: [zabbix alternatives, IT monitoring, network monitoring, open-source monitoring, application performance monitoring]
-
+keywords:
+  [
+    zabbix alternatives,
+    IT monitoring,
+    network monitoring,
+    open-source monitoring,
+    application performance monitoring,
+  ]
 ---
 
 In the ever-evolving landscape of IT infrastructure, effective monitoring is crucial for maintaining system health and performance. While Zabbix has long been a popular choice for many organizations due to its flexibility, its complexity and scalability challenges have led many to seek alternatives. This article explores the top 10 Zabbix alternatives for IT monitoring in 2024, helping you find a solution that best fits your organization's needs.
@@ -58,7 +62,11 @@ Zabbix is powerful but can be challenging to manage, especially as your infrastr
 
 ## Top 10 Zabbix Alternatives for 2024
 
-<Figure src="/img/comparisons/2024/08/zabbix-alternatives-image2.webp" alt="Zabbix Alternatives" caption="Zabbix Alternatives" />
+<Figure
+  src="/img/comparisons/2024/08/zabbix-alternatives-image2.webp"
+  alt="Zabbix Alternatives"
+  caption="Zabbix Alternatives"
+/>
 
 ### 1. SigNoz: A Modern Alternative for Application Monitoring
 
@@ -83,11 +91,20 @@ Comparison with Zabbix:
 
 Signoz stands out for its ease of use and comprehensive monitoring, making it an excellent choice for cloud-native environments.
 
-<Figure src="/img/comparisons/2024/08/zabbix-alternatives-image.webp" alt="SigNoz Correlated Signals" caption="SigNoz Correlated Signals" />
+<Figure
+  src="/img/comparisons/2024/08/zabbix-alternatives-image.webp"
+  alt="SigNoz Correlated Signals"
+  caption="SigNoz Correlated Signals"
+/>
 
 ### 2. Netdata
 
-<a href="https://www.netdata.cloud/" rel="noopener noreferrer nofollow" target="_blank">Netdata</a> is a powerful, open-source monitoring solution designed for real-time insights and ease of use. It's lightweight, making it perfect for organizations that need instant visibility with minimal system impact.
+<a href="https://www.netdata.cloud/" rel="noopener noreferrer nofollow" target="_blank">
+  Netdata
+</a>
+is a powerful, open-source monitoring solution designed for real-time insights and ease of use. It's
+lightweight, making it perfect for organizations that need instant visibility with minimal system
+impact.
 
 Key Features:
 
@@ -106,7 +123,11 @@ Netdata is ideal for organizations seeking quick, low-friction monitoring withou
 
 ### 3. Nagios
 
-<a href="https://www.nagios.org/" rel="noopener noreferrer nofollow" target="_blank">Nagios</a> is a veteran in the IT monitoring space, offering a mature and widely adopted platform for infrastructure monitoring.
+<a href="https://www.nagios.org/" rel="noopener noreferrer nofollow" target="_blank">
+  Nagios
+</a>
+is a veteran in the IT monitoring space, offering a mature and widely adopted platform for
+infrastructure monitoring.
 
 Key features:
 
@@ -125,7 +146,11 @@ While Nagios can be complex to set up, its vast ecosystem of plugins and add-ons
 
 ### 4. Prometheus
 
-<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">Prometheus</a> has gained significant traction as a modern, open-source monitoring and alerting toolkit, especially in cloud-native environments.
+<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Prometheus
+</a>
+has gained significant traction as a modern, open-source monitoring and alerting toolkit, especially
+in cloud-native environments.
 
 Key features:
 
@@ -144,7 +169,11 @@ Prometheus excels in dynamic environments, such as those using containerization
 
 ### 5. Datadog
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> offers a comprehensive, cloud-based monitoring and analytics platform that covers the entire IT stack.
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a>
+offers a comprehensive, cloud-based monitoring and analytics platform that covers the entire IT
+stack.
 
 Key features:
 
@@ -163,7 +192,11 @@ Datadog's strength lies in its ability to provide a holistic view of complex, di
 
 ### 6. Checkmk
 
-<a href="https://checkmk.com/" rel="noopener noreferrer nofollow" target="_blank">Checkmk</a> combines the best of both worlds: the flexibility of open-source with the polish of a commercial product.
+<a href="https://checkmk.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Checkmk
+</a>
+combines the best of both worlds: the flexibility of open-source with the polish of a commercial
+product.
 
 Key Features:
 
@@ -182,7 +215,11 @@ Checkmk's automated discovery and configuration features make it easier to set u
 
 ### 7. PRTG Network Monitor
 
-<a href="https://www.paessler.com/" rel="noopener noreferrer nofollow" target="_blank">PRTG</a> offers an all-in-one solution for network, server, and application monitoring with a focus on ease of use.
+<a href="https://www.paessler.com/" rel="noopener noreferrer nofollow" target="_blank">
+  PRTG
+</a>
+offers an all-in-one solution for network, server, and application monitoring with a focus on ease
+of use.
 
 Key Features:
 
@@ -201,7 +238,11 @@ PRTG's strength lies in its user-friendly approach to monitoring complex IT envi
 
 ### 8. LibreNMS
 
-<a href="https://www.librenms.org/" rel="noopener noreferrer nofollow" target="_blank">LibreNMS</a> is an open-source network monitoring system that emphasizes community-driven development and ease of use.
+<a href="https://www.librenms.org/" rel="noopener noreferrer nofollow" target="_blank">
+  LibreNMS
+</a>
+is an open-source network monitoring system that emphasizes community-driven development and ease of
+use.
 
 Key Features:
 
@@ -220,7 +261,11 @@ LibreNMS shines in network-centric environments, offering detailed insights into
 
 ### 9. Icinga
 
-<a href="https://icinga.com/" rel="noopener noreferrer nofollow" target="_blank">Icinga</a>, a fork of Nagios, offers enhanced features and performance while maintaining compatibility with Nagios plugins.
+<a href="https://icinga.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Icinga
+</a>
+, a fork of Nagios, offers enhanced features and performance while maintaining compatibility with
+Nagios plugins.
 
 Key Features:
 
@@ -239,7 +284,11 @@ Icinga builds upon the Nagios foundation with improved scalability and a more mo
 
 ### 10. OpenNMS
 
-<a href="https://www.opennms.com/" rel="noopener noreferrer nofollow" target="_blank">OpenNMS</a> is an enterprise-grade, open-source network monitoring platform designed for large-scale deployments.
+<a href="https://www.opennms.com/" rel="noopener noreferrer nofollow" target="_blank">
+  OpenNMS
+</a>
+is an enterprise-grade, open-source network monitoring platform designed for large-scale
+deployments.
 
 Key Features:
 
@@ -259,56 +308,54 @@ OpenNMS excels in environments where scalability is a primary concern. Its abili
 ### Setting Up SigNoz for Comprehensive Monitoring
 
 1. Download Otel Java binary agent
-    
-    To get started with SigNoz, begin by cloning the repository:
-    
-    ```bash
-    wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
-    ```
-    
-    Next, run your application:
-    
-    ```bash
-    OTEL_RESOURCE_ATTRIBUTES=service.name=<app_name> \
-    OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=SIGNOZ_INGESTION_KEY" \
-    OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.{region}.signoz.cloud:443 \
-    java -javaagent:$PWD/opentelemetry-javaagent.jar -jar <my-app>.jar
-    ```
-    
-    This command will set up SigNoz using Docker. For Kubernetes or manual installations, refer to the [official documentation](https://signoz.io/docs/cloud/) for detailed instructions.
-    
+
+   To get started with SigNoz, begin by cloning the repository:
+
+   ```bash
+   wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
+   ```
+
+   Next, run your application:
+
+   ```bash
+   OTEL_RESOURCE_ATTRIBUTES=service.name=<app_name> \
+   OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=SIGNOZ_INGESTION_KEY" \
+   OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.{region}.signoz.cloud:443 \
+   java -javaagent:$PWD/opentelemetry-javaagent.jar -jar <my-app>.jar
+   ```
+
+   This command will set up SigNoz using Docker. For Kubernetes or manual installations, refer to the [official documentation](https://signoz.io/docs/cloud/) for detailed instructions.
+
 2. Instrumenting Your Application
-    
-    Integrate OpenTelemetry instrumentation into your application code to capture relevant telemetry data. [OpenTelemetry](https://signoz.io/docs/instrumentation/overview/) provides libraries for most programming languages, making it easy to add instrumentation to your application.
-    
+
+   Integrate OpenTelemetry instrumentation into your application code to capture relevant telemetry data. [OpenTelemetry](https://signoz.io/docs/instrumentation/overview/) provides libraries for most programming languages, making it easy to add instrumentation to your application.
+
 3. Configuring Data Sources
-    
-    Once SigNoz is running, access the web interface at `http://localhost:3301`. Configure data sources to specify how SigNoz should collect data from your instrumented application.
-    
+
+   Once SigNoz is running, access the web interface at `http://localhost:3301`. Configure data sources to specify how SigNoz should collect data from your instrumented application.
 
 4. Setting Up Dashboards
 
 SigNoz offers pre-built [dashboards](https://signoz.io/docs/userguide/manage-dashboards/) to quickly visualize key metrics. You can also create custom dashboards to tailor the monitoring experience to your specific needs.
 
 1. Exploring and Analyzing Data
-    
-    Leverage SigNoz's user interface to explore distributed traces, [analyze metrics](https://signoz.io/blog/metrics-explorer/), and identify performance bottlenecks. The platform's intuitive design makes it easy to understand application behavior and troubleshoot issues.
-    
+
+   Leverage SigNoz's user interface to explore distributed traces, [analyze metrics](https://signoz.io/blog/metrics-explorer/), and identify performance bottlenecks. The platform's intuitive design makes it easy to understand application behavior and troubleshoot issues.
 
 Here’s a quick comparison of all the alternatives:
 
-| Feature | Zabbix | SigNoz | Netdata | Nagios | Prometheus | Datadog | Checkmk | PRTG | LibreNMS | Icinga | OpenNMS |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| Open Source | Yes | Yes | Yes | Yes | Yes | No | Yes | No | Yes | Yes | Yes |
-| Cloud-based | No | Yes | No | No | No | Yes | No | Yes | No | No | No |
-| Agentless | No | Yes | Yes | Yes | Yes | Partial | Yes | Partial | Yes | Yes | Yes |
-| Real-Time | Yes | Yes | Yes | No | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| APM | No | Yes | No | No | No | Yes | No | No | No | No | No |
-| Infrastructure Monitoring | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Application Monitoring | Partial | Yes | No | Partial | Yes | Yes | Partial | Partial | No | Partial | Partial |
-| Log Management | Yes | Yes | No | Partial | No | Yes | Partial | No | No | Partial | Partial |
-| Scalability | Medium | High | High | Medium | High | High | High | Medium | High | High | High |
-| Ease of Use | Medium | High | High | Medium | Medium | High | Medium | High | High | Medium | Medium |
+| Feature                   | Zabbix  | SigNoz | Netdata | Nagios  | Prometheus | Datadog | Checkmk | PRTG    | LibreNMS | Icinga  | OpenNMS |
+| ------------------------- | ------- | ------ | ------- | ------- | ---------- | ------- | ------- | ------- | -------- | ------- | ------- |
+| Open Source               | Yes     | Yes    | Yes     | Yes     | Yes        | No      | Yes     | No      | Yes      | Yes     | Yes     |
+| Cloud-based               | No      | Yes    | No      | No      | No         | Yes     | No      | Yes     | No       | No      | No      |
+| Agentless                 | No      | Yes    | Yes     | Yes     | Yes        | Partial | Yes     | Partial | Yes      | Yes     | Yes     |
+| Real-Time                 | Yes     | Yes    | Yes     | No      | Yes        | Yes     | Yes     | Yes     | Yes      | Yes     | Yes     |
+| APM                       | No      | Yes    | No      | No      | No         | Yes     | No      | No      | No       | No      | No      |
+| Infrastructure Monitoring | Yes     | Yes    | Yes     | Yes     | Yes        | Yes     | Yes     | Yes     | Yes      | Yes     | Yes     |
+| Application Monitoring    | Partial | Yes    | No      | Partial | Yes        | Yes     | Partial | Partial | No       | Partial | Partial |
+| Log Management            | Yes     | Yes    | No      | Partial | No         | Yes     | Partial | No      | No       | Partial | Partial |
+| Scalability               | Medium  | High   | High    | Medium  | High       | High    | High    | Medium  | High     | High    | High    |
+| Ease of Use               | Medium  | High   | High    | Medium  | Medium     | High    | Medium  | High    | High     | Medium  | Medium  |
 
 ## Choosing the Right Zabbix Alternative for Your Organization
 
@@ -348,4 +395,4 @@ Migration complexity depends on the alternative and your current setup. While so
 
 Look for automated discovery, real-time alerts, customizable dashboards, API access, and support for cloud environments. Advanced features like anomaly detection and [distributed tracing](https://signoz.io/blog/distributed-tracing/) are valuable for handling complex systems.
 
-##
\ No newline at end of file
+##
diff --git a/data/comparisons/zabbix-vs-grafana.mdx b/data/comparisons/zabbix-vs-grafana.mdx
index 0ba204de6..d374144e4 100644
--- a/data/comparisons/zabbix-vs-grafana.mdx
+++ b/data/comparisons/zabbix-vs-grafana.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Zabbix vs Grafana - Choosing the Right Observability Tool
-slug: zabbix-vs-grafana
 date: 2025-03-04
-tags: [monitoring,zabbix,grafana]
+tags: [monitoring, zabbix, grafana]
 authors: [simran_kumari]
 description: Compare Zabbix and Grafana for monitoring. Learn key features, use cases, and how to choose the best tool for your organization's needs.
-keywords: [zabbix vs grafana, monitoring platforms, DevOps tools, application performance monitoring, microservices monitoring]
-
+keywords:
+  [
+    zabbix vs grafana,
+    monitoring platforms,
+    DevOps tools,
+    application performance monitoring,
+    microservices monitoring,
+  ]
 ---
 
 When it comes to monitoring and observability, **Zabbix** and **Grafana** are two widely used tools. Each serves a unique purpose in helping organizations monitor their infrastructure and applications effectively. While Zabbix focuses on comprehensive [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), Grafana excels in data visualization and dashboarding. This article dives into their key features, use cases, and examples to help you determine which tool aligns best with your requirements.
@@ -16,14 +20,14 @@ When it comes to monitoring and observability, **Zabbix** and **Grafana** are tw
 
 The following table provides a high-level comparison between Zabbix and Grafana:
 
-| **Feature** | **Zabbix** | **Grafana** |
-| --- | --- | --- |
-| **Core Functionality** | IT infrastructure monitoring with built-in templates. | Data visualization platform for external sources. |
-| **User Interface** | Traditional, preconfigured dashboards. | Modern, customizable, drag-and-drop dashboards. |
-| **Alerting** | Advanced triggers with multi-channel notifications. | Dashboard-based alerts; integrates with Prometheus Alertmanager. |
-| **Setup** | Complex initial setup; scales for enterprises. | Quick setup via Docker or Grafana Cloud. |
-| **Performance** | Optimized for large-scale IT environments. | High performance for time-series data. |
-| **Pricing** | Free and open-source; paid support optional. | Free core; paid plans for advanced features. |
+| **Feature**            | **Zabbix**                                            | **Grafana**                                                      |
+| ---------------------- | ----------------------------------------------------- | ---------------------------------------------------------------- |
+| **Core Functionality** | IT infrastructure monitoring with built-in templates. | Data visualization platform for external sources.                |
+| **User Interface**     | Traditional, preconfigured dashboards.                | Modern, customizable, drag-and-drop dashboards.                  |
+| **Alerting**           | Advanced triggers with multi-channel notifications.   | Dashboard-based alerts; integrates with Prometheus Alertmanager. |
+| **Setup**              | Complex initial setup; scales for enterprises.        | Quick setup via Docker or Grafana Cloud.                         |
+| **Performance**        | Optimized for large-scale IT environments.            | High performance for time-series data.                           |
+| **Pricing**            | Free and open-source; paid support optional.          | Free core; paid plans for advanced features.                     |
 
 Before we dive into the key differences between Zabbix and Grafana, let's briefly explore each platform.
 
@@ -31,7 +35,13 @@ Before we dive into the key differences between Zabbix and Grafana, let's briefl
 
 ### Zabbix: Infrastructure Monitoring and Alerting
 
-<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">Zabbix</a> is an all-in-one, open-source monitoring tool designed primarily for tracking the health and performance of infrastructure components such as servers, networks, databases, and virtual machines. It provides a centralized platform for collecting, analyzing, and acting on metrics to identify and resolve potential issues before they impact users.
+<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Zabbix
+</a>
+is an all-in-one, open-source monitoring tool designed primarily for tracking the health and
+performance of infrastructure components such as servers, networks, databases, and virtual machines.
+It provides a centralized platform for collecting, analyzing, and acting on metrics to identify and
+resolve potential issues before they impact users.
 
 **Key Features of Zabbix**
 
@@ -43,7 +53,12 @@ Before we dive into the key differences between Zabbix and Grafana, let's briefl
 
 ### Grafana: Data Visualization and Dashboarding
 
-<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> is a leading open-source data visualization and analytics platform that helps users turn raw metrics into visually intuitive dashboards. Unlike Zabbix, Grafana does not collect data itself but connects to various sources to display information in an accessible format.
+<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a>
+is a leading open-source data visualization and analytics platform that helps users turn raw metrics
+into visually intuitive dashboards. Unlike Zabbix, Grafana does not collect data itself but connects
+to various sources to display information in an accessible format.
 
 **Key Features of Grafana**
 
@@ -65,22 +80,33 @@ Zabbix and Grafana excel in monitoring and visualization but approach these task
 
 1. **Extensive Metric Collection**: Zabbix collects performance data from a wide range of systems and protocols, including SNMP (Simple Network Management Protocol), IPMI (Intelligent Platform Management Interface), and JMX (Java Management Extensions). This makes it highly versatile for IT environments.
 2. **IT Infrastructure Monitoring**: With a focus on infrastructure, Zabbix monitors servers, databases, and network devices to ensure they operate within acceptable thresholds.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image.webp" alt="Infrastructure Monitoring in Zabbix" caption="Infrastructure Monitoring in Zabbix" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image.webp"
+     alt="Infrastructure Monitoring in Zabbix"
+     caption="Infrastructure Monitoring in Zabbix"
+   />
+
 3. **Built-In Discovery and Monitoring Templates**: Zabbix simplifies setup through automated discovery and prebuilt templates for various devices and applications.
 
 **Grafana**
 
 1. **Advanced-Data Visualization**: Grafana specializes in creating dynamic and interactive dashboards that are perfect for time-series data and logs. It connects to multiple data sources, making it a powerful tool for teams that rely on visual analysis.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%201.webp" alt="Dynamic and interactive dashboards in Grafana" caption="Dynamic and interactive dashboards in Grafana" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%201.webp"
+     alt="Dynamic and interactive dashboards in Grafana"
+     caption="Dynamic and interactive dashboards in Grafana"
+   />
+
 2. **Focus on Time-Series Data**: Grafana excels in time-series data analysis, making it an ideal choice for monitoring metrics like system performance over time or log-based trends.
 3. **Plugins for Extended Functionality:** Grafana supports a rich ecosystem of plugins to add features like heatmaps, alerting, and integration with third-party tools.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%202.webp" alt="Community Plugins for Enhanced Features in Grafana" caption="Community Plugins for Enhanced Features in Grafana" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%202.webp"
+     alt="Community Plugins for Enhanced Features in Grafana"
+     caption="Community Plugins for Enhanced Features in Grafana"
+   />
 
 ### User Interface
 
@@ -89,26 +115,40 @@ The user interface is a critical factor when choosing between Zabbix and Grafana
 **Zabbix**
 
 1. **Web-Based UI**: Zabbix offers a centralized, web-based interface designed for IT administrators. The interface is task-focused and facilitates managing multiple devices from a single location.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%203.webp" alt="Zabbix Web-based UI" caption="Zabbix Web-based UI" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%203.webp"
+     alt="Zabbix Web-based UI"
+     caption="Zabbix Web-based UI"
+   />
+
 2. **Traditional Design**: The UI prioritizes functionality over aesthetics, making it ideal for those who prefer a straightforward, no-frills approach to IT monitoring.
 3. **Preconfigured Templates:** Zabbix includes prebuilt templates for common devices and applications, simplifying the process of creating dashboards.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%204.webp" alt="Built-In Templates for Quick Setup : Zabbix" caption="Built-In Templates for Quick Setup : Zabbix" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%204.webp"
+     alt="Built-In Templates for Quick Setup : Zabbix"
+     caption="Built-In Templates for Quick Setup : Zabbix"
+   />
 
 **Grafana**
 
 1. **Modern and Customizable Interface**: Grafana’s drag-and-drop dashboard builder allows users to create highly customizable visualizations. It’s intuitive enough for non-technical users yet powerful for advanced analytics.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-drag_drop.gif" alt="Grafana’s drag-and-drop dashboard builder" caption="Grafana’s drag-and-drop dashboard builder" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-drag_drop.gif"
+     alt="Grafana’s drag-and-drop dashboard builder"
+     caption="Grafana’s drag-and-drop dashboard builder"
+   />
+
 2. **Real-Time Visualization**: The interface is optimized for real-time metrics and logs, providing live updates as data changes.
 3. **Interactive Themes:** Grafana allows users to switch between light and dark themes for a more personalized experience.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%205.webp" alt="Setting Themes in Grafana" caption="Setting Themes in Grafana" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%205.webp"
+     alt="Setting Themes in Grafana"
+     caption="Setting Themes in Grafana"
+   />
 
 ### Alerting Capabilities
 
@@ -117,19 +157,25 @@ Alerting is a critical aspect of monitoring tools, ensuring that issues are dete
 **Zabbix**
 
 1. **Advanced Triggers and Escalation**: Zabbix provides a powerful trigger system where alerts are defined based on flexible thresholds and conditions. Alerts can be escalated based on severity, ensuring the right teams are notified.
-    - **Example**: If a server's CPU usage exceeds 80% for 10 minutes, Zabbix can trigger an alert and escalate to senior administrators if unresolved.
-        
-        <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%206.webp" alt="Sending alerts in Zabbix using Custom Scripts" caption="Sending alerts in Zabbix using Custom Scripts" />
-        
+   - **Example**: If a server's CPU usage exceeds 80% for 10 minutes, Zabbix can trigger an alert and escalate to senior administrators if unresolved.
+     <Figure
+       src="/img/comparisons/2025/03/zabbix-vs-grafana-image%206.webp"
+       alt="Sending alerts in Zabbix using Custom Scripts"
+       caption="Sending alerts in Zabbix using Custom Scripts"
+     />
 2. **Multi-Channel Notifications**: Zabbix supports notifications via multiple channels, including email, SMS, Slack, Microsoft Teams, and custom scripts. This versatility makes it suitable for enterprise environments.
 3. **Infrastructure Health Focus**: The alerting capabilities in Zabbix are specifically tailored for infrastructure health monitoring, ensuring timely detection of hardware and network issues.
 
 **Grafana**
 
 1. **Metric-Based Alerting:** Grafana’s alerting system is tied directly to the metrics displayed on dashboards, allowing for real-time notifications based on user-defined thresholds.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%207.webp" alt="Custom alerts and notifications in Grafana" caption="Custom alerts and notifications in Grafana" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%207.webp"
+     alt="Custom alerts and notifications in Grafana"
+     caption="Custom alerts and notifications in Grafana"
+   />
+
 2. **Integration with Prometheus Alertmanager**: For more complex workflows, Grafana integrates seamlessly with Prometheus Alertmanager, enabling routing, grouping, and silencing of alerts.
 3. **Less Robust Standalone Alerting**: While Grafana’s alerting works well for visualization-based scenarios, it’s less comprehensive than Zabbix for standalone infrastructure monitoring. It’s best used as part of a larger monitoring stack.
 
@@ -146,16 +192,18 @@ Setting up monitoring tools can vary in complexity, depending on the tool's arch
 **Grafana**
 
 1. **Quick Installation:** Grafana is easy to set up, whether you use Docker, package managers, or Grafana Cloud. The installation process is straightforward and user-friendly.
-    - **Example**: Spinning up Grafana on Docker with a single command:
-        
-        ```bash
-        docker run -d -p 3000:3000 grafana/grafana
-        ```
-        
+   - **Example**: Spinning up Grafana on Docker with a single command:
+     ```bash
+     docker run -d -p 3000:3000 grafana/grafana
+     ```
 2. **Seamless Integration with Data Sources:** Grafana’s setup largely depends on integrating it with data sources like Prometheus, InfluxDB, or Elasticsearch. The configuration process is intuitive, with guided steps for connecting and querying data.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%208.webp" alt="Multiple data sources in Grafana" caption="Multiple data sources in Grafana" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%208.webp"
+     alt="Multiple data sources in Grafana"
+     caption="Multiple data sources in Grafana"
+   />
+
 3. **Scales for Diverse Use Cases**: Grafana’s modular architecture makes it adaptable for different teams and industries. For example, a SaaS company can use Grafana to monitor both infrastructure metrics and user engagement KPIs.
 
 ### Performance and Scalability
@@ -181,18 +229,25 @@ Pricing models can significantly impact your choice of monitoring tools, especia
 **Zabbix**
 
 1. **Completely Free and Open-Source:** Zabbix is entirely open-source under the GNU General Public License (GPL). This means there are no licensing costs, making it an excellent choice for organizations on a tight budget or those favoring open-source solutions.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%209.webp" alt="Zabbix is free to use" caption="Zabbix is free to use" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%209.webp"
+     alt="Zabbix is free to use"
+     caption="Zabbix is free to use"
+   />
+
 2. **Optional Enterprise Support**: For large organizations that require dedicated support, Zabbix offers optional paid enterprise plans. These plans include expert assistance, SLA-based services, and access to additional tools.
 
 **Grafana**
 
 1. **Free for Open-Source Usage**: Grafana’s core functionality is available for free under the Apache 2.0 License. This makes it highly accessible for developers and small teams.
 2. **Paid Plans for Grafana Cloud**: Grafana offers premium plans through Grafana Cloud, which include advanced features like enhanced scalability, hosted solutions, and extended data retention. Plans range from free tiers with basic limits to enterprise-level offerings.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%2010.webp" alt="Grafana Pricing" caption="Grafana Pricing" />
-    
+
+   <Figure
+     src="/img/comparisons/2025/03/zabbix-vs-grafana-image%2010.webp"
+     alt="Grafana Pricing"
+     caption="Grafana Pricing"
+   />
 
 Check out the detailed pricing <a href="https://grafana.com/pricing/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
 
@@ -203,34 +258,36 @@ Choosing between Zabbix and Grafana depends on your organization’s specific ne
 ### When to Choose Zabbix
 
 1. **Proactive IT Infrastructure Monitoring**:
-    
-    If your primary goal is to monitor servers, network devices, and hardware for health and availability, Zabbix provides agent-based monitoring, SNMP support, and built-in discovery.
-    
+
+   If your primary goal is to monitor servers, network devices, and hardware for health and availability, Zabbix provides agent-based monitoring, SNMP support, and built-in discovery.
+
 2. **Comprehensive Alerting and Notification Workflows**:
-    
-    Zabbix excels in creating advanced triggers, alert escalations, and multi-channel notifications for quick issue resolution.
-    
+
+   Zabbix excels in creating advanced triggers, alert escalations, and multi-channel notifications for quick issue resolution.
+
 3. **Out-of-the-Box Templates for Common Environments**:
-    
-    Predefined templates simplify the monitoring setup for popular systems and applications like MySQL, Apache, or Docker.
-    
+
+   Predefined templates simplify the monitoring setup for popular systems and applications like MySQL, Apache, or Docker.
 
 ### When to Choose Grafana
 
 1. **Advanced Visualization of Time-Series Data**:
-    
-    For teams looking to create detailed, dynamic dashboards to visualize metrics over time, Grafana offers unmatched flexibility and aesthetics.
-    
+
+   For teams looking to create detailed, dynamic dashboards to visualize metrics over time, Grafana offers unmatched flexibility and aesthetics.
+
 2. **Integration with Multiple Data Sources**:
-    
-    Grafana seamlessly connects with Prometheus, Elasticsearch, MySQL, and more, making it ideal for consolidating data from diverse systems.
-    
+
+   Grafana seamlessly connects with Prometheus, Elasticsearch, MySQL, and more, making it ideal for consolidating data from diverse systems.
+
 3. **Interactive Dashboards for Analytics**:
-    
-    Grafana’s drag-and-drop interface and customizable widgets are perfect for analytics-driven teams who need to present insights effectively.
-    
 
-<Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-4dddbbcf-ef19-43e5-b772-2b0499370ea6.webp" alt="Choosing between Zabbix and Grafana" caption="Choosing between Zabbix and Grafana" />
+   Grafana’s drag-and-drop interface and customizable widgets are perfect for analytics-driven teams who need to present insights effectively.
+
+<Figure
+  src="/img/comparisons/2025/03/zabbix-vs-grafana-4dddbbcf-ef19-43e5-b772-2b0499370ea6.webp"
+  alt="Choosing between Zabbix and Grafana"
+  caption="Choosing between Zabbix and Grafana"
+/>
 
 ## A Better Alternative to Zabbix and Grafana: SigNoz
 
@@ -241,18 +298,21 @@ If you're looking for a solution that combines the best features of both Zabbix
 - **Focus Area**: Zabbix specializes in **infrastructure monitoring** (CPU, memory, network, hardware metrics), while SigNoz is designed as an **[unified observability](https://signoz.io/unified-observability/)** platform.
 - **Data Collection**: Zabbix relies on **agents** and SNMP polling, whereas SigNoz uses **OpenTelemetry**, allowing deeper insights into application and system behavior.
 - **Observability**: SigNoz offers **[distributed tracing](https://signoz.io/distributed-tracing/)** and **[log correlation](https://signoz.io/opentelemetry/correlating-traces-logs-metrics-nodejs/)**, which are **not core features in Zabbix**.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image%2011.webp" alt="Unified Observability in SigNoz" caption="Unified Observability in SigNoz" /> 
-    
+  <Figure
+    src="/img/comparisons/2025/03/zabbix-vs-grafana-image%2011.webp"
+    alt="Unified Observability in SigNoz"
+    caption="Unified Observability in SigNoz"
+  />
 - **Adoption Curve**: Zabbix has a **steeper learning curve** with complex configuration requirements, while SigNoz provides a **more intuitive setup** with OpenTelemetry's standardized instrumentation.
 
 ### SigNoz vs. Grafana
 
 - **Data Handling**: Grafana is mainly a **visualization layer** that connects to various data sources (Prometheus, Loki, InfluxDB, etc.), whereas SigNoz **stores, processes, and visualizes** telemetry data in one platform.
-    
-    <Figure src="/img/comparisons/2025/03/zabbix-vs-grafana-image_(10).webp" alt="SigNoz Metric Dashboard" caption="SigNoz Metric Dashboard" />
-    
-    
+  <Figure
+    src="/img/comparisons/2025/03/zabbix-vs-grafana-image_(10).webp"
+    alt="SigNoz Metric Dashboard"
+    caption="SigNoz Metric Dashboard"
+  />
 - **Correlation**: Grafana lacks **native trace-log-metric correlation**, requiring multiple tools, while SigNoz **integrates all observability signals natively**.
 - **Querying**: Grafana supports **PromQL** and other query languages but requires external storage. SigNoz provides **native querying** with **PromQL support**.
 - **Deployment Complexity**: With Grafana, you need to **manage multiple components** (Prometheus, Loki, Tempo) separately, while SigNoz offers a **single deployment** for complete observability.
@@ -295,4 +355,4 @@ If you're looking for a solution that combines the best features of both Zabbix
 
 ### How do the pricing models and licensing options of Zabbix and Grafana compare, and what are the considerations for enterprise and open-source deployments?
 
-Both **Zabbix** and **Grafana** offer open-source versions. **Zabbix** has a premium enterprise version, while **Grafana** offers both an open-source and enterprise version with advanced features for team collaboration and security.
\ No newline at end of file
+Both **Zabbix** and **Grafana** offer open-source versions. **Zabbix** has a premium enterprise version, while **Grafana** offers both an open-source and enterprise version with advanced features for team collaboration and security.
diff --git a/data/faqs/are-there-any-hidden-costs-associated-with-using-signoz.mdx b/data/faqs/are-there-any-hidden-costs-associated-with-using-signoz.mdx
index 837ddea58..e557a2910 100644
--- a/data/faqs/are-there-any-hidden-costs-associated-with-using-signoz.mdx
+++ b/data/faqs/are-there-any-hidden-costs-associated-with-using-signoz.mdx
@@ -1,6 +1,5 @@
 ---
 title: Are there any hidden costs associated with using SigNoz?
-slug: are-there-any-hidden-costs-associated-with-using-signoz
 description: SigNoz offers transparent pricing, and to help you maximize value, here are some key features that allow for cost optimisation.
 date: 2024-11-14
 tags: [performance]
@@ -13,9 +12,9 @@ No, Using SigNoz for observability comes with a straightforward pricing model as
 
 1. **Base Subscription**: SigNoz starts at **$49 per month** for its paid plans, which include essential features like traces, log management, metrics and dashboards.
 2. **Usage-Based Costs**:
-    - **Logs**: $0.3 per GB ingested with a retention period of 15 days.
-    - **Traces**: $0.3 per GB ingested, also with a 15-day retention.
-    - **Metrics**: $0.1 per million samples with a retention of 1 month.
+   - **Logs**: $0.3 per GB ingested with a retention period of 15 days.
+   - **Traces**: $0.3 per GB ingested, also with a 15-day retention.
+   - **Metrics**: $0.1 per million samples with a retention of 1 month.
 
 You can estimate your monthly bill using [SigNoz’s Pricing Calculator](https://signoz.io/pricing/).
 
@@ -28,10 +27,10 @@ You can estimate your monthly bill using [SigNoz’s Pricing Calculator](https:/
 
 ## Comparison with Other Tools
 
-SigNoz is often compared to Datadog, which has a more complex pricing structure that can lead to hidden costs due to its per-host and usage-based billing models. [Datadog's charges can escalate quickly with dynamic scaling and custom metrics](https://signoz.io/blog/datadog-pricing/), making it less predictable than [SigNoz's model](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/). 
+SigNoz is often compared to Datadog, which has a more complex pricing structure that can lead to hidden costs due to its per-host and usage-based billing models. [Datadog's charges can escalate quickly with dynamic scaling and custom metrics](https://signoz.io/blog/datadog-pricing/), making it less predictable than [SigNoz's model](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/).
 
 In contrast, SigNoz's open-source version allows users to avoid recurring SaaS fees altogether, making it an attractive option for budget-conscious teams.
 
 You can read more about [SigNoz vs Datadog](https://signoz.io/product-comparison/signoz-vs-datadog).
 
-In summary, while SigNoz offers a relatively clear pricing structure with no hidden fees in its basic offerings, careful management of data ingestion and retention is essential to avoid unexpected costs.
\ No newline at end of file
+In summary, while SigNoz offers a relatively clear pricing structure with no hidden fees in its basic offerings, careful management of data ingestion and retention is essential to avoid unexpected costs.
diff --git a/data/faqs/can-i-integrate-signoz-with-other-tools.mdx b/data/faqs/can-i-integrate-signoz-with-other-tools.mdx
index 40084b9e3..c0e362000 100644
--- a/data/faqs/can-i-integrate-signoz-with-other-tools.mdx
+++ b/data/faqs/can-i-integrate-signoz-with-other-tools.mdx
@@ -1,6 +1,5 @@
 ---
 title: Can I integrate SigNoz with other tools?
-slug: can-i-integrate-signoz-with-other-tools
 description: Learn how SigNoz integrates with various tools and services through OpenTelemetry, including cloud platforms, databases, and monitoring solutions.
 date: 2024-11-14
 tags: [features]
@@ -15,9 +14,9 @@ Yes, SigNoz integrates seamlessly with a variety of tools and cloud services, pr
 2. **Tracetest**: You can connect [SigNoz with Tracetest](https://signoz.io/blog/signoz-tracetest-opentelemetry-native-observability-meets-testing/), a tool that uses observability data for end-to-end testing. Tracetest can utilize the OpenTelemetry Collector to send trace data to both itself and SigNoz, enabling verification of API responses and underlying processes.
 3. **Alerting and Incident Management**: SigNoz supports integration with alerting tools. You can configure alerts to notify incident management systems when critical performance thresholds are crossed.
 4. **Cloud Services (AWS, GCP, Azure)**:
-    - **AWS**: [SigNoz monitors AWS services](https://signoz.io/docs/aws-monitoring/lambda-logs/) like RDS, API Gateway, and Lambda through OpenTelemetry. It can be deployed on AWS EKS using Helm.
-    - **GCP**: [You can monitor GCP services](https://signoz.io/docs/gcp-monitoring/compute-engine/metrics/) like those on GKE with specific configurations in Helm for GCP environments.
-    - **Azure**: [SigNoz supports monitoring Azure services](https://signoz.io/docs/azure-monitoring/az-fns/metrics/) by deploying on AKS with Azure-specific Helm settings.
+   - **AWS**: [SigNoz monitors AWS services](https://signoz.io/docs/aws-monitoring/lambda-logs/) like RDS, API Gateway, and Lambda through OpenTelemetry. It can be deployed on AWS EKS using Helm.
+   - **GCP**: [You can monitor GCP services](https://signoz.io/docs/gcp-monitoring/compute-engine/metrics/) like those on GKE with specific configurations in Helm for GCP environments.
+   - **Azure**: [SigNoz supports monitoring Azure services](https://signoz.io/docs/azure-monitoring/az-fns/metrics/) by deploying on AKS with Azure-specific Helm settings.
 5. **Database Integrations**: [SigNoz integrates with databases](https://signoz.io/docs/integrations/integrations-list/) like Redis, PostgreSQL, MongoDB, and AWS RDS, allowing you to collect and visualize metrics and logs from these sources.
 
 ### Benefits of Integration
@@ -26,4 +25,4 @@ Yes, SigNoz integrates seamlessly with a variety of tools and cloud services, pr
 - **Flexibility**: [SigNoz](https://signoz.io/docs/introduction/) can be deployed as a self-hosted solution (Docker, Kubernetes) or on the cloud, allowing you to choose the setup that suits your needs.
 - **Cost Efficiency**: As an open-source tool, SigNoz offers a budget-friendly alternative to commercial observability solutions without compromising on features.
 
-In summary, SigNoz’s extensive integration capabilities make it a versatile choice for enhancing observability across various platforms and services. For detailed integration options, refer to the [official documentation](https://signoz.io/docs/integrations/integrations-list/).
\ No newline at end of file
+In summary, SigNoz’s extensive integration capabilities make it a versatile choice for enhancing observability across various platforms and services. For detailed integration options, refer to the [official documentation](https://signoz.io/docs/integrations/integrations-list/).
diff --git a/data/faqs/can-signoz-handle-large-scale-production-environments-effectively.mdx b/data/faqs/can-signoz-handle-large-scale-production-environments-effectively.mdx
index cf13603f0..06ec59670 100644
--- a/data/faqs/can-signoz-handle-large-scale-production-environments-effectively.mdx
+++ b/data/faqs/can-signoz-handle-large-scale-production-environments-effectively.mdx
@@ -1,6 +1,5 @@
 ---
 title: Can SigNoz handle large-scale production environments effectively?
-slug: can-signoz-handle-large-scale-production-environments-effectively
 description: SigNoz is an open-source observability platform designed to effectively handle large-scale production environments. Its architecture and features make it suitable for monitoring complex applications and systems, ensuring performance and reliability.
 date: 2024-11-16
 tags: [performance]
@@ -29,4 +28,4 @@ To maximize the effectiveness of [SigNoz in production settings](https://signoz.
 - **Configuration Optimization**: Adjusting configurations such as TTL (time-to-live) for disk storage and using higher batch sizes in the OpenTelemetry collector can enhance performance when dealing with large datasets.
 - **Distributed Tracing**: Implementing distributed tracing capabilities allows teams to monitor requests across microservices effectively, identifying bottlenecks in real-time.
 
-SigNoz is well-equipped to handle large-scale production environments through its scalable architecture, efficient performance metrics, and robust monitoring features. Its ability to integrate various observability signals into a single platform enhances troubleshooting capabilities and operational reliability.
\ No newline at end of file
+SigNoz is well-equipped to handle large-scale production environments through its scalable architecture, efficient performance metrics, and robust monitoring features. Its ability to integrate various observability signals into a single platform enhances troubleshooting capabilities and operational reliability.
diff --git a/data/faqs/does-signoz-work-well-with-existing-prometheus-setups.mdx b/data/faqs/does-signoz-work-well-with-existing-prometheus-setups.mdx
index b57c05402..d05bb3494 100644
--- a/data/faqs/does-signoz-work-well-with-existing-prometheus-setups.mdx
+++ b/data/faqs/does-signoz-work-well-with-existing-prometheus-setups.mdx
@@ -1,6 +1,5 @@
 ---
 title: Does SigNoz work well with existing Prometheus setups?
-slug: does-signoz-work-well-with-existing-prometheus-setups
 description: SigNoz integrates effectively with existing Prometheus setups, facilitating a smooth transition for users looking to enhance their monitoring capabilities. Here are the key aspects of this integration.
 date: 2024-11-14
 tags: [features]
@@ -19,4 +18,4 @@ SigNoz integrates effectively with existing Prometheus setups, facilitating a sm
 - **Unified Observability**: By integrating with SigNoz, users gain access to a comprehensive monitoring platform that combines various telemetry types (metrics, logs, traces) in one interface. This holistic view aids in identifying performance bottlenecks and optimizing resource utilization.
 - **Advanced Alerting**: SigNoz enhances alert management by allowing dynamic configuration through APIs, which provides greater flexibility compared to traditional Prometheus alerting setups.
 
-In summary, SigNoz not only works well with existing Prometheus setups but also enhances them by providing additional features and capabilities that improve overall observability and monitoring efficiency.
\ No newline at end of file
+In summary, SigNoz not only works well with existing Prometheus setups but also enhances them by providing additional features and capabilities that improve overall observability and monitoring efficiency.
diff --git a/data/faqs/how-signoz-ensures-data-security-and-privacy.mdx b/data/faqs/how-signoz-ensures-data-security-and-privacy.mdx
index fda06f6e8..6de77cb3d 100644
--- a/data/faqs/how-signoz-ensures-data-security-and-privacy.mdx
+++ b/data/faqs/how-signoz-ensures-data-security-and-privacy.mdx
@@ -1,6 +1,5 @@
 ---
 title: How does SigNoz ensure data security and privacy?
-slug: how-signoz-ensures-data-security-and-privacy
 description: SigNoz takes a comprehensive approach to data security and privacy, implementing various measures and compliance standards to protect user information. Here are the key aspects of how SigNoz ensures data security and privacy.
 date: 2024-11-14
 tags: [features, security]
@@ -29,4 +28,4 @@ authors: [yuvraj]
 - **Regular Audits and Risk Management**: SigNoz undergoes regular audits as part of its SOC 2 compliance, ensuring effective internal controls for data security. This continuous monitoring helps detect and address potential risks.
 - **Transparent Operations**: SigNoz maintains clear, transparent processes for data handling, giving you confidence in its commitment to industry standards.
 
-By adhering to standards like SOC 2 and HIPAA, implementing strong security features, supporting data privacy through PII scrubbing, and focusing on continuous monitoring, SigNoz provides a secure environment for observability data. These practices protect your information while aligning with regulatory needs, making SigNoz a trustworthy choice for data security and privacy.
\ No newline at end of file
+By adhering to standards like SOC 2 and HIPAA, implementing strong security features, supporting data privacy through PII scrubbing, and focusing on continuous monitoring, SigNoz provides a secure environment for observability data. These practices protect your information while aligning with regulatory needs, making SigNoz a trustworthy choice for data security and privacy.
diff --git a/data/faqs/how-signozs-advanced-filtering-and-aggregation-capabilities-improve-root-cause-analysis.mdx b/data/faqs/how-signozs-advanced-filtering-and-aggregation-capabilities-improve-root-cause-analysis.mdx
index 8c4a16058..e57cf61c7 100644
--- a/data/faqs/how-signozs-advanced-filtering-and-aggregation-capabilities-improve-root-cause-analysis.mdx
+++ b/data/faqs/how-signozs-advanced-filtering-and-aggregation-capabilities-improve-root-cause-analysis.mdx
@@ -1,6 +1,5 @@
 ---
 title: How SigNoz's advanced filtering and aggregation capabilities improve root cause analysis?
-slug: how-signozs-advanced-filtering-and-aggregation-capabilities-improve-root-cause-analysis
 description: SigNoz is an open-source observability platform that helps you perform root cause analysis using advanced filtering and aggregation. With a unified view of metrics, logs, and traces, you can quickly identify and resolve performance issues.
 date: 2024-11-14
 tags: [features]
@@ -35,4 +34,4 @@ SigNoz [correlates metrics, logs, and traces](https://signoz.io/opentelemetry/co
 - When you detect a latency spike, access related logs and traces to determine if the issue is due to a database query or network failure.
 - [Automated anomaly detection](https://signoz.io/blog/introducing-anomaly-detection-for-smarter-alerts/) flags unusual patterns, helping you find root causes faster.
 
-In summary, [SigNoz](https://signoz.io/docs/introduction/)'s filtering, aggregation, and correlation capabilities make root cause analysis more efficient. With detailed queries, efficient data summarization, and seamless correlation, SigNoz helps you resolve issues faster and improve system reliability.
\ No newline at end of file
+In summary, [SigNoz](https://signoz.io/docs/introduction/)'s filtering, aggregation, and correlation capabilities make root cause analysis more efficient. With detailed queries, efficient data summarization, and seamless correlation, SigNoz helps you resolve issues faster and improve system reliability.
diff --git a/data/faqs/how-signozs-columnar-datastore-enhances-query-performance.mdx b/data/faqs/how-signozs-columnar-datastore-enhances-query-performance.mdx
index a8f3aeb7a..1aef3ed30 100644
--- a/data/faqs/how-signozs-columnar-datastore-enhances-query-performance.mdx
+++ b/data/faqs/how-signozs-columnar-datastore-enhances-query-performance.mdx
@@ -1,6 +1,5 @@
 ---
 title: How SigNoz's columnar datastore enhances query performance?
-slug: how-signozs-columnar-datastore-enhances-query-performance
 description: SigNoz uses a columnar datastore, specifically ClickHouse, to boost query performance for observability tasks. This setup is ideal for managing large amounts of telemetry data, including metrics, traces, and logs.
 date: 2024-11-14
 tags: [features, performance]
@@ -31,4 +30,4 @@ The platform includes a [powerful query builder](https://signoz.io/docs/userguid
 
 ClickHouse also improves storage efficiency with features like data compression and partitioning. This lowers [storage costs](https://signoz.io/pricing/) while maintaining high performance during data ingestion and querying. SigNoz effectively manages long-term storage, meeting compliance and auditing needs without sacrificing speed.
 
-By leveraging ClickHouse, SigNoz transforms how you query and analyze observability data. This architecture ensures rapid aggregation, efficient data handling, and a unified experience—all critical for modern monitoring and troubleshooting. SigNoz stands out as a strong choice for developers looking for fast and efficient insights from their telemetry data.
\ No newline at end of file
+By leveraging ClickHouse, SigNoz transforms how you query and analyze observability data. This architecture ensures rapid aggregation, efficient data handling, and a unified experience—all critical for modern monitoring and troubleshooting. SigNoz stands out as a strong choice for developers looking for fast and efficient insights from their telemetry data.
diff --git a/data/faqs/how-signozs-integration-with-opentelemetry-simplifies-instrumentation.mdx b/data/faqs/how-signozs-integration-with-opentelemetry-simplifies-instrumentation.mdx
index ed972bde1..9514d3ffb 100644
--- a/data/faqs/how-signozs-integration-with-opentelemetry-simplifies-instrumentation.mdx
+++ b/data/faqs/how-signozs-integration-with-opentelemetry-simplifies-instrumentation.mdx
@@ -1,6 +1,5 @@
 ---
 title: How SigNoz's integration with OpenTelemetry simplifies instrumentation?
-slug: how-signozs-integration-with-opentelemetry-simplifies-instrumentation
 description: SigNoz is an open-source observability platform that helps you monitor and improve application performance. Built to natively support OpenTelemetry, it simplifies instrumentation and provides a unified view of metrics, logs, and traces, helping you identify and resolve issues quickly.
 date: 2024-11-14
 tags: [features]
@@ -33,12 +32,12 @@ You can deploy [SigNoz as a cloud service or self-hos](https://signoz.io/docs/in
 
 ## Key Features of SigNoz with OpenTelemetry
 
-| Feature | Description |
-| --- | --- |
-| **Full-Stack Observability** | Visibility across all layers of the application stack. |
+| Feature                       | Description                                                |
+| ----------------------------- | ---------------------------------------------------------- |
+| **Full-Stack Observability**  | Visibility across all layers of the application stack.     |
 | **Automatic Instrumentation** | Supports automatic instrumentation for multiple languages. |
-| **Multi-Signal Support** | Handles traces, metrics, and logs in one platform. |
-| **Custom Dashboards** | Create dashboards tailored to your needs. |
-| **Community Support** | Backed by a strong, growing community. |
+| **Multi-Signal Support**      | Handles traces, metrics, and logs in one platform.         |
+| **Custom Dashboards**         | Create dashboards tailored to your needs.                  |
+| **Community Support**         | Backed by a strong, growing community.                     |
 
-By integrating SigNoz with OpenTelemetry, you can simplify the instrumentation process, gain rich visualization capabilities, and deploy observability solutions on your terms. This gives you deeper insights into application performance while keeping control over your data.
\ No newline at end of file
+By integrating SigNoz with OpenTelemetry, you can simplify the instrumentation process, gain rich visualization capabilities, and deploy observability solutions on your terms. This gives you deeper insights into application performance while keeping control over your data.
diff --git a/data/faqs/who-uses-signoz-in-production.mdx b/data/faqs/who-uses-signoz-in-production.mdx
index eb3ffd0e1..e0aae4e4a 100644
--- a/data/faqs/who-uses-signoz-in-production.mdx
+++ b/data/faqs/who-uses-signoz-in-production.mdx
@@ -1,10 +1,10 @@
 ---
 title: Who uses SigNoz in production?
-slug: who-uses-signoz-in-production
 description: SigNoz helps organizations of all sizes, from startups to established companies, improve observability and application performance monitoring. Here are some companies using SigNoz and their experiences.
 date: 2024-11-14
 tags: [usecases]
 authors: [yuvraj]
+related_faqs: ['/how-signozs-columnar-datastore-enhances-query-performance']
 ---
 
 SigNoz helps organizations of all sizes, from startups to established companies, improve observability and application performance monitoring. Here are some companies using SigNoz and their experiences:
@@ -14,7 +14,7 @@ SigNoz helps organizations of all sizes, from startups to established companies,
 - [**Mailmodo**](https://signoz.io/case-study/mailmodo/): Monitors over 200GB of daily logs from 200+ microservices.
 - [**Kiwi**](https://signoz.io/case-study/kiwi/): Reduced API response times from 20 seconds to milliseconds.
 - [**Brainfish**](https://signoz.io/case-study/brainfish/): Uses SigNoz for monitoring and log management in Kubernetes.
-{/* - [**Bands**](https://signoz.io/case-study/bands/): Monitors over 50 integrations for thousands of musicians. */}
+  {/* - [**Bands**](https://signoz.io/case-study/bands/): Monitors over 50 integrations for thousands of musicians. */}
 - [**Cedana**](https://signoz.io/case-study/cedana/): Ensures uptime for real-time compute operations.
 - [**The Hindu**](https://signoz.io/case-study/thehindu/): Optimizes application performance using SigNoz APM.
 - [**Outplay**](https://signoz.io/case-study/outplay/): Improved backend API response times by 35% with SigNoz.
@@ -24,4 +24,4 @@ Major tech companies like Samsung, Salesforce, and NetApp also use SigNoz's self
 
 ## Community Feedback
 
-Users praise SigNoz for its easy setup and wide range of features. It's especially helpful in Kubernetes environments, where it automatically collects logs and metrics with little configuration. [Read more about users' experiences here.](https://www.reddit.com/r/devops/comments/11n272q/who_uses_signoz_in_production/)
\ No newline at end of file
+Users praise SigNoz for its easy setup and wide range of features. It's especially helpful in Kubernetes environments, where it automatically collects logs and metrics with little configuration. [Read more about users' experiences here.](https://www.reddit.com/r/devops/comments/11n272q/who_uses_signoz_in_production/)
diff --git a/data/guides/a-regex-in-query-in-grafana.mdx b/data/guides/a-regex-in-query-in-grafana.mdx
index d89f1d26a..59cda6853 100644
--- a/data/guides/a-regex-in-query-in-grafana.mdx
+++ b/data/guides/a-regex-in-query-in-grafana.mdx
@@ -1,20 +1,26 @@
 ---
-
 title: How to Use Regex in Grafana Queries - A Step-by-Step Guide
-slug: a-regex-in-query-in-grafana
 date: 2024-09-18
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Learn how to effectively use regex in Grafana queries with this comprehensive guide. Boost your data filtering and visualization skills today.
-keywords: [regex in Grafana, Grafana queries, data filtering, log analysis, Grafana dashboards, regex performance, observability]
-
+keywords:
+  [
+    regex in Grafana,
+    Grafana queries,
+    data filtering,
+    log analysis,
+    Grafana dashboards,
+    regex performance,
+    observability,
+  ]
 ---
 
 Regex, short for "regular expressions," is a powerful tool for searching and manipulating text patterns. When combined with Grafana, a popular open-source visualization tool, regex allows users to filter, refine, and visualize data more effectively. This guide will walk you through the process of using regex in Grafana queries, from the basics to advanced techniques, to help you get the most out of your dashboards.
 
 ## Understanding Regex in Grafana Queries
 
-Regex allows you to define complex text patterns that can match specific data points across large datasets. In Grafana, regex is crucial in filtering logs, selecting time series based on specific labels, and even creating dynamic dashboards. Understanding how to harness the power of regex can take your Grafana dashboards to the next level. 
+Regex allows you to define complex text patterns that can match specific data points across large datasets. In Grafana, regex is crucial in filtering logs, selecting time series based on specific labels, and even creating dynamic dashboards. Understanding how to harness the power of regex can take your Grafana dashboards to the next level.
 
 Imagine you're monitoring an application with thousands of log entries. Instead of manually sifting through them, regex can help you isolate errors, warnings, or specific events with just a few characters. Or, if you're tracking metrics like CPU usage across multiple servers, regex can quickly filter out irrelevant data, leaving you with just the pertinent information to display on your dashboard.
 
@@ -31,49 +37,35 @@ Common use cases for regex in Grafana include:
 To harness the full power of regex in Grafana queries, familiarize yourself with these essential operators:
 
 1. Wildcards (`.` and `*`): Used to match any character or multiple characters.``
-    - Dot (`.`): Matches any single character except for newline characters. It’s useful for creating patterns where you need to match varying characters in specific positions.
-        
-        Example: `a.b` matches "a1b", "aXb", etc.
-        
-    - Asterisk (`*`): Matches zero or more occurrences of the preceding element. It allows for flexible matching of repeated characters or patterns.
-        
-        Example: `a*` matches "", "a", "aa", etc.
-        
+   - Dot (`.`): Matches any single character except for newline characters. It’s useful for creating patterns where you need to match varying characters in specific positions.
+     Example: `a.b` matches "a1b", "aXb", etc.
+   - Asterisk (`*`): Matches zero or more occurrences of the preceding element. It allows for flexible matching of repeated characters or patterns.
+     Example: `a*` matches "", "a", "aa", etc.
 2. Character Classes and Negations (`[abc]` and `[^abc]`): Define a set of characters to match or exclude.
-    - Character Classes (`[abc]`): Matches any single character within the brackets. This is useful for specifying a set of acceptable characters at a given position.
-        
-        Example: `[a-z]` matches any lowercase letter.
-        
-    - Negated Character Classes (`[^abc]`): Matches any single character not in the brackets. This is useful for excluding certain characters from matches.
-        
-        Example: `[^0-9]` matches any non-digit character.
-        
-3. Quantifiers (`?`, `+`, `{n}`):  Specify how many times a character or group should appear.
-    - Question Mark (`?`): Matches zero or one occurrence of the preceding element. It makes the preceding character or group optional.
-        
-        Example: `a?` matches "" or "a".
-        
-    - Plus (`+`): Matches one or more occurrences of the preceding element. It ensures that at least one instance of the preceding character or group is present.
-        
-        Example: `a+` matches "a", "aa", etc.
-        
-    - Curly Braces (`{n}`): Matches exactly `n` occurrences of the preceding element. This is useful for specifying precise repetition counts.
-        
-        Example: `a{2}` matches "aa".
-        
+   - Character Classes (`[abc]`): Matches any single character within the brackets. This is useful for specifying a set of acceptable characters at a given position.
+     Example: `[a-z]` matches any lowercase letter.
+   - Negated Character Classes (`[^abc]`): Matches any single character not in the brackets. This is useful for excluding certain characters from matches.
+     Example: `[^0-9]` matches any non-digit character.
+3. Quantifiers (`?`, `+`, `{n}`): Specify how many times a character or group should appear.
+   - Question Mark (`?`): Matches zero or one occurrence of the preceding element. It makes the preceding character or group optional.
+     Example: `a?` matches "" or "a".
+   - Plus (`+`): Matches one or more occurrences of the preceding element. It ensures that at least one instance of the preceding character or group is present.
+     Example: `a+` matches "a", "aa", etc.
+   - Curly Braces (`{n}`): Matches exactly `n` occurrences of the preceding element. This is useful for specifying precise repetition counts.
+     Example: `a{2}` matches "aa".
 4. Anchors and Boundaries (`^` and `$`): Set positions in a string.
-    - Caret (`^`): Matches the start of a string. It ensures that the pattern is found at the beginning of the string.
-        
-        Example: `^start` matches "start of the line" but not "the start".
-        
-    - Dollar Sign (`$`): Matches the end of a string. It ensures that the pattern is found at the end of the string.
-        
-        Example: `end$` matches "the end" but not "end of the line".
-        
+   - Caret (`^`): Matches the start of a string. It ensures that the pattern is found at the beginning of the string.
+     Example: `^start` matches "start of the line" but not "the start".
+   - Dollar Sign (`$`): Matches the end of a string. It ensures that the pattern is found at the end of the string.
+     Example: `end$` matches "the end" but not "end of the line".
 
 Here’s a summary highlighting the Key Regex Operators
 
-<Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image.webp" alt="Key Regex Operators" caption="Key Regex Operators" />
+<Figure
+  src="/img/guides/2024/09/a-regex-in-query-in-grafana-image.webp"
+  alt="Key Regex Operators"
+  caption="Key Regex Operators"
+/>
 
 ## Setting Up Your Grafana Environment for Regex Queries
 
@@ -81,116 +73,144 @@ Before diving into regex queries, ensure your Grafana environment is properly co
 
 1. Configure compatible data sources: Grafana supports several data sources that utilize regex for querying. Ensure you select data sources that support regex operations, such as Prometheus, Loki, InfluxDB, and Elasticsearch.
 2. Enable regex options: In Grafana's settings, ensure regex support is enabled for your data sources.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%201.webp" alt="Regex enabled for data sources in Grafana" caption="Regex enabled for data sources in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%201.webp"
+     alt="Regex enabled for data sources in Grafana"
+     caption="Regex enabled for data sources in Grafana"
+   />
 
 ## Step-by-Step Guide to Writing Regex Queries in Grafana
 
 Regex queries in Grafana can transform how you filter, display, and analyze data. Here’s a step-by-step guide to help you write and implement regex queries effectively:
 
-1. Access the Query Editor
+1.  Access the Query Editor
+
     - Start by opening your Grafana dashboard and selecting the panel where you want to write a query.
     - Click on the panel title, and select Edit to open the query editor.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%202.webp" alt="Query Editor in Grafana Panel" caption="Query Editor in Grafana Panel" />
-    
-2. Write a Basic Regex Query for Log Filtering
-    
+
+    <Figure
+      src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%202.webp"
+      alt="Query Editor in Grafana Panel"
+      caption="Query Editor in Grafana Panel"
+    />
+
+2.  Write a Basic Regex Query for Log Filtering
+
     Start with a Basic Log Query
-    
+
     ```jsx
-    {job="varlogs"}
+    {
+      job = 'varlogs'
+    }
     ```
-    
+
     This selects all logs from the `varlogs` job.
-    
+
     Note: For log filtering, you need to configure Loki and Promtail. Read the details <a href="https://grafana.com/docs/loki/latest/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%203.webp" alt="Basic Regex Query for Log Filtering" caption="Basic Regex Query for Log Filtering" />
-    
-3. Implementing Regex in Prometheus Metric Queries
-Regex can be a powerful tool in Prometheus queries, especially when you want to filter metrics based on their names or labels. Here’s how you can do it:
-    
-    Let’s say you want to filter all metrics related to HTTP requests in your Flask application:
-    
-    ```jsx
-    {__name__=~"http_requests.*"}
-    ```
-    
-    - `name` is a built-in label that stores the metric name.
-    - `=~` is the regex match operator.
-    - `http_requests.*` matches any metric name that starts with http_requests.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%204.webp" alt="Implementing Regex in Prometheus Metric Queries" caption="Implementing Regex in Prometheus Metric Queries" />
-    
-    You can also filter metrics by their labels using regex.
-    
-    Example:
-    
-    ```jsx
-    http_requests_total{instance=~"localhost:[port_number]"}
-    ```
-    
-    This query filters `http_requests_total` metrics for instances with names like `localhost:8080`, [`localhost:8081`](http://localhost:8081), etc.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%205.webp" alt="Filter metrics by their labels using regex in Grafana" caption="Filter metrics by their labels using regex in Grafana" />
-    
+
+    <Figure
+      src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%203.webp"
+      alt="Basic Regex Query for Log Filtering"
+      caption="Basic Regex Query for Log Filtering"
+    />
+
+3.  Implementing Regex in Prometheus Metric Queries
+    Regex can be a powerful tool in Prometheus queries, especially when you want to filter metrics based on their names or labels. Here’s how you can do it:
+
+        Let’s say you want to filter all metrics related to HTTP requests in your Flask application:
+
+        ```jsx
+        {__name__=~"http_requests.*"}
+        ```
+
+        - `name` is a built-in label that stores the metric name.
+        - `=~` is the regex match operator.
+        - `http_requests.*` matches any metric name that starts with http_requests.
+
+        <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%204.webp" alt="Implementing Regex in Prometheus Metric Queries" caption="Implementing Regex in Prometheus Metric Queries" />
+
+        You can also filter metrics by their labels using regex.
+
+        Example:
+
+        ```jsx
+        http_requests_total{instance=~"localhost:[port_number]"}
+        ```
+
+        This query filters `http_requests_total` metrics for instances with names like `localhost:8080`, [`localhost:8081`](http://localhost:8081), etc.
+
+        <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%205.webp" alt="Filter metrics by their labels using regex in Grafana" caption="Filter metrics by their labels using regex in Grafana" />
 
 4.  Leverage Grafana's Variable System
 
 - Grafana’s variable system allows you to make your dashboards dynamic. For instance, you could create a variable `service` to filter data by service names:
-    
-    ```
-    {service=~"$service"}
-    ```
-    
+  ```
+  {service=~"$service"}
+  ```
 - The `$service` variable would populate dynamically based on user input or predefined options, making your dashboard adaptable to different contexts.
-    
-    How do you add variables to the Grafana Dashboard? 
-    
-    1. Navigate to the dashboard where you want to add a variable. Click the gear icon (⚙️) and select "Variables". Then click "Add variable".
-        
-        <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%206.webp" alt="Adding Variable in Grafana Dashboard" caption="Adding Variable in Grafana Dashboard" />
-        
-    2. Configure Variable:
-        1. Name: Assign a name to your variable, such as `instance`.
-        2. Type: Choose "Query".
-        3. Data Source: Select your data source.
-            
-            <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%207.webp" alt="Creating a Variable in Grafana Dashboard" caption="Creating a Variable in Grafana Dashboard" /> 
-            
-        4. Query: Define a query to fetch values, for example, to list all instances. 
-            
-            <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%208.webp" alt="Define Query for fetching values for dynamic variable" caption="Define Query for fetching values for dynamic variable" />
-            
-            Note: There are multiple ways to configure how you want to populate the value for the created variable.
-            
-            - In the image above, the Query type is `label values` , which means the value to be populated is label value.
-            - Next for what label? As defined `Label` = `instance`
-            - Now, it knows the variable needs to be populated for label values for label key = `instance`
-            - Where to look for this label?  In the metric `https_requests_created`
-        5. Options: Set refresh intervals, allow multiple values, or include an "All" option if needed.
-        6. Click the `Run Query` button, to get a preview of values based on the query you have provided.
-            
-            <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%209.webp" alt="Previewing values for dynamic variables in Grafana" caption="Previewing values for dynamic variables in Grafana" />
-            
-        
-        Click "Apply" to save your variable, and the `Save Dashboard` to apply the changes to your dashboard.
-        
-    3. Use the Variable in Queries
-        - Edit a Panel: Open the panel where you want to use the variable.
-            - Apply the Variable: In the query editor, include the variable in your Prometheus query. For example:
-            
-            ```
-            http_requests_total{instance=~"$instance"}
-            ```
-            
-            - `$instance` is the variable you created. It will dynamically reflect the selected value(s) from the dropdown.
-            
-            <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2010.webp" alt="Running Regex query using Dynamic variable in Grafana" caption="Running Regex query using Dynamic variable in Grafana" />
-            
-        - Save Changes: Click "Apply" and save the panel.
+  How do you add variables to the Grafana Dashboard?
+
+  1. Navigate to the dashboard where you want to add a variable. Click the gear icon (⚙️) and select "Variables". Then click "Add variable".
+
+     <Figure
+       src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%206.webp"
+       alt="Adding Variable in Grafana Dashboard"
+       caption="Adding Variable in Grafana Dashboard"
+     />
+
+  2. Configure Variable:
+
+     1. Name: Assign a name to your variable, such as `instance`.
+     2. Type: Choose "Query".
+     3. Data Source: Select your data source.
+
+        <Figure
+          src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%207.webp"
+          alt="Creating a Variable in Grafana Dashboard"
+          caption="Creating a Variable in Grafana Dashboard"
+        />{' '}
+
+     4. Query: Define a query to fetch values, for example, to list all instances.
+
+        <Figure
+          src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%208.webp"
+          alt="Define Query for fetching values for dynamic variable"
+          caption="Define Query for fetching values for dynamic variable"
+        />
+
+        Note: There are multiple ways to configure how you want to populate the value for the created variable.
+
+        - In the image above, the Query type is `label values` , which means the value to be populated is label value.
+        - Next for what label? As defined `Label` = `instance`
+        - Now, it knows the variable needs to be populated for label values for label key = `instance`
+        - Where to look for this label? In the metric `https_requests_created`
+
+     5. Options: Set refresh intervals, allow multiple values, or include an "All" option if needed.
+     6. Click the `Run Query` button, to get a preview of values based on the query you have provided.
+
+        <Figure
+          src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%209.webp"
+          alt="Previewing values for dynamic variables in Grafana"
+          caption="Previewing values for dynamic variables in Grafana"
+        />
+
+     Click "Apply" to save your variable, and the `Save Dashboard` to apply the changes to your dashboard.
+
+  3. Use the Variable in Queries
+     - Edit a Panel: Open the panel where you want to use the variable.
+       - Apply the Variable: In the query editor, include the variable in your Prometheus query. For example:
+       ```
+       http_requests_total{instance=~"$instance"}
+       ```
+       - `$instance` is the variable you created. It will dynamically reflect the selected value(s) from the dropdown.
+         {' '}
+         <Figure
+           src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2010.webp"
+           alt="Running Regex query using Dynamic variable in Grafana"
+           caption="Running Regex query using Dynamic variable in Grafana"
+         />
+     - Save Changes: Click "Apply" and save the panel.
 
 ### Advanced Regex Techniques for Grafana
 
@@ -199,43 +219,35 @@ To take your Grafana queries to the next level, consider these advanced regex te
 <aside>
 💡
 
-Note: 
+Note:
 Prometheus does support regex-based filtering, but advanced regex techniques such as lookaheads, lookbehinds, and non-capturing groups are not supported in Prometheus queries. These work on log filtering with LOKI as the data source.
 
 </aside>
 
 - Lookahead and Lookbehind: Use lookaheads and lookbehinds to filter based on context without including certain characters in the match.
-    - Example: Match instances of "error" followed by digits except "0":
-        
-        ```
-        error(?!0)\d
-        ```
-        
+  - Example: Match instances of "error" followed by digits except "0":
+    ```
+    error(?!0)\d
+    ```
 - Capturing Groups: Capture parts of your pattern to reuse in more complex queries.
-    - Example: Capture "app" or "service" followed by any word:
-        
-        ```
-        (app|service)\w+
-        ```
-        
+  - Example: Capture "app" or "service" followed by any word:
+    ```
+    (app|service)\w+
+    ```
 - Non-Capturing Groups: Use non-capturing groups `(?:...)` to group elements without saving them, improving performance.
-    - Example: Match either "cpu" or "mem" but don’t capture:
-        
-        ```
-        (?:cpu|mem)_usage
-        ```
-        
+  - Example: Match either "cpu" or "mem" but don’t capture:
+    ```
+    (?:cpu|mem)_usage
+    ```
 - Regex Alternation: Use `|` to match alternative patterns.
-    - Example: Match logs with either "timeout" or "error":
-        
-        ```
-        timeout|error
-        ```
-        
+  - Example: Match logs with either "timeout" or "error":
+    ```
+    timeout|error
+    ```
 
 ## Optimizing Regex Performance in Grafana Queries
 
-Efficient regex patterns are crucial for maintaining dashboard performance. 
+Efficient regex patterns are crucial for maintaining dashboard performance.
 
 <aside>
 💡
@@ -247,17 +259,17 @@ Note: Prometheus uses a simplified regex engine with limited features for better
 Consider these optimization techniques:
 
 - Keep Regex Simple: Simplify patterns to reduce the load on Prometheus. Avoid unnecessary wildcards like `.*` that match everything and can degrade performance.
-    - Example: Instead of `.*error.*`, use `error`.
+  - Example: Instead of `.*error.*`, use `error`.
 - Use Anchors for Precision: Use `^` (start) and `$` (end) to define the beginning and end of a match. This makes the query more efficient by narrowing the search scope.
-    - Example: `^node_cpu_.*_total$` matches only metrics with this exact structure.
+  - Example: `^node_cpu_.*_total$` matches only metrics with this exact structure.
 - Avoid Greedy Quantifiers: Use non-greedy quantifiers like `.*?` to minimize backtracking when matching long patterns.
-    - Example: `error.*?log` matches "error" followed by "log" with minimal backtracking.
+  - Example: `error.*?log` matches "error" followed by "log" with minimal backtracking.
 - Leverage Non-Capturing Groups: Use non-capturing groups `(?:...)` to group parts of your regex without storing the match, which can save processing time.
-    - Example: `(?:cpu|mem)_usage` instead of `(cpu|mem)_usage`.
+  - Example: `(?:cpu|mem)_usage` instead of `(cpu|mem)_usage`.
 - Pre-filter with Labels: Where possible, use PromQL label filtering before applying regex, narrowing down the dataset to reduce the regex workload.
-    - Example: `http_requests_total{job="nginx", path=~"^/api.*"}`
+  - Example: `http_requests_total{job="nginx", path=~"^/api.*"}`
 - Limit Use of Alternations: Minimize the use of `|` (alternation) as it can create multiple branches to evaluate. Instead, try combining alternatives more efficiently or use explicit patterns.
-    - Example: Replace `foo|bar|baz` with something like `ba[rz]|foo` if patterns overlap.
+  - Example: Replace `foo|bar|baz` with something like `ba[rz]|foo` if patterns overlap.
 
 ### Best Practices for Organizing Dashboards with Regex-Based Queries
 
@@ -268,67 +280,82 @@ Consider these optimization techniques:
 
 ## Integrating Regex Queries with Grafana Alerting
 
-Regex queries in Grafana can be combined with alerting to dynamically trigger alerts based on complex patterns in your metrics or logs. 
+Regex queries in Grafana can be combined with alerting to dynamically trigger alerts based on complex patterns in your metrics or logs.
 
 1. Create alert rules with regex conditions:
-    
-    ```
-    avg(rate(http_requests_total{status=~"5.."}[5m])) > 10
-    ```
-    
-    This alert triggers when the average rate of 5xx errors exceeds 10 per second over 5 minutes.
-    
+
+   ```
+   avg(rate(http_requests_total{status=~"5.."}[5m])) > 10
+   ```
+
+   This alert triggers when the average rate of 5xx errors exceeds 10 per second over 5 minutes.
+
 2. Design regex patterns for anomaly detection:
-    
-    ```
-    {job="app"} |~ "(?i)exception|error|fail" | rate[5m] > 0.1
-    ```
-    
-    This pattern alerts on an increased rate of exceptions, errors, or failures (case-insensitive).
-    
+
+   ```
+   {job="app"} |~ "(?i)exception|error|fail" | rate[5m] > 0.1
+   ```
+
+   This pattern alerts on an increased rate of exceptions, errors, or failures (case-insensitive).
+
 3. Implement regex in notification templates:
-    
-    ```
-    {{ if reReplaceAll "^CRITICAL: (.+)" .Message "$1" }}
-    High Priority: {{ .Message }}
-    {{ else }}
-    Low Priority: {{ .Message }}
-    {{ end }}
-    ```
-    
-    This template prioritizes alerts based on the presence of "CRITICAL" in the message.
-    
+
+   ```
+   {{ if reReplaceAll "^CRITICAL: (.+)" .Message "$1" }}
+   High Priority: {{ .Message }}
+   {{ else }}
+   Low Priority: {{ .Message }}
+   {{ end }}
+   ```
+
+   This template prioritizes alerts based on the presence of "CRITICAL" in the message.
 
 ### How to Setup Alerts using Regex Queries in Grafana
 
 1. In the Grafana Dashboard, go to the `Alerting` section, and click on `Manage Alert rules`. Next, click on the `+New alert rule` button.
 2. Define the alert rule name, query, and alert conditions. For example, if the rate of errors is greater than 5 in a 5-minute window:
-    
-    ```java
-    rate(http_error_total{error_type=~"^(value|type|another)_error"}[5m])
-    ```
-    
 
- 
+   ```java
+   rate(http_error_total{error_type=~"^(value|type|another)_error"}[5m])
+   ```
 
-<Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2011.webp" alt="Defining alert rule in Grafana Dashboard" caption="Defining alert rule in Grafana Dashboard" />
+<Figure
+  src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2011.webp"
+  alt="Defining alert rule in Grafana Dashboard"
+  caption="Defining alert rule in Grafana Dashboard"
+/>
 
 1. Configure how often you want Grafana to evaluate the alert condition (e.g., every 1 minute).
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2012.webp" alt="Set evaluation behaviour for alert rule in Grafana Dashboard" caption="Set evaluation behaviour for alert rule in Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2012.webp"
+     alt="Set evaluation behaviour for alert rule in Grafana Dashboard"
+     caption="Set evaluation behaviour for alert rule in Grafana Dashboard"
+   />
+
 2. Set up notification channels such as email, Slack, or PagerDuty to receive alerts.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2013.webp" alt="Configure notification channels for Grafana alerts" caption="Configure notification channels for Grafana alerts" />
-    
-    When the alert condition is not satisfied on evaluation:
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2014.webp" alt="No Alert was sent by Grafana based on the regex query evaluation" caption="No Alert was sent by Grafana based on the regex query evaluation" />
-    
-    When the alert condition is met on evaluation:
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2015.webp" alt="Alert fired by Grafana based on regex query evaluation" caption="Alert fired by Grafana based on regex query evaluation" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2013.webp"
+     alt="Configure notification channels for Grafana alerts"
+     caption="Configure notification channels for Grafana alerts"
+   />
+
+   When the alert condition is not satisfied on evaluation:
+
+   <Figure
+     src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2014.webp"
+     alt="No Alert was sent by Grafana based on the regex query evaluation"
+     caption="No Alert was sent by Grafana based on the regex query evaluation"
+   />
+
+   When the alert condition is met on evaluation:
+
+   <Figure
+     src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2015.webp"
+     alt="Alert fired by Grafana based on regex query evaluation"
+     caption="Alert fired by Grafana based on regex query evaluation"
+   />
 
 ### Limitations of Regex Queries in Grafana
 
@@ -346,9 +373,12 @@ Why to prefer SigNoz?
 - Advanced Regex Capabilities: Handles complex regex efficiently for logs and metrics.
 - Optimized Performance: Fast query processing, even with large data volumes.
 - Unified Query Interface: Consistent syntax across metrics, logs, and traces.
-    
-    <Figure src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2016.webp" alt="Running Regex Query in SigNoz" caption="Running Regex Query in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/a-regex-in-query-in-grafana-image%2016.webp"
+    alt="Running Regex Query in SigNoz"
+    caption="Running Regex Query in SigNoz"
+  />
 - Ease of Dashboard Creation: Simple setup for dynamic dashboards with regex variables.
 
 <GetStartedSigNoz />
@@ -380,7 +410,7 @@ Yes, depending on your data source, you might use:
 - PromQL for [Prometheus data](https://signoz.io/guides/how-does-grafana-get-data-from-prometheus/)
 - LogQL for Loki logs
 - SQL for relational databases
-These query languages often provide built-in functions that can replace some regex use cases, potentially offering better performance.
+  These query languages often provide built-in functions that can replace some regex use cases, potentially offering better performance.
 
 ### How does regex support differ across various data sources in Grafana?
 
@@ -389,4 +419,4 @@ Regex support varies by data source:
 - Prometheus fully supports regex in label matching. However, it's worth noting that Prometheus uses RE2 regex syntax, which has some limitations compared to full regex implementations.
 - Loki supports regex for log line filtering.
 - SQL databases may have limited regex support, depending on the specific database engine
-Always check your data source's documentation for specific regex capabilities and syntax variations.
\ No newline at end of file
+  Always check your data source's documentation for specific regex capabilities and syntax variations.
diff --git a/data/guides/ai-log-analysis.mdx b/data/guides/ai-log-analysis.mdx
index abaaa8f8c..141dc9e76 100644
--- a/data/guides/ai-log-analysis.mdx
+++ b/data/guides/ai-log-analysis.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Revolutionizing Log Analysis with AI - A Comprehensive Guide
-slug: ai-log-analysis
 date: 2025-03-04
 tags: [log analysis, artificial intelligence, machine learning, data analytics]
 authors: [adil_shaikh]
 description: Discover how AI revolutionizes log analysis, providing real-time insights, anomaly detection, and enhanced monitoring for improved system performance.
-keywords: [ai log analysis, log monitoring, machine learning logs, intelligent log analytics, ai log intelligence]
-
+keywords:
+  [
+    ai log analysis,
+    log monitoring,
+    machine learning logs,
+    intelligent log analytics,
+    ai log intelligence,
+  ]
 ---
 
 Managing log data is becoming increasingly challenging as systems grow in complexity. Traditional methods, like manually sifting through logs or relying on rigid rule-based systems, are slow, error-prone, and often miss emerging threats.
@@ -53,34 +57,29 @@ AI has transformed log analysis by enabling real-time anomaly detection, intelli
 Machine learning models analyze large-scale log data to detect anomalies and classify events efficiently. The two primary approaches—**supervised learning** and **unsupervised learning**—serve different log analysis objectives.
 
 1. **Supervised Learning**
-    
-    Supervised learning relies on labeled datasets to train models for log event classification and prediction. Below are key applications of supervised learning in log analysis:
-    
-    - **Log Classification:**
-        
-        Engineers can use **Random Forests**, **Gradient Boosting Machines (GBM)**, and **Support Vector Machines (SVM)** to automatically classify logs into categories like error, warning, or informational.
-        
-    - **Event Prediction:**
-        
-        Regression models can be used to identify patterns that may indicate potential system failures or performance degradation based on historical log data.
-        
-    
-    Supervised learning is useful when labeled log data is available, making it effective for predictive maintenance, security threat detection, and automated incident response. However, it requires significant data annotation effort, though semi-supervised approaches can help reduce this burden.
-    
+
+   Supervised learning relies on labeled datasets to train models for log event classification and prediction. Below are key applications of supervised learning in log analysis:
+
+   - **Log Classification:**
+     Engineers can use **Random Forests**, **Gradient Boosting Machines (GBM)**, and **Support Vector Machines (SVM)** to automatically classify logs into categories like error, warning, or informational.
+   - **Event Prediction:**
+     Regression models can be used to identify patterns that may indicate potential system failures or performance degradation based on historical log data.
+
+   Supervised learning is useful when labeled log data is available, making it effective for predictive maintenance, security threat detection, and automated incident response. However, it requires significant data annotation effort, though semi-supervised approaches can help reduce this burden.
+
 2. **Unsupervised Learning**
-    
-    Unsupervised learning is crucial for **anomaly detection and pattern discovery in logs** without requiring labeled datasets. It is especially valuable in identifying unknown threats, unusual system behaviors, and emerging operational issues. The following techniques are commonly used:
-    
-    - **Anomaly Detection:**
-        - **Isolation Forests:** Identify outliers by measuring how easily a log entry can be isolated from normal patterns.
-        - **One-Class SVM:** Creates a boundary that separates normal log patterns from deviations.
-        - **Autoencoders:** Reconstruct normal log sequences and highlight deviations as anomalies.
-    - **Clustering Techniques:**
-        - **K-Means Clustering:** Groups similar log events together, facilitating automatic log categorization.
-        - **DBSCAN:** Effective for identifying rare log events indicative of system issues.
-    
-    Unsupervised learning is especially valuable for detecting previously unknown patterns or anomalies where labeled datasets aren't available. It provides an adaptable approach to log analysis by learning from new data patterns, though it may require tuning to minimize false positives.
-    
+
+   Unsupervised learning is crucial for **anomaly detection and pattern discovery in logs** without requiring labeled datasets. It is especially valuable in identifying unknown threats, unusual system behaviors, and emerging operational issues. The following techniques are commonly used:
+
+   - **Anomaly Detection:**
+     - **Isolation Forests:** Identify outliers by measuring how easily a log entry can be isolated from normal patterns.
+     - **One-Class SVM:** Creates a boundary that separates normal log patterns from deviations.
+     - **Autoencoders:** Reconstruct normal log sequences and highlight deviations as anomalies.
+   - **Clustering Techniques:**
+     - **K-Means Clustering:** Groups similar log events together, facilitating automatic log categorization.
+     - **DBSCAN:** Effective for identifying rare log events indicative of system issues.
+
+   Unsupervised learning is especially valuable for detecting previously unknown patterns or anomalies where labeled datasets aren't available. It provides an adaptable approach to log analysis by learning from new data patterns, though it may require tuning to minimize false positives.
 
 ### Deep Learning for Log Analysis
 
@@ -91,19 +90,18 @@ Deep learning (DL) models, especially **neural networks**, can capture complex p
 Neural networks contribute to **log analysis** through their ability to process and learn from large volumes of log data. Below are key types of neural networks used in log processing:
 
 1. **Recurrent Neural Networks (RNNs) and Long Short-Term Memory (LSTM):**
-    
-    RNNs are designed to process sequential data by maintaining an internal state (memory) that can capture information from previous inputs. However, they can struggle with long-term dependencies due to the vanishing gradient problem.
-    
-    LSTMs, a specialized type of RNN, are particularly effective at processing sequential log data by maintaining contextual memory over time through their gating mechanisms, making them better suited for capturing long-term patterns in log sequences.
-    
+
+   RNNs are designed to process sequential data by maintaining an internal state (memory) that can capture information from previous inputs. However, they can struggle with long-term dependencies due to the vanishing gradient problem.
+
+   LSTMs, a specialized type of RNN, are particularly effective at processing sequential log data by maintaining contextual memory over time through their gating mechanisms, making them better suited for capturing long-term patterns in log sequences.
+
 2. **Convolutional Neural Networks (CNNs):**
-    
-    While less common in log analysis, CNNs can be useful for extracting patterns from structured log data. Their primary strength lies in identifying spatial patterns, making them complementary to sequence-based approaches.
-    
+
+   While less common in log analysis, CNNs can be useful for extracting patterns from structured log data. Their primary strength lies in identifying spatial patterns, making them complementary to sequence-based approaches.
+
 3. **Transformers (e.g., BERT, GPT-based Models):**
-    
-    Modern transformer architectures offer an alternative to RNNs for processing sequential log data. They can be particularly effective at handling long-range dependencies in log sequences, though their performance advantages are context-dependent and should be evaluated for specific use cases.
-    
+
+   Modern transformer architectures offer an alternative to RNNs for processing sequential log data. They can be particularly effective at handling long-range dependencies in log sequences, though their performance advantages are context-dependent and should be evaluated for specific use cases.
 
 ## Leveraging K8sGPT and GPTScript for Kubernetes Troubleshooting
 
@@ -111,54 +109,49 @@ Kubernetes troubleshooting can be complex due to its distributed nature and dyna
 
 ### K8sGPT: **AI-Driven Kubernetes Diagnostics**
 
-K8sGPT is an AI-powered tool designed to scan Kubernetes clusters, identify issues, and provide diagnoses with detailed, actionable insights. By integrating with AI backends like OpenAI, Azure OpenAI, and Amazon Bedrock, K8sGPT enhances observability, making it easier to detect anomalies, optimize performance, and automate root cause analysis. 
+K8sGPT is an AI-powered tool designed to scan Kubernetes clusters, identify issues, and provide diagnoses with detailed, actionable insights. By integrating with AI backends like OpenAI, Azure OpenAI, and Amazon Bedrock, K8sGPT enhances observability, making it easier to detect anomalies, optimize performance, and automate root cause analysis.
 
 **Step 1: Set Up a Sample K3D Cluster for K8sGPT Deployment**
 
 K3D is a lightweight wrapper around K3s, a minimal Kubernetes distribution. It allows Kubernetes clusters to run inside Docker containers, making it ideal for local development and CI/CD pipelines.
 
 - **Prerequisites**
-    - Docker (v20.10.5 or later)
-    - kubectl (for Kubernetes cluster interaction)
+  - Docker (v20.10.5 or later)
+  - kubectl (for Kubernetes cluster interaction)
 - **Install k3d**
-    
-    To install the latest release of K3D, use one of the following methods:
-    
-    - **`wget`**:
-        
-        ```jsx
-        wget -q -O - https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
-        ```
-        
-    - **`curl`**:
-        
-        ```jsx
-        curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
-        ```
-        
-- **Create a k3d Cluster**
-    
-    Run the following command to create a cluster named **`k8sgpt-cluster`**:
-    
+  To install the latest release of K3D, use one of the following methods:
+  - **`wget`**:
     ```jsx
-    k3d cluster create k8sgpt-cluster
+    wget -q -O - https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
     ```
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image.webp" alt="K3D Cluster Creation" caption="K3D Cluster Creation" />
-    
-- **Verify the Cluster**
-    
-    Ensure the cluster is running properly:
-    
+  - **`curl`**:
     ```jsx
-    kubectl cluster-info
-    kubectl get nodes
+    curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
     ```
-    
-    Ensure that all nodes are in a `Ready` state before proceeding.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%201.webp" alt="K3D nodes in ready state" caption="K3D nodes in ready state" />
-    
+- **Create a k3d Cluster**
+  Run the following command to create a cluster named **`k8sgpt-cluster`**:
+  ```jsx
+  k3d cluster create k8sgpt-cluster
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image.webp"
+    alt="K3D Cluster Creation"
+    caption="K3D Cluster Creation"
+  />
+- **Verify the Cluster**
+  Ensure the cluster is running properly:
+  ```jsx
+  kubectl cluster-info
+  kubectl get nodes
+  ```
+  Ensure that all nodes are in a `Ready` state before proceeding.
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%201.webp"
+    alt="K3D nodes in ready state"
+    caption="K3D nodes in ready state"
+  />
 
 **Step 2: Deploy K8sGPT**
 
@@ -172,10 +165,14 @@ sudo dpkg -i k8sgpt_amd64.deb
 **Verify the Installation**
 
 ```jsx
-k8sgpt -h
+k8sgpt - h
 ```
 
-<Figure src="/img/guides/2025/03/ai-log-analysis-image%202.webp" alt="k8sgpt help command" caption="k8sgpt help command" />
+<Figure
+  src="/img/guides/2025/03/ai-log-analysis-image%202.webp"
+  alt="k8sgpt help command"
+  caption="k8sgpt help command"
+/>
 
 **Step 3: Configure AI Backend**
 
@@ -183,12 +180,12 @@ Once installed, authenticate K8sGPT with an AI provider. Below is an example set
 
 ```jsx
 ❯ k8sgpt auth list
-Default: 
+Default:
 > openai
-Active: 
+Active:
 > openai
 > localai
-Unused: 
+Unused:
 > azureopenai
 > noopai
 > cohere
@@ -264,7 +261,7 @@ Verify the installation of the Llama model using the below command:
 
 ```jsx
 ❯ ollama list
-NAME               ID              SIZE      MODIFIED     
+NAME               ID              SIZE      MODIFIED
 llama3.2:latest    a80c4f17acd5    2.0 GB    32 hours ago
 ```
 
@@ -274,13 +271,17 @@ Start Ollama:
 ollama serve
 ```
 
-<Figure src="/img/guides/2025/03/ai-log-analysis-image%203.webp" alt="Ollama serve output" caption="Ollama serve output" />
+<Figure
+  src="/img/guides/2025/03/ai-log-analysis-image%203.webp"
+  alt="Ollama serve output"
+  caption="Ollama serve output"
+/>
 
 Check if Ollama is running:
 
 ```jsx
 ❯ curl http://localhost:11434/
-Ollama is running%   
+Ollama is running%
 ```
 
 By adding the `--explain` flag to the `k8sgpt analyze` command, K8sGPT connects to the AI provider and leverages the LLM to provide detailed recommendations on resolving the issue effectively.
@@ -289,7 +290,11 @@ By adding the `--explain` flag to the `k8sgpt analyze` command, K8sGPT conne
 k8sgpt analyze --explain -b localai
 ```
 
-<Figure src="/img/guides/2025/03/ai-log-analysis-image%204.webp" alt="k8sgpt analyze command" caption="k8sgpt analyze command" />
+<Figure
+  src="/img/guides/2025/03/ai-log-analysis-image%204.webp"
+  alt="k8sgpt analyze command"
+  caption="k8sgpt analyze command"
+/>
 
 For authentication details, refer to the <a href="https://docs.k8sgpt.ai/reference/providers/backend/" rel="noopener noreferrer nofollow" target="_blank">K8sGPT Authentication Documentation</a>.
 
@@ -304,74 +309,63 @@ When combined with K8sGPT, GPTScript enhances Kubernetes troubleshooting by enab
 To demonstrate the capabilities of GPTScript and K8sGPT, let’s create two common Kubernetes issues.
 
 - **Simulate a Pod with High CPU Utilization**
-    
-    The following manifest creates a Pod requesting excessive CPU, which will likely cause it to remain unscheduled due to insufficient resources.
-    
-    ```jsx
-    apiVersion: v1
-    kind: Pod
-    metadata:
-      name: nasty-pod
-      namespace: default
-    spec:
-      containers:
-      - name: nasty-pod
-        image: nginx
-        resources:
-          requests:
-            cpu: "20"     #CPU capacity >=8 i.e node's capacity resulting in pod in pending state
-    ```
-    
-    Apply the manifest file using the below command
-    
-    ```jsx
-    kubectl apply -f nasty-pod.yml
-    ```
-    
+  The following manifest creates a Pod requesting excessive CPU, which will likely cause it to remain unscheduled due to insufficient resources.
+  ```jsx
+  apiVersion: v1
+  kind: Pod
+  metadata:
+    name: nasty-pod
+    namespace: default
+  spec:
+    containers:
+    - name: nasty-pod
+      image: nginx
+      resources:
+        requests:
+          cpu: "20"     #CPU capacity >=8 i.e node's capacity resulting in pod in pending state
+  ```
+  Apply the manifest file using the below command
+  ```jsx
+  kubectl apply -f nasty-pod.yml
+  ```
 - **Deploy a Service with a mismatched Pod label**
-    
-    The Service and Pod in this manifest have mismatched labels in their selectors, which prevents the Service from targeting the Pod.
-    
-    - **Service Selector Label:** `app: dem-app` (incorrect).
-    - **Pod Label:** `app: demo-app` (correct).
-    
-    ```jsx
-    apiVersion: v1
-    kind: Service
-    metadata:
-      name: pod-svc
-      namespace: default
-    spec:
-      selector:
-        app: dem-app  # Intentionally incorrect label
+  The Service and Pod in this manifest have mismatched labels in their selectors, which prevents the Service from targeting the Pod.
+  - **Service Selector Label:** `app: dem-app` (incorrect).
+  - **Pod Label:** `app: demo-app` (correct).
+  ```jsx
+  apiVersion: v1
+  kind: Service
+  metadata:
+    name: pod-svc
+    namespace: default
+  spec:
+    selector:
+      app: dem-app  # Intentionally incorrect label
+    ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 8080  # Updated to match the Pod containerPort
+  ---
+  apiVersion: v1
+  kind: Pod
+  metadata:
+    name: demo-pod
+    namespace: default
+    labels:
+      app: demo-app  # Correct label for the Pod
+  spec:
+    containers:
+    - name: simple-server
+      image: hashicorp/http-echo:0.2.3  # Lightweight, reliable image
+      args:
+        - "-text=Hello, Kubernetes!"
       ports:
-      - protocol: TCP
-        port: 80
-        targetPort: 8080  # Updated to match the Pod containerPort
-    ---
-    apiVersion: v1
-    kind: Pod
-    metadata:
-      name: demo-pod
-      namespace: default
-      labels:
-        app: demo-app  # Correct label for the Pod
-    spec:
-      containers:
-      - name: simple-server
-        image: hashicorp/http-echo:0.2.3  # Lightweight, reliable image
-        args:
-          - "-text=Hello, Kubernetes!"
-        ports:
-        - containerPort: 8080  # Updated to expose the correct port
-    ```
-    
-    Apply the manifest file using the below command:
-    
-    ```jsx
-    kubectl apply -f pod-svc.yml
-    ```
-    
+      - containerPort: 8080  # Updated to expose the correct port
+  ```
+  Apply the manifest file using the below command:
+  ```jsx
+  kubectl apply -f pod-svc.yml
+  ```
 
 **Step 2: GPTScript: Automating Troubleshooting with K8sGPT**
 
@@ -404,48 +398,66 @@ By combining K8sGPT and GPTScript, teams can automate Kubernetes issue detection
 
 For a real-time demonstration of how GPTScript and K8sGPT work to diagnose and resolve issues in our Kubernetes cluster, refer to the video below.
 
-
 <div className="overflow-hidden rounded-xl shadow-2xl">
-    <video autoPlay muted loop className="lg:w-[120%]">
+  <video autoPlay muted loop className="lg:w-[120%]">
     <source src="/img/guides/2025/03/ailoganalysisvideo.mp4" type="video/mp4" />
     Your browser does not support the video tag.
-    </video>
+  </video>
 </div>
 
 Showcasing GPTScript with K8sGPT in the backend for efficient Kubernetes troubleshooting
 
 ## Tools and Platforms for AI-Powered Log Analysis
 
-The ecosystem of tools and platforms for AI-driven log analysis is diverse, offering various options for different needs and budgets.  These solutions range from open-source tools that can be extended with AI capabilities to fully managed commercial platforms and custom-built solutions.
+The ecosystem of tools and platforms for AI-driven log analysis is diverse, offering various options for different needs and budgets. These solutions range from open-source tools that can be extended with AI capabilities to fully managed commercial platforms and custom-built solutions.
 
 **Open-Source Tools:**
 
 - **ELK Stack (Elasticsearch, Logstash, Kibana) with AI Extensions:** The ELK stack is a popular open-source log management platform. By integrating with machine learning libraries and tools like TensorFlow or PyTorch, it can be extended to perform AI-powered anomaly detection and analysis. For example, Elasticsearch's machine learning features can be used to detect anomalies in time series data. Logstash can be used to preprocess and enrich log data before it is fed into the AI model.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%205.webp" alt="ELK Stack - Logstash Search" caption="ELK Stack - Logstash Search" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%205.webp"
+    alt="ELK Stack - Logstash Search"
+    caption="ELK Stack - Logstash Search"
+  />
 - **Prometheus with Anomaly Detection Modules:** Prometheus, a widely used monitoring system, can be combined with anomaly detection modules to identify unusual patterns in metrics data. This allows for proactive identification of performance issues and potential outages. For example, Prometheus can be used to collect metrics on CPU usage, memory usage, and request latency.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%206.webp" alt="Prometheus Dashboard for powerful PROMQL queries and insights" caption="Prometheus Dashboard for powerful PROMQL queries and insights" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%206.webp"
+    alt="Prometheus Dashboard for powerful PROMQL queries and insights"
+    caption="Prometheus Dashboard for powerful PROMQL queries and insights"
+  />
 - **Open Distro for Elasticsearch:** This is a distribution of Elasticsearch that includes security, alerting, and machine learning features. It provides a more comprehensive platform for AI-powered log analysis than the basic ELK stack.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%207.webp" alt="Adding data using Kibana interface in Open Distro for Elasticsearch" caption="Adding data using Kibana interface in Open Distro for Elasticsearch" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%207.webp"
+    alt="Adding data using Kibana interface in Open Distro for Elasticsearch"
+    caption="Adding data using Kibana interface in Open Distro for Elasticsearch"
+  />
 
 **Commercial Platforms:**
 
 - **Splunk (with ML Toolkit):** Splunk is a leading commercial platform for log management and analysis. Its Machine Learning Toolkit provides pre-built algorithms and tools for building and deploying AI models for log analysis. Splunk's platform also offers powerful search and visualization capabilities.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%208.webp" alt="Splunk Dashboard" caption="Splunk Dashboard" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%208.webp"
+    alt="Splunk Dashboard"
+    caption="Splunk Dashboard"
+  />
 - **Datadog:** Datadog is a cloud-based monitoring and analytics platform that offers AI-powered anomaly detection and forecasting. It integrates with a wide range of services and applications, providing a comprehensive view of system performance.
-    
-    <Figure src="/img/guides/2025/03/ai-log-analysis-image%209.webp" alt="Datadog Dashboard" caption="Datadog Dashboard" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/ai-log-analysis-image%209.webp"
+    alt="Datadog Dashboard"
+    caption="Datadog Dashboard"
+  />
 - **Sumo Logic:** Sumo Logic is another cloud-native log management and analytics platform that leverages AI for anomaly detection, threat intelligence, and other use cases. Sumo Logic's machine learning capabilities can be used to identify security threats, performance bottlenecks, and other critical issues.
 
-<Figure src="/img/guides/2025/03/ai-log-analysis-image%2010.webp" alt="Sumo Logic Dashboard" caption="Sumo Logic Dashboard" />
+<Figure
+  src="/img/guides/2025/03/ai-log-analysis-image%2010.webp"
+  alt="Sumo Logic Dashboard"
+  caption="Sumo Logic Dashboard"
+/>
 
 - **Other Commercial Platforms:** Numerous other commercial platforms offer AI-powered log analysis, including Humio, [Graylog](https://signoz.io/comparisons/graylog-vs-splunk/), and Logz.io. These platforms offer different features and pricing models, so it's important to evaluate them carefully to find the best fit for your needs.
 
@@ -527,23 +539,22 @@ E-commerce businesses leverage AI-driven log analysis to optimize customer exper
 AI presents transformative opportunities for log analysis, yet several challenges must be navigated to ensure effective implementation:
 
 1. **Data Quality and Preparation:**
-    - **Handling Noisy Data:** Logs are frequently unstructured and contain inconsistencies. AI models thrive on clean data, necessitating rigorous preprocessing like cleaning, parsing, and normalization to mitigate noise that could skew results.
-    - **Data Volume and Velocity:** The massive influx of log data poses a significant challenge. AI systems must efficiently ingest, process, and store this information to derive meaningful insights without performance bottlenecks.
-    - **Data Variety:** Logs come in various formats from different sources. Integrating and standardizing this diverse data for AI analysis requires careful planning and implementation.
+   - **Handling Noisy Data:** Logs are frequently unstructured and contain inconsistencies. AI models thrive on clean data, necessitating rigorous preprocessing like cleaning, parsing, and normalization to mitigate noise that could skew results.
+   - **Data Volume and Velocity:** The massive influx of log data poses a significant challenge. AI systems must efficiently ingest, process, and store this information to derive meaningful insights without performance bottlenecks.
+   - **Data Variety:** Logs come in various formats from different sources. Integrating and standardizing this diverse data for AI analysis requires careful planning and implementation.
 2. **Dynamic Data Environments:**
-    - **Adapting to Change:** System behaviors are not static; they evolve over time. AI models need continuous retraining to adapt to these changes, as shifts in data distribution can render models ineffective if not regularly updated.
-    - **Real-time Analysis:** Many applications require real-time log analysis. Building AI systems that can process and analyze data with low latency is a significant technical hurdle. The need for speed can introduce complexities in model design and deployment.
+   - **Adapting to Change:** System behaviors are not static; they evolve over time. AI models need continuous retraining to adapt to these changes, as shifts in data distribution can render models ineffective if not regularly updated.
+   - **Real-time Analysis:** Many applications require real-time log analysis. Building AI systems that can process and analyze data with low latency is a significant technical hurdle. The need for speed can introduce complexities in model design and deployment.
 3. **Balancing Sensitivity and Specificity:**
-    - **Sensitivity** refers to a model's ability to detect anomalies accurately, while **specificity** refers to its ability to correctly classify normal behavior. A highly sensitive model may detect all anomalies but also generate **false alarms (false positives)**. On the other hand, a highly specific model may ignore harmless variations but risk **missing real threats (false negatives).**
+   - **Sensitivity** refers to a model's ability to detect anomalies accurately, while **specificity** refers to its ability to correctly classify normal behavior. A highly sensitive model may detect all anomalies but also generate **false alarms (false positives)**. On the other hand, a highly specific model may ignore harmless variations but risk **missing real threats (false negatives).**
 4. **Interpreting AI Outputs:**
-    - **Explainability:** Many AI models operate as "black boxes," making it difficult for IT teams, security analysts, and DevOps engineers to understand why certain anomalies are flagged. Implementing Explainable AI (XAI) techniques helps these operators build trust in the system and make informed decisions.
+   - **Explainability:** Many AI models operate as "black boxes," making it difficult for IT teams, security analysts, and DevOps engineers to understand why certain anomalies are flagged. Implementing Explainable AI (XAI) techniques helps these operators build trust in the system and make informed decisions.
 5. **Costs and Infrastructure:**
-    - **Investment in Tools:** Implementing AI-powered log analysis requires investment in specialized tools and platforms. These tools can be expensive, especially for large organizations.
-    - **Training and Expertise:** Building and maintaining AI systems requires specialized expertise. Training personnel or hiring data scientists can add to the overall cost.
+   - **Investment in Tools:** Implementing AI-powered log analysis requires investment in specialized tools and platforms. These tools can be expensive, especially for large organizations.
+   - **Training and Expertise:** Building and maintaining AI systems requires specialized expertise. Training personnel or hiring data scientists can add to the overall cost.
 6. **Ethical Considerations:**
-    - **Privacy Concerns:** Log data often includes sensitive user information.
-    - **Bias in AI:** AI models can reflect biases present in training data, leading to inequitable outcomes.
-
+   - **Privacy Concerns:** Log data often includes sensitive user information.
+   - **Bias in AI:** AI models can reflect biases present in training data, leading to inequitable outcomes.
 
 ## Does Everyone Need AI Log Analysis?
 
@@ -555,13 +566,12 @@ In large-scale, microservices-heavy environments, AI-driven log analysis becomes
 
 So while not everyone needs AI log analysis today, as systems scale and downtime costs increase, more organizations will find it valuable. Building a foundation with [centralized logging](https://signoz.io/blog/centralized-logging/) and good instrumentation is wise future-proofing. You might not need AI capabilities immediately, but when log volumes surge or complex incidents arise, you'll appreciate having that capability available.
 
-
 ## Key Takeaways
 
 - Log analysis has evolved from the time-consuming processes of traditional log analysis to leveraging AI/ML.
 - Supervised learning classifies logs and predicts events using labeled data. Unsupervised learning detects anomalies and patterns in unlabeled data.
 - Platforms like Signoz offer AI-powered log analysis capabilities, enabling efficient anomaly detection, root cause analysis, and performance monitoring.
-- SigNoz provides advanced log aggregation, real-time analytics, and AI-driven anomaly detection, making it a comprehensive solution for modern log management.
+  - SigNoz provides advanced log aggregation, real-time analytics, and AI-driven anomaly detection, making it a comprehensive solution for modern log management.
 - K8sGPT and GPTScript simplify Kubernetes troubleshooting through AI-driven automation.
 - As AI continues to evolve, its integration into log management systems will unlock greater efficiencies and capabilities, making it an indispensable tool for organizations
 
@@ -597,4 +607,4 @@ They simplify diagnostics, reduce manual effort, and improve cluster reliability
 
 ### How do I use GPTScript with K8sGPT?
 
-You write scripts with `.gpt` extension that call K8sGPT to analyze the cluster and then define actions to take based on the analysis.
\ No newline at end of file
+You write scripts with `.gpt` extension that call K8sGPT to analyze the cluster and then define actions to take based on the analysis.
diff --git a/data/guides/ai-observability.mdx b/data/guides/ai-observability.mdx
index 1785bc187..2f94aa40b 100644
--- a/data/guides/ai-observability.mdx
+++ b/data/guides/ai-observability.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: AI Observability - Enhancing ML Model Performance and Insights
-slug: ai-observability
 date: 2024-08-14
 tags: [observability]
 authors: [sushant_gaurav]
 description: Explore AI observability's role in enhancing ML model performance. Learn key components, best practices, and implementation strategies for robust AI systems.
-keywords: [AI observability, machine learning, model performance, data quality, system health, responsible AI]
-
+keywords:
+  [
+    AI observability,
+    machine learning,
+    model performance,
+    data quality,
+    system health,
+    responsible AI,
+  ]
 ---
 
 AI observability is increasingly becoming an important component of the machine learning lifecycle. Comprehensive monitoring and insights become a must-do task as AI systems become more advanced and widespread. Today we will go through the importance of AI observability, including its major components and practical implementation methodologies. You will learn how AI observability improves ML model performance and delivers vital insights for building effective, dependable AI systems.
@@ -63,389 +68,394 @@ The Evolution from ML Monitoring to AI Observability
 AI observability consists of several important components that work together to provide a comprehensive view of your AI systems:
 
 1. Model performance metrics:
-    - Accuracy: Overall correctness of predictions.
-    - Precision: Proportion of true positive predictions.
-    - Recall: Proportion of actual positives correctly identified.
-    - F1 score: Harmonic mean of precision and recall.
-    
-    To run this example on your system, you need to have Python installed on your system. Also, if you don’t have Scikit-learn on your system, you can install it using the command: `pip install scikit-learn` .
-    
-    ```python
-    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
-    
-    # Example predictions and ground truth labels
-    y_true = [0, 1, 0, 1, 1]
-    y_pred = [0, 1, 0, 0, 1]
-    
-    # Calculating performance metrics
-    accuracy = accuracy_score(y_true, y_pred)
-    precision = precision_score(y_true, y_pred)
-    recall = recall_score(y_true, y_pred)
-    f1 = f1_score(y_true, y_pred)
-    
-    print(f"Accuracy: {accuracy}")
-    print(f"Precision: {precision}")
-    print(f"Recall: {recall}")
-    print(f"F1 Score: {f1}")
-    ```
-    
-    Sample Output:
-    
-    ```
-    Accuracy: 0.8
-    Precision: 1.0
-    Recall: 0.6666666666666666
-    F1 Score: 0.8
-    ```
-    
+
+   - Accuracy: Overall correctness of predictions.
+   - Precision: Proportion of true positive predictions.
+   - Recall: Proportion of actual positives correctly identified.
+   - F1 score: Harmonic mean of precision and recall.
+
+   To run this example on your system, you need to have Python installed on your system. Also, if you don’t have Scikit-learn on your system, you can install it using the command: `pip install scikit-learn` .
+
+   ```python
+   from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+   # Example predictions and ground truth labels
+   y_true = [0, 1, 0, 1, 1]
+   y_pred = [0, 1, 0, 0, 1]
+
+   # Calculating performance metrics
+   accuracy = accuracy_score(y_true, y_pred)
+   precision = precision_score(y_true, y_pred)
+   recall = recall_score(y_true, y_pred)
+   f1 = f1_score(y_true, y_pred)
+
+   print(f"Accuracy: {accuracy}")
+   print(f"Precision: {precision}")
+   print(f"Recall: {recall}")
+   print(f"F1 Score: {f1}")
+   ```
+
+   Sample Output:
+
+   ```
+   Accuracy: 0.8
+   Precision: 1.0
+   Recall: 0.6666666666666666
+   F1 Score: 0.8
+   ```
+
 2. Data quality indicators:
-    - Drift detection: Identifying changes in input data distributions.
-    - Outlier identification: Spotting unusual or anomalous data points.
-    - Data integrity: Ensuring consistency and completeness of data.
-    
-    ```python
-    import numpy as np
-    from sklearn.ensemble import IsolationForest
-    
-    # Example dataset
-    X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [100, 200]])
-    
-    # Identifying outliers using Isolation Forest
-    iso_forest = IsolationForest(contamination=0.2)
-    outliers = iso_forest.fit_predict(X)
-    
-    print(f"Outliers: {outliers}")
-    ```
-    
-    Sample Output:
-    
-    ```
-    Outliers: [ 1  1  1  1 -1]
-    ```
-    
-    - Note
-        
-        The `IsolationForest` library is an algorithm used to detect unusual data points (anomalies) by isolating them in a tree structure. It's efficient for spotting outliers in large datasets.
-        
+
+   - Drift detection: Identifying changes in input data distributions.
+   - Outlier identification: Spotting unusual or anomalous data points.
+   - Data integrity: Ensuring consistency and completeness of data.
+
+   ```python
+   import numpy as np
+   from sklearn.ensemble import IsolationForest
+
+   # Example dataset
+   X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [100, 200]])
+
+   # Identifying outliers using Isolation Forest
+   iso_forest = IsolationForest(contamination=0.2)
+   outliers = iso_forest.fit_predict(X)
+
+   print(f"Outliers: {outliers}")
+   ```
+
+   Sample Output:
+
+   ```
+   Outliers: [ 1  1  1  1 -1]
+   ```
+
+   - Note
+     The `IsolationForest` library is an algorithm used to detect unusual data points (anomalies) by isolating them in a tree structure. It's efficient for spotting outliers in large datasets.
+
 3. System health monitoring:
-    - Resource utilization: Monitoring CPU, memory, and storage usage.
-    - Latency: Measuring response time for model predictions.
-    - Throughput: Counting the number of predictions processed per unit time.
+   - Resource utilization: Monitoring CPU, memory, and storage usage.
+   - Latency: Measuring response time for model predictions.
+   - Throughput: Counting the number of predictions processed per unit time.
 4. Explainability and interpretability tools:
-    - SHAP (SHapley Additive exPlanations) values: Provide insights into individual predictions. SHAP values are a game-theoretic approach to explain the output of any machine learning model. It breaks down a prediction into the contribution of each feature to that prediction.
-    - LIME (Local Interpretable Model-agnostic Explanations): Explains predictions by perturbing inputs and observing changes. LIME is an algorithm that explains the predictions of any machine learning classifier by approximating it locally with an interpretable model. It's model-agnostic, meaning it can be used to interpret predictions from any black-box model.
-    - Feature importance rankings: Highlight the most influential features in the model's decision-making process.
-    
-    <Figure src="/img/guides/2024/08/ai-observability-image.webp" alt="image.webp" caption="image.webp" />
-    
+
+   - SHAP (SHapley Additive exPlanations) values: Provide insights into individual predictions. SHAP values are a game-theoretic approach to explain the output of any machine learning model. It breaks down a prediction into the contribution of each feature to that prediction.
+   - LIME (Local Interpretable Model-agnostic Explanations): Explains predictions by perturbing inputs and observing changes. LIME is an algorithm that explains the predictions of any machine learning classifier by approximating it locally with an interpretable model. It's model-agnostic, meaning it can be used to interpret predictions from any black-box model.
+   - Feature importance rankings: Highlight the most influential features in the model's decision-making process.
+
+   <Figure
+     src="/img/guides/2024/08/ai-observability-image.webp"
+     alt="image.webp"
+     caption="image.webp"
+   />
 
 ## Implementing AI Observability: Best Practices
 
 To implement AI observability effectively, you should follow some of the best practices:
 
 1. Establish baseline metrics:
-    - Set key performance indicators (KPIs) for your models, including accuracy, precision, recall, and F1 score.
-    - Set acceptable thresholds for each metric to define what is considered acceptable model performance.
-    - Document baseline performance during model training and validation to use as a reference point for future comparisons.
-        
-        ```python
-        # Example of establishing baseline metrics
-        baseline_metrics = {
-            "accuracy": 0.85,
-            "precision": 0.80,
-            "recall": 0.75,
-            "f1_score": 0.77
-        }
-        
-        print("Baseline Metrics:", baseline_metrics)
-        ```
-        
-        Sample Output:
-        
-        ```python
-        Baseline Metrics: {'accuracy': 0.85, 'precision': 0.8, 'recall': 0.75, 'f1_score': 0.77}
-        ```
-        
+   - Set key performance indicators (KPIs) for your models, including accuracy, precision, recall, and F1 score.
+   - Set acceptable thresholds for each metric to define what is considered acceptable model performance.
+   - Document baseline performance during model training and validation to use as a reference point for future comparisons.
+     ```python
+     # Example of establishing baseline metrics
+     baseline_metrics = {
+         "accuracy": 0.85,
+         "precision": 0.80,
+         "recall": 0.75,
+         "f1_score": 0.77
+     }
+
+     print("Baseline Metrics:", baseline_metrics)
+     ```
+     Sample Output:
+     ```python
+     Baseline Metrics: {'accuracy': 0.85, 'precision': 0.8, 'recall': 0.75, 'f1_score': 0.77}
+     ```
 2. Set up continuous monitoring and alerting:
-    - Implement real-time monitoring for important metrics to guarantee that performance issues are detected immediately. To implement real-time monitoring for important metrics, you can use tools like Prometheus for collecting and querying metrics, combined with Grafana for visualizing them in real-time dashboards.
-    - Set up notifications for threshold violations so you may respond quickly when measurements go outside of permissible limits.
-    - Use anomaly detection techniques to spot strange trends that could suggest a problem.
-    
-    ```python
-    import numpy as np
-    
-    # Example of setting up a simple anomaly detection using z-score
-    def detect_anomalies(data, threshold=3):
-        mean = np.mean(data)
-        std_dev = np.std(data)
-        anomalies = [(i, x) for i, x in enumerate(data) if abs((x - mean) / std_dev) > threshold]
-        return anomalies
-    
-    # Sample data with clear anomalies
-    performance_data = [0.85, 0.86, 0.82, 0.88, 0.79, 0.90, 0.77, 1.50, 0.76, 0.83, 1.48]
-    
-    anomalies = detect_anomalies(performance_data)
-    print("Detected Anomalies:", anomalies)
-    ```
-    
-    Sample Output
-    
-    ```python
-    Detected Anomalies: [(7, 1.5), (10, 1.48)]
-    ```
-    
-    - Note:
-        
-        A z-score is a statistical measure that indicates how many standard deviations a data point is from the mean of a dataset.
-        
+
+   - Implement real-time monitoring for important metrics to guarantee that performance issues are detected immediately. To implement real-time monitoring for important metrics, you can use tools like Prometheus for collecting and querying metrics, combined with Grafana for visualizing them in real-time dashboards.
+   - Set up notifications for threshold violations so you may respond quickly when measurements go outside of permissible limits.
+   - Use anomaly detection techniques to spot strange trends that could suggest a problem.
+
+   ```python
+   import numpy as np
+
+   # Example of setting up a simple anomaly detection using z-score
+   def detect_anomalies(data, threshold=3):
+       mean = np.mean(data)
+       std_dev = np.std(data)
+       anomalies = [(i, x) for i, x in enumerate(data) if abs((x - mean) / std_dev) > threshold]
+       return anomalies
+
+   # Sample data with clear anomalies
+   performance_data = [0.85, 0.86, 0.82, 0.88, 0.79, 0.90, 0.77, 1.50, 0.76, 0.83, 1.48]
+
+   anomalies = detect_anomalies(performance_data)
+   print("Detected Anomalies:", anomalies)
+   ```
+
+   Sample Output
+
+   ```python
+   Detected Anomalies: [(7, 1.5), (10, 1.48)]
+   ```
+
+   - Note:
+     A z-score is a statistical measure that indicates how many standard deviations a data point is from the mean of a dataset.
+
 3. Integrate observability tools into ML pipelines:
-    - Monitor each stage of the ML process, from data ingestion to model deployment. You can use pipeline orchestration tools like Apache Airflow or Kubeflow to automate and monitor each stage. Integrating logging and monitoring tools such as Prometheus or ELK Stack can be used to track data quality during ingestion, monitor model training performance, and ensure successful deployment.
-    - Automate data collection and metric calculation to decrease manual intervention and improve consistency. Implementing automated scripts using Python or Bash that run at scheduled intervals to collect data from your data sources. Use tools like Pandas for data manipulation and libraries like Scikit-learn or TensorFlow to automatically calculate performance metrics such as accuracy, precision, and recall after each model run. You can also use Apache Kafka for real-time data streaming and processing.
-    - Integrate seamlessly with existing DevOps methods, such as CI/CD pipelines, to enable continuous monitoring and deployment.
+   - Monitor each stage of the ML process, from data ingestion to model deployment. You can use pipeline orchestration tools like Apache Airflow or Kubeflow to automate and monitor each stage. Integrating logging and monitoring tools such as Prometheus or ELK Stack can be used to track data quality during ingestion, monitor model training performance, and ensure successful deployment.
+   - Automate data collection and metric calculation to decrease manual intervention and improve consistency. Implementing automated scripts using Python or Bash that run at scheduled intervals to collect data from your data sources. Use tools like Pandas for data manipulation and libraries like Scikit-learn or TensorFlow to automatically calculate performance metrics such as accuracy, precision, and recall after each model run. You can also use Apache Kafka for real-time data streaming and processing.
+   - Integrate seamlessly with existing DevOps methods, such as CI/CD pipelines, to enable continuous monitoring and deployment.
 4. Develop techniques to address model drift:
-    - Implement regular retraining plans to keep models up to date with current data patterns.
-    - Run A/B tests to validate model improvements and compare their performance to the current production model. A/B testing is a method of comparing two versions of a system, process, or model to determine which performs better. It involves comparing the current production model (A) with a new or improved version of the model (B).
-    - Create explicit protocols for model versioning and rollback to ensure that you may revert to a previous version if a new model fails to function.
-    
-    ```python
-    # Example of a simple versioning system
-    models = {
-        "version_1.0": {"accuracy": 0.85, "precision": 0.80},
-        "version_1.1": {"accuracy": 0.88, "precision": 0.82}
-    }
-    
-    # Function to rollback to a previous model version
-    def rollback_model(current_version, rollback_version):
-        if rollback_version in models:
-            return models[rollback_version]
-        else:
-            return f"Version {rollback_version} not found."
-    
-    # Rollback to version 1.0
-    current_model = rollback_model("version_1.1", "version_1.0")
-    print("Current Model after Rollback:", current_model)
-    ```
-    
-    Output:
-    
-    ```bash
-    Current Model after Rollback: {'accuracy': 0.85, 'precision': 0.8}
-    ```
-    
+
+   - Implement regular retraining plans to keep models up to date with current data patterns.
+   - Run A/B tests to validate model improvements and compare their performance to the current production model. A/B testing is a method of comparing two versions of a system, process, or model to determine which performs better. It involves comparing the current production model (A) with a new or improved version of the model (B).
+   - Create explicit protocols for model versioning and rollback to ensure that you may revert to a previous version if a new model fails to function.
+
+   ```python
+   # Example of a simple versioning system
+   models = {
+       "version_1.0": {"accuracy": 0.85, "precision": 0.80},
+       "version_1.1": {"accuracy": 0.88, "precision": 0.82}
+   }
+
+   # Function to rollback to a previous model version
+   def rollback_model(current_version, rollback_version):
+       if rollback_version in models:
+           return models[rollback_version]
+       else:
+           return f"Version {rollback_version} not found."
+
+   # Rollback to version 1.0
+   current_model = rollback_model("version_1.1", "version_1.0")
+   print("Current Model after Rollback:", current_model)
+   ```
+
+   Output:
+
+   ```bash
+   Current Model after Rollback: {'accuracy': 0.85, 'precision': 0.8}
+   ```
 
 ## Challenges in AI Observability Implementation
 
 Implementing AI observability comes with its share of challenges:
 
 1. High-dimensional data and complex architectures:
-    - Challenge: AI models often deal with high-dimensional data and complex architectures, making it difficult to track and understand the model’s behaviour across all features. Monitoring and interpreting such data can be overwhelming, leading to a loss of key insights.
-    - Solution: Use dimensionality reduction techniques, such as PCA (Principal Component Analysis) or t-SNE (t-Distributed Stochastic Neighbor Embedding), to focus on key features.
-    
-    ```python
-    from sklearn.decomposition import PCA
-    from sklearn.datasets import load_iris
-    
-    # Example dataset
-    iris = load_iris()
-    X = iris.data
-    
-    # Applying PCA for dimensionality reduction
-    pca = PCA(n_components=2)
-    X_reduced = pca.fit_transform(X)
-    
-    print("Reduced Data Shape:", X_reduced.shape)
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Reduced Data Shape: (150, 2)
-    ```
-    
+
+   - Challenge: AI models often deal with high-dimensional data and complex architectures, making it difficult to track and understand the model’s behaviour across all features. Monitoring and interpreting such data can be overwhelming, leading to a loss of key insights.
+   - Solution: Use dimensionality reduction techniques, such as PCA (Principal Component Analysis) or t-SNE (t-Distributed Stochastic Neighbor Embedding), to focus on key features.
+
+   ```python
+   from sklearn.decomposition import PCA
+   from sklearn.datasets import load_iris
+
+   # Example dataset
+   iris = load_iris()
+   X = iris.data
+
+   # Applying PCA for dimensionality reduction
+   pca = PCA(n_components=2)
+   X_reduced = pca.fit_transform(X)
+
+   print("Reduced Data Shape:", X_reduced.shape)
+   ```
+
+   Sample Output:
+
+   ```bash
+   Reduced Data Shape: (150, 2)
+   ```
+
 2. Balancing observability with data privacy:
-    - Challenge: Observability requires detailed logging and monitoring, which can potentially expose sensitive information. Ensuring that observability doesn’t compromise data privacy is a significant challenge, especially with regulations like GDPR and CCPA.
-    - Solution: Implement data anonymization techniques, such as masking personally identifiable information (PII), and use encryption to protect sensitive data.
+   - Challenge: Observability requires detailed logging and monitoring, which can potentially expose sensitive information. Ensuring that observability doesn’t compromise data privacy is a significant challenge, especially with regulations like GDPR and CCPA.
+   - Solution: Implement data anonymization techniques, such as masking personally identifiable information (PII), and use encryption to protect sensitive data.
 3. Scaling observability for large-scale AI systems:
-    - Challenge: Large-scale AI systems, especially those deployed across distributed environments, require observability solutions that can scale accordingly. Managing and monitoring these systems can become complex and resource-intensive.
-    - Solution: Leverage distributed monitoring solutions and edge computing to handle the scale and ensure that observability is maintained across large, distributed systems.
+   - Challenge: Large-scale AI systems, especially those deployed across distributed environments, require observability solutions that can scale accordingly. Managing and monitoring these systems can become complex and resource-intensive.
+   - Solution: Leverage distributed monitoring solutions and edge computing to handle the scale and ensure that observability is maintained across large, distributed systems.
 4. Addressing the skills gap:
-    - Challenge: AI observability requires specialized knowledge, and there’s often a skills gap within teams when it comes to implementing and maintaining these systems. This can hinder the effectiveness of observability initiatives.
-    - Solution: Invest in training programs to upskill your team in AI observability tools and practices. Consider partnering with experts in the field to bridge the knowledge gap.
+   - Challenge: AI observability requires specialized knowledge, and there’s often a skills gap within teams when it comes to implementing and maintaining these systems. This can hinder the effectiveness of observability initiatives.
+   - Solution: Invest in training programs to upskill your team in AI observability tools and practices. Consider partnering with experts in the field to bridge the knowledge gap.
 
 ## Leveraging AI Observability for Business Value
 
 AI observability delivers significant business value by:
 
 1. Improving model reliability:
-    - Reduce downtime and minimize negative effects on the user experience.
-    - Example: A fintech company used AI observability to cut fraud detection errors by 30%, resulting in fewer false positives and a better client experience.
-    
-    ```python
-    # Example: Monitoring model reliability
-    # Uptime percentage
-    model_uptime = 99.9 
-    # This could be dynamically calculated based on actual monitoring data
-    # Errors per month
-    fraud_detection_errors = [5, 3, 2, 4]
-    
-    # Calculating error reduction
-    initial_errors = fraud_detection_errors[0]
-    final_errors = fraud_detection_errors[-1]
-    error_reduction = ((initial_errors - final_errors) / initial_errors) * 100
-    
-    print("Model Uptime:", model_uptime, "%")
-    print("Error Reduction in Fraud Detection:", error_reduction, "%")
-    
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Model Uptime: 99.9 %
-    Error Reduction in Fraud Detection: 80.0 %
-    ```
-    
+
+   - Reduce downtime and minimize negative effects on the user experience.
+   - Example: A fintech company used AI observability to cut fraud detection errors by 30%, resulting in fewer false positives and a better client experience.
+
+   ```python
+   # Example: Monitoring model reliability
+   # Uptime percentage
+   model_uptime = 99.9
+   # This could be dynamically calculated based on actual monitoring data
+   # Errors per month
+   fraud_detection_errors = [5, 3, 2, 4]
+
+   # Calculating error reduction
+   initial_errors = fraud_detection_errors[0]
+   final_errors = fraud_detection_errors[-1]
+   error_reduction = ((initial_errors - final_errors) / initial_errors) * 100
+
+   print("Model Uptime:", model_uptime, "%")
+   print("Error Reduction in Fraud Detection:", error_reduction, "%")
+
+   ```
+
+   Sample Output:
+
+   ```bash
+   Model Uptime: 99.9 %
+   Error Reduction in Fraud Detection: 80.0 %
+   ```
+
 2. Enhancing decision-making:
-    - Offer practical insights for model optimization and company strategy.
-    - Example: An e-commerce platform raised conversion rates by 15% after fine-tuning recommendation algorithms using observability data.
-    
-    ```python
-    # Example: Enhancing decision-making with observability data
-    # Initial conversion rate
-    initial_conversion_rate = 0.10
-    # Improved conversion rate
-    improved_conversion_rate = 0.115
-    
-    # Calculating conversion increase
-    conversion_increase = ((improved_conversion_rate - initial_conversion_rate) / initial_conversion_rate) * 100
-    
-    print("Conversion Rate Increase:", conversion_increase, "%")
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Conversion Rate Increase: 15.0 %
-    ```
-    
+
+   - Offer practical insights for model optimization and company strategy.
+   - Example: An e-commerce platform raised conversion rates by 15% after fine-tuning recommendation algorithms using observability data.
+
+   ```python
+   # Example: Enhancing decision-making with observability data
+   # Initial conversion rate
+   initial_conversion_rate = 0.10
+   # Improved conversion rate
+   improved_conversion_rate = 0.115
+
+   # Calculating conversion increase
+   conversion_increase = ((improved_conversion_rate - initial_conversion_rate) / initial_conversion_rate) * 100
+
+   print("Conversion Rate Increase:", conversion_increase, "%")
+   ```
+
+   Sample Output:
+
+   ```bash
+   Conversion Rate Increase: 15.0 %
+   ```
+
 3. Streamlining compliance and governance:
-    - Facilitate audits and demonstrate responsible AI activities.
-    - Example: A healthcare provider readily passed regulatory inspections by relying on detailed AI observability reports.
-    
-    ```python
-    # Example: Streamlining compliance with observability reports
-    compliance_metrics = {
-        "audit_pass_rate": 100,
-        "regulatory_violations": 0
-    }
-    
-    print("Compliance Metrics:", compliance_metrics)
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Compliance Metrics: {'audit_pass_rate': 100, 'regulatory_violations': 0}
-    ```
-    
+
+   - Facilitate audits and demonstrate responsible AI activities.
+   - Example: A healthcare provider readily passed regulatory inspections by relying on detailed AI observability reports.
+
+   ```python
+   # Example: Streamlining compliance with observability reports
+   compliance_metrics = {
+       "audit_pass_rate": 100,
+       "regulatory_violations": 0
+   }
+
+   print("Compliance Metrics:", compliance_metrics)
+   ```
+
+   Sample Output:
+
+   ```bash
+   Compliance Metrics: {'audit_pass_rate': 100, 'regulatory_violations': 0}
+   ```
 
 ## The Role of AI Observability in Responsible AI
 
 AI observability is key in supporting responsible AI practices.
 
 1. To ensure fairness and bias detection:
-    - Check model results for demographic parity and equitable opportunity.
-    - Use bias detection techniques to uncover potential concerns.
-    
-    ```python
-    # Example: Bias detection
-    from sklearn.metrics import confusion_matrix
-    
-    # True labels representing the actual outcomes (e.g., 0 = negative, 1 = positive)
-    y_true = [0, 1, 0, 1, 0, 1, 0, 1]
-    
-    # Predicted labels generated by the model (e.g., 0 = predicted negative, 1 = predicted positive)
-    y_pred = [0, 1, 0, 1, 0, 0, 0, 1]
-    
-    # Calculate the confusion matrix to assess model performance
-    cm = confusion_matrix(y_true, y_pred)
-    print("Confusion Matrix:\n", cm)
-    
-    # Example: Demographic parity
-    # These values could be calculated from actual data; they represent the rate at which two demographic groups (A and B)
-    # receive positive outcomes from the model.
-    
-    # Suppose we have data on two demographic groups:
-    # Group A has a 50% positive outcome rate
-    # Group B has a 30% positive outcome rate
-    group_a_positive_rate = 0.50  # Positive rate for group A
-    group_b_positive_rate = 0.30  # Positive rate for group B
-    
-    # Calculate demographic parity difference to measure fairness
-    demographic_parity = abs(group_a_positive_rate - group_b_positive_rate)
-    print("Demographic Parity Difference:", demographic_parity)
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Confusion Matrix:
-     [[4 0]
-     [1 3]]
-    Demographic Parity Difference: 0.2
-    ```
-    
+
+   - Check model results for demographic parity and equitable opportunity.
+   - Use bias detection techniques to uncover potential concerns.
+
+   ```python
+   # Example: Bias detection
+   from sklearn.metrics import confusion_matrix
+
+   # True labels representing the actual outcomes (e.g., 0 = negative, 1 = positive)
+   y_true = [0, 1, 0, 1, 0, 1, 0, 1]
+
+   # Predicted labels generated by the model (e.g., 0 = predicted negative, 1 = predicted positive)
+   y_pred = [0, 1, 0, 1, 0, 0, 0, 1]
+
+   # Calculate the confusion matrix to assess model performance
+   cm = confusion_matrix(y_true, y_pred)
+   print("Confusion Matrix:\n", cm)
+
+   # Example: Demographic parity
+   # These values could be calculated from actual data; they represent the rate at which two demographic groups (A and B)
+   # receive positive outcomes from the model.
+
+   # Suppose we have data on two demographic groups:
+   # Group A has a 50% positive outcome rate
+   # Group B has a 30% positive outcome rate
+   group_a_positive_rate = 0.50  # Positive rate for group A
+   group_b_positive_rate = 0.30  # Positive rate for group B
+
+   # Calculate demographic parity difference to measure fairness
+   demographic_parity = abs(group_a_positive_rate - group_b_positive_rate)
+   print("Demographic Parity Difference:", demographic_parity)
+   ```
+
+   Sample Output:
+
+   ```bash
+   Confusion Matrix:
+    [[4 0]
+    [1 3]]
+   Demographic Parity Difference: 0.2
+   ```
+
 2. Promoting transparency and explainability:
-    - Importance: Transparency and explainability are crucial for building trust in AI models, especially in high-stakes applications like healthcare, finance, or legal decisions. Stakeholders need to understand how and why a model makes certain decisions to ensure fairness and accountability.
-    - Use interpretability tools: Utilize tools like LIME (Local Interpretable Model-agnostic Explanations) or SHAP (SHapley Additive exPlanations) to break down the model’s decisions into understandable components. These tools help in explaining the contribution of each feature to a particular prediction.
-    - Example: LIME can be used to explain why a model predicted that a loan should be denied, by showing which features (like income, and credit score) had the most impact on the decision.
-    - Create user-friendly dashboards: Develop dashboards using tools like Tableau or Dash that visualize model behaviour in a clear and accessible way. For instance, a dashboard could show how changes in input features affect predictions, helping non-technical stakeholders grasp the model’s logic.
+   - Importance: Transparency and explainability are crucial for building trust in AI models, especially in high-stakes applications like healthcare, finance, or legal decisions. Stakeholders need to understand how and why a model makes certain decisions to ensure fairness and accountability.
+   - Use interpretability tools: Utilize tools like LIME (Local Interpretable Model-agnostic Explanations) or SHAP (SHapley Additive exPlanations) to break down the model’s decisions into understandable components. These tools help in explaining the contribution of each feature to a particular prediction.
+   - Example: LIME can be used to explain why a model predicted that a loan should be denied, by showing which features (like income, and credit score) had the most impact on the decision.
+   - Create user-friendly dashboards: Develop dashboards using tools like Tableau or Dash that visualize model behaviour in a clear and accessible way. For instance, a dashboard could show how changes in input features affect predictions, helping non-technical stakeholders grasp the model’s logic.
 3. Supporting ethical AI practices:
-    - Conduct compliance checks to ensure that ethical rules are followed.
-    - Develop mechanisms for resolving and minimizing ethical concerns.
-    
-    ```python
-    # Example: Ethical compliance check in an AI model
-    
-    # Simulated results from an AI model audit
-    audit_results = {
-        "data_privacy_compliance": False,  # Data privacy issues detected
-        "bias_in_predictions": True,  # Model is unbiased
-        "explainability_score": 0.7,  # Scale: 0 to 1, higher is better
-        "transparency_in_decision_process": True  # Model decision process is transparent
-    }
-    
-    def perform_ethics_check(audit):
-        issues = []
-        
-        # Check each guideline
-        if not audit["data_privacy_compliance"]:
-            issues.append("Data privacy non-compliance detected.")
-        if audit["bias_in_predictions"] is False:
-            issues.append("Bias in model predictions detected.")
-        if audit["explainability_score"] < 0.8:
-            issues.append("Model explainability is below acceptable levels.")
-        if not audit["transparency_in_decision_process"]:
-            issues.append("Model decision process lacks transparency.")
-        
-        if issues:
-            return "Ethical issues found:\n" + "\n".join(issues)
-        else:
-            return "All ethical guidelines are met."
-    
-    # Run the ethics check
-    ethics_check_result = perform_ethics_check(audit_results)
-    print(ethics_check_result)
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Ethical issues found:
-    Data privacy non-compliance detected.
-    Model explainability is below acceptable levels.
-    ```
-    
+
+   - Conduct compliance checks to ensure that ethical rules are followed.
+   - Develop mechanisms for resolving and minimizing ethical concerns.
+
+   ```python
+   # Example: Ethical compliance check in an AI model
+
+   # Simulated results from an AI model audit
+   audit_results = {
+       "data_privacy_compliance": False,  # Data privacy issues detected
+       "bias_in_predictions": True,  # Model is unbiased
+       "explainability_score": 0.7,  # Scale: 0 to 1, higher is better
+       "transparency_in_decision_process": True  # Model decision process is transparent
+   }
+
+   def perform_ethics_check(audit):
+       issues = []
+
+       # Check each guideline
+       if not audit["data_privacy_compliance"]:
+           issues.append("Data privacy non-compliance detected.")
+       if audit["bias_in_predictions"] is False:
+           issues.append("Bias in model predictions detected.")
+       if audit["explainability_score"] < 0.8:
+           issues.append("Model explainability is below acceptable levels.")
+       if not audit["transparency_in_decision_process"]:
+           issues.append("Model decision process lacks transparency.")
+
+       if issues:
+           return "Ethical issues found:\n" + "\n".join(issues)
+       else:
+           return "All ethical guidelines are met."
+
+   # Run the ethics check
+   ethics_check_result = perform_ethics_check(audit_results)
+   print(ethics_check_result)
+   ```
+
+   Sample Output:
+
+   ```bash
+   Ethical issues found:
+   Data privacy non-compliance detected.
+   Model explainability is below acceptable levels.
+   ```
 
 ## Implementing AI Observability with SigNoz
 
@@ -459,9 +469,9 @@ SigNoz is an open-source observability platform that provides full tracking and
 ### Steps to Implement SigNoz for AI Observability
 
 1. SetUp
-    
-    <GetStartedSigNoz />
-    
+
+   <GetStartedSigNoz />
+
 2. Instrumentation: Integrate [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) into your AI apps to gather and export metrics and traces. This stage guarantees that data from your AI models and infrastructure is appropriately gathered and monitored.
 3. Dashboard Configuration: Create custom dashboards in SigNoz to display the metrics that are most important to your AI observability plan. This aids in tracking real-time performance and making data-driven decisions.
 4. Alert Setup: To receive notifications about potential difficulties, define alerts for important thresholds and enable anomaly detection. This [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) contributes to the stability and performance of your AI models.
@@ -473,29 +483,29 @@ Interested in doing LLM monitoring with SigNoz? Refer SigNoz’s [official doc o
 The topic of AI observability is quickly evolving. Here are some emerging themes to monitor:
 
 1. Integrating Federated Learning and Observability:
-    - Monitor model performance across dispersed data sources while respecting privacy.
-    - Enable extensive observability without jeopardizing data privacy.
+   - Monitor model performance across dispersed data sources while respecting privacy.
+   - Enable extensive observability without jeopardizing data privacy.
 2. Improvements in Automated Observability:
-    - AI-powered anomaly detection and root cause analysis for faster issue resolution.
-    - Creating self-healing systems that automatically resolve common issues, reducing downtime.
+   - AI-powered anomaly detection and root cause analysis for faster issue resolution.
+   - Creating self-healing systems that automatically resolve common issues, reducing downtime.
 3. AI Observability for Edge Computing and IoT:
-    - Lightweight observability solutions for devices with limited resources.
-    - Real-time monitoring of AI models installed at the edge, assuring peak performance even in remote areas.
+   - Lightweight observability solutions for devices with limited resources.
+   - Real-time monitoring of AI models installed at the edge, assuring peak performance even in remote areas.
 4. Evolution of AI Observability Tools:
-    - Prioritized explainable AI and causal inference to improve model transparency and trust.
-    - Integrating observability with MLOps and AIOps platforms to streamline operations and increase productivity.
+   - Prioritized explainable AI and causal inference to improve model transparency and trust.
+   - Integrating observability with MLOps and AIOps platforms to streamline operations and increase productivity.
 5. Enhanced User Interfaces and Experience:
-    - Improved interfaces for improved engagement with observability tools.
-    - Customizable dashboards and reporting based on individual company requirements.
+   - Improved interfaces for improved engagement with observability tools.
+   - Customizable dashboards and reporting based on individual company requirements.
 6. Collaborative and Cross-Functional Observability:
-    - Tools to improve collaboration among data scientists, ML developers, and operations teams.
-    - Share insights and KPIs that help technical and business parties communicate more effectively.
+   - Tools to improve collaboration among data scientists, ML developers, and operations teams.
+   - Share insights and KPIs that help technical and business parties communicate more effectively.
 7. Advanced Visualization Techniques:
-    - Utilizing interactive graphs and augmented reality (AR) for improved data interpretation.
-    - Improved data storytelling to effectively communicate insights to non-technical stakeholders.
+   - Utilizing interactive graphs and augmented reality (AR) for improved data interpretation.
+   - Improved data storytelling to effectively communicate insights to non-technical stakeholders.
 8. Focus on Ethical AI and Governance:
-    - Observability tools with ethical considerations and governance frameworks.
-    - Improved capability for bias identification, fairness monitoring, and compliance reporting.
+   - Observability tools with ethical considerations and governance frameworks.
+   - Improved capability for bias identification, fairness monitoring, and compliance reporting.
 
 ## Key Takeaways
 
@@ -526,4 +536,4 @@ Yes, AI observability can assist detect and prevent model bias by tracking fairn
 
 ### What are the main KPIs for AI observability?
 
-Important measures include model performance (accuracy, precision, recall), data quality indicators (drift, outliers), system health (latency, throughput), and fairness measurements (demographic parity, equal opportunity)
\ No newline at end of file
+Important measures include model performance (accuracy, precision, recall), data quality indicators (drift, outliers), system health (latency, throughput), and fairness measurements (demographic parity, equal opportunity)
diff --git a/data/guides/alerts-as-code.mdx b/data/guides/alerts-as-code.mdx
index 20da0c226..8463c64e5 100644
--- a/data/guides/alerts-as-code.mdx
+++ b/data/guides/alerts-as-code.mdx
@@ -1,16 +1,13 @@
 ---
-
 title: Implementing Alerts as Code - Best Practices for DevOps
-slug: alerts-as-code
 date: 2024-12-19
-tags: [alerts,devops,signoz,monitoring]
+tags: [alerts, devops, signoz, monitoring]
 authors: [simran_kumari]
 description: Learn how to implement Alerts as Code in DevOps. Discover best practices, tools, and benefits for efficient incident management and improved reliability.
 keywords: [alerts as code, DevOps, incident management, monitoring, observability, automation, SRE]
-
 ---
 
-Modern DevOps practices thrive on automation, consistency, and reliability. One key aspect of achieving this is "Alerts as Code" (AaC), a practice that treats alert definitions as version-controlled, reusable configurations. Alerts as Code (AaC) is transforming how DevOps teams manage and respond to incidents. By implementing AaC, you can significantly reduce manual errors, improve collaboration, and enhance your incident response capabilities. 
+Modern DevOps practices thrive on automation, consistency, and reliability. One key aspect of achieving this is "Alerts as Code" (AaC), a practice that treats alert definitions as version-controlled, reusable configurations. Alerts as Code (AaC) is transforming how DevOps teams manage and respond to incidents. By implementing AaC, you can significantly reduce manual errors, improve collaboration, and enhance your incident response capabilities.
 
 This guide walks you through understanding, implementing, and excelling at Alerts as Code, equipping your team to improve monitoring processes and incident response.
 
@@ -24,41 +21,44 @@ Alerts as Code is a methodology that applies software development principles to
 2. Thresholds: Specify the acceptable limits for metrics, ensuring alerts are triggered only when necessary.
 3. Notification Channels: Determine how alerts are delivered, such as via email, Slack, PagerDuty, or custom integrations.
 
-<Figure src="/img/guides/2024/12/alerts-as-code-08701358-8f4a-4c21-a407-fba0319c6a13.webp" alt="Alert Configuration Management Process" caption="Alert Configuration Management Process" />
+<Figure
+  src="/img/guides/2024/12/alerts-as-code-08701358-8f4a-4c21-a407-fba0319c6a13.webp"
+  alt="Alert Configuration Management Process"
+  caption="Alert Configuration Management Process"
+/>
 
 AaC is closely related to Infrastructure as Code (IaC) and Monitoring as Code (MaC). While IaC focuses on provisioning and managing infrastructure, and MaC deals with defining monitoring configurations, AaC specifically addresses the alerting aspect of your [observability stack](https://signoz.io/guides/observability-stack/).
 
 ### Key Benefits of Alerts as Code
 
 1. Consistency: Ensure uniform alert configurations across environments.
-    - Example: Imagine deploying a new service in production, but QA missed critical alert thresholds. With AaC, you ensure uniform alert configurations across dev, staging, and production, avoiding such gaps.
+   - Example: Imagine deploying a new service in production, but QA missed critical alert thresholds. With AaC, you ensure uniform alert configurations across dev, staging, and production, avoiding such gaps.
 2. Version control: Track changes and roll back when needed
-    - Example: A team accidentally lowers an alert threshold, flooding your ops team with false positives. With AaC, you can track changes in Git and quickly roll back to the previous, stable configuration.
+   - Example: A team accidentally lowers an alert threshold, flooding your ops team with false positives. With AaC, you can track changes in Git and quickly roll back to the previous, stable configuration.
 3. Automation: Integrate alert management into CI/CD pipelines
-    - Example: A new microservice is added to your architecture. By integrating AaC into your CI/CD pipeline, you can automatically deploy alerts for the service alongside its code, ensuring instant monitoring.
+   - Example: A new microservice is added to your architecture. By integrating AaC into your CI/CD pipeline, you can automatically deploy alerts for the service alongside its code, ensuring instant monitoring.
 4. Collaboration: Improve teamwork between development and operations
-    - Example: A developer adds a feature that could cause memory spikes. By managing alerts as code, they can work directly with ops to define memory usage alerts in the same repository, improving communication.
+   - Example: A developer adds a feature that could cause memory spikes. By managing alerts as code, they can work directly with ops to define memory usage alerts in the same repository, improving communication.
 
 ## Why Adopt Alerts as Code?
 
 Alerts as Code isn’t just a trend—it’s a game-changer for modern DevOps workflows. Here’s why adopting it can elevate your alerting process:
 
 1. Improved Collaboration Between Development and Operations Teams
-    
-    When developers and operations teams work with the same version-controlled alert configurations, they can collaborate seamlessly. For example, a developer pushing a new feature can define alert thresholds directly in the same repo, ensuring shared responsibility for monitoring.
-    
+
+   When developers and operations teams work with the same version-controlled alert configurations, they can collaborate seamlessly. For example, a developer pushing a new feature can define alert thresholds directly in the same repo, ensuring shared responsibility for monitoring.
+
 2. Reduced Manual Errors and Configuration Drift
-    
-    Manual changes in alert settings across environments often lead to inconsistencies and missed alerts. With Alerts as Code, these configurations are automated and version-controlled, eliminating the risk of misaligned settings during deployments.
-    
+
+   Manual changes in alert settings across environments often lead to inconsistencies and missed alerts. With Alerts as Code, these configurations are automated and version-controlled, eliminating the risk of misaligned settings during deployments.
+
 3. Enhanced Scalability and Reusability Across Projects
-    
-    Managing alerts for a single service is easy, but scaling that to dozens of microservices is not. That’s where reusable alert templates shine. Alerts as Code allows you to define modular, reusable configurations that can be applied consistently across projects.
-    
+
+   Managing alerts for a single service is easy, but scaling that to dozens of microservices is not. That’s where reusable alert templates shine. Alerts as Code allows you to define modular, reusable configurations that can be applied consistently across projects.
+
 4. Faster Incident Response and Reduced Mean Time to Resolve (MTTR)
-    
-    Codified alerts come with detailed context, such as runbooks and incident response playbooks, right in the alert definition. This ensures your team can act swiftly and precisely, cutting down MTTR during incidents.
-    
+
+   Codified alerts come with detailed context, such as runbooks and incident response playbooks, right in the alert definition. This ensures your team can act swiftly and precisely, cutting down MTTR during incidents.
 
 ## Essential Tools for Implementing Alerts as Code
 
@@ -70,7 +70,11 @@ To successfully implement Alerts as Code, you'll need a combination of tools tha
 4. CI/CD pipelines: Jenkins, GitLab CI, or GitHub Actions can automate the deployment of alert configurations.
 5. Configuration management tools: Puppet, Chef, or Ansible can help manage alert configurations across different environments.
 
-<Figure src="/img/guides/2024/12/alerts-as-code-image.webp" alt="Essential Tools for Implementing Alerts as Code" caption="Essential Tools for Implementing Alerts as Code" />
+<Figure
+  src="/img/guides/2024/12/alerts-as-code-image.webp"
+  alt="Essential Tools for Implementing Alerts as Code"
+  caption="Essential Tools for Implementing Alerts as Code"
+/>
 
 ## Best Practices for Alerts as Code Implementation
 
@@ -83,9 +87,9 @@ Establish a consistent naming scheme for your alert configurations. This makes i
 ```yaml
 alerts:
   - name: high_cpu_usage
-    description: "CPU usage exceeds 90% for 5 minutes"
+    description: 'CPU usage exceeds 90% for 5 minutes'
     severity: warning
-    query: "avg(cpu_usage_percent) > 90"
+    query: 'avg(cpu_usage_percent) > 90'
     for: 5m
 ```
 
@@ -97,10 +101,10 @@ Create reusable alert patterns to maintain consistency and reduce duplication. F
 
 ```yaml
 resource_alert_template:
-  - name: "${resource}_high_usage"
-    description: "${resource} usage exceeds ${threshold}% for ${duration}"
+  - name: '${resource}_high_usage'
+    description: '${resource} usage exceeds ${threshold}% for ${duration}'
     severity: ${severity}
-    query: "avg(${resource}_usage_percent) > ${threshold}"
+    query: 'avg(${resource}_usage_percent) > ${threshold}'
     for: ${duration}
 ```
 
@@ -124,18 +128,18 @@ When defining alerts, consider the following practices:
 
 1. Base thresholds on SLOs: Align your alert thresholds with your service level objectives to ensure meaningful alerting.
 2. Implement multi-stage alerting: Use different severity levels for escalating issues. For example:
-    
-    ```yaml
-    alerts:
-      - name: api_error_rate
-        warning:
-          threshold: 1%
-          duration: 5m
-        critical:
-          threshold: 5%
-          duration: 1m
-    ```
-    
+
+   ```yaml
+   alerts:
+     - name: api_error_rate
+       warning:
+         threshold: 1%
+         duration: 5m
+       critical:
+         threshold: 5%
+         duration: 1m
+   ```
+
 3. Use dynamic thresholds: Implement adaptive thresholding to account for normal fluctuations in system behavior.
 4. Include context and runbooks: Provide detailed information and troubleshooting steps in your alert definitions to speed up resolution.
 
@@ -187,27 +191,31 @@ The diagram highlights how metrics and traces flow between components:
 3. OpenTelemetry Collector: Sends traces to SigNoz Cloud for visualization and analytics.
 4. Prometheus Alertmanager: Sends alerts triggered by conditions defined in your alerting rules.
 
-<Figure src="/img/guides/2024/12/alerts-as-code-image%201.webp" alt="Architecture for Implementing Alerts as Code with SigNoz" caption="Architecture for Implementing Alerts as Code with SigNoz" />
+<Figure
+  src="/img/guides/2024/12/alerts-as-code-image%201.webp"
+  alt="Architecture for Implementing Alerts as Code with SigNoz"
+  caption="Architecture for Implementing Alerts as Code with SigNoz"
+/>
 
 Achieving Alerts as Code
 
 The concept of Alerts as Code means defining and managing alerting configurations in code files (like YAML), allowing for better control, consistency, and automation. Here's how this setup enables Alerts as Code:
 
 1. Declarative Configuration:
-    - Alerting rules (`alerts.yml`), Prometheus settings (`prometheus.yml`), and [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) configurations are written in declarative YAML files.
-    - These files describe the desired state of the system, making them easy to read, modify, and share.
+   - Alerting rules (`alerts.yml`), Prometheus settings (`prometheus.yml`), and [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) configurations are written in declarative YAML files.
+   - These files describe the desired state of the system, making them easy to read, modify, and share.
 2. Version Control:
-    - Store all configuration files in a Git repository.
-    - This ensures every change to your alerting setup is tracked, auditable, and reversible. For example, you can roll back to a previous configuration if a new alerting rule causes unexpected issues.
+   - Store all configuration files in a Git repository.
+   - This ensures every change to your alerting setup is tracked, auditable, and reversible. For example, you can roll back to a previous configuration if a new alerting rule causes unexpected issues.
 3. Reusability Across Environments:
-    - The same configuration files can be reused across environments (e.g., development, staging, production) with minor modifications (like endpoint URLs).
-    - This ensures that all environments follow the same alerting standards.
+   - The same configuration files can be reused across environments (e.g., development, staging, production) with minor modifications (like endpoint URLs).
+   - This ensures that all environments follow the same alerting standards.
 4. Automation in CI/CD Pipelines:
-    - Integrate the configuration files into your CI/CD pipelines.
-    - For instance, whenever changes are merged into the repository, the updated configurations can be deployed automatically to Prometheus, OpenTelemetry Collector, and Alertmanager.
+   - Integrate the configuration files into your CI/CD pipelines.
+   - For instance, whenever changes are merged into the repository, the updated configurations can be deployed automatically to Prometheus, OpenTelemetry Collector, and Alertmanager.
 5. Scalability and Consistency:
-    - Managing alerts as code ensures consistent alert definitions across all systems.
-    - As your infrastructure scales, you can easily update or extend your alerting rules by modifying the configuration files.
+   - Managing alerts as code ensures consistent alert definitions across all systems.
+   - As your infrastructure scales, you can easily update or extend your alerting rules by modifying the configuration files.
 
 Prerequisite
 
@@ -221,44 +229,43 @@ Step 1: Flask App with Prometheus Metrics
 First, a Flask app needs to be set up to expose metrics for Prometheus to scrape:
 
 1. Install Flask and the Prometheus client:
-    
-    ```bash
-    pip install Flask prometheus_client
-    ```
-    
+
+   ```bash
+   pip install Flask prometheus_client
+   ```
+
 2. Create a file named `flask_app.py` with the following content:
-    
-    ```python
-    from flask import Flask
-    from flask import request
-    from prometheus_client import Counter, generate_latest, REGISTRY
-    from prometheus_client.exposition import basic_auth_handler
-    
-    app = Flask(__name__)
-    
-    # Define a counter metric
-    http_requests_total = Counter('http_requests_total', 'Total HTTP Requests', ['method', 'endpoint'])
-    
-    # Increment the counter on each request
-    @app.before_request
-    def before_request():
-        http_requests_total.labels(method=request.method, endpoint=request.path).inc()
-    
-    # Expose metrics at /metrics endpoint
-    @app.route('/metrics')
-    def metrics():
-        return generate_latest(REGISTRY)
-    
-    if __name__ == "__main__":
-        app.run(debug=True)
-    ```
-    
+
+   ```python
+   from flask import Flask
+   from flask import request
+   from prometheus_client import Counter, generate_latest, REGISTRY
+   from prometheus_client.exposition import basic_auth_handler
+
+   app = Flask(__name__)
+
+   # Define a counter metric
+   http_requests_total = Counter('http_requests_total', 'Total HTTP Requests', ['method', 'endpoint'])
+
+   # Increment the counter on each request
+   @app.before_request
+   def before_request():
+       http_requests_total.labels(method=request.method, endpoint=request.path).inc()
+
+   # Expose metrics at /metrics endpoint
+   @app.route('/metrics')
+   def metrics():
+       return generate_latest(REGISTRY)
+
+   if __name__ == "__main__":
+       app.run(debug=True)
+   ```
+
 3. Run the Flask app:
-    
-    ```bash
-    python flask_app.py
-    ```
-    
+
+   ```bash
+   python flask_app.py
+   ```
 
 The Flask app will now be running on `http://localhost:5000/` and exposing metrics at `http://localhost:5000/metrics`.
 
@@ -269,105 +276,109 @@ Step 2: Set Up Prometheus to Scrape Metrics
 Next, Prometheus needs to be configured to scrape metrics from the Flask app:
 
 1. Create a `prometheus.yml` configuration file to scrape metrics from the Flask app:
-    
-    ```yaml
-    global:
-      scrape_interval: 10s
-    
-    scrape_configs:
-      - job_name: 'flask-app'
-        static_configs:
-          - targets: ['localhost:5000']  # Flask app metrics endpoint
-    ```
-    
+
+   ```yaml
+   global:
+     scrape_interval: 10s
+
+   scrape_configs:
+     - job_name: 'flask-app'
+       static_configs:
+         - targets: ['localhost:5000'] # Flask app metrics endpoint
+   ```
+
 2. Start Prometheus with the configuration:
-    
-    ```bash
-    prometheus --config.file=prometheus.yml
-    ```
-    
-    Prometheus will now scrape the Flask app’s metrics every 10 seconds.
-    
-    <Figure src="/img/guides/2024/12/alerts-as-code-image%202.webp" alt="Prometheus Scraping" caption="Prometheus Scraping" />
-    
+
+   ```bash
+   prometheus --config.file=prometheus.yml
+   ```
+
+   Prometheus will now scrape the Flask app’s metrics every 10 seconds.
+
+   <Figure
+     src="/img/guides/2024/12/alerts-as-code-image%202.webp"
+     alt="Prometheus Scraping"
+     caption="Prometheus Scraping"
+   />
 
 Step 3: Configuring Alert as Code with [Prometheus Alert Manager](https://signoz.io/guides/how-do-i-add-alerts-to-prometheus/)
 
-Next, update the Prometheus config file to include alert configuration. 
-
-1. Create an alert file named `alerts.yml` with alert condition and threshold. 
-    
-    ```sql
-    groups:
-      - name: flask-app-alerts
-        rules:
-          - alert: HighHTTPRequestCount
-            expr: http_requests_total{method="GET", endpoint="/"} > 250
-            for: 5m  # Trigger alert if condition holds for 5 minutes
-            labels:
-              severity: critical
-            annotations:
-              description: "High HTTP request count detected for endpoint /"
-    ```
-    
+Next, update the Prometheus config file to include alert configuration.
+
+1. Create an alert file named `alerts.yml` with alert condition and threshold.
+
+   ```sql
+   groups:
+     - name: flask-app-alerts
+       rules:
+         - alert: HighHTTPRequestCount
+           expr: http_requests_total{method="GET", endpoint="/"} > 250
+           for: 5m  # Trigger alert if condition holds for 5 minutes
+           labels:
+             severity: critical
+           annotations:
+             description: "High HTTP request count detected for endpoint /"
+   ```
+
 2. In the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file add the reference to the alert rule:
-    
-    ```sql
-    rule_files:
-      - "alerts.yml"
-    ```
-    
-3. Restart the Prometheus server, and check the alerts section to see it the alert is listed. 
-    
-    <Figure src="/img/guides/2024/12/alerts-as-code-image%203.webp" alt="Prometheus Alerts" caption="Prometheus Alerts" /> 
-    
+
+   ```sql
+   rule_files:
+     - "alerts.yml"
+   ```
+
+3. Restart the Prometheus server, and check the alerts section to see it the alert is listed.
+
+   <Figure
+     src="/img/guides/2024/12/alerts-as-code-image%203.webp"
+     alt="Prometheus Alerts"
+     caption="Prometheus Alerts"
+   />{' '}
 
 Step 3: Configure OpenTelemetry Collector
 
 The OpenTelemetry Collector will be used to process the Prometheus metrics and forward them to SigNoz.
 
 1. Create an `otel-collector-config.yaml` configuration file for the OpenTelemetry Collector:
-    
-    ```yaml
-    
-    receivers:
-      prometheus:
-        config:
-          scrape_configs:
-            - job_name: 'flask-app'
-              static_configs:
-                - targets: ['localhost:5000']
-    
-    processors:
-      batch:
-        send_batch_size: 1000
-        timeout: 10s
-      resourcedetection:
-        detectors: [env, system]
-        timeout: 2s
-    
-    exporters:
-      otlp:
-        endpoint: "ingest.in.signoz.cloud:443"  # SigNoz endpoint
-        tls:
-          insecure: false
-        headers:
-          "signoz-ingestion-key": "<your_signoz_ingestion_key>"
-    
-    service:
-      pipelines:
-        metrics:
-          receivers: [prometheus]
-          processors: [batch, resourcedetection]
-          exporters: [otlp]
-    ```
-    
+
+   ```yaml
+   receivers:
+     prometheus:
+       config:
+         scrape_configs:
+           - job_name: 'flask-app'
+             static_configs:
+               - targets: ['localhost:5000']
+
+   processors:
+     batch:
+       send_batch_size: 1000
+       timeout: 10s
+     resourcedetection:
+       detectors: [env, system]
+       timeout: 2s
+
+   exporters:
+     otlp:
+       endpoint: 'ingest.in.signoz.cloud:443' # SigNoz endpoint
+       tls:
+         insecure: false
+       headers:
+         'signoz-ingestion-key': '<your_signoz_ingestion_key>'
+
+   service:
+     pipelines:
+       metrics:
+         receivers: [prometheus]
+         processors: [batch, resourcedetection]
+         exporters: [otlp]
+   ```
+
 2. Run the OpenTelemetry Collector:
-    
-    ```bash
-    ./otelcol-contrib --config otel-collector-config.yaml
-    ```
-    
+
+   ```bash
+   ./otelcol-contrib --config otel-collector-config.yaml
+   ```
 
 Now, the OpenTelemetry Collector will scrape Prometheus metrics, process them, and send them to SigNoz.
 
@@ -377,13 +388,21 @@ Step 4: Visualize Metrics in SigNoz
 2. Navigate to the Metrics dashboard to view the Flask app metrics (from OpenTelemetry Collector).
 3. Create custom dashboards to visualize metrics like request counts, latency, and more.
 
-Say you receive an alert that the HTTP request count exceeded the set threshold. 
+Say you receive an alert that the HTTP request count exceeded the set threshold.
 
-<Figure src="/img/guides/2024/12/alerts-as-code-image%204.webp" alt="Alerts Triggered in Prometheus" caption="Alerts Triggered in Prometheus" />
+<Figure
+  src="/img/guides/2024/12/alerts-as-code-image%204.webp"
+  alt="Alerts Triggered in Prometheus"
+  caption="Alerts Triggered in Prometheus"
+/>
 
-You can visualize the metric in the dashboard and see if there was a sudden spike, or there has been a constant increase. 
+You can visualize the metric in the dashboard and see if there was a sudden spike, or there has been a constant increase.
 
-<Figure src="/img/guides/2024/12/alerts-as-code-image%205.webp" alt="Visualizing Metrics in SigNoz" caption="Visualizing Metrics in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/alerts-as-code-image%205.webp"
+  alt="Visualizing Metrics in SigNoz"
+  caption="Visualizing Metrics in SigNoz"
+/>
 
 ### Best Practices for Integrating SigNoz Alerts into Your IaC Workflow
 
@@ -437,4 +456,4 @@ When implementing Alerts as Code, consider:
 3. Audit trails: Maintain logs of changes to alert configurations
 4. Testing: Implement security testing for your alert configurations to prevent potential vulnerabilities
 
-By addressing these considerations, you can ensure that your Alerts as Code implementation enhances rather than compromises your overall security posture.
\ No newline at end of file
+By addressing these considerations, you can ensure that your Alerts as Code implementation enhances rather than compromises your overall security posture.
diff --git a/data/guides/apache-log.mdx b/data/guides/apache-log.mdx
index 97b0bde10..3c32bffe6 100644
--- a/data/guides/apache-log.mdx
+++ b/data/guides/apache-log.mdx
@@ -1,160 +1,176 @@
 ---
-
 title: Complete Guide to Apache Logs - Access, Analyze, and Manage
-slug: apache-log
 date: 2024-07-16
 tags: [logging]
 authors: [simran_kumari]
 description: Master Apache logs with our comprehensive guide. Learn to access, analyze, and manage Apache log files, understand logging levels, and implement advanced log management techniques.
-keywords: [Apache logs, clear Apache logs, analyze Apache logs, manage Apache logs, Apache logging levels, Apache log files, access Apache logs, Apache log analysis, Apache log management, Apache error logs]
-
+keywords:
+  [
+    Apache logs,
+    clear Apache logs,
+    analyze Apache logs,
+    manage Apache logs,
+    Apache logging levels,
+    Apache log files,
+    access Apache logs,
+    Apache log analysis,
+    Apache log management,
+    Apache error logs,
+  ]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Complete Guide to Apache Logs - Access, Analyze, and Manage",
-  "alternativeHeadline": "Master Apache logs with our comprehensive guide. Learn to access, analyze, and manage Apache log files, understand logging levels, and implement advanced log management techniques.",
-  "author": {
-    "@type": "Person",
-    "name": "Simran Kumari"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-16T00:00:00Z",
-  "dateModified": "2024-07-16T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/apache-log/"
-  },
-  "description": "Master Apache logs with our comprehensive guide. Learn to access, analyze, and manage Apache log files, understand logging levels, and implement advanced log management techniques.",
-  "keywords": "Apache logs, clear Apache logs, analyze Apache logs, manage Apache logs, Apache logging levels, Apache log files, access Apache logs, Apache log analysis, Apache log management, Apache error logs",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Apache Logs",
-      "description": "Logs generated by the Apache HTTP Server that record various events, requests, and errors occurring on the server."
-    },
-    {
-      "@type": "Thing",
-      "name": "Log Management",
-      "description": "Techniques and practices for efficiently handling log files generated by applications and systems."
-    },
-    {
-      "@type": "Thing",
-      "name": "Log Analysis",
-      "description": "The process of reviewing and interpreting log files to monitor system performance and identify issues."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Apache",
-      "applicationCategory": "Web Server"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What are Apache logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Apache logs are text files generated by the Apache HTTP Server that record various events, requests, and errors occurring on the server. They provide valuable insights into server performance and user activity."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How to check access logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "You can check access logs by using command-line tools such as 'cat', 'tail', or 'less' on the log file, typically located at '/var/log/apache2/access.log' or '/var/log/httpd/access_log'. For example, use 'tail -f /var/log/apache2/access.log' to view logs in real-time."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the two types of log files Apache keeps?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Apache primarily keeps two types of log files: access logs, which record all requests received by the server, and error logs, which capture issues and errors encountered during processing requests."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the Apache logging levels?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Apache logging levels indicate the severity of events logged. They range from high-severity levels like 'emerg' and 'alert' to lower-severity levels like 'info' and 'debug'."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Where are Apache logs kept?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Apache logs are usually stored in the '/var/log/apache2/' directory on Debian-based systems or '/var/log/httpd/' on Red Hat-based systems. The specific log file names typically include 'access.log' and 'error.log'."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Access and Manage Apache Logs",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Access Apache Logs",
-        "text": "Apache logs are typically located in the /var/log/apache2/ or /var/log/httpd/ directory. You can view them using command-line tools such as 'cat', 'tail', or 'less'."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Analyze Apache Logs",
-        "text": "Use log analysis tools or scripts to review and interpret Apache log entries. This helps in monitoring server performance, identifying issues, and understanding user behavior."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Manage Apache Logs",
-        "text": "Implement log rotation and compression using tools like 'logrotate' to manage log file sizes and ensure efficient log management."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Apache Logging",
-        "text": "Modify the httpd.conf or apache2.conf file to customize log file paths and formats. Use the ErrorLog and CustomLog directives to specify log file locations and log formats."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Integrate with SigNoz",
-        "text": "Set up SigNoz and configure Apache to send logs to SigNoz for centralized monitoring and advanced log analysis capabilities."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to Apache Logs - Access, Analyze, and Manage',
+        alternativeHeadline:
+          'Master Apache logs with our comprehensive guide. Learn to access, analyze, and manage Apache log files, understand logging levels, and implement advanced log management techniques.',
+        author: {
+          '@type': 'Person',
+          name: 'Simran Kumari',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-16T00:00:00Z',
+        dateModified: '2024-07-16T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/apache-log/',
+        },
+        description:
+          'Master Apache logs with our comprehensive guide. Learn to access, analyze, and manage Apache log files, understand logging levels, and implement advanced log management techniques.',
+        keywords:
+          'Apache logs, clear Apache logs, analyze Apache logs, manage Apache logs, Apache logging levels, Apache log files, access Apache logs, Apache log analysis, Apache log management, Apache error logs',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Apache Logs',
+            description:
+              'Logs generated by the Apache HTTP Server that record various events, requests, and errors occurring on the server.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log Management',
+            description:
+              'Techniques and practices for efficiently handling log files generated by applications and systems.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log Analysis',
+            description:
+              'The process of reviewing and interpreting log files to monitor system performance and identify issues.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Apache',
+            applicationCategory: 'Web Server',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are Apache logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Apache logs are text files generated by the Apache HTTP Server that record various events, requests, and errors occurring on the server. They provide valuable insights into server performance and user activity.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How to check access logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "You can check access logs by using command-line tools such as 'cat', 'tail', or 'less' on the log file, typically located at '/var/log/apache2/access.log' or '/var/log/httpd/access_log'. For example, use 'tail -f /var/log/apache2/access.log' to view logs in real-time.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the two types of log files Apache keeps?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Apache primarily keeps two types of log files: access logs, which record all requests received by the server, and error logs, which capture issues and errors encountered during processing requests.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the Apache logging levels?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Apache logging levels indicate the severity of events logged. They range from high-severity levels like 'emerg' and 'alert' to lower-severity levels like 'info' and 'debug'.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where are Apache logs kept?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Apache logs are usually stored in the '/var/log/apache2/' directory on Debian-based systems or '/var/log/httpd/' on Red Hat-based systems. The specific log file names typically include 'access.log' and 'error.log'.",
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Access and Manage Apache Logs',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Access Apache Logs',
+              text: "Apache logs are typically located in the /var/log/apache2/ or /var/log/httpd/ directory. You can view them using command-line tools such as 'cat', 'tail', or 'less'.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Analyze Apache Logs',
+              text: 'Use log analysis tools or scripts to review and interpret Apache log entries. This helps in monitoring server performance, identifying issues, and understanding user behavior.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Manage Apache Logs',
+              text: "Implement log rotation and compression using tools like 'logrotate' to manage log file sizes and ensure efficient log management.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Apache Logging',
+              text: 'Modify the httpd.conf or apache2.conf file to customize log file paths and formats. Use the ErrorLog and CustomLog directives to specify log file locations and log formats.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with SigNoz',
+              text: 'Set up SigNoz and configure Apache to send logs to SigNoz for centralized monitoring and advanced log analysis capabilities.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
-
 Apache logs are crucial for understanding and managing the behavior of your web server. They provide detailed records of server activity, capturing essential data such as client IP addresses, request methods, requested URLs, response status codes, user agents, and timestamps. This information is invaluable for troubleshooting issues, performing security analysis, and optimizing performance, making Apache logs an essential component of server management.
 
 This guide aims to provide a thorough understanding of Apache logs, covering everything from their basic structure to advanced analysis and automation techniques using tools like SigNoz.
@@ -172,41 +188,35 @@ Apache logs are records of various events and activities that occur on an Apache
 Apache logs come in different types, each serving a specific purpose. The two primary types of logs are access logs and error logs.
 
 1. Access Logs
-    - Access logs record all requests made to the server. They typically include information such as the IP address of the client, request time, requested URL, HTTP status code, and user agent.
-    - Example:
-        
-        ```bash
-        127.0.0.1 - frank [18/Jul/2024:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
-        ```
-        
-        Explanation of Components:
-        
-        - 127.0.0.1: The IP address of the client making the request.
-        - frank: The user identifier for the client, typically provided by HTTP authentication.
-        - [18/Jul/2024:13:55:36 -0700]: The date and time when the request was made, followed by the time zone offset.
-        - "GET /apache_pb.gif HTTP/1.0": The request line from the client. This includes:
-            - GET: The HTTP method used.
-            - /apache_pb.gif: The requested URL.
-            - HTTP/1.0: The HTTP protocol version used.
-        - 200: The HTTP status code returned by the server, indicating the result of the request (200 means OK).
-        - 2326: The size of the response in bytes, excluding headers.
+   - Access logs record all requests made to the server. They typically include information such as the IP address of the client, request time, requested URL, HTTP status code, and user agent.
+   - Example:
+     ```bash
+     127.0.0.1 - frank [18/Jul/2024:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
+     ```
+     Explanation of Components:
+     - 127.0.0.1: The IP address of the client making the request.
+     - frank: The user identifier for the client, typically provided by HTTP authentication.
+     - [18/Jul/2024:13:55:36 -0700]: The date and time when the request was made, followed by the time zone offset.
+     - "GET /apache_pb.gif HTTP/1.0": The request line from the client. This includes:
+       - GET: The HTTP method used.
+       - /apache_pb.gif: The requested URL.
+       - HTTP/1.0: The HTTP protocol version used.
+     - 200: The HTTP status code returned by the server, indicating the result of the request (200 means OK).
+     - 2326: The size of the response in bytes, excluding headers.
 2. Error Logs
-    - Error logs capture issues that the server encounters while processing requests. This includes errors such as file not found, server misconfigurations, and more.
-    - Example:
-        
-        ```bash
-        [Fri Jul 14 14:32:14.873076 2024] [core:notice] [pid 1234] AH00094: Command line: '/usr/sbin/httpd -D FOREGROUND'
-        ```
-        
-        Explanation of Components:
-        
-        - [Fri Jul 14 14:32:14.873076 2024]: The date and time when the error occurred, down to microseconds.
-        - [core]: The module and the severity level of the message.
-            - core: The module where the error or notice originated.
-            - notice: The severity level of the message, indicating its importance.
-        - [pid 1234]: The process ID of the server process that encountered the issue.
-        - AH00094: The unique identifier for the specific error or notice.
-        - Command line: '/usr/sbin/httpd -D FOREGROUND': The command line that was used to start the server.
+   - Error logs capture issues that the server encounters while processing requests. This includes errors such as file not found, server misconfigurations, and more.
+   - Example:
+     ```bash
+     [Fri Jul 14 14:32:14.873076 2024] [core:notice] [pid 1234] AH00094: Command line: '/usr/sbin/httpd -D FOREGROUND'
+     ```
+     Explanation of Components:
+     - [Fri Jul 14 14:32:14.873076 2024]: The date and time when the error occurred, down to microseconds.
+     - [core]: The module and the severity level of the message.
+       - core: The module where the error or notice originated.
+       - notice: The severity level of the message, indicating its importance.
+     - [pid 1234]: The process ID of the server process that encountered the issue.
+     - AH00094: The unique identifier for the specific error or notice.
+     - Command line: '/usr/sbin/httpd -D FOREGROUND': The command line that was used to start the server.
 
 ### Common Use Cases for Log Analysis
 
@@ -217,7 +227,11 @@ Analyzing Apache logs is essential for various aspects of web server management.
 3. Troubleshooting: Use error logs to diagnose and resolve issues such as server misconfigurations, missing files, or application errors. This aids in maintaining server reliability and uptime.
 4. Traffic Analysis: Analyze access logs by analyzing user behaviour, popular pages, and traffic sources. This information can be used to improve user experience and strategic planning.
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled.webp" alt="Common use case for Apache log analysis" caption="Common use case for Apache log analysis" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled.webp"
+  alt="Common use case for Apache log analysis"
+  caption="Common use case for Apache log analysis"
+/>
 
 ## Configuring Apache Logging
 
@@ -228,11 +242,11 @@ Configuring Apache logging is crucial for ensuring that log data is properly cap
 Knowing the default log locations helps in quickly accessing the logs for initial setup and troubleshooting. The default log locations vary between operating systems.
 
 - Linux
-    - Access Logs: `/var/log/apache2/access.log` or `/var/log/httpd/access_log`
-    - Error Logs: `/var/log/apache2/error.log` or `/var/log/httpd/error_log`
+  - Access Logs: `/var/log/apache2/access.log` or `/var/log/httpd/access_log`
+  - Error Logs: `/var/log/apache2/error.log` or `/var/log/httpd/error_log`
 - Windows
-    - Access Logs: `C:\Program Files\Apache Group\Apache2\logs\access.log`
-    - Error Logs: `C:\Program Files\Apache Group\Apache2\logs\error.log`
+  - Access Logs: `C:\Program Files\Apache Group\Apache2\logs\access.log`
+  - Error Logs: `C:\Program Files\Apache Group\Apache2\logs\error.log`
 
 ### Changing the Default Apache Log Location
 
@@ -279,13 +293,13 @@ LogFormat "%h %l %u %t "%r" %>s %b" custom
 
 - LogFormat: This directive defines the format of log entries.
 - "%h %l %u %t "%r" %>s %b": This format string specifies what data to include in the log entries.
-    - %h: Remote host (IP address)
-    - %l: Remote logname (usually)``
-    - %u: Remote user (if authenticated)
-    - %t: Time the request was received
-    - "%r": The request line from the client (e.g., `GET / HTTP/1.0`)
-    - %>s: Status code sent to the client
-    - %b: Size of the response in bytes, excluding HTTP headers
+  - %h: Remote host (IP address)
+  - %l: Remote logname (usually)``
+  - %u: Remote user (if authenticated)
+  - %t: Time the request was received
+  - "%r": The request line from the client (e.g., `GET / HTTP/1.0`)
+  - %>s: Status code sent to the client
+  - %b: Size of the response in bytes, excluding HTTP headers
 - custom: This keyword assigns a name to this custom log format, which can be referenced later.
 
 CustomLog "/var/log/apache2/custom_access.log" custom
@@ -313,15 +327,15 @@ CustomLog "|/usr/bin/rotatelogs /var/log/apache2/access_log.%Y-%m-%d 86400" cust
 ```
 
 - ErrorLog "|/usr/bin/rotatelogs /var/log/apache2/error_log.%Y-%m-%d 86400"
-    - This configuration uses `rotatelogs`, a utility that manages log file rotation.
-    - "|/usr/bin/rotatelogs": The pipe symbol (`|`) directs the log output to the `rotatelogs` program.
-    - "/var/log/apache2/error_log.%Y-%m-%d": The log file name pattern includes the date, creating a new log file daily.
-    - 86400: The time in seconds (86400 seconds = 24 hours) to rotate the log file.
+  - This configuration uses `rotatelogs`, a utility that manages log file rotation.
+  - "|/usr/bin/rotatelogs": The pipe symbol (`|`) directs the log output to the `rotatelogs` program.
+  - "/var/log/apache2/error_log.%Y-%m-%d": The log file name pattern includes the date, creating a new log file daily.
+  - 86400: The time in seconds (86400 seconds = 24 hours) to rotate the log file.
 - CustomLog "|/usr/bin/rotatelogs /var/log/apache2/access_log.%Y-%m-%d 86400" custom
-    - This configuration similarly uses `rotatelogs` for the access log.
-    - "|/usr/bin/rotatelogs": The pipe symbol (`|`) directs the log output to the `rotatelogs` program.
-    - "/var/log/apache2/access_log.%Y-%m-%d": The log file name pattern includes the date, creating a new log file daily.
-    - custom: This references the previously defined custom log format.
+  - This configuration similarly uses `rotatelogs` for the access log.
+  - "|/usr/bin/rotatelogs": The pipe symbol (`|`) directs the log output to the `rotatelogs` program.
+  - "/var/log/apache2/access_log.%Y-%m-%d": The log file name pattern includes the date, creating a new log file daily.
+  - custom: This references the previously defined custom log format.
 
 ### Log rotation and management with `logrotate`
 
@@ -330,50 +344,50 @@ To ensure Apache logs do not consume excessive disk space, integrating `logrotat
 ### Configuring `logrotate` for Apache Logs:
 
 1. Install `logrotate`: Ensure `logrotate` is installed on your system. It is typically pre-installed on most Linux distributions. If not, you can install it using the package manager:
-    
-    ```bash
-    sudo yum install logrotate
-    ```
-    
+
+   ```bash
+   sudo yum install logrotate
+   ```
+
 2. Create a Logrotate Configuration File: Create a configuration file `/etc/logrotate/httpd` for Apache logs. This file will define how and when logs are rotated.
-    
-    Example Configuration:
-    
-    ```
-    /var/log/httpd/*.log {
-        daily
-        rotate 7
-        compress
-        delaycompress
-        missingok
-        notifempty
-        create 0640 root adm
-        sharedscripts
-        postrotate
-            /etc/init.d/httpd reload > /dev/null
-        endscript
-    }
-    ```
-    
-    - Explanation of Configuration Options:
-        - /var/log/httpd/*.log: Specifies the log files to be rotated.
-        - daily: Rotates the logs daily.
-        - rotate 7: Keeps seven days’ worth of old log files before deleting them.
-        - compress: Compresses the rotated log files to save space.
-        - delaycompress: Delays compression of the log file until the next rotation cycle.
-        - missingok: Ignores the error if the log file is missing.
-        - notifempty: Does not rotate the log file if it is empty.
-        - create 0640 root adm: Sets permissions for the new log file and specifies the owner and group.
-        - sharedscripts: Ensures that the postrotate script is run only once, even if multiple log files are rotated.
-        - postrotate/endscript: Defines a script to be run after log rotation. In this case, it reloads the Apache server to ensure it starts writing to the new log file.
+
+   Example Configuration:
+
+   ```
+   /var/log/httpd/*.log {
+       daily
+       rotate 7
+       compress
+       delaycompress
+       missingok
+       notifempty
+       create 0640 root adm
+       sharedscripts
+       postrotate
+           /etc/init.d/httpd reload > /dev/null
+       endscript
+   }
+   ```
+
+   - Explanation of Configuration Options:
+     - /var/log/httpd/\*.log: Specifies the log files to be rotated.
+     - daily: Rotates the logs daily.
+     - rotate 7: Keeps seven days’ worth of old log files before deleting them.
+     - compress: Compresses the rotated log files to save space.
+     - delaycompress: Delays compression of the log file until the next rotation cycle.
+     - missingok: Ignores the error if the log file is missing.
+     - notifempty: Does not rotate the log file if it is empty.
+     - create 0640 root adm: Sets permissions for the new log file and specifies the owner and group.
+     - sharedscripts: Ensures that the postrotate script is run only once, even if multiple log files are rotated.
+     - postrotate/endscript: Defines a script to be run after log rotation. In this case, it reloads the Apache server to ensure it starts writing to the new log file.
+
 3. Test the Configuration: You can manually test your `logrotate` configuration to ensure it works as expected.
-    
-    ```bash
-    sudo logrotate -d /etc/logrotate.d/httpd
-    ```
-    
 
-Note: You will have to replace the occurrences of `httpd` with `apache2`based on your system. 
+   ```bash
+   sudo logrotate -d /etc/logrotate.d/httpd
+   ```
+
+Note: You will have to replace the occurrences of `httpd` with `apache2`based on your system.
 
 By implementing `logrotate` with the appropriate configuration, you can ensure efficient log management in Apache environments, preventing log files from consuming excessive disk space and maintaining the server’s performance and stability.
 
@@ -386,21 +400,23 @@ Understanding Apache log formats is essential for effective log analysis and mon
 The Common Log Format is a standardized format that provides essential information about each request. It includes:
 
 - Format: `%h %l %u %t \"%r\" %>s %b`
-    - `%h`: Remote host (IP address)
-    - `%l`: Remote logname (usually)``
-    - `%u`: Remote user (authenticated user)
-    - `%t`: Time the request was received
-    - `%r`: Request line from the client (method, resource, protocol)
-    - `%>s`: Status code sent to the client
-    - `%b`: Size of the object sent to the client (excluding headers)
+  - `%h`: Remote host (IP address)
+  - `%l`: Remote logname (usually)``
+  - `%u`: Remote user (authenticated user)
+  - `%t`: Time the request was received
+  - `%r`: Request line from the client (method, resource, protocol)
+  - `%>s`: Status code sent to the client
+  - `%b`: Size of the object sent to the client (excluding headers)
 - Example:
-    
-    ```bash
-    127.0.0.1 - - [14/Jul/2024:12:34:56 +0000] "GET /index.html HTTP/1.1" 200 1043
-    ```
-    
+  ```bash
+  127.0.0.1 - - [14/Jul/2024:12:34:56 +0000] "GET /index.html HTTP/1.1" 200 1043
+  ```
 
-<Figure src="/img/guides/2024/07/apache-log-napkin-selection_(2).webp" alt="common log format" caption="Common Log Format" />
+<Figure
+  src="/img/guides/2024/07/apache-log-napkin-selection_(2).webp"
+  alt="common log format"
+  caption="Common Log Format"
+/>
 
 ### Combined Log Format
 
@@ -413,15 +429,13 @@ Imagine you run a popular online store. You want to know not just how many peopl
 - Referrer Insight: The referrer field tells you which page a visitor was on before they arrived at your site. This can help you identify which external links or marketing campaigns are driving traffic to your store.
 - User Agent Details: The user agent string reveals information about the visitor's browser and operating system. Knowing this helps you optimize your site for the most popular devices and troubleshoot compatibility issues
 - Format: `%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"`
-    - `%h`, `%l`, `%u`, `%t`, `%r`, `%>s`, `%b`: Same as in CLF
-    - `%{Referer}i`: Referrer URL
-    - `%{User-Agent}i`: User agent string
+  - `%h`, `%l`, `%u`, `%t`, `%r`, `%>s`, `%b`: Same as in CLF
+  - `%{Referer}i`: Referrer URL
+  - `%{User-Agent}i`: User agent string
 - Example:
-    
-    ```bash
-    127.0.0.1 - - [14/Jul/2024:12:34:56 +0000] "GET /index.html HTTP/1.1" 200 1043 "http://example.com" "Mozilla/5.0"
-    ```
-    
+  ```bash
+  127.0.0.1 - - [14/Jul/2024:12:34:56 +0000] "GET /index.html HTTP/1.1" 200 1043 "http://example.com" "Mozilla/5.0"
+  ```
 
 Real-Life Example:
 
@@ -455,17 +469,13 @@ Custom log formats allow you to tailor the information logged to meet your speci
 Imagine you're running a tech blog and want to track not just the traffic but also the search terms visitors use to find your articles. By customizing your log format, you can capture this specific data.
 
 - Example: You might define a custom log format that includes the search term as a custom field. This could look like:
-    
-    ```bash
-    "%h %t \"%r\" %>s %b \"%{User-Agent}i\" \"%{Search-Term}i\""
-    ```
-    
+  ```bash
+  "%h %t \"%r\" %>s %b \"%{User-Agent}i\" \"%{Search-Term}i\""
+  ```
 - Real-Life Scenario:
-    
-    ```arduino
-    192.168.1.1 [18/Jul/2024:14:00:00 -0700] "GET /article/seo-tips HTTP/1.1" 200 5120 "Mozilla/5.0
-    ```
-    
+  ```arduino
+  192.168.1.1 [18/Jul/2024:14:00:00 -0700] "GET /article/seo-tips HTTP/1.1" 200 5120 "Mozilla/5.0
+  ```
 
 By leveraging custom log formats, you can transform raw server data into actionable insights, making your web analytics as detailed and relevant as you need them to be.
 
@@ -485,16 +495,16 @@ Sample Log Entry:
 
 ### Key Fields and Their Meanings
 
-| Field | Example | Meaning |
-| --- | --- | --- |
-| IP Address | 127.0.0.1 | Identifies the client making the request. |
-| Request Method | GET | Type of HTTP request (e.g., GET, POST). |
-| Requested URL | /index.html | Resource being requested from the server. |
-| HTTP Version | HTTP/1.1 | Version of the HTTP protocol used. |
-| Status Code | 200 | Response status indicating success (200 OK). |
-| Response Size | 1043 | Size of the response in bytes (excluding headers). |
-| User-Agent | "Mozilla/5.0" | Information about the client's browser/application. |
-| Referrer | "http://example.com" | Previous page that linked to the requested resource. |
+| Field          | Example              | Meaning                                              |
+| -------------- | -------------------- | ---------------------------------------------------- |
+| IP Address     | 127.0.0.1            | Identifies the client making the request.            |
+| Request Method | GET                  | Type of HTTP request (e.g., GET, POST).              |
+| Requested URL  | /index.html          | Resource being requested from the server.            |
+| HTTP Version   | HTTP/1.1             | Version of the HTTP protocol used.                   |
+| Status Code    | 200                  | Response status indicating success (200 OK).         |
+| Response Size  | 1043                 | Size of the response in bytes (excluding headers).   |
+| User-Agent     | "Mozilla/5.0"        | Information about the client's browser/application.  |
+| Referrer       | "http://example.com" | Previous page that linked to the requested resource. |
 
 ## Analyzing Apache Error Logs
 
@@ -512,14 +522,14 @@ Sample Log Entry:
 
 ### Common Error Messages and Their Interpretations
 
-| Error Message | Example | Interpretation |
-| --- | --- | --- |
-| File Does Not Exist | File does not exist: /var/www/html/missing.html | The requested file was not found on the server. |
-| Permission Denied | Permission denied: /var/www/html/protected.html | The server does not have permission to access the file. |
-| Internal Server Error | Internal Server Error: /index.php | A general error occurred; check the application for issues. |
-| Script Not Found | script not found or unable to stat: /cgi-bin/script.cgi | The specified CGI script is missing or not executable. |
-| Maximum File Size Exceeded | client exceeded max request body size: /upload | The client uploaded a file that exceeds the server's maximum allowed size. |
-| Connection Timeout | Connection timed out: /path/to/resource | The server took too long to respond to the request. |
+| Error Message              | Example                                                 | Interpretation                                                             |
+| -------------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------- |
+| File Does Not Exist        | File does not exist: /var/www/html/missing.html         | The requested file was not found on the server.                            |
+| Permission Denied          | Permission denied: /var/www/html/protected.html         | The server does not have permission to access the file.                    |
+| Internal Server Error      | Internal Server Error: /index.php                       | A general error occurred; check the application for issues.                |
+| Script Not Found           | script not found or unable to stat: /cgi-bin/script.cgi | The specified CGI script is missing or not executable.                     |
+| Maximum File Size Exceeded | client exceeded max request body size: /upload          | The client uploaded a file that exceeds the server's maximum allowed size. |
+| Connection Timeout         | Connection timed out: /path/to/resource                 | The server took too long to respond to the request.                        |
 
 By understanding these error messages, administrators can quickly diagnose issues and take appropriate actions to resolve them, ensuring the server operates efficiently.
 
@@ -531,11 +541,15 @@ CGI stands for Common Gateway Interface. It is a standard protocol used to inter
 
 Analyzing Apache logs provides valuable insights that can significantly enhance server management and website performance. Here are some key practical applications:
 
-- Monitoring Web Traffic and User Behavior:  By analyzing access logs, administrators can track user interactions, popular pages, and traffic patterns. This information helps in understanding user behavior, optimizing content delivery, and making informed decisions about website changes.
+- Monitoring Web Traffic and User Behavior: By analyzing access logs, administrators can track user interactions, popular pages, and traffic patterns. This information helps in understanding user behavior, optimizing content delivery, and making informed decisions about website changes.
 - Identifying and Mitigating Security Threats: Error logs and access logs are crucial for identifying potential security threats. By monitoring for unusual patterns, such as repeated failed login attempts or access to non-existent pages, administrators can detect and respond to attacks like brute force or SQL injection attempts.
 - Performance Optimization Through Log Analysis: Log analysis allows for performance monitoring by identifying slow requests, high error rates, or resource-intensive pages. This information can guide optimization efforts, such as caching strategies, code improvements, or server configuration adjustments, leading to a more efficient and responsive web application.
 
-<Figure src="/img/guides/2024/07/apache-log-napkin-selection_(1).webp" alt="Practical applications of Analyzing Apache logs" caption="Practical applications of Analyzing Apache logs" />
+<Figure
+  src="/img/guides/2024/07/apache-log-napkin-selection_(1).webp"
+  alt="Practical applications of Analyzing Apache logs"
+  caption="Practical applications of Analyzing Apache logs"
+/>
 
 Practical applications of Analyzing Apache logs
 
@@ -564,7 +578,11 @@ To send Apache logs to SigNoz, you'll need to follow these steps. The process in
 yum install httpd -y
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%201.webp" alt="Installing Apache server" caption="Installing Apache server" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%201.webp"
+  alt="Installing Apache server"
+  caption="Installing Apache server"
+/>
 
 - Start and enable the Apache service by running the command:
 
@@ -574,60 +592,74 @@ systemctl enable httpd
 systemctl status httpd
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%202.webp" alt="Starting and enabling Apache server" caption="Starting and enabling Apache server" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%202.webp"
+  alt="Starting and enabling Apache server"
+  caption="Starting and enabling Apache server"
+/>
 
 - Access Log Configuration:
-    - By default, Apache logs access information to `/var/log/httpd/access_log`.
-    - Ensure that the `CustomLog` directive is enabled in your Apache configuration file (usually found at `/etc/httpd/conf/httpd.conf`):
-        
-        ```
-        CustomLog logs/access_log combined
-        ```
-        
+  - By default, Apache logs access information to `/var/log/httpd/access_log`.
+  - Ensure that the `CustomLog` directive is enabled in your Apache configuration file (usually found at `/etc/httpd/conf/httpd.conf`):
+    ```
+    CustomLog logs/access_log combined
+    ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%203.webp" alt="CustomLog directive in Apache Configuration File" caption="CustomLog directive in Apache Configuration File" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%203.webp"
+  alt="CustomLog directive in Apache Configuration File"
+  caption="CustomLog directive in Apache Configuration File"
+/>{' '}
 
 - Error Log Configuration:
-    - Apache logs error information to `/var/log/httpd/error_log`.
-    - Ensure that the `ErrorLog` directive is enabled in your Apache configuration file (found at `/etc/httpd/conf/httpd.conf`)
-        
-        ```
-        ErrorLog logs/error_log
-        ```
-        
+  - Apache logs error information to `/var/log/httpd/error_log`.
+  - Ensure that the `ErrorLog` directive is enabled in your Apache configuration file (found at `/etc/httpd/conf/httpd.conf`)
+    ```
+    ErrorLog logs/error_log
+    ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%204.webp" alt="ErrorLog Configuration in Apache Configuration File" caption="ErrorLog Configuration in Apache Configuration File" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%204.webp"
+  alt="ErrorLog Configuration in Apache Configuration File"
+  caption="ErrorLog Configuration in Apache Configuration File"
+/>
 
 ### Step 2: Install and Configure OpenTelemetry Collector
 
 Install the OpenTelemetry Collector on your EC2 instance.
 
 1. Update Packages:
-    
-    ```
-    sudo yum update -y
-    ```
-    
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%205.webp" alt="Updating packages" caption="Updating packages" />
+   ```
+   sudo yum update -y
+   ```
+
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%205.webp"
+  alt="Updating packages"
+  caption="Updating packages"
+/>
 
 1. Download and Install OpenTelemetry Collector:
-    - Ensure you have the OpenTelemetry Collector installed on your system. If not, install it using the following commands:
-        
-        ```bash
-        wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.116.0/otelcol-contrib_0.116.0_linux_amd64.tar.gz
-        mkdir otelcol-contrib && tar xvzf otelcol-contrib_0.116.0_linux_amd64.tar.gz -C otelcol-contrib
-        ```
-        
-    
-    <Figure src="/img/guides/2024/07/apache-log-Untitled%206.webp" alt="Installing OpenTelemetry collector" caption="Installing OpenTelemetry collector" />
-    
-    *Installing OpenTelemetry collector*
-    
-    Note: Ensure you have the latest version of the OpenTelemetry Collector. The commands above use version 0.116.0, which is the latest at the time of writing. To verify and download the most current version, visit the <a href="https://github.com/open-telemetry/opentelemetry-collector-releases" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry Collector Releases</a> page.
-    
+
+   - Ensure you have the OpenTelemetry Collector installed on your system. If not, install it using the following commands:
+     ```bash
+     wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.116.0/otelcol-contrib_0.116.0_linux_amd64.tar.gz
+     mkdir otelcol-contrib && tar xvzf otelcol-contrib_0.116.0_linux_amd64.tar.gz -C otelcol-contrib
+     ```
+
+   <Figure
+     src="/img/guides/2024/07/apache-log-Untitled%206.webp"
+     alt="Installing OpenTelemetry collector"
+     caption="Installing OpenTelemetry collector"
+   />
+
+   _Installing OpenTelemetry collector_
+
+   Note: Ensure you have the latest version of the OpenTelemetry Collector. The commands above use version 0.116.0, which is the latest at the time of writing. To verify and download the most current version, visit the <a href="https://github.com/open-telemetry/opentelemetry-collector-releases" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry Collector Releases</a> page.
+
 2. Create Configuration File:
-    - Create the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) configuration file, `config.yaml` in the folder otelcol-contrib with the below content in it.
+   - Create the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) configuration file, `config.yaml` in the folder otelcol-contrib with the below content in it.
 
 ```yaml
 receivers:
@@ -662,7 +694,7 @@ receivers:
             - targets:
               # - localhost:8888
   filelog:
-    include: 
+    include:
 	    - /var/log/httpd/access_log
 	    - /var/log/httpd/error_log
     start_at: end
@@ -678,7 +710,7 @@ processors:
       hostname_sources: [os]
 
 extensions:
-  health_check: 
+  health_check:
     endpoint: "0.0.0.0:13134"
   zpages:
     endpoint: "127.0.0.1:55680"
@@ -718,13 +750,15 @@ service:
 Replace the endpoint and ingestion key value with the actual OTLP endpoint and token provided by SigNoz.
 
 - To run otel-collector, run the following command inside the `otelcol-contrib` directory:
-    
-    ```bash
-    ./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-    ```
-    
+  ```bash
+  ./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
+  ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%207.webp" alt="Running Otel-collector" caption="Running Otel-collector" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%207.webp"
+  alt="Running Otel-collector"
+  caption="Running Otel-collector"
+/>
 
 ### Step 3: Testing Apache Logs on SigNoz
 
@@ -736,7 +770,11 @@ Replace the endpoint and ingestion key value with the actual OTLP endpoint and t
 for i in {1..10}; do curl http://localhost/; done
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%208.webp" alt="Sending GET requests to Apache server" caption="Sending GET requests to Apache server" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%208.webp"
+  alt="Sending GET requests to Apache server"
+  caption="Sending GET requests to Apache server"
+/>{' '}
 
 - Replace `localhost` with your server's IP address or domain name if you are testing from a different machine.
 - Generate different types of HTTP requests to test various logging scenarios.
@@ -748,11 +786,23 @@ curl -X PUT http://localhost/
 curl -X DELETE http://localhost/
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%209.webp" alt="Sending POST requests to Apache server" caption="Sending POST requests to Apache server" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%209.webp"
+  alt="Sending POST requests to Apache server"
+  caption="Sending POST requests to Apache server"
+/>{' '}
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%2010.webp" alt="Sending PUT requests to Apache server" caption="Sending PUT requests to Apache server" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%2010.webp"
+  alt="Sending PUT requests to Apache server"
+  caption="Sending PUT requests to Apache server"
+/>{' '}
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%2011.webp" alt="Sending DELETE requests to Apache server" caption="Sending DELETE requests to Apache server" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%2011.webp"
+  alt="Sending DELETE requests to Apache server"
+  caption="Sending DELETE requests to Apache server"
+/>{' '}
 
 2. Verify Logs in Apache
 
@@ -762,7 +812,11 @@ curl -X DELETE http://localhost/
 sudo tail -f /var/log/httpd/access_log
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-01e06ec6-e80a-4add-b463-5051fd10c75c.webp" alt="Verifying access logs in Apache" caption="Verifying access logs in Apache" />
+<Figure
+  src="/img/guides/2024/07/apache-log-01e06ec6-e80a-4add-b463-5051fd10c75c.webp"
+  alt="Verifying access logs in Apache"
+  caption="Verifying access logs in Apache"
+/>
 
 You should see entries corresponding to the requests you generated.
 
@@ -772,18 +826,30 @@ You should see entries corresponding to the requests you generated.
 sudo tail -f /var/log/httpd/error_log
 ```
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%2012.webp" alt="Verifying Error logs in Apache" caption="Verifying Error logs in Apache" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%2012.webp"
+  alt="Verifying Error logs in Apache"
+  caption="Verifying Error logs in Apache"
+/>
 
 3. Verify Logs in SigNoz
 
 - Log in to your SigNoz cloud and navigate to the logs section.
 - Verify that you can see the Apache access and error logs in the SigNoz dashboard.
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%2013.webp" alt="Visualizing and monitoring Apache logs in Signoz Dashboard" caption="Visualizing and monitoring Apache logs in Signoz Dashboard" /> 
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%2013.webp"
+  alt="Visualizing and monitoring Apache logs in Signoz Dashboard"
+  caption="Visualizing and monitoring Apache logs in Signoz Dashboard"
+/>{' '}
 
 - Use the search and filter options to find specific log entries related to the requests you generated.
 
-<Figure src="/img/guides/2024/07/apache-log-Untitled%2014.webp" alt="Filtering Apache logs based on log file name" caption="Filtering Apache logs based on log file name" />
+<Figure
+  src="/img/guides/2024/07/apache-log-Untitled%2014.webp"
+  alt="Filtering Apache logs based on log file name"
+  caption="Filtering Apache logs based on log file name"
+/>
 
 ## Conclusion
 
diff --git a/data/guides/apache-monitoring.mdx b/data/guides/apache-monitoring.mdx
index a22773e0e..498adf431 100644
--- a/data/guides/apache-monitoring.mdx
+++ b/data/guides/apache-monitoring.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Apache Monitoring - Essential Guide for Web Admins
-slug: apache-monitoring
 date: 2024-10-03
 tags: [monitoring]
 authors: [vivek_goswami]
 description: Learn essential Apache monitoring techniques, key metrics, and best practices for web admins. Optimize performance and security with this comprehensive guide.
-keywords: [apache monitoring, web server management, performance optimization, server metrics, log analysis]
-
+keywords:
+  [apache monitoring, web server management, performance optimization, server metrics, log analysis]
 ---
 
 Apache, the world's most popular web server, powers millions of websites across the internet. As a web administrator, you ensure your Apache servers run smoothly, efficiently, and securely. But how do you keep track of your server's health and performance? The answer lies in Apache monitoring. This guide will walk you through the essentials of Apache monitoring, from understanding key metrics to implementing advanced techniques for optimal server management.
@@ -37,7 +35,13 @@ In the context of web infrastructure, Apache plays a vital role in serving web p
 
 ## Essential Apache Metrics to Monitor
 
-<Figure src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.04.57_AM.webp" alt="" caption="" />Monitoring Apache server performance is crucial for ensuring efficient operation and detecting potential issues. The following are key metrics that should be tracked regularly:
+<Figure
+  src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.04.57_AM.webp"
+  alt=""
+  caption=""
+/>
+Monitoring Apache server performance is crucial for ensuring efficient operation and detecting
+potential issues. The following are key metrics that should be tracked regularly:
 
 ### Server-level metrics
 
@@ -67,135 +71,135 @@ In the context of web infrastructure, Apache plays a vital role in serving web p
 Multi-Processing Modules (MPMs) in Apache determine how the server manages incoming requests, significantly affecting its performance, scalability, and resource allocation. The choice of MPM influences monitoring strategies and helps optimize server configurations.
 
 1. Prefork MPM:
-    - Description: Prefork creates separate processes for each connection, allowing each request to be handled in isolation. This model is straightforward and stable, making it suitable for applications that require high reliability.
-    - Monitoring Focus: When using Prefork, monitoring should emphasize process-level metrics, such as the number of active processes and memory usage per process. This helps identify memory leaks and resource bottlenecks associated with individual processes.
+   - Description: Prefork creates separate processes for each connection, allowing each request to be handled in isolation. This model is straightforward and stable, making it suitable for applications that require high reliability.
+   - Monitoring Focus: When using Prefork, monitoring should emphasize process-level metrics, such as the number of active processes and memory usage per process. This helps identify memory leaks and resource bottlenecks associated with individual processes.
 2. Worker MPM:
-    - Description: The Worker MPM utilizes multiple processes, each capable of handling multiple threads. This design allows for improved resource utilization and can handle more concurrent requests compared to Prefork.
-    - Monitoring Focus: For Worker MPM, monitoring should focus on thread usage, including the number of active threads and their respective states. Observing thread-related issues, such as contention or blocking, is crucial for maintaining performance under load.
+   - Description: The Worker MPM utilizes multiple processes, each capable of handling multiple threads. This design allows for improved resource utilization and can handle more concurrent requests compared to Prefork.
+   - Monitoring Focus: For Worker MPM, monitoring should focus on thread usage, including the number of active threads and their respective states. Observing thread-related issues, such as contention or blocking, is crucial for maintaining performance under load.
 3. Event MPM:
-    - Description: Similar to Worker, the Event MPM is optimized to handle keep-alive connections more efficiently. It allows the server to manage idle connections without consuming unnecessary resources, making it ideal for high-traffic environments.
-    - Monitoring Focus: Monitoring with Event MPM should include metrics on connection handling, specifically the number of idle threads and the response time for keep-alive connections. This information helps identify potential bottlenecks during high-traffic periods.
+   - Description: Similar to Worker, the Event MPM is optimized to handle keep-alive connections more efficiently. It allows the server to manage idle connections without consuming unnecessary resources, making it ideal for high-traffic environments.
+   - Monitoring Focus: Monitoring with Event MPM should include metrics on connection handling, specifically the number of idle threads and the response time for keep-alive connections. This information helps identify potential bottlenecks during high-traffic periods.
 
 Understanding which MPM is in use helps accurately interpret monitoring data, allowing administrators to make informed decisions about server optimization and resource allocation. By aligning monitoring strategies with the characteristics of the chosen MPM, potential issues can be identified and resolved more efficiently.
 
 ## How to Set Up Apache Monitoring: Step-by-Step Guide
 
-1. Enable the Apache Status Module
-    
+1.  Enable the Apache Status Module
+
     Apache’s status module provides real-time data about the web server’s performance. To enable it, first, ensure that the `mod_status` module is installed. Open the Apache configuration file, typically located at `/etc/apache2/apache2.conf` or `/etc/httpd/conf/httpd.conf`. To edit this file, follow these steps:
-    
+
     - Open Terminal.
     - Use a text editor to edit the configuration file. For example, using `nano`, type:
-    (Adjust the path based on your installation, using `/etc/httpd/conf/httpd.conf` if applicable.)
-        
-        ```bash
-        sudo nano /etc/apache2/apache2.conf
-        
-        ```
-        
+      (Adjust the path based on your installation, using `/etc/httpd/conf/httpd.conf` if applicable.)
+          ```bash
+          sudo nano /etc/apache2/apache2.conf
+
+          ```
     - Find and uncomment the following line (if it exists) to enable the `mod_status` module:
-        
-        ```
-        LoadModule status_module libexec/apache2/mod_status.so
-        
-        ```
-        
+      ```
+      LoadModule status_module libexec/apache2/mod_status.so
+
+      ```
     - Add the following configuration to allow access to the status page (usually under the `<Location /server-status>` directive):
-        
-        ```
-        <Location /server-status>
-            SetHandler server-status
-            Require host localhost
-        </Location>
-        
-        ```
-        
+      ```
+      <Location /server-status>
+          SetHandler server-status
+          Require host localhost
+      </Location>
+
+      ```
     - Save the changes by pressing `Ctrl + O`, then `Enter`, and exit `nano` by pressing `Ctrl + X`.
     - Restart Apache to apply the changes:
-        
-        ```bash
-        sudo apachectl restart
-        
-        ```
-        
-    
+      ```bash
+      sudo apachectl restart
+
+      ```
+
     This ensures the necessary steps for editing the configuration file are included.
-    
-2. Accessing the Status Page
-    
-    <Figure src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.19.01_AM.webp" alt="" caption="" />The status page provides valuable insights such as the current number of active connections and server uptime. To access the status page, visit `http://localhost/server-status`. If the server is not local, modify the configuration by replacing `Require local` with `Require all granted`, which allows remote access (ensure proper security controls).
-    
-3. Implement Real-Time Monitoring with `mod_status`
-    
-    <Figure src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.54.00_AM.webp" alt="" caption="" />To enhance real-time monitoring, integrate the `mod_status` module. This will provide information such as server load, idle workers, and traffic statistics. Use this data to track the server’s health and identify any performance issues. The status page updates in real-time and can be customized by adding parameters to the URL, such as `?auto` for machine-readable output.
-    
+
+2.  Accessing the Status Page
+
+    <Figure
+      src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.19.01_AM.webp"
+      alt=""
+      caption=""
+    />
+    The status page provides valuable insights such as the current number of active connections and
+    server uptime. To access the status page, visit `http://localhost/server-status`. If the server
+    is not local, modify the configuration by replacing `Require local` with `Require all granted`,
+    which allows remote access (ensure proper security controls).
+
+3.  Implement Real-Time Monitoring with `mod_status`
+
+    <Figure
+      src="/img/guides/2024/10/apache-monitoring-Screenshot_2024-09-26_at_3.54.00_AM.webp"
+      alt=""
+      caption=""
+    />
+    To enhance real-time monitoring, integrate the `mod_status` module. This will provide
+    information such as server load, idle workers, and traffic statistics. Use this data to track
+    the server’s health and identify any performance issues. The status page updates in real-time
+    and can be customized by adding parameters to the URL, such as `?auto` for machine-readable
+    output.
 
 These steps provide a foundation for Apache monitoring. As you become more comfortable, you can implement more advanced techniques.
 
 ## Advanced Apache Monitoring Techniques
 
 1. Implementing distributed tracing for microservices architectures
-    - In a microservices environment, tracking a request’s journey through multiple services can be complex. Distributed tracing provides visibility into how Apache interacts with other services, helping to identify latency issues.
-    - Tools like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) can be integrated with Apache to capture trace data. This allows monitoring of each service's contribution to the overall request time, offering insights into which services may need optimization.
-    - Example: Consider an e-commerce application composed of several microservices, including an API gateway, product service, order service, and payment service. When a user initiates a purchase, the request travels through multiple services. By implementing distributed tracing with OpenTelemetry, each service can record its processing time. If the tracing data reveals that the payment service takes significantly longer than expected, developers can investigate and optimize that specific service, thereby improving the overall user experience and reducing transaction times.
+   - In a microservices environment, tracking a request’s journey through multiple services can be complex. Distributed tracing provides visibility into how Apache interacts with other services, helping to identify latency issues.
+   - Tools like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) can be integrated with Apache to capture trace data. This allows monitoring of each service's contribution to the overall request time, offering insights into which services may need optimization.
+   - Example: Consider an e-commerce application composed of several microservices, including an API gateway, product service, order service, and payment service. When a user initiates a purchase, the request travels through multiple services. By implementing distributed tracing with OpenTelemetry, each service can record its processing time. If the tracing data reveals that the payment service takes significantly longer than expected, developers can investigate and optimize that specific service, thereby improving the overall user experience and reducing transaction times.
 2. Correlating Apache metrics with application performance
-    - Apache performance metrics such as response times, throughput, and error rates can be correlated with the performance of backend applications. Monitoring tools like Signoz can be configured to collect Apache metrics and display them alongside application metrics for a holistic view.
-    - For instance, if there is a spike in Apache 500 errors and application logs show increased database connection failures, it can help diagnose whether the application or Apache is causing the issue.
+   - Apache performance metrics such as response times, throughput, and error rates can be correlated with the performance of backend applications. Monitoring tools like Signoz can be configured to collect Apache metrics and display them alongside application metrics for a holistic view.
+   - For instance, if there is a spike in Apache 500 errors and application logs show increased database connection failures, it can help diagnose whether the application or Apache is causing the issue.
 3. Using machine learning for anomaly detection in Apache logs
-    - Machine learning models can be applied to Apache logs to automatically detect anomalies, such as unusual traffic patterns or error spikes. These anomalies could indicate security threats, misconfigurations, or performance issues.
-    - An example is leveraging tools like Elasticsearch and Kibana with the Elastic ML features to set up real-time monitoring and detect outliers in traffic patterns that may signal a DDoS attack or a sudden resource bottleneck.
+   - Machine learning models can be applied to Apache logs to automatically detect anomalies, such as unusual traffic patterns or error spikes. These anomalies could indicate security threats, misconfigurations, or performance issues.
+   - An example is leveraging tools like Elasticsearch and Kibana with the Elastic ML features to set up real-time monitoring and detect outliers in traffic patterns that may signal a DDoS attack or a sudden resource bottleneck.
 
 ## Best Practices for Apache Performance Tuning
 
 The following are essential practices to ensure the efficient operation of Apache.
 
-1. Optimizing Apache configuration files:
+1.  Optimizing Apache configuration files:
     - Adjusting the `KeepAlive` setting to reduce the number of open connections. Setting `KeepAliveTimeout` to a low value (e.g., 2-5 seconds) can improve response times by limiting idle connections.
     - Tuning the `MaxRequestWorkers` and `ServerLimit` directives helps manage the maximum number of simultaneous requests, preventing resource overloads. A typical example would be setting `MaxRequestWorkers` to 256 for moderate traffic.
     - Disabling unnecessary modules. For example, disabling the `mod_status` module when real-time server metrics aren't required can free up resources.
-2. Implementing caching strategies:
+2.  Implementing caching strategies:
     - Browser caching can be configured by adding `ExpiresActive` and `ExpiresDefault` directives. For instance, enabling a cache expiration of one week for static resources like images can reduce the load on the server:
-        
-        ```bash
-        <IfModule mod_expires.c>
-            ExpiresActive On
-            ExpiresByType image/jpg "access plus 1 week"
-        </IfModule>
-        ```
-        
+      ```bash
+      <IfModule mod_expires.c>
+          ExpiresActive On
+          ExpiresByType image/jpg "access plus 1 week"
+      </IfModule>
+      ```
     - Server-side caching using modules like `mod_cache` or reverse proxies such as Varnish helps by storing static content. For example, enabling `mod_cache` on Apache can be achieved by configuring:
-    This improves performance by serving cached content instead of processing new requests.
-        
-        ```bash
-        CacheQuickHandler off
-        CacheLock on
-        CacheRoot "/var/cache/apache"
-        CacheEnable disk /
-        
-        ```
-        
-3. Load balancing techniques for high-traffic Apache servers:
+      This improves performance by serving cached content instead of processing new requests.
+          ```bash
+          CacheQuickHandler off
+          CacheLock on
+          CacheRoot "/var/cache/apache"
+          CacheEnable disk /
+
+          ```
+3.  Load balancing techniques for high-traffic Apache servers:
     - Implementing load balancing using `mod_proxy_balancer` is effective for distributing traffic across multiple servers. A basic configuration may look like this:
-    This ensures that traffic is evenly distributed, improving server responsiveness during peak loads.
-        
-        ```bash
-        <Proxy balancer://mycluster>
-            BalancerMember <http://server1.example.com>
-            BalancerMember <http://server2.example.com>
-        </Proxy>
-        
-        ProxyPass / balancer://mycluster/
-        ProxyPassReverse / balancer://mycluster/
-        ```
-        
-4. Regular security audits and updates:
+      This ensures that traffic is evenly distributed, improving server responsiveness during peak loads.
+          ```bash
+          <Proxy balancer://mycluster>
+              BalancerMember <http://server1.example.com>
+              BalancerMember <http://server2.example.com>
+          </Proxy>
+
+          ProxyPass / balancer://mycluster/
+          ProxyPassReverse / balancer://mycluster/
+          ```
+4.  Regular security audits and updates:
     - Performing routine security checks helps identify vulnerabilities. Regularly updating Apache to the latest stable version ensures that known security issues are patched.
     - Using security modules like `mod_security` and keeping its rules updated can prevent malicious requests. A common example is blocking SQL injection attempts:
-        
-        ```bash
-        SecRule REQUEST_URI|REQUEST_BODY "@contains select" "id:1234,deny,status:403"
-        ```
-        
+      ```bash
+      SecRule REQUEST_URI|REQUEST_BODY "@contains select" "id:1234,deny,status:403"
+      ```
     - Reviewing error and access logs regularly for suspicious activities provides an early warning system for potential attacks.
 
 ## Leveraging SigNoz for Comprehensive Apache Monitoring
@@ -250,4 +254,4 @@ Yes, Apache monitoring can significantly enhance website security. By analyzing
 
 ### What's the difference between Apache monitoring and general server monitoring?
 
-While general server monitoring focuses on system-wide metrics like CPU, memory, and disk usage, Apache monitoring specifically tracks web server performance metrics such as requests per second, worker threads, and HTTP status codes. Both are essential for maintaining a healthy web server environment.
\ No newline at end of file
+While general server monitoring focuses on system-wide metrics like CPU, memory, and disk usage, Apache monitoring specifically tracks web server performance metrics such as requests per second, worker threads, and HTTP status codes. Both are essential for maintaining a healthy web server environment.
diff --git a/data/guides/api-monitoring.mdx b/data/guides/api-monitoring.mdx
index a2b325de7..667b5731c 100644
--- a/data/guides/api-monitoring.mdx
+++ b/data/guides/api-monitoring.mdx
@@ -1,6 +1,5 @@
 ---
 title: Essential Guide to API Monitoring - Boost Performance
-slug: api-monitoring
 date: 2024-12-05
 tags: [monitoring]
 authors: [soumya_gupta]
diff --git a/data/guides/api-observability.mdx b/data/guides/api-observability.mdx
index 317870449..2cc9de698 100644
--- a/data/guides/api-observability.mdx
+++ b/data/guides/api-observability.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: API Observability - Enhancing Monitoring and Performance
-slug: api-observability
 date: 2024-08-14
 tags: [observability]
 authors: [simran_kumari]
 description: Discover how API observability enhances monitoring and performance in modern, distributed systems. Learn key components, implementation strategies, and tools.
-keywords: [API observability, API monitoring, distributed tracing, API performance, microservices, SigNoz, API metrics, structured logging]
-
+keywords:
+  [
+    API observability,
+    API monitoring,
+    distributed tracing,
+    API performance,
+    microservices,
+    SigNoz,
+    API metrics,
+    structured logging,
+  ]
 ---
 
 In today's API-driven world, understanding the behavior and performance of your APIs is crucial. Traditional monitoring methods often fall short in providing the deep insights needed to manage complex, distributed systems effectively. This is where API observability comes in. But what exactly is API observability, and how does it differ from conventional monitoring approaches?
@@ -18,7 +25,11 @@ API observability refers to the comprehensive ability to understand and analyze
 
 Unlike traditional monitoring, which focuses on predefined metrics and thresholds, API observability allows you to ask new questions about your system's behavior without deploying new code or instrumentation. It relies on four key pillars:
 
-<Figure src="/img/guides/2024/08/api-observability-Untitled.webp" alt="Key Components(Pillars) of API Observability" caption="Key Components(Pillars) of API Observability" />
+<Figure
+  src="/img/guides/2024/08/api-observability-Untitled.webp"
+  alt="Key Components(Pillars) of API Observability"
+  caption="Key Components(Pillars) of API Observability"
+/>
 
 1. Logs: Detailed records of events and actions within the system
 
@@ -87,7 +98,7 @@ Overall, API observability supports faster development, reliable operations, and
 
 ### Structured Logs
 
-Structured logging involves capturing logs in a predefined format or schema, often in JSON or key-value pairs. This structured format allows logs to be easily parsed and queried, rather than being free-form text. 
+Structured logging involves capturing logs in a predefined format or schema, often in JSON or key-value pairs. This structured format allows logs to be easily parsed and queried, rather than being free-form text.
 
 For example, instead of a log entry like "Error occurred in API", a structured log might look like this:
 
@@ -103,7 +114,7 @@ For example, instead of a log entry like "Error occurred in API", a structured l
 
 Why It Matters?
 
-Structured logs play a crucial role in observability by providing a clear and consistent format for tracking API requests, errors, and performance metrics. The following are the major benefits: 
+Structured logs play a crucial role in observability by providing a clear and consistent format for tracking API requests, errors, and performance metrics. The following are the major benefits:
 
 1. Consistency: Every log entry follows the same format, making it easier to aggregate and analyze logs from various sources.
 2. Searchability: Fields like `level`, `endpoint`, and `userId` can be used to filter and [search logs](https://signoz.io/docs/logs-management/logs-api/search-logs/) effectively.
@@ -127,8 +138,11 @@ Key metrics associated with API Health and Performance include:
 4. Latency: The time taken for a request to travel from the client to the server and back. Lower latency means faster communication.
 5. Uptime: The percentage of time the API is available and operational. High uptime is essential for reliability.
 
-<Figure src="/img/guides/2024/08/api-observability-Untitled%201.webp" alt="API Health and Performance Metrics" caption="API Health and Performance Metrics" />
-
+<Figure
+  src="/img/guides/2024/08/api-observability-Untitled%201.webp"
+  alt="API Health and Performance Metrics"
+  caption="API Health and Performance Metrics"
+/>
 
 To collect and analyze API metrics:
 
@@ -141,9 +155,13 @@ Metrics are essential for capacity planning and performance optimization. They h
 
 ### Distributed Tracing
 
-In a microservices architecture, a single API request might pass through multiple services before completion. Distributed tracing tags and tracks each step of the request, creating a trace that shows the entire journey from start to finish. 
+In a microservices architecture, a single API request might pass through multiple services before completion. Distributed tracing tags and tracks each step of the request, creating a trace that shows the entire journey from start to finish.
 
-<Figure src="/img/guides/2024/08/api-observability-image.webp" alt="Distributed Tracing" caption="Distributed Tracing" />
+<Figure
+  src="/img/guides/2024/08/api-observability-image.webp"
+  alt="Distributed Tracing"
+  caption="Distributed Tracing"
+/>
 
 This visibility is crucial for understanding how services interact, identifying bottlenecks, and diagnosing issues. For example, if a request takes too long, tracing can reveal which service caused the delay and why.
 
@@ -165,7 +183,7 @@ User analytics focuses on understanding how your APIs are being used. User behav
 - Error rates and types from the user perspective
 - API response times as experienced by users
 
-Analytics data can guide API design decisions by highlighting areas where users struggle or drop off. For example, if users frequently encounter errors at a specific endpoint, it may indicate a need for better documentation or a redesign of that part of the API. 
+Analytics data can guide API design decisions by highlighting areas where users struggle or drop off. For example, if users frequently encounter errors at a specific endpoint, it may indicate a need for better documentation or a redesign of that part of the API.
 
 To implement user analytics:
 
@@ -192,7 +210,11 @@ Here’s a list of popular API observability tools, both open-source and commerc
 - Overview: Grafana is a versatile data visualization tool that works with various data sources, including Prometheus. It allows you to create interactive and customizable dashboards for monitoring API performance metrics and logs.
 - Best For: Visualizing metrics, logs, and traces; creating interactive dashboards.
 
-<Figure src="/img/guides/2024/08/api-observability-image%201.webp" alt="Prometheus and Grafana working together" caption="Prometheus and Grafana working together" />
+<Figure
+  src="/img/guides/2024/08/api-observability-image%201.webp"
+  alt="Prometheus and Grafana working together"
+  caption="Prometheus and Grafana working together"
+/>
 
 3. OpenTelemetry
 
@@ -218,11 +240,15 @@ Here’s a list of popular API observability tools, both open-source and commerc
 - Overview: Elastic Observability, part of the ELK Stack (Elasticsearch, Logstash, Kibana), is a solution for monitoring, logging, and tracing. It provides powerful search and analysis capabilities for your API logs and metrics.
 - Best For: Log analysis, centralized monitoring, and custom observability setups.
 
-<Figure src="/img/guides/2024/08/api-observability-Untitled%202.webp" alt="API Observability tools: Summary" caption="API Observability tools: Summary" />
+<Figure
+  src="/img/guides/2024/08/api-observability-Untitled%202.webp"
+  alt="API Observability tools: Summary"
+  caption="API Observability tools: Summary"
+/>
 
 ## How to Implement API Observability
 
-Implementing API observability involves setting up a comprehensive system that collects, monitors, and analyzes various telemetry data (metrics, logs, and traces) to gain insights into the performance and health of your APIs. 
+Implementing API observability involves setting up a comprehensive system that collects, monitors, and analyzes various telemetry data (metrics, logs, and traces) to gain insights into the performance and health of your APIs.
 
 Implementing API observability requires a strategic approach:
 
@@ -240,7 +266,7 @@ Best practices for implementation include:
 - Automate data collection and analysis where possible
 - Regularly review and refine your observability strategy
 
-For a detailed guide: Read our documentation on [API Monitoring in SigNoz](https://signoz.io/docs/application-monitoring/api-monitoring/). 
+For a detailed guide: Read our documentation on [API Monitoring in SigNoz](https://signoz.io/docs/application-monitoring/api-monitoring/).
 
 Remember, observability is not just about tools—it's a cultural shift. Encourage a mindset of curiosity and continuous improvement across your development teams.
 
@@ -257,17 +283,17 @@ By continuously analyzing observability data, you can drive ongoing performance
 
 ## API Observability vs. API Monitoring: Understanding the Differences
 
-API observability and API monitoring are often used interchangeably, but they represent different approaches to understanding and maintaining the health of your APIs. While monitoring focuses on tracking predefined metrics and alerting on specific conditions, observability offers a broader, more comprehensive view, enabling you to understand the inner workings of your system and diagnose issues more effectively. 
+API observability and API monitoring are often used interchangeably, but they represent different approaches to understanding and maintaining the health of your APIs. While monitoring focuses on tracking predefined metrics and alerting on specific conditions, observability offers a broader, more comprehensive view, enabling you to understand the inner workings of your system and diagnose issues more effectively.
 
-Here are the key differences between the two: 
+Here are the key differences between the two:
 
-| Aspect | API Monitoring | API Observability |
-| --- | --- | --- |
-| Scope | Focused on predefined metrics and alerts | Holistic view including logs, metrics, and traces  |
-| Data Collection | Limited to specific performance metrics | Comprehensive, including contextual data |
-| Complexity | Relatively simple to implement - Provides a high-level view | More complex, requires advanced tools and expertise- Offers deep, granular insights |
-|  Problem Detection | Reactive: alerts on predefined conditions | Proactive: provides context to understand and resolve issues |
-| Use Cases  | Ensuring API is up and meeting SLAs	 | Troubleshooting complex issues, improving performance, and optimizing resources |
+| Aspect            | API Monitoring                                              | API Observability                                                                   |
+| ----------------- | ----------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| Scope             | Focused on predefined metrics and alerts                    | Holistic view including logs, metrics, and traces                                   |
+| Data Collection   | Limited to specific performance metrics                     | Comprehensive, including contextual data                                            |
+| Complexity        | Relatively simple to implement - Provides a high-level view | More complex, requires advanced tools and expertise- Offers deep, granular insights |
+| Problem Detection | Reactive: alerts on predefined conditions                   | Proactive: provides context to understand and resolve issues                        |
+| Use Cases         | Ensuring API is up and meeting SLAs                         | Troubleshooting complex issues, improving performance, and optimizing resources     |
 
 ### Example: Highlighting the difference between API Monitoring and API Observability using E-Commerce API
 
@@ -310,41 +336,53 @@ As APIs continue to play a central role in digital transformation, observability
 [SigNoz](https://signoz.io/) is an open-source observability platform designed to help you monitor and troubleshoot your APIs. It provides comprehensive tools for collecting and analyzing metrics, logs, and traces, making it easier to maintain the health and performance of your APIs. With its user-friendly interface and robust features, SigNoz enables you to gain deep insights into your application's behavior. It incorporates the key pillars of API observability:
 
 - Logs:
-    - Feature: SigNoz aggregates and manages logs from your API, providing a centralized view for log analysis.
-    - Benefit: Helps you search, filter, and troubleshoot issues by analyzing detailed log data. Logs provide context for understanding events and errors occurring within your API.4
-    
-    <Figure src="/img/guides/2024/08/api-observability-saved-view.gif" alt="Logs searching and filtering in SigNoz" caption="Logs searching and filtering in SigNoz" />
-    
+  - Feature: SigNoz aggregates and manages logs from your API, providing a centralized view for log analysis.
+  - Benefit: Helps you search, filter, and troubleshoot issues by analyzing detailed log data. Logs provide context for understanding events and errors occurring within your API.4
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/api-observability-saved-view.gif"
+    alt="Logs searching and filtering in SigNoz"
+    caption="Logs searching and filtering in SigNoz"
+  />
 - Metrics:
-    - Feature: SigNoz collects and visualizes performance metrics such as response times, error rates, and throughput.
-    - Benefit: Enables real-time monitoring of API performance, helping you track key indicators and detect anomalies or performance degradation.
-    
-    <Figure src="/img/guides/2024/08/api-observability-Untitled%203.webp" alt="Real-time monitoring of API performance using Metrics in SigNoz" caption="Real-time monitoring of API performance using Metrics in SigNoz" />
-    
+  - Feature: SigNoz collects and visualizes performance metrics such as response times, error rates, and throughput.
+  - Benefit: Enables real-time monitoring of API performance, helping you track key indicators and detect anomalies or performance degradation.
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/api-observability-Untitled%203.webp"
+    alt="Real-time monitoring of API performance using Metrics in SigNoz"
+    caption="Real-time monitoring of API performance using Metrics in SigNoz"
+  />
 - Traces:
-    - Feature: SigNoz supports [distributed tracing](https://signoz.io/distributed-tracing/), allowing you to track the flow of requests through different microservices.
-    - Benefit: Provides end-to-end visibility into request processing, helping you identify bottlenecks, latency issues, and the interactions between various components.
-    
-    <Figure src="/img/guides/2024/08/api-observability-b8b19d46-36e5-4807-90b7-c6c44a0f701f.webp" alt="End to end request tracing using SigNoz" caption="End to end request tracing using SigNoz" />
-    
+  - Feature: SigNoz supports [distributed tracing](https://signoz.io/distributed-tracing/), allowing you to track the flow of requests through different microservices.
+  - Benefit: Provides end-to-end visibility into request processing, helping you identify bottlenecks, latency issues, and the interactions between various components.
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/api-observability-b8b19d46-36e5-4807-90b7-c6c44a0f701f.webp"
+    alt="End to end request tracing using SigNoz"
+    caption="End to end request tracing using SigNoz"
+  />
 - User Analytics:
-    - Feature: SigNoz provides tools for tracking API usage patterns and user journeys.
-    - Benefit: Allows you to understand how users interact with your API, identify common usage patterns, and make data-driven decisions to improve API design and user experience.
-    
-    <Figure src="/img/guides/2024/08/api-observability-Untitled%204.webp" alt="SigNoz Dashboards for Analysis" caption="SigNoz Dashboards for Analysis" />
-    
+  - Feature: SigNoz provides tools for tracking API usage patterns and user journeys.
+  - Benefit: Allows you to understand how users interact with your API, identify common usage patterns, and make data-driven decisions to improve API design and user experience.
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/api-observability-Untitled%204.webp"
+    alt="SigNoz Dashboards for Analysis"
+    caption="SigNoz Dashboards for Analysis"
+  />
 
 To get started with SigNoz:
 
 1. Install SigNoz:
-    
-    <GetStartedSigNoz />
-    
+
+   <GetStartedSigNoz />
+
 2. Integrate OpenTelemetry:
-    - Instrument your API with OpenTelemetry libraries. Configure the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) to export data to SigNoz. Follow the OpenTelemetry documentation for integration details.
+   - Instrument your API with OpenTelemetry libraries. Configure the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) to export data to SigNoz. Follow the OpenTelemetry documentation for integration details.
 3. Configure Dashboards and Alerts:
-    - Create and customize dashboards in SigNoz to visualize logs, metrics, and traces.
-    - Set up alerts for key performance indicators to monitor and respond to issues effectively.
+   - Create and customize dashboards in SigNoz to visualize logs, metrics, and traces.
+   - Set up alerts for key performance indicators to monitor and respond to issues effectively.
 
 By following these steps, you’ll have SigNoz up and running to start monitoring and optimizing your API.
 
@@ -386,4 +424,4 @@ Yes, API observability can enhance API security by providing visibility into unu
 
 - [Distributed Tracing in Java application using SigNoz](https://signoz.io/blog/distributed-tracing-java/)
 - [API Monitoring in SigNoz](https://signoz.io/docs/application-monitoring/api-monitoring/)
-- [Implementing observability in microservices using SigNoz](https://signoz.io/blog/microservices-observability-with-distributed-tracing/)
\ No newline at end of file
+- [Implementing observability in microservices using SigNoz](https://signoz.io/blog/microservices-observability-with-distributed-tracing/)
diff --git a/data/guides/apm-metrics.mdx b/data/guides/apm-metrics.mdx
index b1405d453..bc9990b0c 100644
--- a/data/guides/apm-metrics.mdx
+++ b/data/guides/apm-metrics.mdx
@@ -1,11 +1,22 @@
 ---
-title: "APM Metrics: All You Need to Know"
-slug: "apm-metrics"
-date: "2025-09-02"
+title: 'APM Metrics: All You Need to Know'
+date: '2025-09-02'
 tags: [apm, monitoring]
-authors: ["yuvraj"]
-description: "Learn APM metrics in 2025: P50/P95/P99 latency, throughput, error rates, SLIs/SLOs, thresholds, dashboards, and OpenTelemetry setup—plus real examples."
-keywords: [APM metrics, application performance monitoring, APM tools, performance metrics, application monitoring, SigNoz, monitoring metrics, distributed tracing, microservices monitoring, OpenTelemetry]
+authors: ['yuvraj']
+description: 'Learn APM metrics in 2025: P50/P95/P99 latency, throughput, error rates, SLIs/SLOs, thresholds, dashboards, and OpenTelemetry setup—plus real examples.'
+keywords:
+  [
+    APM metrics,
+    application performance monitoring,
+    APM tools,
+    performance metrics,
+    application monitoring,
+    SigNoz,
+    monitoring metrics,
+    distributed tracing,
+    microservices monitoring,
+    OpenTelemetry,
+  ]
 ---
 
 ## What are APM Metrics?
@@ -17,14 +28,14 @@ When something goes wrong in this intricate web, **APM metrics become your diagn
 The difference between a minor hiccup and a costly outage often comes down to how quickly you can answer three fundamental questions:
 
 1. **Is my application working properly?** (Availability and error rates)
-2. **How fast is it responding?** (Performance and latency)  
+2. **How fast is it responding?** (Performance and latency)
 3. **What's the user experience like?** (User satisfaction metrics)
 
 **Analogy:**
 
-Think of your application like a patient in a hospital. Just as doctors rely on vital signs: heart rate, blood pressure, temperature to assess human health, Application Performance Monitoring (APM) uses metrics to assess application health. 
+Think of your application like a patient in a hospital. Just as doctors rely on vital signs: heart rate, blood pressure, temperature to assess human health, Application Performance Monitoring (APM) uses metrics to assess application health.
 
-But here's where the analogy gets interesting: while human vital signs are relatively straightforward to measure, modern applications are like complex organisms with thousands of interconnected systems. A single user request might travel through multiple services, databases, caches, and third-party APIs before returning a response. 
+But here's where the analogy gets interesting: while human vital signs are relatively straightforward to measure, modern applications are like complex organisms with thousands of interconnected systems. A single user request might travel through multiple services, databases, caches, and third-party APIs before returning a response.
 
 In this comprehensive guide, we'll explore 15+ essential APM metrics and when to use what metric to help you build robust application monitoring that prevents incidents before they impact users.
 
@@ -43,14 +54,16 @@ Response time measures the complete duration from when your application receives
 Most engineers instinctively reach for average response time as their primary metric. This intuition makes sense, after all, we use averages everywhere in daily life. However, averages can be dangerously misleading when it comes to user experience. Here's a real-world example that illustrates why:
 
 Your API endpoint serves 1,000 requests with these response times:
+
 - 900 requests: 50ms each
-- 80 requests: 100ms each  
+- 80 requests: 100ms each
 - 15 requests: 500ms each
 - 5 requests: 5,000ms each (database timeouts)
 
 **The calculations reveal the problem:**
+
 - Average: 115ms
-- P50 (Median): 50ms 
+- P50 (Median): 50ms
 - P95: 100ms
 - P99: 500ms
 
@@ -60,7 +73,8 @@ This is where percentiles become invaluable. **P95** tells you that 95% of your
 
 Explore how different response times impact performance metrics in real-time. Rapidly click the client below to send requests and watch how P50, P95, P99, and average metrics respond differently:
 
- <ResponseTimeVisualizer />
+{' '}
+<ResponseTimeVisualizer />
 
 #### Throughput: Measuring Your Application's Capacity
 
@@ -71,9 +85,10 @@ Throughput becomes particularly interesting when viewed alongside response time
 **Understanding the Relationship Between Throughput and Response Time:**
 
 Consider this progression during a traffic spike:
+
 ```
 Time 10:00: 1000 req/min, 200ms avg response
-Time 10:05: 800 req/min, 500ms avg response  
+Time 10:05: 800 req/min, 500ms avg response
 Time 10:10: 600 req/min, 1000ms avg response
 ```
 
@@ -81,7 +96,6 @@ Notice the inverse relationship? As response times increase, throughput actually
 
 This throughput degradation often indicates resource saturation. Your application might be waiting for database connections, struggling with high CPU usage, or hitting memory limits. The beauty of monitoring throughput alongside response time is that it helps you distinguish between genuine performance issues and simple load variations.
 
-
 #### Time to First Byte (TTFB): The Foundation of User Experience
 
 Time to First Byte represents the initial response your server provides to a client request. While it might seem like a technical detail, TTFB significantly impacts user perception because it determines how quickly browsers can begin rendering content.
@@ -89,13 +103,12 @@ Time to First Byte represents the initial response your server provides to a cli
 TTFB encompasses several sequential steps, each contributing to the total time:
 
 1. **DNS Resolution**: 20-120ms (varies by caching)
-2. **TCP Connection**: 50-200ms (depends on geographic distance)  
+2. **TCP Connection**: 50-200ms (depends on geographic distance)
 3. **SSL Handshake**: 100-300ms (HTTPS connections)
 4. **Server Processing**: 50-500ms+ (varies by complexity)
 
 Understanding these components helps you optimize systematically. For example, if your server processing time is excellent (50ms) but overall TTFB is poor (800ms), the issue likely lies in network or connection overhead rather than your application code.
 
-
 ### Reliability Metrics: Building Trust Through Consistency
 
 Performance metrics tell you how fast your application runs, but [reliability metrics](https://signoz.io/guides/reliability-metrics/) tell you whether it runs at all. These metrics directly impact user trust and business outcomes.
@@ -107,13 +120,13 @@ Error rates serve as your application's immune system indicator: they show how o
 Understanding different error categories helps you prioritize responses and identify root causes:
 
 **Error Categories:**
+
 - **HTTP 4xx errors**: Client-side issues (400 Bad Request, 404 Not Found)
-- **HTTP 5xx errors**: Server-side issues (500 Internal Server Error, 503 Service Unavailable)  
+- **HTTP 5xx errors**: Server-side issues (500 Internal Server Error, 503 Service Unavailable)
 - **Application-specific errors**: Business logic failures, validation errors
 
 The distinction matters because each category requires different response strategies. A spike in 404 errors might indicate broken links or changed URLs (potentially fixed with redirects), while 500 errors suggest server problems requiring immediate technical attention.
 
-
 #### Availability/Uptime: The Foundation of Service Reliability
 
 Availability measures the percentage of time your application is operational and accessible to users. While conceptually simple, availability measurement reveals interesting complexities that affect how you architect and monitor systems.
@@ -123,14 +136,14 @@ Availability measures the percentage of time your application is operational and
 This straightforward formula becomes nuanced when you consider what "downtime" means. Is it when your servers are down? When users can't log in? When critical features are broken but the site loads? Your definition of availability should align with user expectations and business requirements.
 
 **The "Nines" Explained:**
+
 - 99% availability = 87.6 hours downtime per year
-- 99.9% availability = 8.76 hours downtime per year  
+- 99.9% availability = 8.76 hours downtime per year
 - 99.99% availability = 52.6 minutes downtime per year
 - 99.999% availability = 5.26 minutes downtime per year
 
 Each additional "nine" represents roughly a 10x reduction in allowable downtime and often a significant increase in infrastructure costs and complexity. Most applications target 99.9% availability as the sweet spot between cost and reliability.
 
-
 ### User Experience Metrics: Connecting Technical Performance to Business Impact
 
 Technical metrics tell you what's happening in your systems, but user experience metrics tell you what's happening to your business. These metrics bridge the gap between technical performance and user satisfaction.
@@ -144,14 +157,16 @@ The beauty of Apdex lies in its recognition that users have different tolerance
 **Formula:** (Satisfied + (Tolerating × 0.5)) / Total Samples
 
 **Categories:**
+
 - **Satisfied**: Response time ≤ T (your defined threshold)
-- **Tolerating**: T < Response time ≤ 4T  
+- **Tolerating**: T < Response time ≤ 4T
 - **Frustrated**: Response time > 4T
 
 **Real Example:**
 E-commerce checkout with 1,000 transactions, threshold T = 2 seconds:
+
 - 700 transactions ≤ 2 seconds (Satisfied)
-- 200 transactions 2-8 seconds (Tolerating)  
+- 200 transactions 2-8 seconds (Tolerating)
 - 100 transactions > 8 seconds (Frustrated)
 
 Apdex = (700 + (200 × 0.5)) / 1000 = 0.8
@@ -160,8 +175,6 @@ This score (0.8) immediately tells you that 80% of your users had a good experie
 
 The critical decision in Apdex implementation is setting the threshold (T). This shouldn't be an arbitrary technical decision, it should be based on user behavior research and business requirements. For the checkout example, if user studies show 85% abandon after 4 seconds, setting T = 2 seconds ensures you maintain good satisfaction scores.
 
-
-
 #### Page Load Time Components: Understanding the Complete User Journey
 
 Page load time represents the complete user experience from clicking a link to seeing a fully interactive page. Breaking this down into components helps you identify specific optimization opportunities and understand where performance bottlenecks occur.
@@ -170,7 +183,7 @@ Understanding each component's contribution reveals where to focus optimization
 
 1. **DNS Lookup**: 20-120ms
 2. **TCP Connection**: 50-200ms
-3. **SSL Handshake**: 100-300ms  
+3. **SSL Handshake**: 100-300ms
 4. **Time to First Byte**: 200-500ms
 5. **Content Download**: 100-500ms
 6. **DOM Processing**: 50-200ms
@@ -179,6 +192,7 @@ Understanding each component's contribution reveals where to focus optimization
 Modern web performance focuses on specific milestones that correlate with user perception:
 
 **Core Web Vitals (2025 Standards):**
+
 - **Largest Contentful Paint (LCP)**: < 2.5 seconds
 - **Interaction to Next Paint (INP)**: < 200ms (replaced FID in 2024)
 - **Cumulative Layout Shift (CLS)**: < 0.1
@@ -196,15 +210,17 @@ Resource utilization metrics reveal whether your infrastructure can adequately s
 
 **CPU Usage Patterns:**
 CPU utilization follows predictable patterns that help you identify normal vs. problematic behavior:
+
 - **< 70%**: Healthy utilization with room for spikes
 - **70-80%**: Monitor closely, consider scaling
-- **80-90%**: High utilization, scaling recommended  
+- **80-90%**: High utilization, scaling recommended
 - **> 90%**: Critical, immediate attention required
 
 However, sustained high CPU usage affects more than just response times. It creates a cascade effect: garbage collection increases in managed languages, context switching overhead grows, and system responsiveness degrades even for simple operations.
 
 **Memory Consumption Insights:**
 Memory monitoring requires understanding both current usage and trends over time:
+
 - Track heap vs non-heap usage in managed languages
 - Monitor for memory leaks (gradual increase over time)
 - Set alerts for sustained usage > 85%
@@ -215,13 +231,15 @@ Memory leaks particularly insidious because they appear gradually. A small leak
 Modern applications depend heavily on I/O performance:
 
 **Disk I/O Metrics:**
+
 - **IOPS**: Input/output operations per second
 - **Throughput**: MB/s read/write rates
 - **Queue depth**: Pending I/O operations
 
 **Network I/O:**
+
 - Bandwidth utilization
-- Packet loss rates  
+- Packet loss rates
 - Connection counts and limits
 
 **Container-Specific Considerations:**
@@ -246,6 +264,7 @@ The relationship between these metrics tells important stories. A query that exa
 
 **Connection Management:**
 Database connection pooling affects both performance and resource utilization:
+
 - **Pool utilization**: Available vs. used connections
 - **Connection wait time**: How long requests wait for available connections
 - **Connection lifetime**: Average connection duration
@@ -256,11 +275,13 @@ Connection pool exhaustion often manifests as sudden response time spikes rather
 Database locking and caching significantly impact concurrent request handling:
 
 **Lock Analysis:**
+
 - **Lock contention**: Blocking and deadlock frequency
 - **Lock wait time**: Duration requests wait for locks
 - **Lock escalation**: Row locks escalating to table locks
 
 **Cache Performance:**
+
 - **Hit ratio**: Percentage of requests served from cache
 - **Cache efficiency**: Memory usage vs. performance gains
 - **Cache eviction rate**: How frequently cache entries are removed
@@ -294,7 +315,6 @@ Managing data consistency across multiple services requires monitoring transacti
 - **Compensation event frequency**: Rollback operations in saga patterns
 - **Cross-service correlation**: Tracking requests across service boundaries
 
-
 ## Scenario-Specific Metric Frameworks
 
 Different application architectures benefit from focused monitoring approaches. Rather than trying to monitor everything, these frameworks help you select the most impactful metrics for your specific situation.
@@ -318,13 +338,13 @@ Error tracking should include both obvious failures (HTTP 500 errors) and subtle
 Saturation indicates how close your system is to hitting capacity limits.
 
 **When to use Golden Signals:**
+
 - Large-scale web applications
 - Microservices architectures
 - Systems with high request volumes
 - Applications requiring comprehensive health overview
 
-
-### RED Method for Request-Driven Applications  
+### RED Method for Request-Driven Applications
 
 The RED method focuses specifically on request-centric metrics, making it ideal for applications where user requests drive all important business functionality.
 
@@ -335,29 +355,29 @@ The RED method focuses specifically on request-centric metrics, making it ideal
 RED works particularly well because it aligns with how users experience your application. Users care about whether their requests succeed (Errors), how long requests take (Duration), and whether your system can handle their traffic levels (Rate).
 
 **When to use RED Method:**
+
 - RESTful APIs and web services
-- Request-response pattern applications  
+- Request-response pattern applications
 - Service-oriented architectures
 - Applications where user-facing requests are primary concern
 
-
 ### USE Method for Infrastructure Focus
 
 The USE method provides systematic resource analysis, making it invaluable for infrastructure bottleneck identification and capacity planning.
 
-**Utilization**: Percentage of time resource is busy  <br />
-**Saturation**: Amount of work resource cannot service (queued)    <br />
+**Utilization**: Percentage of time resource is busy <br />
+**Saturation**: Amount of work resource cannot service (queued) <br />
 **Errors**: Error events occurring at the resource level
 
 USE excels at helping you systematically examine every resource in your system. By checking utilization, saturation, and errors for each resource, you can methodically identify bottlenecks.
 
 **When to use USE Method:**
+
 - Infrastructure bottleneck identification
-- Capacity planning activities 
+- Capacity planning activities
 - Performance optimization efforts
 - Resource-constrained environments
 
-
 ## SLIs, SLOs, and Error Budgets in Practice
 
 Service Level Indicators (SLIs), Service Level Objectives (SLOs), and error budgets represent the evolution from reactive monitoring to proactive reliability management. They transform APM metrics from technical measurements into business-aligned reliability targets.
@@ -368,6 +388,7 @@ SLIs bridge the gap between technical metrics and user experience by measuring s
 
 **Good SLI Characteristics:**
 Effective SLIs share several important qualities:
+
 - **User-centric**: Reflects actual user experience, not internal technical details
 - **Measurable**: Can be reliably collected and calculated from your systems
 - **Attributable**: Can be tied to specific service components for debugging
@@ -376,13 +397,15 @@ Effective SLIs share several important qualities:
 **Common SLI Types:**
 
 **Request/Response SLIs:**
+
 ```
 Availability = (Successful requests / Total requests) × 100
-Latency = (Requests completed within 200ms / Total requests) × 100  
+Latency = (Requests completed within 200ms / Total requests) × 100
 Quality = (Requests producing correct output / Total requests) × 100
 ```
 
 **Data Processing SLIs:**
+
 - **Freshness**: How up-to-date processed data is
 - **Coverage**: Proportion of data successfully processed
 - **Correctness**: Proportion of data processed without errors
@@ -395,18 +418,21 @@ SLOs combine SLIs with target values and time windows to create concrete reliabi
 
 **SLO Components:**
 Every well-formed SLO includes four essential elements:
+
 1. **SLI**: What you're measuring
 2. **Target**: The threshold for acceptable performance
-3. **Time Window**: Period over which target applies  
+3. **Time Window**: Period over which target applies
 4. **Consequences**: Actions when SLO is missed
 
 **Example SLOs:**
+
 - "99.9% of requests will complete successfully over a rolling 30-day window"
-- "95% of API requests will complete within 200ms over a rolling 7-day window"  
+- "95% of API requests will complete within 200ms over a rolling 7-day window"
 - "99.5% of data processing jobs will complete without errors monthly"
 
 **SLO Setting Best Practices:**
 Setting effective SLOs requires balancing user expectations, technical capabilities, and business requirements:
+
 - **Start conservative**: Begin with achievable targets based on current performance
 - **Align with business needs**: Balance reliability requirements with development velocity
 - **Use error budgets**: Track remaining failure allowance to guide decisions
@@ -417,6 +443,7 @@ Setting effective SLOs requires balancing user expectations, technical capabilit
 Error budgets quantify acceptable failure levels, enabling teams to make data-driven decisions about the trade-off between reliability and feature development velocity.
 
 **Error Budget Calculation:**
+
 ```
 Error Budget = (100% - SLO Target) × Time Window
 Example: (100% - 99.9%) × 30 days = 0.1% × 30 days = 43.2 minutes downtime allowed
@@ -426,13 +453,13 @@ This calculation makes the abstract concept of "99.9% reliability" concrete: you
 
 **Error Budget Policy Framework:**
 Error budget policies provide clear guidance for decision-making:
+
 - **Budget remaining > 50%**: Normal development pace, feature releases approved
 - **Budget remaining 10-50%**: Increased caution, additional testing required
-- **Budget remaining < 10%**: Focus on reliability, halt risky deployments  
+- **Budget remaining < 10%**: Focus on reliability, halt risky deployments
 - **Budget exhausted**: Incident response mode, only critical fixes allowed
 
-
-## Quick Start with SigNoz: Out of the box APM Implementation  
+## Quick Start with SigNoz: Out of the box APM Implementation
 
 [SigNoz](https://signoz.io/docs/introduction/) offers an excellent starting point for implementing comprehensive APM without the complexity and cost concerns of enterprise solutions.
 
@@ -463,7 +490,11 @@ To instrument your application with OpenTelemetry and send data to SigNoz, follo
 
 **3. View your data**: Within minutes, you'll see service maps, performance metrics, and [distributed traces](https://signoz.io/blog/distributed-tracing/) in the SigNoz dashboard.
 
-<Figure src="/img/blog/2025/06/opentelemetry-nextjs-image%202.webp" alt="SigNoz out of the box APM" caption="SigNoz out of the box APM" />
+<Figure
+  src="/img/blog/2025/06/opentelemetry-nextjs-image%202.webp"
+  alt="SigNoz out of the box APM"
+  caption="SigNoz out of the box APM"
+/>
 
 ## Get Started with SigNoz
 
@@ -482,27 +513,33 @@ Here is a quick reference to the APM metrics we covered in this guide:
 ### APM Metrics Quick Reference
 
 #### Performance Metrics
+
 - [Response Time/Latency](#response-timelatency-beyond-simple-averages) - P50, P95, P99 percentiles
 - [Throughput](#throughput-measuring-your-applications-capacity) - Requests per second/minute
 - [Time to First Byte (TTFB)](#time-to-first-byte-ttfb-the-foundation-of-user-experience) - Initial server response time
 
 #### Reliability Metrics
+
 - [Error Rates](#error-rates-your-applications-health-indicator) - Failed request percentages
 - [Availability/Uptime](#availabilityuptime-the-foundation-of-service-reliability) - Service operational time
 
 #### User Experience Metrics
+
 - [Apdex Score](#apdex-score-quantifying-user-satisfaction) - User satisfaction index
 - [Page Load Time](#page-load-time-components-understanding-the-complete-user-journey) - Core Web Vitals (LCP, INP, CLS)
 
 #### Infrastructure Metrics
+
 - [Resource Utilization](#resource-utilization-reading-your-systems-vital-signs) - CPU, memory, disk, network usage
 
 #### Database Performance Metrics
+
 - [Query Performance](#database-performance-metrics-the-hidden-performance-killer) - Slow queries, execution frequency
 - Connection Pool Health - Pool utilization and wait times
 - Cache Hit Ratios - Database and application cache performance
 
 #### Microservices Metrics
+
 - [Service Dependencies](#microservices-specific-metrics-navigating-distributed-complexity) - Circuit breaker status, retry patterns
 - Inter-Service Communication - Service-to-service latency
 - Distributed Transactions - Cross-service transaction success rates
@@ -515,4 +552,4 @@ Your applications' reliability and your users' trust depends on the insights tha
 
 Hope we answered all your questions regarding APM metrics. If you have more questions, feel free to use the SigNoz AI chatbot, or join our [slack community](https://signoz.io/slack/).
 
-You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
\ No newline at end of file
+You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
diff --git a/data/guides/apm-vs-observability.mdx b/data/guides/apm-vs-observability.mdx
index 31a15b70c..c079f910a 100644
--- a/data/guides/apm-vs-observability.mdx
+++ b/data/guides/apm-vs-observability.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: APM vs Observability - Key Differences for Modern Monitoring
-slug: apm-vs-observability
 date: 2024-08-23
 tags: [apm, observability]
 authors: [vivek_goswami]
 description: Discover the key differences between APM and Observability in modern monitoring. Learn how these approaches complement each other for comprehensive system insights.
-keywords: [APM, Observability, Monitoring, DevOps, SRE, Performance, Microservices, Distributed Systems]
-
+keywords:
+  [APM, Observability, Monitoring, DevOps, SRE, Performance, Microservices, Distributed Systems]
 ---
 
 Effective system management is crucial in today's complex IT landscape. Understanding the nuances between Application Performance Monitoring (APM) and Observability is significant to the efficiency of system management. The increase of distributed architectures in organizations requires comprehensive monitoring solutions. In this article, various aspects of APM and Observability have been discussed and their respective differences have been mentioned exploring their unique strengths and how they complement each other.
@@ -22,7 +20,11 @@ APM involves several key components:
 2. Traces: Traces track the flow of individual requests through the system, providing detailed insights into the interactions between different components, which helps in identifying bottlenecks or errors.
 3. Alerts: Alerts are notifications triggered when specific thresholds are exceeded, enabling rapid response to potential issues before they impact users.
 
-<Figure src="/img/guides/2024/08/apm-vs-observability-image.webp" alt="image.webp" caption="APM Components" />
+<Figure
+  src="/img/guides/2024/08/apm-vs-observability-image.webp"
+  alt="image.webp"
+  caption="APM Components"
+/>
 
 APM was initially developed to monitor monolithic applications, which were self-contained and ran on a single server or a small number of servers. Traditional APM tools were designed with the following specifications: collecting data on application performance in a centralized system and ensuring stability and performance within a limited server environment.
 
@@ -82,17 +84,17 @@ Application Performance Monitoring (APM) and observability are important in mana
 Here’s a comparison to highlight their key differences:
 
 1. Scope:
-    - APM: Focuses on the performance and health of specific applications.
-    - Observability: Provides a system-wide view, encompassing the entire infrastructure and its interactions.
+   - APM: Focuses on the performance and health of specific applications.
+   - Observability: Provides a system-wide view, encompassing the entire infrastructure and its interactions.
 2. Data Handling:
-    - APM: Uses predefined metrics such as response times, error rates, and throughput.
-    - Observability: Emphasizes raw data collection, including logs, traces, and metrics, for a more comprehensive understanding.
+   - APM: Uses predefined metrics such as response times, error rates, and throughput.
+   - Observability: Emphasizes raw data collection, including logs, traces, and metrics, for a more comprehensive understanding.
 3. Problem-Solving:
-    - APM: Effective at detecting known issues, such as performance bottlenecks and application errors.
-    - Observability: Aims to uncover unknown issues by analyzing data patterns and anomalies, offering deeper insights into system performance.
+   - APM: Effective at detecting known issues, such as performance bottlenecks and application errors.
+   - Observability: Aims to uncover unknown issues by analyzing data patterns and anomalies, offering deeper insights into system performance.
 4. Scalability:
-    - APM: May encounter challenges with the complexities of microservices and distributed systems.
-    - Observability: Designed to handle scalable, distributed environments, providing visibility into interactions across various components and services.
+   - APM: May encounter challenges with the complexities of microservices and distributed systems.
+   - Observability: Designed to handle scalable, distributed environments, providing visibility into interactions across various components and services.
 
 The need for monitoring and analyzing system performance is the basis for choosing between APM and observability. APM is proficient in managing known performance issues within applications, while observability provides a broader view, helping to discover and troubleshoot complex, unknown issues in distributed systems.
 
diff --git a/data/guides/application-dependency-map.mdx b/data/guides/application-dependency-map.mdx
index 773031249..52ff34988 100644
--- a/data/guides/application-dependency-map.mdx
+++ b/data/guides/application-dependency-map.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: What is Application Dependency Mapping - A Complete Guide
-slug: application-dependency-map
 date: 2024-11-20
 tags: [monitoring, faq]
 authors: [sushant_gaurav]
 description: Learn how application dependency mapping helps visualize relationships between applications, services, and infrastructure components for better system management and troubleshooting.
-keywords: [application dependency map, dependency mapping, application monitoring, service dependencies, infrastructure mapping, system topology, distributed tracing, application observability]
-
+keywords:
+  [
+    application dependency map,
+    dependency mapping,
+    application monitoring,
+    service dependencies,
+    infrastructure mapping,
+    system topology,
+    distributed tracing,
+    application observability,
+  ]
 ---
 
 Application Dependency Mapping (ADM) is a process that enables a user to create a detailed visual representation of how various components in an individual’s IT infrastructure interact and connect. It outlines the relationships between applications, services, databases, and other infrastructure elements. Consider it a GPS for your application architecture - it enables you to navigate complex systems and understand the minute effects of changes in one component on the others.
@@ -134,7 +141,7 @@ ADM is more than simply a visualization tool; it is a realistic framework for ad
 
 ### Faster Problem Resolution
 
-ADM enables IT teams to identify the cause of problems and their possible consequences. 
+ADM enables IT teams to identify the cause of problems and their possible consequences.
 
 Example: Assume a service interruption happens in an online booking system. Visualizing dependencies allows you to rapidly identify the source of the problem, such as a misconfigured database or a sluggish API.
 
@@ -183,21 +190,21 @@ Application Dependency Mapping (ADM) takes a systematic method that begins with
 ### Discovery Methods
 
 - Agent-based Discovery: This strategy involves installing specialized agents on servers or services to get precise information about dependencies.
-    - Advantages:
-        - Very accurate and thorough data.
-        - Details about runtime settings, resource use, and direct service calls.
-    - Challenges:
-        - Requires software installation and maintenance.
-        - This may influence system performance in high-load scenarios.
-    - Example Use Case: A financial services company uses agent-based tools like Dynatrace to monitor its microservices dependencies and detect anomalies in real-time
+  - Advantages:
+    - Very accurate and thorough data.
+    - Details about runtime settings, resource use, and direct service calls.
+  - Challenges:
+    - Requires software installation and maintenance.
+    - This may influence system performance in high-load scenarios.
+  - Example Use Case: A financial services company uses agent-based tools like Dynatrace to monitor its microservices dependencies and detect anomalies in real-time
 - Agentless Discovery: This method analyzes network traffic and logs to infer dependencies without installing additional software.
-    - Advantages:
-        - Non-intrusive and easy to implement.
-        - Ideal for environments with strict security policies.
-    - Challenges:
-        - Deeper runtime dependencies refer to the intricate relationships and interactions within the application that occur during its execution. For example, agentless methods might fail to capture how specific functions, libraries, or frameworks interact under certain conditions, such as database query optimizations, dynamic API calls, or runtime-generated code paths. This lack of detail can lead to gaps in understanding performance bottlenecks or diagnosing critical issues.
-        - Agentless discovery primarily relies on external observations like network traffic and log analysis, which provide surface-level insights. It cannot directly inspect the inner workings of the application, such as thread-level operations, resource allocation patterns, or application-specific logic flow, which are critical for comprehensive dependency mapping in complex systems.
-    - Example Use Case: A company preparing for a cloud migration uses AWS Application Discovery Service to identify its network-level dependencies without disturbing its current environment.
+  - Advantages:
+    - Non-intrusive and easy to implement.
+    - Ideal for environments with strict security policies.
+  - Challenges:
+    - Deeper runtime dependencies refer to the intricate relationships and interactions within the application that occur during its execution. For example, agentless methods might fail to capture how specific functions, libraries, or frameworks interact under certain conditions, such as database query optimizations, dynamic API calls, or runtime-generated code paths. This lack of detail can lead to gaps in understanding performance bottlenecks or diagnosing critical issues.
+    - Agentless discovery primarily relies on external observations like network traffic and log analysis, which provide surface-level insights. It cannot directly inspect the inner workings of the application, such as thread-level operations, resource allocation patterns, or application-specific logic flow, which are critical for comprehensive dependency mapping in complex systems.
+  - Example Use Case: A company preparing for a cloud migration uses AWS Application Discovery Service to identify its network-level dependencies without disturbing its current environment.
 
 ### Data Collection Process
 
@@ -315,24 +322,20 @@ Once SigNoz is set up, the next step is instrumenting your applications using Op
 
 - Adding Instrumentation: Inject [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) libraries into your application to capture trace data.
 - Example: Instrumenting a Python application:
-    
-    ```bash
-    opentelemetry-bootstrap -a install
-    opentelemetry-instrument \\
-        --traces_exporter otlp \\
-        --service_name=my-service \\
-        python app.py
-    ```
-    
+  ```bash
+  opentelemetry-bootstrap -a install
+  opentelemetry-instrument \\
+      --traces_exporter otlp \\
+      --service_name=my-service \\
+      python app.py
+  ```
 - Set Sampling Rates: Configure how much trace data to sample to balance performance with observability.
-    - Example configuration snippet for a tracing YAML:
-        
-        ```yaml
-        otel:
-          sampling:
-            rate: 0.5  # Sample 50% of traces
-        ```
-        
+  - Example configuration snippet for a tracing YAML:
+    ```yaml
+    otel:
+      sampling:
+        rate: 0.5 # Sample 50% of traces
+    ```
 - Define Service Names: Ensure each service in your system has a unique, descriptive name to improve map readability.
 
 ### 3. View Dependencies
@@ -388,4 +391,4 @@ Challenges:
 1. Rapidly changing dependencies in modern systems.Solution: Implement continuous monitoring and automated discovery tools.
 2. Lack of native support in legacy systems.Solution: Use a combination of manual mapping and modern ADM tools.
 3. Maintaining accuracy for effective troubleshooting.Solution: Schedule regular updates and automate data collection processes.
-4. Potential performance overhead from monitoring.Solution: Optimize sample rates and focus on critical pathways to minimize impact.
\ No newline at end of file
+4. Potential performance overhead from monitoring.Solution: Optimize sample rates and focus on critical pathways to minimize impact.
diff --git a/data/guides/average-memory-usage-query-prometheus.mdx b/data/guides/average-memory-usage-query-prometheus.mdx
index 09aaa7c81..b5c696db2 100644
--- a/data/guides/average-memory-usage-query-prometheus.mdx
+++ b/data/guides/average-memory-usage-query-prometheus.mdx
@@ -1,20 +1,25 @@
 ---
-
 title: How to Calculate Average Memory Usage in Prometheus
-slug: average-memory-usage-query-prometheus
 date: 2024-10-14
 tags: [Prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to calculate average memory usage in Prometheus using PromQL. Discover advanced queries, visualization techniques, and best practices for effective memory monitoring.
-keywords: [Average Memory Usage Query Prometheus, PromQL, Memory Monitoring, Grafana, SigNoz, System Performance]
-
+keywords:
+  [
+    Average Memory Usage Query Prometheus,
+    PromQL,
+    Memory Monitoring,
+    Grafana,
+    SigNoz,
+    System Performance,
+  ]
 ---
 
 Monitoring memory usage is crucial for maintaining healthy systems and optimizing application performance. Prometheus, a popular open-source monitoring system, offers powerful tools for tracking and analyzing memory metrics. This guide will show you how to calculate average memory usage in Prometheus, helping you gain valuable insights into your system's performance.
 
 ## Understanding Memory Usage Metrics in Prometheus
 
-Before diving into calculations, it's essential to understand the key memory metrics Prometheus collects. 
+Before diving into calculations, it's essential to understand the key memory metrics Prometheus collects.
 
 Memory usage refers to the amount of RAM (Random Access Memory) currently utilized by your system. It's a crucial indicator of system health; high memory usage can lead to performance degradation or even system crashes if left unmonitored.
 
@@ -26,40 +31,39 @@ Prometheus collects various system metrics related to memory usage. Key metrics
 - `node_memory_Buffers_bytes`: Memory used by kernel buffers
 - `node_memory_Cached_bytes`: Memory used by the page cache and slabs
 
-Note: Memory usage differs from memory availability. Usage refers to the amount of memory currently in use, while availability indicates the memory that can be allocated to processes without swapping. 
+Note: Memory usage differs from memory availability. Usage refers to the amount of memory currently in use, while availability indicates the memory that can be allocated to processes without swapping.
 
 ## Common Memory Usage Queries in Prometheus
 
 To get started with memory usage analysis, here are some basic Prometheus queries:
 
 1. Basic Query for Total Memory Usage
-    
-    To calculate the total memory used as a percentage of total memory:
-    
-    ```arduino
-    (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) 
-    ```
-    
+
+   To calculate the total memory used as a percentage of total memory:
+
+   ```arduino
+   (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes)
+   ```
+
 2. Query for Percentage of Memory Used
-    
-    To get the percentage of memory in use:
-    
-    ```arduino
-    (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100
-    ```
-    
+
+   To get the percentage of memory in use:
+
+   ```arduino
+   (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100
+   ```
+
 3. Query for Memory Usage Over Time
-    
-    The `rate()` function can be used with a memory-related metric that has a counter-like behavior. For example, if you're tracking memory usage via a process or container metric that increases over time, you can use:
-    
-    Example Query for Memory Usage Increase Over Time:
-    
-    ```arduino
-    rate(container_memory_usage_bytes[5m])
-    ```
-    
-    Note: The above works for containers and not Linux-based servers.
-    
+
+   The `rate()` function can be used with a memory-related metric that has a counter-like behavior. For example, if you're tracking memory usage via a process or container metric that increases over time, you can use:
+
+   Example Query for Memory Usage Increase Over Time:
+
+   ```arduino
+   rate(container_memory_usage_bytes[5m])
+   ```
+
+   Note: The above works for containers and not Linux-based servers.
 
 <aside>
 💡
@@ -75,23 +79,22 @@ Tip: Choosing the appropriate time range is critical for accurate memory usage c
 Here's a step-by-step guide to constructing an average memory usage query:
 
 1. Calculate the used memory:
-    
-    ```
-    node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes
-    ```
-    
+
+   ```
+   node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes
+   ```
+
 2. Calculate the average over time:
-    
-    ```
-    avg_over_time(node_memory_MemTotal_bytes[1h]) - avg_over_time(node_memory_MemAvailable_bytes[1h])
-    ```
-    
+
+   ```
+   avg_over_time(node_memory_MemTotal_bytes[1h]) - avg_over_time(node_memory_MemAvailable_bytes[1h])
+   ```
+
 3. Calculate the average across multiple instances:
-    
-    ```
-    avg(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance)
-    ```
-    
+
+   ```
+   avg(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance)
+   ```
 
 This query calculates the average memory usage across all monitored nodes over the past hour. Adjust the time range `[1h]` as needed for your specific use case.
 
@@ -100,31 +103,34 @@ This query calculates the average memory usage across all monitored nodes over t
 For more complex scenarios, you can use advanced PromQL features:
 
 1. Calculate memory usage across multiple nodes:
-    
-    ```
-    sum(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance)
-    ```
-    
-    `sum()` with `by (instance)` gives total memory usage per instance. If you want the average memory usage across instances, you could do:
-    
-    ```
-    avg(sum(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance))
-    ```
-    
+
+   ```
+   sum(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance)
+   ```
+
+   `sum()` with `by (instance)` gives total memory usage per instance. If you want the average memory usage across instances, you could do:
+
+   ```
+   avg(sum(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance))
+   ```
+
 2. Use label selectors to filter data:
-    
-    To filter memory usage by a specific label (e.g., job):
-    
-    ```
-    avg(node_memory_MemTotal_bytes{job="webserver"} - node_memory_MemAvailable_bytes{job="webserver"})
-    ```
-    
+
+   To filter memory usage by a specific label (e.g., job):
+
+   ```
+   avg(node_memory_MemTotal_bytes{job="webserver"} - node_memory_MemAvailable_bytes{job="webserver"})
+   ```
 
 ### Memory Usage on Different Operating Systems
 
-Based on different operating systems, different metrics are used for monitoring memory usage: 
+Based on different operating systems, different metrics are used for monitoring memory usage:
 
-<Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-1d586591-adb8-4062-9bcd-89bb2faa382d.webp" alt="Memory Usage on Different Operating Systems" caption="Memory Usage on Different Operating Systems" />
+<Figure
+  src="/img/guides/2024/10/average-memory-usage-query-prometheus-1d586591-adb8-4062-9bcd-89bb2faa382d.webp"
+  alt="Memory Usage on Different Operating Systems"
+  caption="Memory Usage on Different Operating Systems"
+/>
 
 ### Linux-Based Systems
 
@@ -176,30 +182,50 @@ Grafana is a popular visualization tool that enables users to create dynamic and
 To effectively visualize average memory usage in Grafana, follow these steps:
 
 1. Add a new panel to your Grafana dashboard.
-    - Visit the `Dashboards` section and click on the `New` button.
-        
-        <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image.webp" alt="Creating new dashboards" caption="Creating new dashboards" />
-        
-    - Add `New Dashboard` and click the `Add visualization` button.
-        
-        <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%201.webp" alt="Adding visualization" caption="Adding visualization" />
-        
-    - Select the Prometheus as your data source
-        
-        <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%202.webp" alt="Selecting the datasource" caption="Selecting the datasource" />
-        
+   - Visit the `Dashboards` section and click on the `New` button.
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/average-memory-usage-query-prometheus-image.webp"
+       alt="Creating new dashboards"
+       caption="Creating new dashboards"
+     />
+   - Add `New Dashboard` and click the `Add visualization` button.
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%201.webp"
+       alt="Adding visualization"
+       caption="Adding visualization"
+     />
+   - Select the Prometheus as your data source
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%202.webp"
+       alt="Selecting the datasource"
+       caption="Selecting the datasource"
+     />
 2. In the query editor, enter your PromQL query for average memory usage.
-    
-    <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%203.webp" alt="PromQL query for average memory usage" caption="PromQL query for average memory usage" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%203.webp"
+     alt="PromQL query for average memory usage"
+     caption="PromQL query for average memory usage"
+   />
+
 3. Choose an appropriate visualization type (e.g., graph or gauge).
-    
-    <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%204.webp" alt="Choose an appropriate visualization type" caption="Choose an appropriate visualization type" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%204.webp"
+     alt="Choose an appropriate visualization type"
+     caption="Choose an appropriate visualization type"
+   />
+
 4. You should be able to visualize the average memory usage in your dashboard panel.
-    
-    <Figure src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%205.webp" alt="Dashboard panel for Average memory usage in Grafana" caption="Dashboard panel for Average memory usage in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/average-memory-usage-query-prometheus-image%205.webp"
+     alt="Dashboard panel for Average memory usage in Grafana"
+     caption="Dashboard panel for Average memory usage in Grafana"
+   />
 
 Adding Alerts for Critical Memory Usage
 
@@ -219,7 +245,7 @@ While Prometheus and Grafana offer robust monitoring capabilities, SigNoz provid
 
 <GetStartedSigNoz />
 
-Memory Usage Monitoring in SigNoz VS Prometheus 
+Memory Usage Monitoring in SigNoz VS Prometheus
 
 - Ease of Setup: [SigNoz](https://signoz.io/docs/introduction/) offers out-of-the-box dashboards, while Prometheus requires manual setup and Grafana integration.
 - Metrics Storage: SigNoz uses scalable backends (e.g., ClickHouse), whereas Prometheus relies on local storage with potential scaling issues.
@@ -274,4 +300,4 @@ To set up alerts for critical memory usage:
 3. Set the duration for which the condition must be true before alerting.
 4. Configure notification routes in Alertmanager to send alerts via email, Slack, or other channels.
 
-Remember to test your alerts thoroughly to ensure they trigger appropriately and don't cause [alert fatigue](https://signoz.io/blog/alert-fatigue/). You can also make use of Grafana alerts.
\ No newline at end of file
+Remember to test your alerts thoroughly to ensure they trigger appropriately and don't cause [alert fatigue](https://signoz.io/blog/alert-fatigue/). You can also make use of Grafana alerts.
diff --git a/data/guides/aws-lambda-monitoring.mdx b/data/guides/aws-lambda-monitoring.mdx
index 7289f52b2..acff4c867 100644
--- a/data/guides/aws-lambda-monitoring.mdx
+++ b/data/guides/aws-lambda-monitoring.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Essential Guide to AWS Lambda Monitoring - Best Practices
-slug: aws-lambda-monitoring
 date: 2024-10-14
 tags: [aws, monitoring, aws lambda]
 authors: [sushant_gaurav]
 description: Master AWS Lambda monitoring with this comprehensive guide. Learn key metrics, best practices, and tools to optimize performance and costs.
-keywords: [AWS Lambda, serverless monitoring, CloudWatch, performance optimization, cost management, SigNoz]
-
+keywords:
+  [AWS Lambda, serverless monitoring, CloudWatch, performance optimization, cost management, SigNoz]
 ---
 
 AWS Lambda has transformed how developers build and deploy apps by providing a serverless computing platform that automatically maintains infrastructure. However, with great power comes great responsibility—specifically, the requirement for effective supervision. AWS Lambda monitoring is important as it guarantees peak performance, cost management, and serverless application uptime. In this article, you learn AWS lambda monitoring in detail.
@@ -37,72 +35,60 @@ If you want to effectively monitor Lambda functions you should consider several
 ### Invocation Count and Duration
 
 - Invocation count: This indicates how frequently your function is called. High invocation counts may indicate increased demand, necessitating the scalability of downstream services or changing concurrency constraints.
-    
-    Example CloudWatch Insight query for invocation count:
-    
-    ```python
-    stats = client.get_metric_statistics(
-        Namespace='AWS/Lambda',
-        MetricName='Invocations',
-        Dimensions=[{'Name': 'FunctionName', 'Value': 'my-function'}],
-        StartTime=datetime.utcnow() - timedelta(hours=1),
-        EndTime=datetime.utcnow(),
-        Period=60,
-        Statistics=['Sum']
-    )
-    
-    ```
-    
+  Example CloudWatch Insight query for invocation count:
+  ```python
+  stats = client.get_metric_statistics(
+      Namespace='AWS/Lambda',
+      MetricName='Invocations',
+      Dimensions=[{'Name': 'FunctionName', 'Value': 'my-function'}],
+      StartTime=datetime.utcnow() - timedelta(hours=1),
+      EndTime=datetime.utcnow(),
+      Period=60,
+      Statistics=['Sum']
+  )
+
+  ```
 - Duration: It shows how long your function takes to execute. Monitoring duration helps identify performance bottlenecks and ensures you’re not paying for inefficient executions.
-    
-    Example query for duration:
-    
-    ```python
-    stats = client.get_metric_statistics(
-        Namespace='AWS/Lambda',
-        MetricName='Duration',
-        Dimensions=[{'Name': 'FunctionName', 'Value': 'my-function'}],
-        StartTime=datetime.utcnow() - timedelta(hours=1),
-        EndTime=datetime.utcnow(),
-        Period=60,
-        Statistics=['Average', 'Maximum']
-    )
-    
-    ```
-    
+  Example query for duration:
+  ```python
+  stats = client.get_metric_statistics(
+      Namespace='AWS/Lambda',
+      MetricName='Duration',
+      Dimensions=[{'Name': 'FunctionName', 'Value': 'my-function'}],
+      StartTime=datetime.utcnow() - timedelta(hours=1),
+      EndTime=datetime.utcnow(),
+      Period=60,
+      Statistics=['Average', 'Maximum']
+  )
+
+  ```
 
 ### Error Rate and Types
 
 Monitoring error rates is important for discovering faults in your function. Errors can occur from a variety of causes, including code errors, timeouts, permission issues, or unsuccessful integrations with external services. CloudWatch logs and metrics contain useful information for diagnosing these issues.
 
 - Error types: Timeout, out-of-memory, and permission failures should be documented and monitored to ensure speedy debugging.
-    
-    Error metric example:
-    
-    ```bash
-    aws cloudwatch get-metric-statistics \\
-        --namespace AWS/Lambda --metric-name Errors \\
-        --dimensions Name=FunctionName,Value=my-function \\
-        --start-time 2023-09-01T00:00:00Z --end-time 2023-09-01T23:59:59Z \\
-        --period 60 --statistics Maximum
-    ```
-    
+  Error metric example:
+  ```bash
+  aws cloudwatch get-metric-statistics \\
+      --namespace AWS/Lambda --metric-name Errors \\
+      --dimensions Name=FunctionName,Value=my-function \\
+      --start-time 2023-09-01T00:00:00Z --end-time 2023-09-01T23:59:59Z \\
+      --period 60 --statistics Maximum
+  ```
 
 ### Throttles and Concurrent Executions
 
 - Throttles happen when the number of invocations exceeds the concurrent limit of your AWS account or the function. Monitoring throttles can help you set these limitations.
 - Concurrent executions monitor the number of function instances running concurrently to control the load.
-    
-    Example Query for concurrency metrics:
-    
-    ```bash
-    aws cloudwatch get-metric-statistics \\
-        --namespace AWS/Lambda --metric-name ConcurrentExecutions \\
-        --dimensions Name=FunctionName,Value=my-function \\
-        --start-time 2023-09-01T00:00:00Z --end-time 2023-09-01T23:59:59Z \\
-        --period 60 --statistics Average
-    ```
-    
+  Example Query for concurrency metrics:
+  ```bash
+  aws cloudwatch get-metric-statistics \\
+      --namespace AWS/Lambda --metric-name ConcurrentExecutions \\
+      --dimensions Name=FunctionName,Value=my-function \\
+      --start-time 2023-09-01T00:00:00Z --end-time 2023-09-01T23:59:59Z \\
+      --period 60 --statistics Average
+  ```
 
 ### Cold Starts
 
@@ -120,27 +106,30 @@ Memory allocation has a direct impact on Lambda performance and cost. Monitoring
 
 ```yaml
 {
-  "widgets": [
-    {
-      "type": "metric",
-      "x": 0,
-      "y": 0,
-      "width": 6,
-      "height": 6,
-      "properties": {
-        "metrics": [
-          ["AWS/Lambda", "MemorySize", "FunctionName", "my-function"],
-          [ ".", "Duration", ".", ".", { "stat": "Average" }],
-          [ ".", "Invocations", ".", ".", { "stat": "Sum" }]
-        ],
-        "view": "timeSeries",
-        "stacked": false,
-        "region": "us-east-1",
-        "title": "Lambda Monitoring Dashboard",
-        "period": 60
-      }
-    }
-  ]
+  'widgets':
+    [
+      {
+        'type': 'metric',
+        'x': 0,
+        'y': 0,
+        'width': 6,
+        'height': 6,
+        'properties':
+          {
+            'metrics':
+              [
+                ['AWS/Lambda', 'MemorySize', 'FunctionName', 'my-function'],
+                ['.', 'Duration', '.', '.', { 'stat': 'Average' }],
+                ['.', 'Invocations', '.', '.', { 'stat': 'Sum' }],
+              ],
+            'view': 'timeSeries',
+            'stacked': false,
+            'region': 'us-east-1',
+            'title': 'Lambda Monitoring Dashboard',
+            'period': 60,
+          },
+      },
+    ],
 }
 ```
 
@@ -167,38 +156,35 @@ Some tools that can be used for tracking:
 AWS CloudWatch is the native monitoring solution for AWS Lambda. It provides a strong platform for monitoring and managing Lambda functions. Let's have a look at the step-by-step guide for setting it up.
 
 1. Enable CloudWatch Logs:
-    - CloudWatch Logs are usually enabled by default for all Lambda functions. However, make sure your function's execution role (`AWSLambdaBasicExecutionRole`) has permissions to write logs to CloudWatch.
-    - CloudWatch collects data such as invocation requests, errors, and execution time, providing insight into your function's behaviour.
+   - CloudWatch Logs are usually enabled by default for all Lambda functions. However, make sure your function's execution role (`AWSLambdaBasicExecutionRole`) has permissions to write logs to CloudWatch.
+   - CloudWatch collects data such as invocation requests, errors, and execution time, providing insight into your function's behaviour.
 2. Create Custom Metrics:
-    - Lambda generates default metrics (like invocations, errors, and duration), but for more granular monitoring, you can create custom metrics.
-    - Example command to create a custom error metric via AWS CLI:
-        
-        ```bash
-        aws cloudwatch put-metric-data --namespace "MyLambdaMetrics" --metric-name "FunctionErrors" --value 1 --unit "Count"
-        ```
-        
-    - Custom metrics can help you track application-specific data, such as user signups or processing rates.
+   - Lambda generates default metrics (like invocations, errors, and duration), but for more granular monitoring, you can create custom metrics.
+   - Example command to create a custom error metric via AWS CLI:
+     ```bash
+     aws cloudwatch put-metric-data --namespace "MyLambdaMetrics" --metric-name "FunctionErrors" --value 1 --unit "Count"
+     ```
+   - Custom metrics can help you track application-specific data, such as user signups or processing rates.
 3. Set Up Alarms:
-    - You can configure alarms on critical metrics like error rates, throttles, or memory usage. This ensures you're immediately notified of any potential issues.
-    - In the CloudWatch console, navigate to "Alarms", select "Create Alarm", choose the metric to monitor, and set thresholds. For example, you can set an alarm to trigger if your Lambda error rate exceeds 5%.
-    
-    Example command to set an alarm:
-    
-    ```bash
-    aws cloudwatch put-metric-alarm --alarm-name "HighErrorRate" --metric-name Errors --namespace AWS/Lambda --statistic Sum --period 300 --threshold 5 --comparison-operator GreaterThanThreshold --evaluation-periods 1 --alarm-actions arn:aws:sns:us-east-1:123456789012:my-sns-topic
-    ```
-    
+
+   - You can configure alarms on critical metrics like error rates, throttles, or memory usage. This ensures you're immediately notified of any potential issues.
+   - In the CloudWatch console, navigate to "Alarms", select "Create Alarm", choose the metric to monitor, and set thresholds. For example, you can set an alarm to trigger if your Lambda error rate exceeds 5%.
+
+   Example command to set an alarm:
+
+   ```bash
+   aws cloudwatch put-metric-alarm --alarm-name "HighErrorRate" --metric-name Errors --namespace AWS/Lambda --statistic Sum --period 300 --threshold 5 --comparison-operator GreaterThanThreshold --evaluation-periods 1 --alarm-actions arn:aws:sns:us-east-1:123456789012:my-sns-topic
+   ```
+
 4. Use CloudWatch Logs Insights:
-    - CloudWatch Logs Insights allows you to analyze logs in real-time, helping you extract meaningful data from your Lambda logs. It's particularly useful for tracking performance trends and debugging.
-    - An example query to find the average duration of your function:
-        
-        ```sql
-        filter @type = "REPORT"
-        | stats avg(@duration) as avgDuration
-        
-        ```
-        
-    - You can set up more sophisticated queries, like tracking the frequency of specific errors or analyzing memory usage patterns over time.
+   - CloudWatch Logs Insights allows you to analyze logs in real-time, helping you extract meaningful data from your Lambda logs. It's particularly useful for tracking performance trends and debugging.
+   - An example query to find the average duration of your function:
+     ```sql
+     filter @type = "REPORT"
+     | stats avg(@duration) as avgDuration
+
+     ```
+   - You can set up more sophisticated queries, like tracking the frequency of specific errors or analyzing memory usage patterns over time.
 
 ### Custom CloudWatch Dashboard for AWS Lambda
 
@@ -206,27 +192,30 @@ Setting up a custom CloudWatch dashboard is a best practice for better visualiza
 
 ```yaml
 {
-  "widgets": [
-    {
-      "type": "metric",
-      "x": 0,
-      "y": 0,
-      "width": 6,
-      "height": 6,
-      "properties": {
-        "metrics": [
-          ["AWS/Lambda", "MemorySize", "FunctionName", "my-function"],
-          [ ".", "Duration", ".", ".", { "stat": "Average" }],
-          [ ".", "Invocations", ".", ".", { "stat": "Sum" }]
-        ],
-        "view": "timeSeries",
-        "stacked": false,
-        "region": "us-east-1",
-        "title": "Lambda Monitoring Dashboard",
-        "period": 60
-      }
-    }
-  ]
+  'widgets':
+    [
+      {
+        'type': 'metric',
+        'x': 0,
+        'y': 0,
+        'width': 6,
+        'height': 6,
+        'properties':
+          {
+            'metrics':
+              [
+                ['AWS/Lambda', 'MemorySize', 'FunctionName', 'my-function'],
+                ['.', 'Duration', '.', '.', { 'stat': 'Average' }],
+                ['.', 'Invocations', '.', '.', { 'stat': 'Sum' }],
+              ],
+            'view': 'timeSeries',
+            'stacked': false,
+            'region': 'us-east-1',
+            'title': 'Lambda Monitoring Dashboard',
+            'period': 60,
+          },
+      },
+    ],
 }
 ```
 
@@ -238,23 +227,23 @@ After you've set up basic monitoring, a few advanced techniques can improve your
 
 AWS X-Ray allows you to trace requests as they flow across multiple services, including Lambda. This allows access to a request's complete execution route, making it easier to discover performance bottlenecks or problems.
 
-To enable [X-Ray tracing](https://signoz.io/comparisons/opentelemetry-vs-xray/) in your Lambda function, 
+To enable [X-Ray tracing](https://signoz.io/comparisons/opentelemetry-vs-xray/) in your Lambda function,
 
 1. Go to the Configuration tab in the Lambda interface and select Active Tracing.
 2. Include the AWS X-Ray SDK in your Lambda function code to capture extra traces.
-    
-    ```python
-    from aws_xray_sdk.core import xray_recorder
-    from aws_xray_sdk.core import patch_all
-    
-    patch_all()
-    
-    def lambda_handler(event, context):
-        with xray_recorder.in_segment('Lambda Function'):
-            # Function logic here
-            return {"statusCode": 200, "body": "X-Ray enabled!"}
-    ```
-    
+
+   ```python
+   from aws_xray_sdk.core import xray_recorder
+   from aws_xray_sdk.core import patch_all
+
+   patch_all()
+
+   def lambda_handler(event, context):
+       with xray_recorder.in_segment('Lambda Function'):
+           # Function logic here
+           return {"statusCode": 200, "body": "X-Ray enabled!"}
+   ```
+
 3. Add the required X-Ray permissions to your Lambda execution role.
 
 ### Custom Metrics for Application-Specific Monitoring
@@ -297,13 +286,10 @@ To get a holistic view of your application performance, integrate Lambda monitor
 Setting up immediate alert alerts is critical for real-time monitoring and prompt repair. Let's see how you can set up effective alerts:
 
 - SNS Notifications: Use Amazon SNS to provide real-time alerts when important thresholds are exceeded. You are notified by email if your error rate exceeds a certain threshold.
-    
-    Example CLI command to set up a notification:
-    
-    ```bash
-    aws sns publish --topic-arn arn:aws:sns:us-east-1:123456789012:my-sns-topic --message "Lambda error rate too high!"
-    ```
-    
+  Example CLI command to set up a notification:
+  ```bash
+  aws sns publish --topic-arn arn:aws:sns:us-east-1:123456789012:my-sns-topic --message "Lambda error rate too high!"
+  ```
 - Integration with Incident Management Tools: For more sophisticated alerting, integrate with tools like PagerDuty or Opsgenie to manage incident response and escalation.
 
 ## Optimizing Lambda Performance Through Monitoring
@@ -311,97 +297,100 @@ Setting up immediate alert alerts is critical for real-time monitoring and promp
 Monitoring your AWS Lambda functions is more than just recording metrics; it's an important method for improving performance. You can fine-tune your Lambda functions for faster and more cost-effective performance by employing monitoring tool data.
 
 1. Analyze Cold Start Times:
-    - Cold starts occur when a new instance of your Lambda function is initialized, which might cause latency.
-    - Use CloudWatch Logs or X-Ray to identify functions with high cold start times, particularly those are activated infrequently.
-    - Provisioned Concurrency is an efficient way to reduce cold start times in important functions. It maintains function instances warm, avoiding the initialization delay.
-    
-    Example CLI command to enable provisioned concurrency:
-    
-    ```bash
-    aws lambda put-provisioned-concurrency-config \\
-        --function-name my-function \\
-        --provisioned-concurrent-executions 5
-    ```
-    
+
+   - Cold starts occur when a new instance of your Lambda function is initialized, which might cause latency.
+   - Use CloudWatch Logs or X-Ray to identify functions with high cold start times, particularly those are activated infrequently.
+   - Provisioned Concurrency is an efficient way to reduce cold start times in important functions. It maintains function instances warm, avoiding the initialization delay.
+
+   Example CLI command to enable provisioned concurrency:
+
+   ```bash
+   aws lambda put-provisioned-concurrency-config \\
+       --function-name my-function \\
+       --provisioned-concurrent-executions 5
+   ```
+
 2. Fine-Tune Memory Allocation:
-    - AWS Lambda allocates CPU power in proportion to the memory you choose. This means that adding memory can occasionally increase speed, even shortening execution times sufficiently to reduce overall costs.
-    - Monitor memory usage with CloudWatch to achieve the best combination of performance and cost.
-    - Use the Lambda Power Tuning tool to automatically test alternative memory settings.
+   - AWS Lambda allocates CPU power in proportion to the memory you choose. This means that adding memory can occasionally increase speed, even shortening execution times sufficiently to reduce overall costs.
+   - Monitor memory usage with CloudWatch to achieve the best combination of performance and cost.
+   - Use the Lambda Power Tuning tool to automatically test alternative memory settings.
 3. Identify and Resolve Bottlenecks:
-    - Use AWS X-Ray to trace request flow and identify bottlenecks in Lambda code. This could include sluggish-performing code parts, wasteful database queries, or slow external API requests.
-    - You may optimize these locations by studying comprehensive traces for speedier execution and a better user experience.
-    
-    Example of slow database call optimization:
-    
-    ```python
-    # Before optimization: Single database query per request
-    results = db.query("SELECT * FROM users WHERE id = %s", user_id)
-    
-    # After optimization: Use batch queries
-    results = db.query("SELECT * FROM users WHERE id IN (%s)", batch_of_user_ids)
-    ```
-    
+
+   - Use AWS X-Ray to trace request flow and identify bottlenecks in Lambda code. This could include sluggish-performing code parts, wasteful database queries, or slow external API requests.
+   - You may optimize these locations by studying comprehensive traces for speedier execution and a better user experience.
+
+   Example of slow database call optimization:
+
+   ```python
+   # Before optimization: Single database query per request
+   results = db.query("SELECT * FROM users WHERE id = %s", user_id)
+
+   # After optimization: Use batch queries
+   results = db.query("SELECT * FROM users WHERE id IN (%s)", batch_of_user_ids)
+   ```
+
 4. Implement Caching Strategies:
-    - Lambda Layers can store dependencies like libraries across several Lambda functions, lowering load times and boosting performance.
-    - Application-level caching, using services such as Amazon ElastiCache or AWS Lambda@Edge, can cache frequently requested data, eliminating the need to query databases or repeatedly perform API calls.
-    
-    Example of using Amazon ElastiCache for caching:
-    
-    ```python
-    import redis
-    redis_client = redis.StrictRedis(host='my-redis-cluster', port=6379, db=0)
-    
-    def lambda_handler(event, context):
-        cache_key = "some-key"
-        cached_value = redis_client.get(cache_key)
-    
-        if cached_value:
-            return cached_value
-        else:
-            # Fetch from the source, then cache the result
-            result = fetch_from_database()
-            redis_client.set(cache_key, result)
-            return result
-    ```
-    
+
+   - Lambda Layers can store dependencies like libraries across several Lambda functions, lowering load times and boosting performance.
+   - Application-level caching, using services such as Amazon ElastiCache or AWS Lambda@Edge, can cache frequently requested data, eliminating the need to query databases or repeatedly perform API calls.
+
+   Example of using Amazon ElastiCache for caching:
+
+   ```python
+   import redis
+   redis_client = redis.StrictRedis(host='my-redis-cluster', port=6379, db=0)
+
+   def lambda_handler(event, context):
+       cache_key = "some-key"
+       cached_value = redis_client.get(cache_key)
+
+       if cached_value:
+           return cached_value
+       else:
+           # Fetch from the source, then cache the result
+           result = fetch_from_database()
+           redis_client.set(cache_key, result)
+           return result
+   ```
 
 ## Cost Optimization Through Effective Lambda Monitoring
 
 Monitoring not only helps maximize performance but it also plays an important part in cost management. Here's how you can use monitoring data to reduce Lambda expenses.
 
 1. Understand the Cost-Metrics Relationship:
-    - The length and memory allocation of your Lambda functions directly impact your AWS account. Monitoring these parameters allows you to balance performance and cost.
-    - By monitoring duration with CloudWatch Logs Insights, you may minimize execution time and ultimately reduce Lambda expenses.
+   - The length and memory allocation of your Lambda functions directly impact your AWS account. Monitoring these parameters allows you to balance performance and cost.
+   - By monitoring duration with CloudWatch Logs Insights, you may minimize execution time and ultimately reduce Lambda expenses.
 2. Remove Unused or Inefficient Functions:
-    - Some Lambda functions may receive infrequent calls or perform poorly.
-    - Use CloudWatch analytics to detect underutilized functions and consider deactivating or redesigning them to reduce expenses.
-    
-    CloudWatch Query to Identify Low-Utilization Functions:
-    
-    ```sql
-    filter @type = "REPORT"
-    | stats count() as invocationCount by @logStream
-    | filter invocationCount < 10
-    ```
-    
+
+   - Some Lambda functions may receive infrequent calls or perform poorly.
+   - Use CloudWatch analytics to detect underutilized functions and consider deactivating or redesigning them to reduce expenses.
+
+   CloudWatch Query to Identify Low-Utilization Functions:
+
+   ```sql
+   filter @type = "REPORT"
+   | stats count() as invocationCount by @logStream
+   | filter invocationCount < 10
+   ```
+
 3. Optimize Function Duration:
-    - The shorter your function runs, the less you'll pay. Use monitoring tools such as X-Ray to discover long-running functions and determine why they are taking so long.
-    - For example, slow database calls or external API requests can frequently be improved to minimize execution time and cost.
+   - The shorter your function runs, the less you'll pay. Use monitoring tools such as X-Ray to discover long-running functions and determine why they are taking so long.
+   - For example, slow database calls or external API requests can frequently be improved to minimize execution time and cost.
 4. Implement Auto-Scaling Policies:
-    - CloudWatch Alarms can trigger scaling actions when specific thresholds are hit, guaranteeing adequate concurrency without overpaying.
-    - You can utilize Provisioned Concurrency for predictable workloads and auto-scaling for demand spikes.
-    
-    Example Auto-Scaling Command for Provisioned Concurrency:
-    
-    ```bash
-    aws application-autoscaling register-scalable-target \\
-        --service-namespace lambda \\
-        --resource-id function:my-function \\
-        --scalable-dimension lambda:function:ProvisionedConcurrency \\
-        --min-capacity 1 \\
-        --max-capacity 10
-    ```
-    
+
+   - CloudWatch Alarms can trigger scaling actions when specific thresholds are hit, guaranteeing adequate concurrency without overpaying.
+   - You can utilize Provisioned Concurrency for predictable workloads and auto-scaling for demand spikes.
+
+   Example Auto-Scaling Command for Provisioned Concurrency:
+
+   ```bash
+   aws application-autoscaling register-scalable-target \\
+       --service-namespace lambda \\
+       --resource-id function:my-function \\
+       --scalable-dimension lambda:function:ProvisionedConcurrency \\
+       --min-capacity 1 \\
+       --max-capacity 10
+   ```
 
 ## Enhancing Lambda Monitoring with SigNoz
 
@@ -424,44 +413,40 @@ While AWS has powerful built-in monitoring capabilities, third-party solutions s
 Effective AWS Lambda monitoring is critical for ensuring application performance, reducing costs, and swiftly resolving issues. Here are some best practices to help you build a comprehensive and efficient monitoring strategy:
 
 - Use a Multi-Layer Approach:
-    - Relying on a single tool is insufficient. Combine CloudWatch for metric monitoring, AWS X-Ray for tracing, and third-party solutions like SigNoz to gain advanced insights.
-    - Example: Utilize X-Ray to monitor a user's request across several AWS services (like Lambda, API Gateway, and DynamoDB), and CloudWatch to monitor Lambda-specific metrics like duration and memory usage.
+  - Relying on a single tool is insufficient. Combine CloudWatch for metric monitoring, AWS X-Ray for tracing, and third-party solutions like SigNoz to gain advanced insights.
+  - Example: Utilize X-Ray to monitor a user's request across several AWS services (like Lambda, API Gateway, and DynamoDB), and CloudWatch to monitor Lambda-specific metrics like duration and memory usage.
 - Set Up Meaningful Alerts:
-    - Avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/) by setting thresholds that matter. Focus on critical metrics such as error rates, duration, and throttle rates.
-    - Example: Set up a CloudWatch Alarm to notify you when function errors exceed 5%:
-    
-    ```bash
-    aws cloudwatch put-metric-alarm --alarm-name "HighErrorRate" \\
-        --metric-name Errors --namespace AWS/Lambda --statistic Sum \\
-        --period 60 --threshold 5 --comparison-operator GreaterThanThreshold \\
-        --dimensions Name=FunctionName,Value=your-function-name \\
-        --evaluation-periods 1 --alarm-actions arn:aws:sns:region:account-id:your-sns-topic
-    ```
-    
+  - Avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/) by setting thresholds that matter. Focus on critical metrics such as error rates, duration, and throttle rates.
+  - Example: Set up a CloudWatch Alarm to notify you when function errors exceed 5%:
+  ```bash
+  aws cloudwatch put-metric-alarm --alarm-name "HighErrorRate" \\
+      --metric-name Errors --namespace AWS/Lambda --statistic Sum \\
+      --period 60 --threshold 5 --comparison-operator GreaterThanThreshold \\
+      --dimensions Name=FunctionName,Value=your-function-name \\
+      --evaluation-periods 1 --alarm-actions arn:aws:sns:region:account-id:your-sns-topic
+  ```
 - Regularly Review and Update Strategies:
-    - As your application grows and new features are added, your monitoring method should develop. Perform frequent audits on your CloudWatch Logs, custom metrics, and alerts.
-    - Monitor for new types of failures or performance bottlenecks caused by new functionalities.
+  - As your application grows and new features are added, your monitoring method should develop. Perform frequent audits on your CloudWatch Logs, custom metrics, and alerts.
+  - Monitor for new types of failures or performance bottlenecks caused by new functionalities.
 - Incorporate Monitoring into Development:
-    - Monitoring should be an integral part of the development process rather than an afterthought. When creating new Lambda functions, include custom CloudWatch metrics and full X-Ray traces.
-    - Example: Developers can utilize logging and custom metrics to track key events like successful user logins or signups.
-    
-    ```python
-    import boto3
-    cloudwatch = boto3.client('cloudwatch')
-    
-    def lambda_handler(event, context):
-        # Custom metric: User signups
-        cloudwatch.put_metric_data(
-            Namespace='MyApp',
-            MetricData=[{
-                'MetricName': 'UserSignups',
-                'Value': 1,
-                'Unit': 'Count'
-            }]
-        )
-        # Continue with the rest of the Lambda function logic
-    ```
-    
+  - Monitoring should be an integral part of the development process rather than an afterthought. When creating new Lambda functions, include custom CloudWatch metrics and full X-Ray traces.
+  - Example: Developers can utilize logging and custom metrics to track key events like successful user logins or signups.
+  ```python
+  import boto3
+  cloudwatch = boto3.client('cloudwatch')
+
+  def lambda_handler(event, context):
+      # Custom metric: User signups
+      cloudwatch.put_metric_data(
+          Namespace='MyApp',
+          MetricData=[{
+              'MetricName': 'UserSignups',
+              'Value': 1,
+              'Unit': 'Count'
+          }]
+      )
+      # Continue with the rest of the Lambda function logic
+  ```
 
 ## FAQs
 
@@ -519,4 +504,4 @@ Monitoring Lambda functions differs from standard containers or virtual machines
 - Statelessness: Because Lambda functions are stateless and ephemeral, you prioritize per-invocation metrics such as execution time and cold starts above the long-term health of a running instance.
 - Dynamic Scaling: Lambda functions scale automatically based on demand, so you must monitor concurrency and throttles rather than manually scaling resources like containers or VMs.
 - Cost-Driven Monitoring: Because you pay per request and time in Lambda, monitoring performance and optimizing for cost is more important than for long-running containers or virtual machines.
-- Limited Infrastructure Control: Unlike containers or VMs, where you handle the underlying hardware, Lambda isolates the infrastructure completely, making application-level metrics (such as invocation, error rate, and memory usage) more crucial.
\ No newline at end of file
+- Limited Infrastructure Control: Unlike containers or VMs, where you handle the underlying hardware, Lambda isolates the infrastructure completely, making application-level metrics (such as invocation, error rate, and memory usage) more crucial.
diff --git a/data/guides/aws-monitoring.mdx b/data/guides/aws-monitoring.mdx
index 9f67d46b5..67313f09c 100644
--- a/data/guides/aws-monitoring.mdx
+++ b/data/guides/aws-monitoring.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: AWS Monitoring - How to, Tools, and Best Practices
-slug: aws-monitoring
 date: 2024-08-30
 tags: [monitoring]
 authors: [hridyesh_bisht]
 description: Learn essential AWS monitoring techniques, tools, and best practices to optimize performance, security, and cost-efficiency in your cloud infrastructure.
-keywords: [AWS monitoring, CloudWatch, AWS tools, cloud infrastructure, performance optimization, security monitoring, cost management]
-
+keywords:
+  [
+    AWS monitoring,
+    CloudWatch,
+    AWS tools,
+    cloud infrastructure,
+    performance optimization,
+    security monitoring,
+    cost management,
+  ]
 ---
 
 In today's cloud-driven world, monitoring is essential to ensure that apps and infrastructures are secure and cost-effective. Whether you have a simple web app or a complex architecture, you need robust monitoring solutions.
@@ -35,7 +41,13 @@ For example, consider you are managing an e-commerce app on AWS that spans multi
 - Automate responses, such as provisioning new EC2 instances when CPU utilization exceeds 70%.
 - Monitor unusual login attempts by auditing API calls.
 
-<a href="https://lh7-rt.googleusercontent.com/docsz/AD_4nXevp_tkeHFmGNgBL2PQkk9of4dFuIUjsnc_Rwr73QtZ5RgzykShlI-6AD8AA-7utzKd653rDMl3zTqvYSmTXgTsjiTjUiw7nS7zB9FxKWBD5z7-5NFNfMRwe0xLp7C3toDmXPqPptYeuMo3-gLwM3mooVeK?key=ZjafRB_DBuexN87b67xpLg" rel="noopener noreferrer nofollow" target="_blank">Vital monitoring metrics for an E-commerce application deployed in AWS</a>
+<a
+  href="https://lh7-rt.googleusercontent.com/docsz/AD_4nXevp_tkeHFmGNgBL2PQkk9of4dFuIUjsnc_Rwr73QtZ5RgzykShlI-6AD8AA-7utzKd653rDMl3zTqvYSmTXgTsjiTjUiw7nS7zB9FxKWBD5z7-5NFNfMRwe0xLp7C3toDmXPqPptYeuMo3-gLwM3mooVeK?key=ZjafRB_DBuexN87b67xpLg"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Vital monitoring metrics for an E-commerce application deployed in AWS
+</a>
 
 Vital monitoring metrics for an E-commerce application deployed in AWS
 
@@ -43,12 +55,16 @@ Vital monitoring metrics for an E-commerce application deployed in AWS
 
 AWS offers several tools to help you monitor your cloud resources. Some of the core [AWS monitoring tools](https://signoz.io/comparisons/aws-monitoring-tools/) are:
 
-- CloudWatch: It collects and tracks metrics, logs, and events for AWS resources. You can aggregate logs from multiple AWS services for a unified view. You can set up alarms to trigger actions. 
+- CloudWatch: It collects and tracks metrics, logs, and events for AWS resources. You can aggregate logs from multiple AWS services for a unified view. You can set up alarms to trigger actions.
 - CloudTrail: It enables governance, compliance, and operational auditing by logging all API calls in your AWS account. You can Integrate CloudTrail with CloudWatch to trigger alarms for specific API events.
 - X-Ray: It helps you debug and analyze distributed apps, particularly microservices. You can trace requests as they flow through the systems to find performance bottlenecks or errors.
 - EventBridge: It enables event-driven architectures by routing events between AWS services and custom apps. You must define event buses to route events from different AWS services. Set rules to capture specific events and trigger actions.
 
-<Figure src="/img/guides/2024/08/aws-monitoring-a.webp" alt="Use cases for AWS monitoring tools" caption="Use cases for AWS monitoring tools" />
+<Figure
+  src="/img/guides/2024/08/aws-monitoring-a.webp"
+  alt="Use cases for AWS monitoring tools"
+  caption="Use cases for AWS monitoring tools"
+/>
 
 ### Deep Dive into Amazon CloudWatch
 
@@ -61,7 +77,13 @@ CloudWatch lets you track your resources' performance, health, and usage in real
 
 CloudWatch seamlessly integrates with other AWS services, such as Lambda or Simple Notification Service (SNS). For example, you can configure a CloudWatch to trigger a Lambda function to scale your servers or to notify your developers using SNS during traffic spikes.
 
-<a href="https://lh7-rt.googleusercontent.com/docsz/AD_4nXe3GmpRLsBbg5XRHwqO9JC44B5Z99st7PmwC3JDIybeqHSMfKTy7CtTXozVeFOvZUjv44kBYiiFiD2P5sBXZEgzowdPX9W7cp7bKOmEiAQGk16A3hdX5yOsEBBqOw_UfKY0MCUtjPLqueeoqYnMpLOQ3JxU?key=ZjafRB_DBuexN87b67xpLg" rel="noopener noreferrer nofollow" target="_blank">How CloudWatch integrates with other AWS services</a>
+<a
+  href="https://lh7-rt.googleusercontent.com/docsz/AD_4nXe3GmpRLsBbg5XRHwqO9JC44B5Z99st7PmwC3JDIybeqHSMfKTy7CtTXozVeFOvZUjv44kBYiiFiD2P5sBXZEgzowdPX9W7cp7bKOmEiAQGk16A3hdX5yOsEBBqOw_UfKY0MCUtjPLqueeoqYnMpLOQ3JxU?key=ZjafRB_DBuexN87b67xpLg"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  How CloudWatch integrates with other AWS services
+</a>
 
 How CloudWatch integrates with other AWS services
 
@@ -78,30 +100,42 @@ To implement monitoring in AWS, follow these steps:
 
 1. Go to the AWS Management Console and identify the key AWS services and apps to monitor. For each resource, determine metrics that are vital to track.
 2. Go to AWS console > CloudWatch > Alarms and click Create alarm to display a select metric popup.
-    
-    <Figure src="/img/guides/2024/08/aws-monitoring-select-metric.webp" alt="CloudWatch Metrics" caption="CloudWatch Metrics" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/aws-monitoring-select-metric.webp"
+     alt="CloudWatch Metrics"
+     caption="CloudWatch Metrics"
+   />
+
 3. Select metric and configure the settings, including the Period, Threshold Type, and Alarm Condition.
-    
-    <Figure src="/img/guides/2024/08/aws-monitoring-configure-action.webp" alt="Configure alarm actions" caption="Configure alarm actions" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/aws-monitoring-configure-action.webp"
+     alt="Configure alarm actions"
+     caption="Configure alarm actions"
+   />
+
 4. Select the Alarm state that triggers this action from:
-    - OK: The metric is within the defined configured threshold.
-    - ALARM: The metric has exceeded the thresholds set.
-    - INSUFFICIENT_DATA : There is insufficient data for the metric to determine the alarm state.
+   - OK: The metric is within the defined configured threshold.
+   - ALARM: The metric has exceeded the thresholds set.
+   - INSUFFICIENT_DATA : There is insufficient data for the metric to determine the alarm state.
 5. Use SNS topics to notify relevant stakeholders when alarms trigger. Notifications can be sent via email, SMS, or even automated into ticketing systems.
 6. Configure response actions to respond to alarms. For example, auto-scale EC2 instances or trigger Lambda functions based on the alarm.
 7. Give your alarm a clear name and description(Optional).
 8. Enable CloudWatch logs for relevant services. For more information, refer to logging <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-vended-logs-permissions" rel="noopener noreferrer nofollow" target="_blank">which requires additional parameters</a>.
 9. Organize your logs into logical groups (e.g., by service or app) and streams (e.g., by instance or function) to simplify querying and analysis.
-    
-    <Figure src="/img/guides/2024/08/aws-monitoring-log-groups-aws.webp" alt="Log groups in CloudWatch" caption="Log groups in CloudWatch" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/aws-monitoring-log-groups-aws.webp"
+     alt="Log groups in CloudWatch"
+     caption="Log groups in CloudWatch"
+   />
+
 10. Use CloudWatch Logs Insights to query and analyze your logs. This can help you identify anomalies such as high error rates or slow API responses.
 
 Build custom CloudWatch dashboards to display your most important metrics. Organize widgets to group related metrics, enabling you to monitor system health at a glance.
 
-You can integrate AWS monitoring tools with SigNoz to provide a unified view of multiple platforms. SigNoz provides detailed tracing capabilities, giving deeper insight into metrics. 
+You can integrate AWS monitoring tools with SigNoz to provide a unified view of multiple platforms. SigNoz provides detailed tracing capabilities, giving deeper insight into metrics.
 
 ## AWS Monitoring Best Practices
 
@@ -133,14 +167,18 @@ Integrating AWS monitoring tools with [SigNoz](https://signoz.io/docs/introducti
 
 To learn more, refer to [CloudWatch metrics in SigNoz](https://signoz.io/blog/cloudwatch-metrics/).
 
-<Figure src="/img/guides/2024/08/aws-monitoring-AWS-SigNoz.webp" alt="How CloudWatch metrics can be integrated with SigNoz" caption="How CloudWatch metrics can be integrated with SigNoz" />
+<Figure
+  src="/img/guides/2024/08/aws-monitoring-AWS-SigNoz.webp"
+  alt="How CloudWatch metrics can be integrated with SigNoz"
+  caption="How CloudWatch metrics can be integrated with SigNoz"
+/>
 
 ### Getting Started with SigNoz:
 
 To get started with SigNoz, follow these steps:
 
-1. Set up SigNoz on your infrastructure. 
-<GetStartedSigNoz />
+1. Set up SigNoz on your infrastructure.
+   <GetStartedSigNoz />
 2. Set up your apps to send telemetry data, such as traces, metrics, and logs to SigNoz. Once your app is configured with OpenTelemetry client libraries. You can send the data to the SigNoz backend by specifying a specific port. For more information, refer to [open telemetry visualization](https://signoz.io/blog/opentelemetry-visualization/).
 3. Use the SigNoz dashboard to explore and gain new insights into your AWS infrastructure and apps. For example, visualize request latencies across different services or analyze error rates over time.
 
@@ -199,4 +237,4 @@ Best practices include:
 
 ### Why should I consider using SigNoz with AWS?
 
-SigNoz is an open-source tool that provides deeper insights through advanced tracing and custom metrics. It’s a good choice if you need more detailed observability across your cloud environment.
\ No newline at end of file
+SigNoz is an open-source tool that provides deeper insights through advanced tracing and custom metrics. It’s a good choice if you need more detailed observability across your cloud environment.
diff --git a/data/guides/aws-observability.mdx b/data/guides/aws-observability.mdx
index 9368a0f0a..01a66d21e 100644
--- a/data/guides/aws-observability.mdx
+++ b/data/guides/aws-observability.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: AWS Observability - A Guide to Monitoring Cloud Performance
-slug: aws-observability
 date: 2024-09-06
 tags: [observability]
 authors: [nitin_gouda]
 description: Learn how AWS observability enhances cloud performance monitoring. Discover key components, best practices, and advanced techniques for effective AWS observability.
-keywords: [aws observability, cloud monitoring, aws cloudwatch, aws x-ray, cloudtrail, microservices, distributed tracing]
-
+keywords:
+  [
+    aws observability,
+    cloud monitoring,
+    aws cloudwatch,
+    aws x-ray,
+    cloudtrail,
+    microservices,
+    distributed tracing,
+  ]
 ---
 
 Cloud performance monitoring is crucial for businesses relying on AWS infrastructure. As applications grow more complex, traditional monitoring methods fall short. AWS observability offers a comprehensive solution to this challenge. It provides deep insights into your cloud environment, helping you maintain optimal performance and reliability. This guide explores AWS observability, its key components, and how to implement it effectively in your cloud infrastructure.
@@ -18,11 +24,15 @@ AWS observability is a comprehensive approach to understanding and monitoring th
 
 AWS observability is built on three core pillars:
 
-- Metrics: Metrics are quantitative metrics that provide different aspects of an application's performance in a numerical representation. They provide a high-level overview of the functionality and state of the system. 
-- Traces: Traces provide detailed records of transactions as they flow through an application. They track the path of individual requests and show how they interact with various system components. Traces can show how a user request moves through different services, databases, and third-party APIs. They highlight the duration of each step, helping to identify slow or failing components. 
-- Logs: Logs are text-based records of events and errors within an application. They provide a chronological record of what has happened within the system. Logs can include error messages, debug information, and audit trails. They record events such as user logins, database queries, and application errors. 
+- Metrics: Metrics are quantitative metrics that provide different aspects of an application's performance in a numerical representation. They provide a high-level overview of the functionality and state of the system.
+- Traces: Traces provide detailed records of transactions as they flow through an application. They track the path of individual requests and show how they interact with various system components. Traces can show how a user request moves through different services, databases, and third-party APIs. They highlight the duration of each step, helping to identify slow or failing components.
+- Logs: Logs are text-based records of events and errors within an application. They provide a chronological record of what has happened within the system. Logs can include error messages, debug information, and audit trails. They record events such as user logins, database queries, and application errors.
 
-<Figure src="/img/guides/2024/09/aws-observability-pillars.webp" alt="Venn Diagram of logs, metrics and traces" caption="Venn Diagram of logs, metrics and traces" />
+<Figure
+  src="/img/guides/2024/09/aws-observability-pillars.webp"
+  alt="Venn Diagram of logs, metrics and traces"
+  caption="Venn Diagram of logs, metrics and traces"
+/>
 
 Example: Imagine you have an e-commerce application, and users report that the checkout process is slow. To identify the root cause:
 
@@ -37,7 +47,7 @@ AWS observability is important because it:
 - Supports proactive problem prevention: Understanding system behaviour allows you to predict and handle possible issues before they impact users.
 - Improves data-driven decision-making: With detailed insights, you can make sound decisions to improve system performance and dependability.
 
-Unlike traditional monitoring, which often relies on predefined metrics, observability enables you to explore and understand your system in depth. This approach allows you to ask new questions and discover insights that were not anticipated, providing a more flexible and thorough understanding of your cloud environment. 
+Unlike traditional monitoring, which often relies on predefined metrics, observability enables you to explore and understand your system in depth. This approach allows you to ask new questions and discover insights that were not anticipated, providing a more flexible and thorough understanding of your cloud environment.
 To learn more, refer to [Observability vs Monitoring vs Telemetry - Key Differences](https://signoz.io/guides/observability-vs-monitoring-vs-telemetry/).
 
 ## Key Components of AWS Observability
@@ -52,7 +62,11 @@ CloudWatch is the primary service for collecting and tracking metrics, logs, and
 - Alarms: Set up alarms to automatically notify you of significant events or conditions, such as high CPU usage or low disk space. These alarms can trigger automated responses, such as scaling up resources or sending notifications, helping you manage potential issues proactively.
 - Log Insights: Analyze log data to discover trends, identify patterns, and diagnose issues. Log Insights allows you to run queries on log data to extract meaningful information, which can be used to improve application performance and troubleshoot problems.
 
-<Figure src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_11.07.41_PM.webp" alt="AWS Cloudwatch Dashboard" caption="AWS Cloudwatch Dashboard" />
+<Figure
+  src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_11.07.41_PM.webp"
+  alt="AWS Cloudwatch Dashboard"
+  caption="AWS Cloudwatch Dashboard"
+/>
 
 ### AWS X-Ray
 
@@ -90,11 +104,11 @@ Metrics are quantitative data points that are collected over time. These data po
 Use Cases:
 
 - Monitoring Performance Trends: Metrics help you identify how a resource or application performs over time. By analyzing trends, you can proactively respond to potential issues.
-Example: Monitoring CPU utilization in an EC2 instance to determine if it's consistently under or over-utilized.
+  Example: Monitoring CPU utilization in an EC2 instance to determine if it's consistently under or over-utilized.
 - Setting Alerts: [CloudWatch metrics](https://signoz.io/blog/cloudwatch-metrics/) can be paired with alarms that notify you when predefined thresholds are crossed.
-Example: Creating an alarm to alert you if the request count for a web application exceeds 1,000 per minute, indicating high traffic or possible service overload.
+  Example: Creating an alarm to alert you if the request count for a web application exceeds 1,000 per minute, indicating high traffic or possible service overload.
 - Capacity Planning: Metrics guide infrastructure scaling by providing data on resource utilization, ensuring you're neither under-provisioned nor wasting resources.
-Example: Analyzing metrics over time to understand peak hours of demand, allowing you to plan resource scaling accordingly.
+  Example: Analyzing metrics over time to understand peak hours of demand, allowing you to plan resource scaling accordingly.
 
 ### Logs
 
@@ -103,11 +117,11 @@ Logs are detailed records of events and actions occurring within your AWS enviro
 Use Cases:
 
 - Debugging Application Issues: Logs provide detailed information on system errors, failures, or unexpected behaviors. By analyzing log data, you can identify the root cause of problems.
-Example: Using application logs to trace a request that failed due to an exception, helping to pinpoint the exact location in the code that caused the error.
+  Example: Using application logs to trace a request that failed due to an exception, helping to pinpoint the exact location in the code that caused the error.
 - Tracking User Activity: Logs can be used to audit user activities across your AWS environment, which is essential for security and compliance.
-Example: CloudTrail logs track all API calls made by users in your account, giving visibility into who performed specific actions, such as launching or terminating an EC2 instance.
+  Example: CloudTrail logs track all API calls made by users in your account, giving visibility into who performed specific actions, such as launching or terminating an EC2 instance.
 - Security and Auditing: Logs play a key role in monitoring security events, detecting breaches, and ensuring compliance with industry regulations.
-Example: Analyzing security logs to detect unauthorized access attempts or unusual activities, such as multiple failed login attempts.
+  Example: Analyzing security logs to detect unauthorized access attempts or unusual activities, such as multiple failed login attempts.
 
 AWS CloudWatch Logs Insights provides powerful querying capabilities to analyze logs efficiently, helping you identify patterns, detect anomalies, and diagnose system issues quickly.
 
@@ -118,11 +132,11 @@ Traces are used to understand the journey of requests as they traverse through d
 ### Use Cases:
 
 - Understanding Request Flow: Traces give insight into how a request travels from the frontend to backend services and databases, providing visibility into each step.
-Example: Tracing a user login request from the web application through the authentication service and the database, identifying if there's any delay in one of these services.
+  Example: Tracing a user login request from the web application through the authentication service and the database, identifying if there's any delay in one of these services.
 - Detecting Bottlenecks: In complex applications, delays can occur in certain services or APIs. Traces help you pinpoint where those bottlenecks exist so you can resolve performance issues.
-Example: Using AWS X-Ray to identify that a specific microservice is adding latency to the overall response time, prompting you to optimize that service.
+  Example: Using AWS X-Ray to identify that a specific microservice is adding latency to the overall response time, prompting you to optimize that service.
 - Troubleshooting Distributed Systems: Distributed applications often make debugging more challenging. Traces help visualize the end-to-end request lifecycle, making it easier to identify where errors or failures are occurring.
-Example: Identifying a timeout error in a specific backend service during a payment transaction process in an e-commerce application.
+  Example: Identifying a timeout error in a specific backend service during a payment transaction process in an e-commerce application.
 
 By using metrics, logs, and traces together, AWS observability ensures that you're not only able to monitor your system but also proactively troubleshoot and optimize it. This integrated approach provides the necessary tools to maintain high performance and resolve issues before they impact your users.
 
@@ -130,55 +144,56 @@ By using metrics, logs, and traces together, AWS observability ensures that you'
 
 To implement effective AWS observability, follow these steps:
 
-1. Set up robust alerting and notification systems
-    
+1.  Set up robust alerting and notification systems
+
     AWS CloudWatch is a monitoring service that gathers and tracks information including CPU utilisation, memory use, and error rates. You may set alerts in CloudWatch to continually monitor these essential parameters.
-    
+
     Purpose of CloudWatch Alarms:
-    
+
     - CloudWatch alarms are designed to keep an eye on the performance and health of your AWS resources. When a metric exceeds a predefined threshold, the alarm is triggered.
     - For example, you can set an alarm to notify you if CPU utilization exceeds 80% for more than 5 minutes. This alert helps you recognize when a resource is under stress, potentially leading to performance issues if not addressed promptly.
-    
+
     Use Simple Notification Service(SNS) Topics:
     Amazon Simple Notification Service (SNS) is a fully managed messaging service that enables you to send notifications or messages to a large number of recipients in a scalable and reliable manner. SNS supports various communication protocols, including email, SMS, and mobile push notifications, making it a versatile tool for alerting and automated notifications.
-    
+
     - SNS topics act as channels through which notifications are sent. When a CloudWatch alarm is triggered, SNS can deliver messages to multiple subscribers via different communication methods like email, SMS, or even invoking Lambda functions for automated responses.
     - You can create an SNS topic and subscribe your desired communication endpoints (e.g., email addresses, phone numbers) to it.
     - Link your CloudWatch alarms to the SNS topic. When an alarm is triggered, SNS will automatically send notifications to all subscribers, ensuring that your operations team is informed immediately.
     - Example: Suppose you have a critical application running on AWS, and you've set a CloudWatch alarm to monitor its CPU utilization. By configuring an SNS topic linked to this alarm, you can automatically send an email alert to your operations team whenever the CPU utilization exceeds 80% for more than 5 minutes. This proactive approach allows your team to investigate and address the issue before it escalates into a more serious problem.
-2. Implement proper tagging and resource organization
-    
+
+2.  Implement proper tagging and resource organization
+
     Consistent Tagging:
-    
+
     - Apply consistent tagging strategies across all AWS resources. Tags are key-value pairs that help categorize and manage resources effectively. Use tags to group resources by environment (e.g., development, staging, production), application, or department.
     - Example: Tag EC2 instances with "Environment: Production" and "Application: WebServer" to facilitate resource management and cost tracking.
-    
+
     Logical Grouping:
-    
+
     - Organize resources into logical groups or resource pools based on their functions or roles. This organization helps streamline management and makes it easier to apply policies or monitor related resources collectively.
     - Example: Group all resources related to a specific application into a resource group, making it simpler to manage and monitor those resources as a unit.
-3. Utilize AWS-native tools for cost-effective observability
-Leveraging AWS-native tools is essential for implementing a cost-effective observability strategy. AWS provides powerful tools like CloudWatch Logs Insights and AWS X-Ray, which offer deep visibility into your system without the need for extensive additional infrastructure.
-    
-    CloudWatch Logs Insights
-    
-    - CloudWatch Logs Insights is used to search, analyze, and visualize log data. It’s especially useful for identifying trends, troubleshooting issues, and understanding system performance over time. By using this tool, you can extract meaningful information from vast amounts of log data without needing to export it to external systems.
-    - Example: Suppose your application is experiencing intermittent errors, and you want to identify the root cause. Using CloudWatch Logs Insights, you can run a query to search for error messages within your application logs. For instance, you could filter logs by error level, aggregate the results by the specific error type, and analyze the time of occurrence to identify patterns. This proactive analysis helps you spot recurring issues, understand their impact, and take corrective actions to enhance application reliability.
-    
-    AWS X-Ray
-    
-    - X-Ray is used to trace requests as they travel through your application, from the frontend to the backend, across multiple microservices. This level of visibility is crucial for understanding the internal workings of complex, distributed systems, especially when diagnosing latency issues or errors.
-    - Imagine a scenario where users are reporting slow response times from your application. By using AWS X-Ray, you can trace a user request from the frontend (e.g., a web or mobile application) through multiple backend services (e.g., APIs, databases). X-Ray will show you a timeline of how long each service took to process the request. If you notice that a particular microservice is causing delays, you can focus your efforts on optimizing that service, such as by improving its code or scaling its resources.
-4. Integrate observability into your CI/CD pipeline: 
-    
-    Observability Checks: 
-    
+
+3.  Utilize AWS-native tools for cost-effective observability
+    Leveraging AWS-native tools is essential for implementing a cost-effective observability strategy. AWS provides powerful tools like CloudWatch Logs Insights and AWS X-Ray, which offer deep visibility into your system without the need for extensive additional infrastructure.
+        CloudWatch Logs Insights
+
+        - CloudWatch Logs Insights is used to search, analyze, and visualize log data. It’s especially useful for identifying trends, troubleshooting issues, and understanding system performance over time. By using this tool, you can extract meaningful information from vast amounts of log data without needing to export it to external systems.
+        - Example: Suppose your application is experiencing intermittent errors, and you want to identify the root cause. Using CloudWatch Logs Insights, you can run a query to search for error messages within your application logs. For instance, you could filter logs by error level, aggregate the results by the specific error type, and analyze the time of occurrence to identify patterns. This proactive analysis helps you spot recurring issues, understand their impact, and take corrective actions to enhance application reliability.
+
+        AWS X-Ray
+
+        - X-Ray is used to trace requests as they travel through your application, from the frontend to the backend, across multiple microservices. This level of visibility is crucial for understanding the internal workings of complex, distributed systems, especially when diagnosing latency issues or errors.
+        - Imagine a scenario where users are reporting slow response times from your application. By using AWS X-Ray, you can trace a user request from the frontend (e.g., a web or mobile application) through multiple backend services (e.g., APIs, databases). X-Ray will show you a timeline of how long each service took to process the request. If you notice that a particular microservice is causing delays, you can focus your efforts on optimizing that service, such as by improving its code or scaling its resources.
+4.  Integrate observability into your CI/CD pipeline:
+
+    Observability Checks:
+
     - Incorporate observability checks into your Continuous Integration/Continuous Deployment (CI/CD) pipeline to ensure that new code deployments are monitored effectively.
     - This includes configuring monitoring tools to track performance metrics and log data as part of the deployment process.
     - Example: Include steps in your CI/CD pipeline to automatically set up new CloudWatch alarms and update existing dashboards when deploying new versions of your application.
-    
-     Automate Updates:
-    
+
+    Automate Updates:
+
     - Automate the process of updating dashboards and alerts to reflect changes made during deployments. Ensure that monitoring tools and visualizations are kept up to date with the latest system configurations and releases.
     - Example: Use deployment scripts to update Grafana dashboards with new metrics or data sources associated with the latest application version.
 
@@ -193,11 +208,11 @@ Challenge: Managing large volumes of observability data in AWS environments can
 Solution:
 
 - Implement [Log Retention](https://signoz.io/guides/log-retention/) Policies:
-Set up retention policies in CloudWatch Logs to automatically delete old data that is no longer needed. This helps in reducing storage costs and keeping your logs manageable. For instance, you might choose to retain application logs for 30 days while keeping critical security logs for a longer duration.
+  Set up retention policies in CloudWatch Logs to automatically delete old data that is no longer needed. This helps in reducing storage costs and keeping your logs manageable. For instance, you might choose to retain application logs for 30 days while keeping critical security logs for a longer duration.
 - Use CloudWatch Logs Insights for Efficient Log Querying:
-CloudWatch Logs Insights allows you to efficiently query large volumes of log data without sifting through it manually. This can save time and resources when diagnosing issues or analyzing trends. The tool's powerful query language lets you filter and analyze logs quickly, helping you focus on the most relevant data.
+  CloudWatch Logs Insights allows you to efficiently query large volumes of log data without sifting through it manually. This can save time and resources when diagnosing issues or analyzing trends. The tool's powerful query language lets you filter and analyze logs quickly, helping you focus on the most relevant data.
 - Leverage S3 for Long-Term Storage of Historical Data:
-Consider exporting logs to Amazon S3 for longer-term data storage. S3 is a cost-effective and scalable option for long-term storage, allowing you to preserve historical logs that are seldom viewed yet necessary for compliance or auditing.
+  Consider exporting logs to Amazon S3 for longer-term data storage. S3 is a cost-effective and scalable option for long-term storage, allowing you to preserve historical logs that are seldom viewed yet necessary for compliance or auditing.
 
 ### Security and Compliance
 
@@ -206,11 +221,11 @@ Challenge: Ensuring that observability data in AWS environments is secure and co
 Solution:
 
 - Use IAM Roles to Control Access to Observability Data:
-Use AWS Identity and Access Management (IAM) roles to implement rigorous access constraints. By assigning precise roles and permissions, you can guarantee that important observability data is only accessible to authorised people and services, lowering the risk of unauthorised access.
+  Use AWS Identity and Access Management (IAM) roles to implement rigorous access constraints. By assigning precise roles and permissions, you can guarantee that important observability data is only accessible to authorised people and services, lowering the risk of unauthorised access.
 - Encrypt Data at Rest and in Transit:
-Protect your observability data by encrypting it both at rest and in transit. AWS provides several encryption options, including AWS Key Management Service (KMS), to secure your data. This is particularly important for compliance with regulations that mandate data protection measures.
+  Protect your observability data by encrypting it both at rest and in transit. AWS provides several encryption options, including AWS Key Management Service (KMS), to secure your data. This is particularly important for compliance with regulations that mandate data protection measures.
 - Implement Audit Trails Using CloudTrail
-AWS CloudTrail provides detailed logs of API activity across your AWS environment. By enabling CloudTrail, you can maintain a comprehensive audit trail that records who accessed what data and when, supporting both security and compliance efforts.
+  AWS CloudTrail provides detailed logs of API activity across your AWS environment. By enabling CloudTrail, you can maintain a comprehensive audit trail that records who accessed what data and when, supporting both security and compliance efforts.
 
 ### Cost Management
 
@@ -219,11 +234,11 @@ Challenge: Implementing observability in AWS environments can result in unexpect
 Solution:
 
 - Use CloudWatch Contributor Insights to Identify Top Contributors to Costs:
-CloudWatch Contributor Insights helps you analyze your observability data to identify the most significant contributors to your costs. By pinpointing specific services, users, or actions that generate high volumes of logs or metrics, you can take targeted actions to optimize and reduce expenses.
+  CloudWatch Contributor Insights helps you analyze your observability data to identify the most significant contributors to your costs. By pinpointing specific services, users, or actions that generate high volumes of logs or metrics, you can take targeted actions to optimize and reduce expenses.
 - Implement Data Sampling for High-Volume Metrics:
-For metrics that are collected at high volumes, consider using data sampling techniques to reduce the amount of data processed and stored. By sampling data, you can maintain visibility into system performance while keeping costs under control.
+  For metrics that are collected at high volumes, consider using data sampling techniques to reduce the amount of data processed and stored. By sampling data, you can maintain visibility into system performance while keeping costs under control.
 - Regularly Review and Optimize Your Observability Setup:
-Conduct periodic reviews of your observability configuration to identify areas where you can cut costs. This might involve adjusting retention policies, consolidating dashboards, or optimizing data collection practices.
+  Conduct periodic reviews of your observability configuration to identify areas where you can cut costs. This might involve adjusting retention policies, consolidating dashboards, or optimizing data collection practices.
 
 ### Multi-Account and Multi-Region Observability
 
@@ -232,11 +247,11 @@ Challenge: Maintaining consistent observability across complex AWS environments,
 Solution:
 
 1. Use AWS Organizations for Centralized Management:
-AWS Organisations enables you to centrally manage many AWS accounts inside your organisation. Creating a hierarchical account structure allows you to impose similar observability policies across all settings, simplifying management and increasing visibility.
+   AWS Organisations enables you to centrally manage many AWS accounts inside your organisation. Creating a hierarchical account structure allows you to impose similar observability policies across all settings, simplifying management and increasing visibility.
 2. Implement Cross-Account and Cross-Region CloudWatch Dashboards:
-CloudWatch supports cross-account and cross-region dashboards, enabling you to monitor metrics from different accounts and regions in a single, unified view. This helps maintain a consistent observability strategy across your entire AWS environment, regardless of its complexity.
+   CloudWatch supports cross-account and cross-region dashboards, enabling you to monitor metrics from different accounts and regions in a single, unified view. This helps maintain a consistent observability strategy across your entire AWS environment, regardless of its complexity.
 3. Leverage AWS Control Tower for Standardized Observability Setups:
-AWS Control Tower provides a framework for setting up and governing a multi-account AWS environment. By using Control Tower, you can enforce standardized observability setups, ensuring that all accounts adhere to the same monitoring and logging practices from the start.
+   AWS Control Tower provides a framework for setting up and governing a multi-account AWS environment. By using Control Tower, you can enforce standardized observability setups, ensuring that all accounts adhere to the same monitoring and logging practices from the start.
 
 ## Advanced AWS Observability Techniques
 
@@ -310,34 +325,52 @@ Here's how you can leverage SigNoz for AWS Monitoring solutions:
 
 <GetStartedSigNoz />
 
-1. Using SigNoz AWS Monitoring: 
+1. Using SigNoz AWS Monitoring:
 
-In the top left corner, click on `Get Started`. 
+In the top left corner, click on `Get Started`.
 
-<Figure src="/img/guides/2024/09/aws-observability-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/09/aws-observability-Screenshot_2024-08-07_at_2.39.26_PM.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
 You will be redirected to “Get Started Page”. Choose `AWS Monitoring`.
 
-<Figure src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_9.30.07_PM.webp" alt="AWS Monitoring" caption="AWS Monitoring" />
+<Figure
+  src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_9.30.07_PM.webp"
+  alt="AWS Monitoring"
+  caption="AWS Monitoring"
+/>
 
 1. Select Data Source:
-You need to select the Data Source. Since the metrics to be collected here are from the EC2 Infrastructure, select `EC2 - Infra Metrics`.
-
-<Figure src="/img/guides/2024/09/aws-observability-c1fc1482-4981-441d-b6e0-5a4165a2cce0.webp" alt="Select Data Source" caption="Select Data Source" />
-
-Choose the environment of your host system. For this demo, I am using my `AWS EC2 t2.micro Instance`, which is Linux AMD64, choose according to your infrastructure. 
-
-<Figure src="/img/guides/2024/09/aws-observability-2e586d84-0549-45b7-aafa-72b6fd009816.webp" alt="Select Data Source" caption="Select Data Source" />
-
-1. Setup OpenTelemetry Binary as an agent:
-Follow the steps in the SigNoz Cloud section of this [tutorial](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to get your OTel Collector agent up and running.
-    
-    Note: Download the <a href="https://github.com/open-telemetry/opentelemetry-collector/releases" rel="noopener noreferrer nofollow" target="_blank">latest version</a> of the Otel Collector that matches your host operating system.
-    
-2. Configure the Host Metrics Dashboard: 
-To send host metrics to SigNoz, refer to the [documentation](https://signoz.io/docs/userguide/hostmetrics) for detailed instructions.
-
-<Figure src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_11.03.50_PM.webp" alt="SigNoz Dashboard for EC2 Instance" caption="SigNoz Dashboard for EC2 Instance" />
+   You need to select the Data Source. Since the metrics to be collected here are from the EC2 Infrastructure, select `EC2 - Infra Metrics`.
+
+<Figure
+  src="/img/guides/2024/09/aws-observability-c1fc1482-4981-441d-b6e0-5a4165a2cce0.webp"
+  alt="Select Data Source"
+  caption="Select Data Source"
+/>
+
+Choose the environment of your host system. For this demo, I am using my `AWS EC2 t2.micro Instance`, which is Linux AMD64, choose according to your infrastructure.
+
+<Figure
+  src="/img/guides/2024/09/aws-observability-2e586d84-0549-45b7-aafa-72b6fd009816.webp"
+  alt="Select Data Source"
+  caption="Select Data Source"
+/>
+
+1.  Setup OpenTelemetry Binary as an agent:
+    Follow the steps in the SigNoz Cloud section of this [tutorial](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to get your OTel Collector agent up and running.
+        Note: Download the <a href="https://github.com/open-telemetry/opentelemetry-collector/releases" rel="noopener noreferrer nofollow" target="_blank">latest version</a> of the Otel Collector that matches your host operating system.
+2.  Configure the Host Metrics Dashboard:
+    To send host metrics to SigNoz, refer to the [documentation](https://signoz.io/docs/userguide/hostmetrics) for detailed instructions.
+
+<Figure
+  src="/img/guides/2024/09/aws-observability-Screenshot_2024-09-03_at_11.03.50_PM.webp"
+  alt="SigNoz Dashboard for EC2 Instance"
+  caption="SigNoz Dashboard for EC2 Instance"
+/>
 
 ## Key Takeaways
 
@@ -378,4 +411,4 @@ Yes, many AWS observability solutions are compatible with non-AWS resources. Ama
 - Consistent tagging and naming conventions: Use uniform tags and naming conventions across all accounts to simplify data organization and retrieval.
 - Scalable data collection and storage solutions: Design solutions that can handle the growing volume of observability data across multiple accounts without compromising performance.
 - Cross-account access controls: Implement robust access controls to ensure that the right stakeholders can access the observability data they need while maintaining security.
-- Create dashboards that combine data from all accounts, giving you a full picture of your AWS environment for better monitoring and insights.
\ No newline at end of file
+- Create dashboards that combine data from all accounts, giving you a full picture of your AWS environment for better monitoring and insights.
diff --git a/data/guides/azure-app-insights.mdx b/data/guides/azure-app-insights.mdx
index ec155ce79..6d58d9fab 100644
--- a/data/guides/azure-app-insights.mdx
+++ b/data/guides/azure-app-insights.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Azure Application Insights - How to Monitor
-slug: azure-app-insights
 date: 2024-08-21
 tags: [monitoring]
 authors: [simran_kumari]
 description: Learn how to effectively monitor your applications using Azure Application Insights. Discover setup, key metrics, troubleshooting, and best practices.
-keywords: [azure application insights, app monitoring, performance tracking, web analytics, cloud monitoring, application performance management, azure monitor, telemetry]
-
+keywords:
+  [
+    azure application insights,
+    app monitoring,
+    performance tracking,
+    web analytics,
+    cloud monitoring,
+    application performance management,
+    azure monitor,
+    telemetry,
+  ]
 ---
 
 Azure Application Insights is a powerful monitoring service that helps you keep your applications running smoothly. It provides real-time insights into your application's performance, user behaviour, and potential issues. This comprehensive guide will walk you through the essentials of Azure App Insights, from setup to advanced usage.
@@ -21,7 +28,11 @@ Azure Application Insights is a comprehensive application performance management
 3. Detect and diagnose issues quickly
 4. Make data-driven decisions for improvements
 
-<Figure src="/img/guides/2024/08/azure-app-insights-image.webp" alt="Working of Azure App Insights" caption="Working of Azure App Insights" /> 
+<Figure
+  src="/img/guides/2024/08/azure-app-insights-image.webp"
+  alt="Working of Azure App Insights"
+  caption="Working of Azure App Insights"
+/>{' '}
 
 This service supports a wide range of web, mobile, desktop, and even IoT applications. It's part of the broader Azure Monitor platform, which provides a complete solution for collecting, analyzing, and acting on telemetry from your cloud and on-premises environments.
 
@@ -42,116 +53,158 @@ Setting up Application Insights is straightforward. Here's a step-by-step guide:
 
 1. Log in to the Azure Portal: Go to the <a href="https://portal.azure.com/" rel="noopener noreferrer nofollow" target="_blank">Azure Portal</a> and sign in with your Azure account credentials.
 2. Create a New Resource: In the Azure Portal, click on the “Create a resource” button in the left-hand menu.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%201.webp" alt="Creating a new Resource" caption="Creating a new Resource" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%201.webp"
+     alt="Creating a new Resource"
+     caption="Creating a new Resource"
+   />
+
 3. Search for Application Insights: In the search bar, type “Application Insights” and select it from the list.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%202.webp" alt="Search for Application Insights in Azure Portal" caption="Search for Application Insights in Azure Portal" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%202.webp"
+     alt="Search for Application Insights in Azure Portal"
+     caption="Search for Application Insights in Azure Portal"
+   />
+
 4. Configure Your Resource: Click on “Create” and fill out the required details such as Subscription, Resource Group, and Name. You can also choose your preferred Region and the type of application you want to monitor.
-    
-    Here's a brief summary of what to fill:
-    
-    - Subscription: Choose the billing account.
-    - Resource Group: Select or create a logical container for related resources.
-    - Name: Enter a unique and descriptive resource name.
-    - Region: Pick a geographical location for the resource.
-    - Type of Application: Select the application type you want to monitor (e.g., web, mobile).
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%203.webp" alt="Creating an Application Insights in Azure" caption="Creating an Application Insights in Azure" />
-    
+
+   Here's a brief summary of what to fill:
+
+   - Subscription: Choose the billing account.
+   - Resource Group: Select or create a logical container for related resources.
+   - Name: Enter a unique and descriptive resource name.
+   - Region: Pick a geographical location for the resource.
+   - Type of Application: Select the application type you want to monitor (e.g., web, mobile).
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%203.webp"
+     alt="Creating an Application Insights in Azure"
+     caption="Creating an Application Insights in Azure"
+   />
+
 5. Review and Create: Review your configuration and click “Create” to provision your Application Insights resource.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%204.webp" alt="Azure Application Insights deployment in progress" caption="Azure Application Insights deployment in progress" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%204.webp"
+     alt="Azure Application Insights deployment in progress"
+     caption="Azure Application Insights deployment in progress"
+   />
 
 ### Obtaining the Connection String
 
 1. Navigate to Your Application Insights Resource: Once your resource is created, go to the resource overview page in the Azure Portal.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%205.webp" alt="Navigating to Application Insights Resource" caption="Navigating to Application Insights Resource" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%205.webp"
+     alt="Navigating to Application Insights Resource"
+     caption="Navigating to Application Insights Resource"
+   />
+
 2. Copy the Connection String: Under the “Overview” tab, you’ll find the Connection String. Copy this string as it will be needed to configure your application for telemetry data.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%206.webp" alt="Fetching the Connection String" caption="Fetching the Connection String" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%206.webp"
+     alt="Fetching the Connection String"
+     caption="Fetching the Connection String"
+   />
 
 ### Integrating Application Insights SDK into Your Application
 
 1. Add the SDK to Your Application: Depending on your application’s technology stack, install the appropriate Application Insights SDK. For example:
-    - .NET: Use NuGet to install `Microsoft.ApplicationInsights.AspNetCore` package.
-    - Java: Add `applicationinsights-core` dependency in your `pom.xml` or `build.gradle`.
-    - Node.js: Use npm to install the `applicationinsights` package.
-2. Initialize the SDK: In your application’s startup code, initialize the Application Insights SDK by providing the `Connection String`you obtained earlier. For example, in a Node.js application: 
-    - Before initializing application insights SDK:
-    
-    ```jsx
-    const express = require('express');
-    const app = express();
-    const port = 3000;
-    
-    app.get('/', (req, res) => {
-      res.send('Hello World!');
-    });
-    
-    app.listen(port, () => {
-      console.log(`App listening at http://localhost:${port}`);
-    });
-    ```
-    
-    - After initializing application insights SDK:
-    
-    ```jsx
-    const express = require('express');
-    const app = express();
-    const port = 3000;
-    const appInsights = require('applicationinsights');
-    
-    // Initialize Application Insights with your Instrumentation Key
-    appInsights.setup('YOUR_CONNECTION_STRING')
-      .setAutoCollectConsole(true, true)
-      .setAutoCollectExceptions(true)
-      .setAutoCollectRequests(true)
-      .start();
-    
-    // Create a default client
-    const client = appInsights.defaultClient;
-    
-    app.get('/', (req, res) => {
-      client.trackEvent({ name: "Homepage accessed" }); // Track a custom event
-      res.send('Hello World!');
-    });
-    
-    app.listen(port, () => {
-      console.log(`App listening at http://localhost:${port}`);
-    });
-    ```
-    
+   - .NET: Use NuGet to install `Microsoft.ApplicationInsights.AspNetCore` package.
+   - Java: Add `applicationinsights-core` dependency in your `pom.xml` or `build.gradle`.
+   - Node.js: Use npm to install the `applicationinsights` package.
+2. Initialize the SDK: In your application’s startup code, initialize the Application Insights SDK by providing the `Connection String`you obtained earlier. For example, in a Node.js application:
+
+   - Before initializing application insights SDK:
+
+   ```jsx
+   const express = require('express')
+   const app = express()
+   const port = 3000
+
+   app.get('/', (req, res) => {
+     res.send('Hello World!')
+   })
+
+   app.listen(port, () => {
+     console.log(`App listening at http://localhost:${port}`)
+   })
+   ```
+
+   - After initializing application insights SDK:
+
+   ```jsx
+   const express = require('express')
+   const app = express()
+   const port = 3000
+   const appInsights = require('applicationinsights')
+
+   // Initialize Application Insights with your Instrumentation Key
+   appInsights
+     .setup('YOUR_CONNECTION_STRING')
+     .setAutoCollectConsole(true, true)
+     .setAutoCollectExceptions(true)
+     .setAutoCollectRequests(true)
+     .start()
+
+   // Create a default client
+   const client = appInsights.defaultClient
+
+   app.get('/', (req, res) => {
+     client.trackEvent({ name: 'Homepage accessed' }) // Track a custom event
+     res.send('Hello World!')
+   })
+
+   app.listen(port, () => {
+     console.log(`App listening at http://localhost:${port}`)
+   })
+   ```
+
 3. Verify the Integration: Start your application and ensure that the Application Insights SDK is correctly initialized and sending telemetry data to Azure.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%207.webp" alt="Visualizing Request trace data" caption="Visualizing Request trace data" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%207.webp"
+     alt="Visualizing Request trace data"
+     caption="Visualizing Request trace data"
+   />
 
 ### Configuring Data Collection and Sampling Options
 
 1. Access the Configuration Settings: In the Azure Portal, navigate to your Application Insights resource and go to the “Configure” section.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%208.webp" alt="Configuring Data Collection and Sampling Options" caption="Configuring Data Collection and Sampling Options" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%208.webp"
+     alt="Configuring Data Collection and Sampling Options"
+     caption="Configuring Data Collection and Sampling Options"
+   />
+
 2. Adjust Sampling Settings: Configure sampling settings to control the volume of data sent to Application Insights. This helps in reducing data storage costs and avoiding noise from unimportant telemetry. To configure data sampling, under the Configure section go to `Usage and Estimated Costs` click on `Data Sampling`, and adjust the data volume accordingly.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-image%209.webp" alt="Data sampling in Azure app insights" caption="Data sampling in Azure app insights" />
-    
-3. Set Up Data Collection: 
-    1. Move to Monitoring section, under that select the `Diagnostic settings` and click on the `Add diagnostic setting` option. 
-        
-        <Figure src="/img/guides/2024/08/azure-app-insights-image%2010.webp" alt="image.webp" caption="image.webp" />
-        
-    2. Here, you can choose what kind of telemetry you want to collect, such as requests, exceptions, traces, custom events, and metrics.  If you want to collect all types of data, we can select `allLogs` checkbox.
-        
-        <Figure src="/img/guides/2024/08/azure-app-insights-image%2011.webp" alt="Data collection configuration in Azure application insights" caption="Data collection configuration in Azure application insights" />
-        
+
+   <Figure
+     src="/img/guides/2024/08/azure-app-insights-image%209.webp"
+     alt="Data sampling in Azure app insights"
+     caption="Data sampling in Azure app insights"
+   />
+
+3. Set Up Data Collection:
+   1. Move to Monitoring section, under that select the `Diagnostic settings` and click on the `Add diagnostic setting` option.
+
+      <Figure
+        src="/img/guides/2024/08/azure-app-insights-image%2010.webp"
+        alt="image.webp"
+        caption="image.webp"
+      />
+
+   2. Here, you can choose what kind of telemetry you want to collect, such as requests, exceptions, traces, custom events, and metrics. If you want to collect all types of data, we can select `allLogs` checkbox.
+
+      <Figure
+        src="/img/guides/2024/08/azure-app-insights-image%2011.webp"
+        alt="Data collection configuration in Azure application insights"
+        caption="Data collection configuration in Azure application insights"
+      />
 4. Save and Apply Settings: Save your settings once you have configured the data collection and sampling options. Your application is now set up with Azure Application Insights, and you can start monitoring its performance and usage in real-time.
 
 By following these steps, you can effectively set up Azure Application Insights to gain deep insights into your application’s health and usage, enabling you to make data-driven decisions to enhance performance and reliability.
@@ -209,72 +262,79 @@ Performance counters and resource utilization metrics provide insights into the
 - Memory Usage: Tracks the amount of memory used by your application. Monitoring memory usage helps identify memory leaks and optimize resource allocation.
 - Disk I/O: Measures the read and write operations on the disk. High disk I/O can impact application performance and indicate the need for optimization.
 
-<Figure src="/img/guides/2024/08/azure-app-insights-image%2012.webp" alt="Key Monitoring Metrics in Azure Application Insights: Summary" caption="Key Monitoring Metrics in Azure Application Insights: Summary" />
+<Figure
+  src="/img/guides/2024/08/azure-app-insights-image%2012.webp"
+  alt="Key Monitoring Metrics in Azure Application Insights: Summary"
+  caption="Key Monitoring Metrics in Azure Application Insights: Summary"
+/>
 
 ## How to Use Application Insights for Troubleshooting
 
 Application Insights shines when it comes to troubleshooting. Here's how to leverage its features:
 
 1. Analyze application logs and traces:
-    - Use the Logs feature to query your telemetry data.
-    - Look for patterns or anomalies in your logs.
-    - Example: If you notice a spike in specific error messages, it can indicate a recurring issue that needs addressing.
-2. Identify performance bottlenecks: 
-    - Use the Performance blade to see end-to-end transaction details.
-    - Drill down into slow requests or dependencies.
-    - Example: If the Application Map shows a delay in a particular microservice, you can investigate that service’s performance and optimize its efficiency.
+   - Use the Logs feature to query your telemetry data.
+   - Look for patterns or anomalies in your logs.
+   - Example: If you notice a spike in specific error messages, it can indicate a recurring issue that needs addressing.
+2. Identify performance bottlenecks:
+   - Use the Performance blade to see end-to-end transaction details.
+   - Drill down into slow requests or dependencies.
+   - Example: If the Application Map shows a delay in a particular microservice, you can investigate that service’s performance and optimize its efficiency.
 3. Debug exceptions and failures:
-    - The Failures blade provides detailed stack traces for exceptions.
-    - Correlate failures with other metrics to understand root causes.
-    - Example: By analyzing a stack trace for an uncaught exception, you might find that an unexpected null reference caused the issue, leading to a code fix.
+   - The Failures blade provides detailed stack traces for exceptions.
+   - Correlate failures with other metrics to understand root causes.
+   - Example: By analyzing a stack trace for an uncaught exception, you might find that an unexpected null reference caused the issue, leading to a code fix.
 4. Correlate issues across distributed systems:
-    - Correlation IDs: Implement correlation IDs to trace the flow of a request through different services.
-        - Neglecting to use correlation IDs, making it difficult to connect related logs and telemetry from different services.
-        
-        <Figure src="/img/guides/2024/08/azure-app-insights-image%2013.webp" alt="Using Correlation IDs" caption="Using Correlation IDs" />
-        
+   - Correlation IDs: Implement correlation IDs to trace the flow of a request through different services.
+     - Neglecting to use correlation IDs, making it difficult to connect related logs and telemetry from different services.
+     {' '}
+     <Figure
+       src="/img/guides/2024/08/azure-app-insights-image%2013.webp"
+       alt="Using Correlation IDs"
+       caption="Using Correlation IDs"
+     />
 
 ## Best Practices for Azure Application Insights
 
 Tips to Enhance Troubleshooting Experience:
 
 - Implementing Proper Sampling Techniques to Manage Data Volume: Sampling helps manage the volume of data collected and processed, preventing data overload and reducing costs while still capturing representative performance insights.
-    - Example: Set up dynamic sampling in Application Insights to collect data from 10% of high-traffic requests, ensuring you capture enough data to analyze performance trends without exceeding data limits.
+  - Example: Set up dynamic sampling in Application Insights to collect data from 10% of high-traffic requests, ensuring you capture enough data to analyze performance trends without exceeding data limits.
 - Setting Up Meaningful Alerts and Action Groups: Alerts and action groups help you respond proactively to issues by notifying the right people and automating responses based on predefined conditions.
-    - Example: Configure an alert to trigger if the error rate exceeds 5% and send notifications to the on-call support team via SMS and email.
+  - Example: Configure an alert to trigger if the error rate exceeds 5% and send notifications to the on-call support team via SMS and email.
 - Using Application Map for Visualizing Application Dependencies: Application Map visually represents the relationships and dependencies between different components of your application, making it easier to identify issues and bottlenecks.
-    
-    <Figure src="/img/guides/2024/08/azure-app-insights-4bb9a52a-e36f-4f90-a5ff-558aab58290a.webp" alt="Using Application Map in Azure App Insights for Visualizing Application Dependencies" caption="Using Application Map in Azure App Insights for Visualizing Application Dependencies" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/azure-app-insights-4bb9a52a-e36f-4f90-a5ff-558aab58290a.webp"
+    alt="Using Application Map in Azure App Insights for Visualizing Application Dependencies"
+    caption="Using Application Map in Azure App Insights for Visualizing Application Dependencies"
+  />
 - Leverage Log Analytics with Kusto Query Language (KQL): KQL allows you to perform advanced querying on your telemetry data, providing deeper insights into application behavior and issues.
-    - Example: A KQL query might look like this:
-    
-    ```bash
-    requests
-    | where resultCode != "200"
-    | summarize count() by resultCode, bin(timestamp, 1h)
-    | order by count_ desc
-    ```
-    
-    This query counts failed requests by result code and shows trends over time.
-    
+  - Example: A KQL query might look like this:
+  ```bash
+  requests
+  | where resultCode != "200"
+  | summarize count() by resultCode, bin(timestamp, 1h)
+  | order by count_ desc
+  ```
+  This query counts failed requests by result code and shows trends over time.
 
 ## Cost Optimization Strategies for Application Insights
 
 While Application Insights is powerful, it's important to manage costs. Here are some strategies:
 
 1. Understand the pricing model:
-    - Costs are based on data ingestion and retention
-    - Plan your budget based on expected application usage
+   - Costs are based on data ingestion and retention
+   - Plan your budget based on expected application usage
 2. Implement intelligent data sampling:
-    - Use adaptive sampling to automatically adjust sampling rates
-    - Configure fixed-rate sampling for consistent data reduction
+   - Use adaptive sampling to automatically adjust sampling rates
+   - Configure fixed-rate sampling for consistent data reduction
 3. Utilize data retention policies:
-    - Set appropriate retention periods for your data
-    - Archive important data for long-term storage
+   - Set appropriate retention periods for your data
+   - Archive important data for long-term storage
 4. Monitor and adjust data caps:
-    - Set daily data volume caps to prevent unexpected charges
-    - Regularly review and adjust caps based on your needs
+   - Set daily data volume caps to prevent unexpected charges
+   - Regularly review and adjust caps based on your needs
 
 ## Limitations of Azure Application Insights
 
@@ -335,4 +395,4 @@ To reduce costs:
 3. Use daily data caps to prevent unexpected charges
 4. Regularly review and optimize your usage
 
-You can explore products like SigNoz for comprehensive yet cost effective approach to observability.
\ No newline at end of file
+You can explore products like SigNoz for comprehensive yet cost effective approach to observability.
diff --git a/data/guides/azure-observability.mdx b/data/guides/azure-observability.mdx
index da4aa8fe5..5decad288 100644
--- a/data/guides/azure-observability.mdx
+++ b/data/guides/azure-observability.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Azure Observability - Mastering Cloud Monitoring
-slug: azure-observability
 date: 2024-10-03
 tags: [observability]
 authors: [nitin_gouda]
 description: Discover how Azure Observability can revolutionize your cloud monitoring. Learn key components, implementation strategies, and best practices for optimal performance.
-keywords: [azure observability, cloud monitoring, application insights, log analytics, azure monitor, distributed tracing, observability patterns]
-
+keywords:
+  [
+    azure observability,
+    cloud monitoring,
+    application insights,
+    log analytics,
+    azure monitor,
+    distributed tracing,
+    observability patterns,
+  ]
 ---
 
 Azure Observability transforms how you monitor and manage your cloud infrastructure. It provides deep insights into your applications, infrastructure, and network — empowering you to detect and resolve issues faster than ever before. This comprehensive guide will walk you through the essentials of Azure Observability, from its core components to advanced implementation techniques.
@@ -18,27 +24,23 @@ Azure Observability is an advanced approach to understanding and monitoring the
 
 Key components of Azure Observability include:
 
-1. Azure Monitor:
-This is the core tool for observability within Azure. Azure Monitor collects and analyzes data from various Azure resources, applications, and virtual machines. It provides a centralized platform for gathering logs, metrics, and traces, allowing for real-time monitoring and alerting.
-    
-    <Figure src="/img/guides/2024/10/azure-observability-Screenshot_2024-09-23_at_9.15.59_PM.webp" alt="Azure Monitor" caption="Azure Monitor" />
-    
-2. Application Insights:
-Application Insights focuses specifically on application performance monitoring (APM). It allows you to track the performance of your applications in detail, providing insights such as request response times, user interactions, and error rates. This helps you ensure your applications run efficiently and meet user expectations.
-    
-    <Figure src="/img/guides/2024/10/azure-observability-image.webp" alt="Application insights ~ From Azure Docs" caption="Application insights ~ From Azure Docs" />
-    
+1.  Azure Monitor:
+    This is the core tool for observability within Azure. Azure Monitor collects and analyzes data from various Azure resources, applications, and virtual machines. It provides a centralized platform for gathering logs, metrics, and traces, allowing for real-time monitoring and alerting.
+        <Figure src="/img/guides/2024/10/azure-observability-Screenshot_2024-09-23_at_9.15.59_PM.webp" alt="Azure Monitor" caption="Azure Monitor" />
+2.  Application Insights:
+    Application Insights focuses specifically on application performance monitoring (APM). It allows you to track the performance of your applications in detail, providing insights such as request response times, user interactions, and error rates. This helps you ensure your applications run efficiently and meet user expectations.
+        <Figure src="/img/guides/2024/10/azure-observability-image.webp" alt="Application insights ~ From Azure Docs" caption="Application insights ~ From Azure Docs" />
 
 Implementing observability in Azure environments offers several benefits:
 
 - Proactive issue detection:
-Azure Observability allows you to spot issues before they impact end users. Monitoring key performance indicators (KPIs) and setting up alerts allows you to spot anomalies early on and take action to avoid downtime or performance degradation.
-- Faster troubleshooting: 
-Observability tools allow you to pinpoint the root cause when issues arise. By correlating logs, metrics, and traces, you get a complete picture of the issue, making it easier to diagnose and resolve problems faster than traditional monitoring would allow.
-- Improved performance: 
-With [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and real-time insights, you can optimize your applications by identifying bottlenecks and areas for improvement. Whether it's tuning resource allocation or refining application code, observability gives you the data needed to enhance performance.
-- Enhanced decision-making: 
-Azure Observability supports data-driven decisions around scaling, resource allocation, and infrastructure management. Instead of guessing, you can rely on insights from observability tools to determine when to scale up or down, ensuring cost-efficiency and performance balance.
+  Azure Observability allows you to spot issues before they impact end users. Monitoring key performance indicators (KPIs) and setting up alerts allows you to spot anomalies early on and take action to avoid downtime or performance degradation.
+- Faster troubleshooting:
+  Observability tools allow you to pinpoint the root cause when issues arise. By correlating logs, metrics, and traces, you get a complete picture of the issue, making it easier to diagnose and resolve problems faster than traditional monitoring would allow.
+- Improved performance:
+  With [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and real-time insights, you can optimize your applications by identifying bottlenecks and areas for improvement. Whether it's tuning resource allocation or refining application code, observability gives you the data needed to enhance performance.
+- Enhanced decision-making:
+  Azure Observability supports data-driven decisions around scaling, resource allocation, and infrastructure management. Instead of guessing, you can rely on insights from observability tools to determine when to scale up or down, ensuring cost-efficiency and performance balance.
 
 Unlike traditional monitoring, which often provides a fragmented view of your environment, Azure Observability gives you a holistic and interconnected view. This means you can see how different components of your system—like applications, databases, and virtual machines—interact. This interconnected data allows for deeper understanding, making it easier to maintain system health, detect and prevent issues, and continuously improve application performance.
 
@@ -49,13 +51,17 @@ Azure Monitor forms the foundation of Azure observability. It collects and analy
 Telemetry data is the key to understanding the performance and health of your systems. In Azure Observability, this data is categorized into three main types:
 
 1. Metrics:
-Metrics are numerical values that measure the state of a specific aspect of your system at a given moment. Examples include CPU usage, memory consumption, and request response times. Metrics provide real-time insights into how your system is performing at any particular point in time, helping you identify trends or spikes in resource usage.
+   Metrics are numerical values that measure the state of a specific aspect of your system at a given moment. Examples include CPU usage, memory consumption, and request response times. Metrics provide real-time insights into how your system is performing at any particular point in time, helping you identify trends or spikes in resource usage.
 2. Logs:
-Logs are records of events that happen on your system. They record information regarding system activities, such as when a service begins or ends, when mistakes occur, or when particular thresholds are met. Logs give a thorough historical record that is essential for troubleshooting, auditing, and determining how your system acted over time.
+   Logs are records of events that happen on your system. They record information regarding system activities, such as when a service begins or ends, when mistakes occur, or when particular thresholds are met. Logs give a thorough historical record that is essential for troubleshooting, auditing, and determining how your system acted over time.
 3. Traces:
-Traces give a thorough record of how a request moves through your system. They provide insight into how various components in your system interact, allowing you to understand how data flows across services and detect bottlenecks or sites of failure. This is particularly useful in microservices systems, where queries may span numerous services.
+   Traces give a thorough record of how a request moves through your system. They provide insight into how various components in your system interact, allowing you to understand how data flows across services and detect bottlenecks or sites of failure. This is particularly useful in microservices systems, where queries may span numerous services.
 
-<Figure src="/img/guides/2024/10/azure-observability-image%201.webp" alt="Venn Diagram of logs, metrics and traces" caption="Venn Diagram of logs, metrics and traces" />
+<Figure
+  src="/img/guides/2024/10/azure-observability-image%201.webp"
+  alt="Venn Diagram of logs, metrics and traces"
+  caption="Venn Diagram of logs, metrics and traces"
+/>
 
 Azure Observability also integrates with Azure Resource Health and Azure Service Health to provide additional layers of visibility. These tools focus on the availability and health of Azure services and your specific resources:
 
@@ -66,98 +72,78 @@ Azure Observability also integrates with Azure Resource Health and Azure Service
 
 To make the most of Azure Observability, it's essential to implement specific patterns that enhance visibility, troubleshooting, and system optimization. These patterns allow you to understand your systems at a deeper level and respond proactively to issues before they impact your users. Here are some of the key observability patterns to focus on:
 
-1. [Distributed tracing](https://signoz.io/blog/distributed-tracing/) for microservices architectures: 
-In microservices architectures, applications are often composed of multiple independent services that work together to fulfill requests. Distributed tracing helps you follow a request as it flows through each of these services. 
-By capturing the full journey of a request, you can:
-    - Identify bottlenecks or slow services that affect overall performance.
-    - Pinpoint failures or errors in specific parts of your architecture.
-    - Understand how various services are interacting and dependent on one another.
-    
-    Distributed tracing is extremely useful for troubleshooting complicated, distributed systems, where errors in one service might have far-reaching consequences throughout the application. Distributed tracing is typically done by instrumenting your services with tracing libraries or agents that generate trace data for each request. This data is then collected and visualized in tools like Jaeger, Zipkin, or Azure Monitor, allowing you to track the flow of requests across microservices and identify performance issues or failures.
-    
-2. Centralized logging and log analytics:
-Managing logs from multiple resources, applications, and environments can be overwhelming without a centralized logging approach. By aggregating all your logs in a single location, such as Azure Monitor's Log Analytics, you can:
-    - Correlate events across different services, making it easier to troubleshoot complex issues.
-    - Use queries and filters to extract meaningful insights from large volumes of log data.
-    - Set up alerts based on log patterns, such as repeated errors or failure events.
-    
-    Centralized logging provides a unified view of your system’s behaviour and simplifies the task of identifying and responding to issues. To setup your own Centralized logging you can check the steps <a href="https://learn.microsoft.com/en-us/azure/azure-monitor/logs/quick-create-workspace?tabs=azure-portal" rel="noopener noreferrer nofollow" target="_blank">here</a>.
-    
-3. Real-time metrics and dashboards: 
-Real-time metrics are crucial to monitor the health of your systems effectively. With Azure Monitor, you can create custom dashboards that visualize key performance indicators (KPIs) such as CPU usage, memory consumption, or application response times. These dashboards allow you to:
-    - Spot trends and anomalies quickly.
-    - Keep track of critical performance metrics in real time.
-    - Customize your views to focus on the data most relevant to your team.
-    
-    Dashboards help you monitor your environment at a glance, making it easier to react swiftly to changes or potential issues.
-    
-    <Figure src="/img/guides/2024/10/azure-observability-image%202.webp" alt="Azure Dashboard ~ From Azure Docs" caption="Azure Dashboard ~ From Azure Docs" />
-    
-4. Anomaly detection and predictive analytics: 
-Azure’s advanced observability tools use machine learning algorithms to automatically detect unusual patterns or behaviours in your system. By implementing anomaly detection and predictive analytics, you can:
-    - Identify performance issues or system degradation before they become critical.
-    - Leverage predictive insights to forecast potential outages or resource shortages.
-    - Automatically trigger alerts or remediation actions when anomalies are detected.
-    
-    This proactive approach ensures you can fix problems before they affect end users, improving system reliability and reducing downtime. To learn more about it, you can see the documentation page <a href="https://learn.microsoft.com/en-gb/azure/ai-services/anomaly-detector/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
-    
+1.  [Distributed tracing](https://signoz.io/blog/distributed-tracing/) for microservices architectures:
+    In microservices architectures, applications are often composed of multiple independent services that work together to fulfill requests. Distributed tracing helps you follow a request as it flows through each of these services.
+    By capturing the full journey of a request, you can: - Identify bottlenecks or slow services that affect overall performance. - Pinpoint failures or errors in specific parts of your architecture. - Understand how various services are interacting and dependent on one another.
+        Distributed tracing is extremely useful for troubleshooting complicated, distributed systems, where errors in one service might have far-reaching consequences throughout the application. Distributed tracing is typically done by instrumenting your services with tracing libraries or agents that generate trace data for each request. This data is then collected and visualized in tools like Jaeger, Zipkin, or Azure Monitor, allowing you to track the flow of requests across microservices and identify performance issues or failures.
+2.  Centralized logging and log analytics:
+    Managing logs from multiple resources, applications, and environments can be overwhelming without a centralized logging approach. By aggregating all your logs in a single location, such as Azure Monitor's Log Analytics, you can: - Correlate events across different services, making it easier to troubleshoot complex issues. - Use queries and filters to extract meaningful insights from large volumes of log data. - Set up alerts based on log patterns, such as repeated errors or failure events.
+        Centralized logging provides a unified view of your system’s behaviour and simplifies the task of identifying and responding to issues. To setup your own Centralized logging you can check the steps <a href="https://learn.microsoft.com/en-us/azure/azure-monitor/logs/quick-create-workspace?tabs=azure-portal" rel="noopener noreferrer nofollow" target="_blank">here</a>.
+3.  Real-time metrics and dashboards:
+    Real-time metrics are crucial to monitor the health of your systems effectively. With Azure Monitor, you can create custom dashboards that visualize key performance indicators (KPIs) such as CPU usage, memory consumption, or application response times. These dashboards allow you to: - Spot trends and anomalies quickly. - Keep track of critical performance metrics in real time. - Customize your views to focus on the data most relevant to your team.
+        Dashboards help you monitor your environment at a glance, making it easier to react swiftly to changes or potential issues.
+
+        <Figure src="/img/guides/2024/10/azure-observability-image%202.webp" alt="Azure Dashboard ~ From Azure Docs" caption="Azure Dashboard ~ From Azure Docs" />
+4.  Anomaly detection and predictive analytics:
+    Azure’s advanced observability tools use machine learning algorithms to automatically detect unusual patterns or behaviours in your system. By implementing anomaly detection and predictive analytics, you can: - Identify performance issues or system degradation before they become critical. - Leverage predictive insights to forecast potential outages or resource shortages. - Automatically trigger alerts or remediation actions when anomalies are detected.
+        This proactive approach ensures you can fix problems before they affect end users, improving system reliability and reducing downtime. To learn more about it, you can see the documentation page <a href="https://learn.microsoft.com/en-gb/azure/ai-services/anomaly-detector/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
 
 ## Implementing Azure Observability: A Step-by-Step Guide
 
 Follow these steps to set up Azure Observability for your environment:
 
-1. Set up Azure Monitor:
-    - Navigate to the Azure portal: 
-    Log in to the <a href="https://portal.azure.com/" rel="noopener noreferrer nofollow" target="_blank">Azure portal</a>.
-    
-    <Figure src="/img/guides/2024/10/azure-observability-Screenshot_2024-09-23_at_9.02.15_PM.webp" alt="Azure Home Page" caption="Azure Home Page" />
-    
-    - Search for "Monitor" and select it: 
-    Use the search bar at the portal's top to find "Monitor.”
-    
-    <Figure src="/img/guides/2024/10/azure-observability-595d84dd-1799-4fa1-9c0c-585af26fd4a1.webp" alt="Azure Monitor" caption="Azure Monitor" />
-    
-    - Create a Monitor Workspace: 
-    Click on “Monitor,” and then click the "Create" button to set up a new Azure Monitor workspace. This workspace will act as a central hub for your observability data, including metrics, logs, and alerts.
-2. Configure Application Insights for web applications:
+1.  Set up Azure Monitor:
+
+    - Navigate to the Azure portal:
+      Log in to the <a href="https://portal.azure.com/" rel="noopener noreferrer nofollow" target="_blank">Azure portal</a>.
+
+    <Figure
+      src="/img/guides/2024/10/azure-observability-Screenshot_2024-09-23_at_9.02.15_PM.webp"
+      alt="Azure Home Page"
+      caption="Azure Home Page"
+    />
+
+    - Search for "Monitor" and select it:
+      Use the search bar at the portal's top to find "Monitor.”
+
+    <Figure
+      src="/img/guides/2024/10/azure-observability-595d84dd-1799-4fa1-9c0c-585af26fd4a1.webp"
+      alt="Azure Monitor"
+      caption="Azure Monitor"
+    />
+
+    - Create a Monitor Workspace:
+      Click on “Monitor,” and then click the "Create" button to set up a new Azure Monitor workspace. This workspace will act as a central hub for your observability data, including metrics, logs, and alerts.
+
+2.  Configure Application Insights for web applications:
     - To configure Application insights from web applications, you can follow the [Azure App Insights guide](https://signoz.io/guides/azure-app-insights/) to effectively integrate your Azure services.
-3. Establish log collection with Log Analytics:
-    - Access Log Analytics in Azure Monitor: 
-    In the Azure Monitor section, click on "Logs" from the left-hand menu.
-        
-        <Figure src="/img/guides/2024/10/azure-observability-image%203.webp" alt="Azure Logs Monitor Overview" caption="Azure Logs Monitor Overview" /> 
-        
-    - Create a Log Analytics Workspace: 
-    If you don’t already have one, click "Create" to set up a new Log Analytics workspace. This is where your system and application logs will be collected and analyzed.
-        
-        <Figure src="/img/guides/2024/10/azure-observability-image%204.webp" alt="Log Analytics Workspace Azure Monitor Logs" caption="Log Analytics Workspace Azure Monitor Logs" />
-        
-    - Connect Resources: 
-    After creating the workspace, connect your Azure resources (e.g., VMs, databases, applications) to start collecting logs. This enables you to search and analyze logs for troubleshooting and auditing purposes.
-4. Create custom dashboards and alerts:
-    - Create Dashboards for Monitoring: 
-    In Azure Monitor, click on “Dashboards” in the menu. Then, click “New dashboard” to start building a custom dashboard.
-    
-
-        <Figure src="/img/guides/2024/10/azure-observability-4a.webp" alt="Custom Azure Dashboard Creation" caption="Creating a custom dashboard in Azure Monitor to visualize metrics and logs. (Image: Azure Docs)" />
-        
-        
+3.  Establish log collection with Log Analytics:
+    - Access Log Analytics in Azure Monitor:
+      In the Azure Monitor section, click on "Logs" from the left-hand menu.
+          <Figure src="/img/guides/2024/10/azure-observability-image%203.webp" alt="Azure Logs Monitor Overview" caption="Azure Logs Monitor Overview" />
+    - Create a Log Analytics Workspace:
+      If you don’t already have one, click "Create" to set up a new Log Analytics workspace. This is where your system and application logs will be collected and analyzed.
+          <Figure src="/img/guides/2024/10/azure-observability-image%204.webp" alt="Log Analytics Workspace Azure Monitor Logs" caption="Log Analytics Workspace Azure Monitor Logs" />
+    - Connect Resources:
+      After creating the workspace, connect your Azure resources (e.g., VMs, databases, applications) to start collecting logs. This enables you to search and analyze logs for troubleshooting and auditing purposes.
+4.  Create custom dashboards and alerts:
+
+    - Create Dashboards for Monitoring:
+      In Azure Monitor, click on “Dashboards” in the menu. Then, click “New dashboard” to start building a custom dashboard.
+
+          <Figure src="/img/guides/2024/10/azure-observability-4a.webp" alt="Custom Azure Dashboard Creation" caption="Creating a custom dashboard in Azure Monitor to visualize metrics and logs. (Image: Azure Docs)" />
+
     - Select Create, then select Custom.
-    This action opens the Tile Gallery, from which you can select tiles displaying different information types. You'll also see an empty grid representing the dashboard layout, where you can arrange the tiles.
-        - Select the text in the dashboard label and enter a name to help you easily identify the custom dashboard.
-        
-        <Figure src="/img/guides/2024/10/azure-observability-4b.webp" alt="DashBoard view ~ Image Azure Docs" caption="DashBoard view ~ Image Azure Docs" />
-        
-        To save the dashboard as is, select Save in the page header.
-        The dashboard view now shows your new dashboard. Select the arrow next to the dashboard name to see other available dashboards. The list might include dashboards that other users have created and shared.
-        
-    - Set Up Alerts: 
-    To be notified of critical events, go to the “Alerts” section in Azure Monitor. Click “New alert rule” and define the conditions for triggering an alert (e.g., when CPU usage exceeds 80%). You can configure these alerts to send notifications via email or integrate with third-party tools like Slack or Teams.
-        
-        <Figure src="/img/guides/2024/10/azure-observability-image%206.webp" alt="Alerts Page ~ Image ~ Azure Docs" caption="Alerts Page ~ Image ~ Azure Docs" />
-        
-        <Figure src="/img/guides/2024/10/azure-observability-image%207.webp" alt="Timeline View Alerts ~ Image Azure Docs" caption="Timeline View Alerts ~ Image Azure Docs" />
-        
+      This action opens the Tile Gallery, from which you can select tiles displaying different information types. You'll also see an empty grid representing the dashboard layout, where you can arrange the tiles. - Select the text in the dashboard label and enter a name to help you easily identify the custom dashboard.
+          <Figure src="/img/guides/2024/10/azure-observability-4b.webp" alt="DashBoard view ~ Image Azure Docs" caption="DashBoard view ~ Image Azure Docs" />
+
+          To save the dashboard as is, select Save in the page header.
+          The dashboard view now shows your new dashboard. Select the arrow next to the dashboard name to see other available dashboards. The list might include dashboards that other users have created and shared.
+    - Set Up Alerts:
+      To be notified of critical events, go to the “Alerts” section in Azure Monitor. Click “New alert rule” and define the conditions for triggering an alert (e.g., when CPU usage exceeds 80%). You can configure these alerts to send notifications via email or integrate with third-party tools like Slack or Teams.
+          <Figure src="/img/guides/2024/10/azure-observability-image%206.webp" alt="Alerts Page ~ Image ~ Azure Docs" caption="Alerts Page ~ Image ~ Azure Docs" />
+
+          <Figure src="/img/guides/2024/10/azure-observability-image%207.webp" alt="Timeline View Alerts ~ Image Azure Docs" caption="Timeline View Alerts ~ Image Azure Docs" />
 
 ### Best Practices for Azure Observability
 
@@ -174,14 +160,14 @@ By applying these practices, you'll enhance the visibility, efficiency, and secu
 
 Take your observability to the next level with these advanced techniques:
 
-1. Azure Monitor for containers and Kubernetes: 
-If you're running containerized applications or using Kubernetes, Azure Monitor provides specialized monitoring for these environments. It offers insights into the performance, health, and resource utilization of your containers and clusters, helping you maintain optimal performance and quickly resolve issues.
-2. Cross-component transaction monitoring: 
-Transactions in today's distributed systems frequently include numerous services. You may track requests as they pass through different services and apps using Azure's cross-component transaction monitoring. This enables you to understand how various components interact and affect overall performance, allowing for faster troubleshooting and improvement.
-3. AI and machine learning for intelligent insights: 
-Azure leverages AI and machine learning to automatically detect anomalies and forecast potential issues. This helps in predicting system failures or performance bottlenecks before they occur, allowing you to take preemptive actions and improve system reliability.
+1. Azure Monitor for containers and Kubernetes:
+   If you're running containerized applications or using Kubernetes, Azure Monitor provides specialized monitoring for these environments. It offers insights into the performance, health, and resource utilization of your containers and clusters, helping you maintain optimal performance and quickly resolve issues.
+2. Cross-component transaction monitoring:
+   Transactions in today's distributed systems frequently include numerous services. You may track requests as they pass through different services and apps using Azure's cross-component transaction monitoring. This enables you to understand how various components interact and affect overall performance, allowing for faster troubleshooting and improvement.
+3. AI and machine learning for intelligent insights:
+   Azure leverages AI and machine learning to automatically detect anomalies and forecast potential issues. This helps in predicting system failures or performance bottlenecks before they occur, allowing you to take preemptive actions and improve system reliability.
 4. Integration with third-party observability tools:
-While Azure provides robust native observability features, there may be cases where third-party tools offer additional specialized capabilities. By integrating tools like SigNoz, you can extend Azure’s observability for specific use cases, such as custom dashboards or enhanced tracing, to meet your organization's unique needs.
+   While Azure provides robust native observability features, there may be cases where third-party tools offer additional specialized capabilities. By integrating tools like SigNoz, you can extend Azure’s observability for specific use cases, such as custom dashboards or enhanced tracing, to meet your organization's unique needs.
 
 ## Enhancing Azure Observability with SigNoz
 
@@ -191,8 +177,8 @@ To optimize your Azure observability, leveraging an advanced platform like [SigN
 
 Getting started with SigNoz:
 
-- Create a SigNoz Cloud Account or Set up SigNoz locally: 
-[SigNoz Cloud](https://signoz.io/teams/) offers a 30-day free trial, allowing you to experience its full capabilities. This guide uses SigNoz Cloud, but you can also opt for the open-source version if preferred.
+- Create a SigNoz Cloud Account or Set up SigNoz locally:
+  [SigNoz Cloud](https://signoz.io/teams/) offers a 30-day free trial, allowing you to experience its full capabilities. This guide uses SigNoz Cloud, but you can also opt for the open-source version if preferred.
 
 To enhance your Azure monitoring strategy with SigNoz, you can follow the [Azure Monitor Metrics](https://signoz.io/blog/opentelemetry-azure-monitor-metrics/) for effective integration of Azure Monitor Metrics using [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) to SigNoz.
 
@@ -201,35 +187,35 @@ To enhance your Azure monitoring strategy with SigNoz, you can follow the [Azure
 When adopting Azure Observability, especially for beginners, it’s important to be aware of the challenges that may arise. Here are some common hurdles and strategies to overcome them:
 
 1. Data volume and retention costs:
-As you begin collecting observability data, the volume of logs, metrics, and traces can quickly become overwhelming. This leads to increased storage and retention costs. To manage these expenses without losing valuable insights, it’s important to implement data sampling—this technique captures a representative subset of data rather than collecting everything. Additionally, setting appropriate data retention periods ensures that you're only keeping what is necessary, striking a balance between cost-efficiency and the depth of information available for troubleshooting and analysis.
+   As you begin collecting observability data, the volume of logs, metrics, and traces can quickly become overwhelming. This leads to increased storage and retention costs. To manage these expenses without losing valuable insights, it’s important to implement data sampling—this technique captures a representative subset of data rather than collecting everything. Additionally, setting appropriate data retention periods ensures that you're only keeping what is necessary, striking a balance between cost-efficiency and the depth of information available for troubleshooting and analysis.
 2. Observability in hybrid and multi-cloud environments:
-Many organizations use a combination of on-premises, multi-cloud, and hybrid environments, making observability more complex. Azure’s native observability tools primarily focus on Azure services, but you can extend these capabilities to resources outside of Azure with tools like Azure Arc. Azure Arc allows you to bring external systems under the same observability framework, providing a unified view of all your infrastructure, whether it resides in Azure, on-premises, or other cloud providers. This ensures consistent monitoring and reduces gaps in your observability strategy.
+   Many organizations use a combination of on-premises, multi-cloud, and hybrid environments, making observability more complex. Azure’s native observability tools primarily focus on Azure services, but you can extend these capabilities to resources outside of Azure with tools like Azure Arc. Azure Arc allows you to bring external systems under the same observability framework, providing a unified view of all your infrastructure, whether it resides in Azure, on-premises, or other cloud providers. This ensures consistent monitoring and reduces gaps in your observability strategy.
 3. Security and compliance concerns:
-Observability frequently entails the collection of extensive system data, which can pose security and compliance concerns, particularly in regulated businesses. Azure provides sophisticated security features including encryption, role-based access control (RBAC), and network isolation to protect your observability data. Furthermore, Azure complies with a number of industry standards, including GDPR, HIPAA, and ISO/IEC 27001, which aids in meeting legal obligations. Using these built-in features, you may securely deploy observability while protecting sensitive information.
-4. Balancing granularity and performance: 
-One of the key decisions in observability is determining the level of granularity in your monitoring data. Collecting highly detailed metrics, logs, and traces can provide deep insights, but it may also introduce performance overhead and impact system performance. The challenge is to find the right balance—monitor critical components at a high level of detail while using lighter monitoring for less important or less resource-intensive areas. Azure offers tools like adaptive sampling to help manage this balance, ensuring that your observability data remains useful without negatively affecting your application’s performance.
+   Observability frequently entails the collection of extensive system data, which can pose security and compliance concerns, particularly in regulated businesses. Azure provides sophisticated security features including encryption, role-based access control (RBAC), and network isolation to protect your observability data. Furthermore, Azure complies with a number of industry standards, including GDPR, HIPAA, and ISO/IEC 27001, which aids in meeting legal obligations. Using these built-in features, you may securely deploy observability while protecting sensitive information.
+4. Balancing granularity and performance:
+   One of the key decisions in observability is determining the level of granularity in your monitoring data. Collecting highly detailed metrics, logs, and traces can provide deep insights, but it may also introduce performance overhead and impact system performance. The challenge is to find the right balance—monitor critical components at a high level of detail while using lighter monitoring for less important or less resource-intensive areas. Azure offers tools like adaptive sampling to help manage this balance, ensuring that your observability data remains useful without negatively affecting your application’s performance.
 
 ## Future Trends in Azure Observability
 
 To ensure your monitoring strategies remain effective and scalable, it's important to stay informed about key trends shaping the future of Azure Observability. Here are some developments to watch:
 
 1. AIOps and predictive analytics:
-The integration of Artificial Intelligence for IT Operations (AIOps) is transforming how organizations manage their infrastructure. In the future, expect predictive analytics capabilities to improve significantly. AIOps will allow for the automatic detection of patterns, early identification of anomalies, and even the prediction of potential failures before they occur. Azure is likely to expand its use of AI to not only identify issues but to automatically resolve them, reducing downtime and minimizing the need for manual intervention.
+   The integration of Artificial Intelligence for IT Operations (AIOps) is transforming how organizations manage their infrastructure. In the future, expect predictive analytics capabilities to improve significantly. AIOps will allow for the automatic detection of patterns, early identification of anomalies, and even the prediction of potential failures before they occur. Azure is likely to expand its use of AI to not only identify issues but to automatically resolve them, reducing downtime and minimizing the need for manual intervention.
 2. Observability-driven development
-Observability will increasingly become a core part of the development lifecycle, integrated into CI/CD pipelines. Developers will embed observability tools directly into their workflows to monitor code changes and ensure they meet performance expectations. This tighter integration ensures that issues can be detected and fixed earlier in the development process, reducing downtime and improving code quality.
+   Observability will increasingly become a core part of the development lifecycle, integrated into CI/CD pipelines. Developers will embed observability tools directly into their workflows to monitor code changes and ensure they meet performance expectations. This tighter integration ensures that issues can be detected and fixed earlier in the development process, reducing downtime and improving code quality.
 3. Edge computing and IoT observability:
-With the emergence of edge computing and the proliferation of Internet of Things (IoT) devices, observability will become increasingly important in these domains. Azure's monitoring and observability capabilities will most likely be expanded to include distributed, decentralized systems operating at the network's edge. As enterprises deploy more edge computing solutions, guaranteeing observability in these environments will become critical to sustaining performance, security, and dependability.
-4. Advanced visualizations and data exploration: 
-As observability data grows in complexity, the tools for visualizing and exploring this data must evolve. Expect more advanced visualizations in Azure, allowing users to easily understand complex system behaviors and pinpoint issues quickly. These tools will likely incorporate interactive dashboards, heatmaps, and other visualization techniques that make it easier to explore data in real time, enhancing both monitoring efficiency and decision-making.
+   With the emergence of edge computing and the proliferation of Internet of Things (IoT) devices, observability will become increasingly important in these domains. Azure's monitoring and observability capabilities will most likely be expanded to include distributed, decentralized systems operating at the network's edge. As enterprises deploy more edge computing solutions, guaranteeing observability in these environments will become critical to sustaining performance, security, and dependability.
+4. Advanced visualizations and data exploration:
+   As observability data grows in complexity, the tools for visualizing and exploring this data must evolve. Expect more advanced visualizations in Azure, allowing users to easily understand complex system behaviors and pinpoint issues quickly. These tools will likely incorporate interactive dashboards, heatmaps, and other visualization techniques that make it easier to explore data in real time, enhancing both monitoring efficiency and decision-making.
 
 ## Key Takeaways
 
 - Azure Observability combines Azure Monitor, Application Insights, and Log Analytics for a unified view of your cloud and on-premises environments, enabling effective monitoring of application performance and infrastructure health.
 - Key observability patterns like distributed tracing (tracking requests across microservices) and [centralized logging](https://signoz.io/blog/centralized-logging/) (consolidating logs) provide deeper insights and faster troubleshooting for complex systems.
 - Best practices include:
-    - Defining meaningful metrics for critical system performance.
-    - Using tagging for easier data organization and analysis.
-    - Leveraging AI-driven insights to detect anomalies and predict issues.
+  - Defining meaningful metrics for critical system performance.
+  - Using tagging for easier data organization and analysis.
+  - Leveraging AI-driven insights to detect anomalies and predict issues.
 - Tools like SigNoz complement Azure by enhancing monitoring, especially for open-source or custom applications.
 - Stay current with trends like AIOps and observability-driven development for automated, intelligent monitoring solutions that adapt to evolving systems.
 
@@ -264,4 +250,4 @@ Costs for Azure Observability depend on several factors:
 - Retention periods: How long you retain the data for analysis and troubleshooting.
 - Specific features used: Certain features, such as advanced analytics or AI-driven insights, may add to the cost.
 
-To manage costs effectively, Azure offers a pricing calculator where you can estimate your usage based on data volume, retention, and features. You can also implement cost-saving strategies like data sampling or adjusting retention policies to balance observability needs with budget considerations.
\ No newline at end of file
+To manage costs effectively, Azure offers a pricing calculator where you can estimate your usage based on data volume, retention, and features. You can also implement cost-saving strategies like data sampling or adjusting retention policies to balance observability needs with budget considerations.
diff --git a/data/guides/can-jaeger-show-metrics.mdx b/data/guides/can-jaeger-show-metrics.mdx
index 3d3bc2604..852f47306 100644
--- a/data/guides/can-jaeger-show-metrics.mdx
+++ b/data/guides/can-jaeger-show-metrics.mdx
@@ -1,164 +1,177 @@
 ---
-
 title: Can Jaeger Show Metrics? - How to Monitor and Visualize Performance
-slug: can-jaeger-show-metrics
 date: 2024-07-30
 tags: [faq, jaeger]
 authors: [ankit_anand]
 description: Discover Jaeger's metrics capabilities, learn how to enable and visualize performance data, and integrate with other monitoring tools for comprehensive system insights.
-keywords: [Jaeger metrics, performance monitoring, distributed tracing, Prometheus, OpenTelemetry, service performance monitoring]
-
+keywords:
+  [
+    Jaeger metrics,
+    performance monitoring,
+    distributed tracing,
+    Prometheus,
+    OpenTelemetry,
+    service performance monitoring,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Can Jaeger Show Metrics? - How to Monitor and Visualize Performance",
-    "alternativeHeadline": "Discover Jaeger's Metrics Capabilities and Integrations for Comprehensive Performance Monitoring",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/can-jaeger-show-metrics/"
-    },
-    "description": "Discover Jaeger's metrics capabilities, learn how to enable and visualize performance data, and integrate with other monitoring tools for comprehensive system insights.",
-    "keywords": "Jaeger metrics, performance monitoring, distributed tracing, Prometheus, OpenTelemetry, service performance monitoring",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Jaeger",
-        "description": "An open-source, end-to-end distributed tracing system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "OpenTelemetry",
-        "description": "A collection of tools, APIs, and SDKs for instrumenting, generating, collecting, and exporting telemetry data such as metrics, logs, and traces."
-      },
-      {
-        "@type": "Thing",
-        "name": "Service Performance Monitoring",
-        "description": "Monitoring the performance of various services to ensure they meet performance and availability standards."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Jaeger",
-        "applicationCategory": "Distributed Tracing"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "OpenTelemetry",
-        "applicationCategory": "Observability Framework"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "How do I enable metrics collection in Jaeger?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Enable metrics collection in Jaeger by starting its components with the appropriate flags, such as `--metrics-backend prometheus` for Prometheus integration."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can Jaeger replace dedicated metrics monitoring tools?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While Jaeger can expose metrics, it's not designed to replace dedicated metrics monitoring tools. It's best used in conjunction with specialized metrics solutions for comprehensive monitoring."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Can Jaeger Show Metrics? - How to Monitor and Visualize Performance',
+        alternativeHeadline:
+          "Discover Jaeger's Metrics Capabilities and Integrations for Comprehensive Performance Monitoring",
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "What's the difference between Jaeger's metrics and traditional APM metrics?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Jaeger's metrics focus on its internal operations and trace-related data, while traditional APM metrics often cover a broader range of application and infrastructure performance indicators."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "How can I correlate Jaeger traces with application metrics?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use a unified observability framework like OpenTelemetry to collect both traces and metrics. This allows you to link trace IDs with corresponding metric timestamps for correlation."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Using Jaeger for Metrics and Tracing",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Enable Metrics in Jaeger",
-          "text": "Start the Jaeger agent with Prometheus metrics enabled using the command `jaeger-agent --metrics-backend prometheus`."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/can-jaeger-show-metrics/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Up Prometheus",
-          "text": "Set up Prometheus in your environment and configure it to scrape Jaeger's metrics endpoint."
+        description:
+          "Discover Jaeger's metrics capabilities, learn how to enable and visualize performance data, and integrate with other monitoring tools for comprehensive system insights.",
+        keywords:
+          'Jaeger metrics, performance monitoring, distributed tracing, Prometheus, OpenTelemetry, service performance monitoring',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Create Grafana Dashboards",
-          "text": "Use Grafana to create dashboards for visualizing Jaeger metrics."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Jaeger',
+            description: 'An open-source, end-to-end distributed tracing system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'OpenTelemetry',
+            description:
+              'A collection of tools, APIs, and SDKs for instrumenting, generating, collecting, and exporting telemetry data such as metrics, logs, and traces.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Service Performance Monitoring',
+            description:
+              'Monitoring the performance of various services to ensure they meet performance and availability standards.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Jaeger',
+            applicationCategory: 'Distributed Tracing',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'OpenTelemetry',
+            applicationCategory: 'Observability Framework',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'How do I enable metrics collection in Jaeger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Enable metrics collection in Jaeger by starting its components with the appropriate flags, such as `--metrics-backend prometheus` for Prometheus integration.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Jaeger replace dedicated metrics monitoring tools?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While Jaeger can expose metrics, it's not designed to replace dedicated metrics monitoring tools. It's best used in conjunction with specialized metrics solutions for comprehensive monitoring.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What's the difference between Jaeger's metrics and traditional APM metrics?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Jaeger's metrics focus on its internal operations and trace-related data, while traditional APM metrics often cover a broader range of application and infrastructure performance indicators.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I correlate Jaeger traces with application metrics?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use a unified observability framework like OpenTelemetry to collect both traces and metrics. This allows you to link trace IDs with corresponding metric timestamps for correlation.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Enable Service Performance Monitoring (SPM)",
-          "text": "Set the `-query.max-clock-skew-adjustment` flag when starting the Jaeger query service and configure your Jaeger client to send necessary metadata with spans."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Using Jaeger for Metrics and Tracing',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Enable Metrics in Jaeger',
+              text: 'Start the Jaeger agent with Prometheus metrics enabled using the command `jaeger-agent --metrics-backend prometheus`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Prometheus',
+              text: "Set up Prometheus in your environment and configure it to scrape Jaeger's metrics endpoint.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create Grafana Dashboards',
+              text: 'Use Grafana to create dashboards for visualizing Jaeger metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Enable Service Performance Monitoring (SPM)',
+              text: 'Set the `-query.max-clock-skew-adjustment` flag when starting the Jaeger query service and configure your Jaeger client to send necessary metadata with spans.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use OpenTelemetry for Unified Observability',
+              text: 'Implement OpenTelemetry to collect both traces and metrics, providing a comprehensive view of system performance.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use OpenTelemetry for Unified Observability",
-          "text": "Implement OpenTelemetry to collect both traces and metrics, providing a comprehensive view of system performance."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Jaeger can show metrics, but it's not its primary function. Jaeger is primarily a distributed tracing system that exposes metrics in Prometheus format. To use Jaeger for metrics, you need to configure it properly and set up a compatible backend. Let's explore how you can leverage Jaeger's metrics capabilities and integrate them with other monitoring tools for comprehensive performance visualization.
@@ -299,4 +312,4 @@ While Jaeger is a popular choice for distributed tracing, it's worth considering
 
 If you're looking for a comprehensive observability solution that goes beyond just distributed tracing, SigNoz might be the right fit for your needs. It provides a seamless experience for developers and operations teams, combining the power of metrics, traces, and logs in one tool.
 
-To learn more about how SigNoz compares to Jaeger and how it can enhance your [observability stack](https://signoz.io/guides/observability-stack/), visit [https://signoz.io](https://signoz.io/).
\ No newline at end of file
+To learn more about how SigNoz compares to Jaeger and how it can enhance your [observability stack](https://signoz.io/guides/observability-stack/), visit [https://signoz.io](https://signoz.io/).
diff --git a/data/guides/cannot-start-prometheus-by-using-systemd.mdx b/data/guides/cannot-start-prometheus-by-using-systemd.mdx
index 9f5b26e69..403de7a74 100644
--- a/data/guides/cannot-start-prometheus-by-using-systemd.mdx
+++ b/data/guides/cannot-start-prometheus-by-using-systemd.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Fix Prometheus Systemd Service Start Issues
-slug: cannot-start-prometheus-by-using-systemd
 date: 2024-11-14
 tags: [prometheus, faq]
 authors: [nitin_gouda]
 description: Learn how to fix Prometheus systemd service start issues with our comprehensive guide. Step-by-step solutions for common startup failures and configuration problems.
-keywords: [prometheus systemd, prometheus service, systemd troubleshooting, prometheus startup issues, prometheus permissions, prometheus configuration, prometheus monitoring]
-
+keywords:
+  [
+    prometheus systemd,
+    prometheus service,
+    systemd troubleshooting,
+    prometheus startup issues,
+    prometheus permissions,
+    prometheus configuration,
+    prometheus monitoring,
+  ]
 ---
 
 When Prometheus fails to start using systemd, the issue typically stems from incorrect permissions, configuration errors, or service unit file problems. You can fix this by checking systemd logs, verifying permissions, and ensuring proper configuration settings. This guide provides step-by-step solutions to get your Prometheus service running.
@@ -30,8 +36,8 @@ Key points to understand:
 Systemd records service activity and errors in logs, which can be accessed using the `journalctl` command. Common errors for Prometheus include:
 
 - Service Not Starting: This can occur due to incorrect configuration or missing files. Look for messages such as:
-    - `prometheus.service: Failed to start Prometheus`
-    - `execvp failed: No such file or directory` (indicating an incorrect path to the Prometheus binary)
+  - `prometheus.service: Failed to start Prometheus`
+  - `execvp failed: No such file or directory` (indicating an incorrect path to the Prometheus binary)
 - Permission Denied Errors: If the Prometheus service does not have appropriate permissions to access necessary files or directories, systemd will log “permission denied” errors.
 - Configuration File Access Issues: Incorrect permissions or missing configuration files can prevent Prometheus from starting, which [systemd logs](https://signoz.io/guides/systemctl-logs/) can help identify. Errors such as `error loading configuration file 'prometheus.yml'` can indicate syntax issues or missing files in the configuration.
 - Storage Directory Problems: Prometheus requires access to specific directories for data storage. Problems such as missing directories or improper permissions can cause the service to fail.
@@ -43,12 +49,10 @@ Prometheus needs specific permissions and ownership settings to function properl
 
 - Prometheus Binary: The Prometheus binary must be executable by the user or group specified in the systemd service unit file (typically a non-root user for security reasons, e.g., `prometheus`).
 - Configuration Files: The `prometheus.yml` configuration file and any other files Prometheus needs (e.g., alerting rules, TLS certificates) should be readable only by Prometheus or privileged users. Using `chown` and `chmod` commands can help set the appropriate permissions and ownership on critical files and directories.
-    
-    ```bash
-    sudo chown -R prometheus:prometheus /etc/prometheus
-    sudo chmod -R 755 /etc/prometheus
-    ```
-    
+  ```bash
+  sudo chown -R prometheus:prometheus /etc/prometheus
+  sudo chmod -R 755 /etc/prometheus
+  ```
 - Data Directory: Prometheus stores its time-series data on disk, usually under `/var/lib/prometheus/`. The Prometheus user needs write permissions to this directory. If the ownership or permissions are incorrect, Prometheus may fail to write data, resulting in errors.
 
 ### Service Unit File Structure and Dependencies
@@ -76,7 +80,11 @@ Restart=on-failure
 WantedBy=multi-user.target
 ```
 
-<Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-72fb595a-9985-426d-a3ea-e657bd3ba4eb.webp" alt="Service File" caption="Service File" />
+<Figure
+  src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-72fb595a-9985-426d-a3ea-e657bd3ba4eb.webp"
+  alt="Service File"
+  caption="Service File"
+/>
 
 This structure allows systemd to manage Prometheus effectively, handling automatic restarts and managing dependencies with other system services, ensuring Prometheus runs smoothly within the system environment.
 
@@ -84,203 +92,196 @@ This structure allows systemd to manage Prometheus effectively, handling automat
 
 This checklist offers a step-by-step approach to diagnose and resolve common issues with the Prometheus service running under systemd. By following these steps, you can quickly identify potential causes of service failures and address them effectively.
 
-1. Check Service Status: Start by verifying whether the Prometheus service is active and running. Using `systemctl status`, you can check the current status of the Prometheus service and see if it’s in an active, failed, or inactive state. This command also provides insights into any immediate issues, such as failed dependencies or permission errors. 
-    
-    ```bash
-    sudo systemctl status prometheus
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-563f5eb4-0845-4fc7-be9e-5663e8b3d175.webp" alt="Checking Service Status" caption="Checking Service Status" />
-    
+1. Check Service Status: Start by verifying whether the Prometheus service is active and running. Using `systemctl status`, you can check the current status of the Prometheus service and see if it’s in an active, failed, or inactive state. This command also provides insights into any immediate issues, such as failed dependencies or permission errors.
+
+   ```bash
+   sudo systemctl status prometheus
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-563f5eb4-0845-4fc7-be9e-5663e8b3d175.webp"
+     alt="Checking Service Status"
+     caption="Checking Service Status"
+   />
+
 2. View Detailed Logs: The `journalctl` command provides detailed logs for services managed by systemd. By checking the logs for Prometheus, you can find specific error messages or warnings that help pinpoint issues, such as file access errors or missing dependencies. The `-f` flag allows you to monitor the logs in real-time as changes occur
-    
-    ```bash
-    sudo journalctl -u prometheus -f
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-7e98a6eb-621b-48c2-a59e-24a4c402b601.webp" alt="Detailed logs for Prometheus" caption="Detailed logs for Prometheus" />
-    
+
+   ```bash
+   sudo journalctl -u prometheus -f
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-7e98a6eb-621b-48c2-a59e-24a4c402b601.webp"
+     alt="Detailed logs for Prometheus"
+     caption="Detailed logs for Prometheus"
+   />
+
 3. Verify File Permissions: Prometheus requires correct permissions on its configuration files to operate. Incorrect permissions may prevent the service from reading or writing to necessary directories, leading to failures. The following commands check permissions for both the configuration file (`prometheus.yml`) and the storage directory (`/var/lib/prometheus/`).
-    
-    ```bash
-    ls -l /etc/prometheus/prometheus.yml
-    ls -l /var/lib/prometheus/
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-8a0e8890-7170-4026-ad56-f37b267e4633.webp" alt="Verifying File permissions" caption="Verifying File permissions" />
-    
+
+   ```bash
+   ls -l /etc/prometheus/prometheus.yml
+   ls -l /var/lib/prometheus/
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-8a0e8890-7170-4026-ad56-f37b267e4633.webp"
+     alt="Verifying File permissions"
+     caption="Verifying File permissions"
+   />
+
 4. Validate Service Configuration: Review the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file (`prometheus.yml`) to check for any syntax errors or misconfigurations, as these can prevent the service from starting or cause unexpected behavior. After making any changes, remember to reload or restart the service to apply them.
-    
-    To verify the systemd service configuration for Prometheus, you can use: 
-    
-    ```bash
-    sudo systemd-analyze verify prometheus.service
-    ```
-    
 
-### Common Error Messages Explained
+   To verify the systemd service configuration for Prometheus, you can use:
 
-Understanding common Prometheus error messages can save valuable troubleshooting time. Here, we break down frequent issues and provide clear solutions to help you keep your monitoring running smoothly.
+   ```bash
+   sudo systemd-analyze verify prometheus.service
+   ```
 
-1. Failed to Start Prometheus Server: 
-This error usually means that the Prometheus service encountered a problem during startup, commonly caused by syntax errors in the configuration file or missing dependencies. To troubleshoot this issue, start by checking the syntax of your configuration file.
-    
-    Solution: Check Configuration File Syntax
-    Use the `promtool` command to validate the `prometheus.yml` file for any syntax errors. This tool will highlight specific mistakes, helping you make corrections before restarting the service.
-    
-    ```bash
-    promtool check config /etc/prometheus/prometheus.yml
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-a5babbaf-0d65-4fc4-929b-a19f42aeb748.webp" alt="Checking config syntax" caption="Checking config syntax" />
-    
-    Explanation: The `promtool` command checks for syntax issues in `prometheus.yml`. If there are any, this command will specify them, enabling you to fix errors promptly and restart the service without issues.
-    
-2. Permission Denied: 
-This error indicates that Prometheus does not have the necessary permissions to access certain files or directories, such as its configuration file or data directories. Without the proper permissions, Prometheus cannot read or write to the resources it requires to run.
-    
-    Solution: Adjust Permissions
-    To resolve this issue, ensure that the Prometheus user owns the configuration and data directories. The following commands adjust ownership and permissions so that Prometheus can access its files as needed:
-    
-    ```bash
-    # Fix ownership for Prometheus directories
-    sudo chown -R prometheus:prometheus /etc/prometheus
-    sudo chown -R prometheus:prometheus /var/lib/prometheus
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-4ec70258-50ce-4550-b4a8-6a82e5647cb9.webp" alt="Fix file ownership" caption="Fix file ownership" />
-    
-    Explanation: These commands assign ownership of critical Prometheus directories to the Prometheus user. This gives Prometheus the permissions it needs to read configuration files and write to data directories, preventing “permission denied” errors.
-    
-3. Service Start Request Repeated too Quickly: 
-This error occurs when systemd detects multiple restart attempts within a short time. If Prometheus repeatedly fails to start, systemd places the service in a “failed” state to prevent continuous, unsuccessful restarts. You’ll need to reset this state before you can attempt to start Prometheus again.
-    
-    Solution: Reset Failed State: 
-    To clear the service’s failed state, use the `reset-failed` command and then attempt to start Prometheus anew.
-    
-    ```bash
-    # Reset the failed state and start Prometheus
-    sudo systemctl reset-failed prometheus
-    sudo systemctl start prometheus
-    ```
-    
-    Explanation: The `reset-failed` command clears the failed state in systemd, enabling a fresh start attempt for the Prometheus service. This is especially helpful after addressing any underlying issues that were causing the repeated failures.
-    
-4. Exit Code Failures: 
-Exit codes provide information on why the Prometheus service stopped. For example, Exit Code 1 often indicates a configuration or permissions issue, while Exit Code 2 may suggest a syntax error within the `prometheus.yml` file.
-    
-    Solution: Check Logs for Exit Code Details
-    To understand the specific reason for an exit code failure, examine the Prometheus logs with `journalctl`, which provides a more detailed error message:
-    
-    ```bash
-    sudo journalctl -u prometheus -f
-    ```
-    
-    Explanation: Reviewing logs in `journalctl` gives context for the exit codes and helps pinpoint the exact problem, such as syntax issues or missing dependencies, so you can apply targeted fixes to restart Prometheus successfully.
-    
+### Common Error Messages Explained
 
-## Step-by-Step Solutions
+Understanding common Prometheus error messages can save valuable troubleshooting time. Here, we break down frequent issues and provide clear solutions to help you keep your monitoring running smoothly.
 
-For production-grade Prometheus setups, it’s essential to address common issues related to permissions, storage directories, and service configurations. Here’s a guide to troubleshooting and configuring Prometheus step-by-step:
+1.  Failed to Start Prometheus Server:
+    This error usually means that the Prometheus service encountered a problem during startup, commonly caused by syntax errors in the configuration file or missing dependencies. To troubleshoot this issue, start by checking the syntax of your configuration file.
+        Solution: Check Configuration File Syntax
+        Use the `promtool` command to validate the `prometheus.yml` file for any syntax errors. This tool will highlight specific mistakes, helping you make corrections before restarting the service.
 
-1. Fix Permission Issues: 
-Permissions are crucial for Prometheus to access its configuration and data directories securely. These steps will ensure Prometheus has the necessary user and group setup and correct permissions.
-    1. Create a dedicated Prometheus user: This user will run the Prometheus service without unnecessary system access.
-        
-        ```bash
-        sudo useradd --no-create-home --shell /bin/false prometheus
-        ```
-        
-        Explanation: The `-no-create-home` and `-shell /bin/false` flags restrict this user from logging into the server, enhancing security.
-        
-    2. Lock the Prometheus User Account: This prevents login access to the Prometheus user.
-        
-        ```bash
-        sudo usermod -L prometheus
-        ```
-        
-    3. Set permissions for Prometheus directories: Ensure that Prometheus has read-write access to the necessary directories.
-        
         ```bash
-        sudo chmod 755 /etc/prometheus
-        sudo chmod 755 /var/lib/prometheus
+        promtool check config /etc/prometheus/prometheus.yml
         ```
-        
-        Explanation: Setting directory permissions to `755` allows the Prometheus user access while restricting other users from making changes.
-        
-2. Resolve Storage Directory Problems: 
-Prometheus requires a dedicated storage directory to save time series data. If this directory isn’t set up correctly, Prometheus may fail to start or encounter issues.
-    1. Create the required storage directory:
-        
+
+        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-a5babbaf-0d65-4fc4-929b-a19f42aeb748.webp" alt="Checking config syntax" caption="Checking config syntax" />
+
+        Explanation: The `promtool` command checks for syntax issues in `prometheus.yml`. If there are any, this command will specify them, enabling you to fix errors promptly and restart the service without issues.
+2.  Permission Denied:
+    This error indicates that Prometheus does not have the necessary permissions to access certain files or directories, such as its configuration file or data directories. Without the proper permissions, Prometheus cannot read or write to the resources it requires to run.
+        Solution: Adjust Permissions
+        To resolve this issue, ensure that the Prometheus user owns the configuration and data directories. The following commands adjust ownership and permissions so that Prometheus can access its files as needed:
+
         ```bash
-        sudo mkdir -p /var/lib/prometheus
+        # Fix ownership for Prometheus directories
+        sudo chown -R prometheus:prometheus /etc/prometheus
+        sudo chown -R prometheus:prometheus /var/lib/prometheus
         ```
-        
-    2. Set Directory Ownership: Assign the Prometheus user as the owner of the storage directory.
-        
+
+        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-4ec70258-50ce-4550-b4a8-6a82e5647cb9.webp" alt="Fix file ownership" caption="Fix file ownership" />
+
+        Explanation: These commands assign ownership of critical Prometheus directories to the Prometheus user. This gives Prometheus the permissions it needs to read configuration files and write to data directories, preventing “permission denied” errors.
+3.  Service Start Request Repeated too Quickly:
+    This error occurs when systemd detects multiple restart attempts within a short time. If Prometheus repeatedly fails to start, systemd places the service in a “failed” state to prevent continuous, unsuccessful restarts. You’ll need to reset this state before you can attempt to start Prometheus again.
+        Solution: Reset Failed State:
+        To clear the service’s failed state, use the `reset-failed` command and then attempt to start Prometheus anew.
+
         ```bash
-        sudo chown prometheus:prometheus /var/lib/prometheus
+        # Reset the failed state and start Prometheus
+        sudo systemctl reset-failed prometheus
+        sudo systemctl start prometheus
         ```
-        
-        Explanation: These commands create the storage directory with Prometheus ownership, ensuring the service has access to store its data reliably.
-        
-3. Update Service Configuration: 
-If the Prometheus service repeatedly fails to start, systemd may prevent it from restarting quickly. You can adjust settings to control restart frequency and delays for smoother operations.
-    1. Edit the Prometheus Service Configuration:
-        
+
+        Explanation: The `reset-failed` command clears the failed state in systemd, enabling a fresh start attempt for the Prometheus service. This is especially helpful after addressing any underlying issues that were causing the repeated failures.
+4.  Exit Code Failures:
+    Exit codes provide information on why the Prometheus service stopped. For example, Exit Code 1 often indicates a configuration or permissions issue, while Exit Code 2 may suggest a syntax error within the `prometheus.yml` file.
+        Solution: Check Logs for Exit Code Details
+        To understand the specific reason for an exit code failure, examine the Prometheus logs with `journalctl`, which provides a more detailed error message:
+
         ```bash
-        sudo systemctl edit prometheus
-        ```
-        
-        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_9.58.50_PM.webp" alt="Editing Service File" caption="Editing Service File" />
-        
-    2. Add the following Settings to Configure Service Start Limits and Delays:
-        
+        sudo journalctl -u prometheus -f
         ```
-        [Service]
-        StartLimitInterval=5min
-        StartLimitBurst=10
-        RestartSec=30s
-        ```
-        
-        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_9.59.12_PM.webp" alt="Add more Service Configs" caption="Add more Service Configs" />
-        
-        Explanation: These settings limit the number of restart attempts within a 5-minute period (10 attempts) and add a 30-second delay between restart attempts, preventing rapid retries that could cause issues.
-        
+
+        Explanation: Reviewing logs in `journalctl` gives context for the exit codes and helps pinpoint the exact problem, such as syntax issues or missing dependencies, so you can apply targeted fixes to restart Prometheus successfully.
+
+## Step-by-Step Solutions
+
+For production-grade Prometheus setups, it’s essential to address common issues related to permissions, storage directories, and service configurations. Here’s a guide to troubleshooting and configuring Prometheus step-by-step:
+
+1.  Fix Permission Issues:
+    Permissions are crucial for Prometheus to access its configuration and data directories securely. These steps will ensure Prometheus has the necessary user and group setup and correct permissions. 1. Create a dedicated Prometheus user: This user will run the Prometheus service without unnecessary system access.
+            ```bash
+            sudo useradd --no-create-home --shell /bin/false prometheus
+            ```
+
+            Explanation: The `-no-create-home` and `-shell /bin/false` flags restrict this user from logging into the server, enhancing security.
+
+        2. Lock the Prometheus User Account: This prevents login access to the Prometheus user.
+
+            ```bash
+            sudo usermod -L prometheus
+            ```
+
+        3. Set permissions for Prometheus directories: Ensure that Prometheus has read-write access to the necessary directories.
+
+            ```bash
+            sudo chmod 755 /etc/prometheus
+            sudo chmod 755 /var/lib/prometheus
+            ```
+
+            Explanation: Setting directory permissions to `755` allows the Prometheus user access while restricting other users from making changes.
+
+2.  Resolve Storage Directory Problems:
+    Prometheus requires a dedicated storage directory to save time series data. If this directory isn’t set up correctly, Prometheus may fail to start or encounter issues. 1. Create the required storage directory:
+            ```bash
+            sudo mkdir -p /var/lib/prometheus
+            ```
+
+        2. Set Directory Ownership: Assign the Prometheus user as the owner of the storage directory.
+
+            ```bash
+            sudo chown prometheus:prometheus /var/lib/prometheus
+            ```
+
+            Explanation: These commands create the storage directory with Prometheus ownership, ensuring the service has access to store its data reliably.
+
+3.  Update Service Configuration:
+    If the Prometheus service repeatedly fails to start, systemd may prevent it from restarting quickly. You can adjust settings to control restart frequency and delays for smoother operations. 1. Edit the Prometheus Service Configuration:
+            ```bash
+            sudo systemctl edit prometheus
+            ```
+
+            <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_9.58.50_PM.webp" alt="Editing Service File" caption="Editing Service File" />
+
+        2. Add the following Settings to Configure Service Start Limits and Delays:
+
+            ```
+            [Service]
+            StartLimitInterval=5min
+            StartLimitBurst=10
+            RestartSec=30s
+            ```
+
+            <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_9.59.12_PM.webp" alt="Add more Service Configs" caption="Add more Service Configs" />
+
+            Explanation: These settings limit the number of restart attempts within a 5-minute period (10 attempts) and add a 30-second delay between restart attempts, preventing rapid retries that could cause issues.
+
 
 ## Advanced Configuration Tips
 
 For optimized performance and reliability, consider these additional systemd configuration options.
 
-1. Set Proper Systemd Limits: 
-Prometheus benefits from increased file and process limits, especially in larger deployments. Adjusting these values can prevent resource constraints from affecting performance.
-    1. Edit the Prometheus service file
-        
-        ```bash
-        sudo systemctl edit prometheus
-        ```
-        
-    2. Add Systemd Limits under the `[Service]` section:
-        
-        ```
-        [Service]
-        LimitNOFILE=65535
-        LimitNPROC=4096
-        ```
-        
-        Explanation: `LimitNOFILE=65535` increases the maximum number of open files, and `LimitNPROC=4096` raises the process limit. These values support high-traffic environments and prevent Prometheus from hitting file or process limits.
-        
-2. Enable Core Dumps for Debugging: 
-Core dumps help capture program states at the moment of failure, useful for debugging crashes or unexpected behavior in Prometheus.
-    1. Add the following settings to the `[Service]` section in the Prometheus service file:
-        
-        ```
-        [Service]
-        LimitCORE=infinity
-        ```
-        
-        Explanation: `LimitCORE=infinity` allows core dumps to be generated without size restrictions. For debugging, ensure core dumps are stored securely as they may contain sensitive data.
-        
+1.  Set Proper Systemd Limits:
+    Prometheus benefits from increased file and process limits, especially in larger deployments. Adjusting these values can prevent resource constraints from affecting performance. 1. Edit the Prometheus service file
+            ```bash
+            sudo systemctl edit prometheus
+            ```
+
+        2. Add Systemd Limits under the `[Service]` section:
+
+            ```
+            [Service]
+            LimitNOFILE=65535
+            LimitNPROC=4096
+            ```
+
+            Explanation: `LimitNOFILE=65535` increases the maximum number of open files, and `LimitNPROC=4096` raises the process limit. These values support high-traffic environments and prevent Prometheus from hitting file or process limits.
+
+2.  Enable Core Dumps for Debugging:
+    Core dumps help capture program states at the moment of failure, useful for debugging crashes or unexpected behavior in Prometheus. 1. Add the following settings to the `[Service]` section in the Prometheus service file:
+            ```
+            [Service]
+            LimitCORE=infinity
+            ```
+
+            Explanation: `LimitCORE=infinity` allows core dumps to be generated without size restrictions. For debugging, ensure core dumps are stored securely as they may contain sensitive data.
+
 
 By following these steps, you can resolve common Prometheus issues, set up secure permissions, and optimize your Prometheus deployment for production reliability and performance.
 
@@ -301,47 +302,41 @@ Elevate your monitoring game with SigNoz—an open-source observability tool tha
 
 Deploying Prometheus in a production environment requires careful configuration and security settings to ensure performance, data integrity, and reliability. Here are some essential practices to follow:
 
-1. Security Settings: Securing Prometheus is critical to protect both the monitoring data and configuration settings. A key step in securing Prometheus is to limit access to sensitive files, especially the configuration file (`prometheus.yml`), which may contain important settings and credentials.
-Restrict File Permissions: Set strict permissions to restrict access, so only the Prometheus service can read its configuration file.
-    
-    ```bash
-    sudo chmod 600 /etc/prometheus/prometheus.yml
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.01.14_PM.webp" alt="Restricting File Permissions" caption="Restricting File Permissions" />
-    
-    Explanation: Setting permissions to `600` ensures that only the owner (Prometheus) has read and write permissions. This prevents other users or services from accessing sensitive information in the configuration file, enhancing security in multi-user environments.
-    
-2. Backup Configuration:
-Regular backups of Prometheus configuration files are crucial in production environments to recover quickly from accidental changes or data corruption. You can create a simple backup script to automate this process.
-    
-    Create Backup Script: Make regular backups of the configuration file to a secure location to ensure you have recent configurations saved.
-    
-    ```bash
-    # Create backup script
-    sudo cp /etc/prometheus/prometheus.yml /etc/prometheus/prometheus.yml.backup
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.02.20_PM.webp" alt="Making Backups from configuration" caption="Making Backups from configuration" />
-    
-    Explanation: The `cp` command creates a backup of `prometheus.yml`, which can be invaluable for restoring configurations if the original file is accidentally modified or deleted. Automating this backup as part of a script or cron job is a best practice in production environments.
-    
-3. Performance Settings: 
-Configuring [Prometheus storage](https://signoz.io/guides/how-to-increase-prometheus-storage-retention/) to manage resource usage efficiently is important for production environments with large data volumes. You can control the amount of data stored by setting retention policies based on time or storage limits.
-    
-    Configure Storage Retention: Adjust retention settings in `prometheus.yml` to define how much historical data Prometheus should keep.
-    
-    ```yaml
-    storage:
-      tsdb:
-        retention.time: 15d
-        retention.size: 50GB
-    ```
-    
-    <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.09.05_PM.webp" alt="Managing Performance Settings" caption="Managing Performance Settings" />
-    
-    Explanation: Here, `retention.time` limits the stored data to the most recent 15 days, while `retention.size` caps storage at 50GB. These settings prevent Prometheus from consuming excessive disk space, helping maintain high performance and ensuring that your storage does not fill up unexpectedly. Tailor these values to your organization’s data requirements and storage capacity.
-    
+1.  Security Settings: Securing Prometheus is critical to protect both the monitoring data and configuration settings. A key step in securing Prometheus is to limit access to sensitive files, especially the configuration file (`prometheus.yml`), which may contain important settings and credentials.
+    Restrict File Permissions: Set strict permissions to restrict access, so only the Prometheus service can read its configuration file.
+        ```bash
+        sudo chmod 600 /etc/prometheus/prometheus.yml
+        ```
+
+        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.01.14_PM.webp" alt="Restricting File Permissions" caption="Restricting File Permissions" />
+
+        Explanation: Setting permissions to `600` ensures that only the owner (Prometheus) has read and write permissions. This prevents other users or services from accessing sensitive information in the configuration file, enhancing security in multi-user environments.
+2.  Backup Configuration:
+    Regular backups of Prometheus configuration files are crucial in production environments to recover quickly from accidental changes or data corruption. You can create a simple backup script to automate this process.
+        Create Backup Script: Make regular backups of the configuration file to a secure location to ensure you have recent configurations saved.
+
+        ```bash
+        # Create backup script
+        sudo cp /etc/prometheus/prometheus.yml /etc/prometheus/prometheus.yml.backup
+        ```
+
+        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.02.20_PM.webp" alt="Making Backups from configuration" caption="Making Backups from configuration" />
+
+        Explanation: The `cp` command creates a backup of `prometheus.yml`, which can be invaluable for restoring configurations if the original file is accidentally modified or deleted. Automating this backup as part of a script or cron job is a best practice in production environments.
+3.  Performance Settings:
+    Configuring [Prometheus storage](https://signoz.io/guides/how-to-increase-prometheus-storage-retention/) to manage resource usage efficiently is important for production environments with large data volumes. You can control the amount of data stored by setting retention policies based on time or storage limits.
+        Configure Storage Retention: Adjust retention settings in `prometheus.yml` to define how much historical data Prometheus should keep.
+
+        ```yaml
+        storage:
+          tsdb:
+            retention.time: 15d
+            retention.size: 50GB
+        ```
+
+        <Figure src="/img/guides/2024/11/cannot-start-prometheus-by-using-systemd-Screenshot_2024-11-01_at_10.09.05_PM.webp" alt="Managing Performance Settings" caption="Managing Performance Settings" />
+
+        Explanation: Here, `retention.time` limits the stored data to the most recent 15 days, while `retention.size` caps storage at 50GB. These settings prevent Prometheus from consuming excessive disk space, helping maintain high performance and ensuring that your storage does not fill up unexpectedly. Tailor these values to your organization’s data requirements and storage capacity.
 
 ## FAQs
 
@@ -380,4 +375,4 @@ Restart=on-failure
 RestartSec=5s
 ```
 
-This setup restarts Prometheus automatically on failure with a 5-second delay, reducing downtime.
\ No newline at end of file
+This setup restarts Prometheus automatically on failure with a 5-second delay, reducing downtime.
diff --git a/data/guides/caused-by-java-lang-noclassdeffounderror-org-apache-log4j-logger.mdx b/data/guides/caused-by-java-lang-noclassdeffounderror-org-apache-log4j-logger.mdx
index ca42a8f2d..a0ffe49b1 100644
--- a/data/guides/caused-by-java-lang-noclassdeffounderror-org-apache-log4j-logger.mdx
+++ b/data/guides/caused-by-java-lang-noclassdeffounderror-org-apache-log4j-logger.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Fix NoClassDefFoundError - org.apache.log4j.Logger
-slug: caused-by-java-lang-noclassdeffounderror-org-apache-log4j-logger
 date: 2024-09-18
 tags: [faq]
 authors: [nilesh_sinha]
 description: Learn how to fix NoClassDefFoundError for org.apache.log4j.Logger in Java applications. Discover causes, solutions, and prevention techniques.
-keywords: [NoClassDefFoundError, log4j.Logger, Java error, ClassNotFoundException, Debugging Java, Dependency management, Maven troubleshooting, Java classpath]
-
+keywords:
+  [
+    NoClassDefFoundError,
+    log4j.Logger,
+    Java error,
+    ClassNotFoundException,
+    Debugging Java,
+    Dependency management,
+    Maven troubleshooting,
+    Java classpath,
+  ]
 ---
 
 Java developers often encounter the dreaded `NoClassDefFoundError` — a runtime exception that can bring your application to a screeching halt. When this error involves the `org.apache.log4j.Logger` class, it's particularly frustrating as logging is crucial for debugging and monitoring. This comprehensive guide will help you understand, resolve, and prevent this error, ensuring your Java applications run smoothly.
@@ -57,12 +64,12 @@ log4j.appender.FILE.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
 
 - INFO: Only log messages at the INFO level or higher (WARN, ERROR).
 - Pattern Layout: Defines the format of log messages: date, thread, log level, logger name, and message. Let’s comprehend what the pattern `%d [%t] %-5p %c - %m%n` in the code example signifies:
-    - `%d`: Timestamp of the log event.
-    - `[%t]`: Name of the thread generating the log message, enclosed in square brackets.
-    - `%-5p`: Log level (e.g., INFO, ERROR), padded to 5 characters for alignment.
-    - `%c`: Logger name (usually the class name).
-    - `%m`: The actual log message.
-    - `%n`: Platform-specific newline (ensures each log entry is on a new line).
+  - `%d`: Timestamp of the log event.
+  - `[%t]`: Name of the thread generating the log message, enclosed in square brackets.
+  - `%-5p`: Log level (e.g., INFO, ERROR), padded to 5 characters for alignment.
+  - `%c`: Logger name (usually the class name).
+  - `%m`: The actual log message.
+  - `%n`: Platform-specific newline (ensures each log entry is on a new line).
 
 Console and File Logging:
 
@@ -89,7 +96,7 @@ Let’s look at some of the common scenarios where this situation might arise:
 
 ### Missing or Incorrect Log4j Dependency in Classpath
 
-If the Log4j library is missing from the runtime classpath or incorrectly configured, the JVM will throw this error. This can happen if the Log4j JAR was accidentally removed or not specified properly in the build file. 
+If the Log4j library is missing from the runtime classpath or incorrectly configured, the JVM will throw this error. This can happen if the Log4j JAR was accidentally removed or not specified properly in the build file.
 
 Fix: Add the correct Log4j version to your project’s dependencies.
 
@@ -125,53 +132,45 @@ Trying these quick fixes would help you resolve the issue quickly before jumping
 
 ### Restart and clean:
 
-It’s always better to perform a simple task that doesn’t consume much of your time and fixes your issue as well. Perform a clean build and restart your IDE or application server. 
+It’s always better to perform a simple task that doesn’t consume much of your time and fixes your issue as well. Perform a clean build and restart your IDE or application server.
 
 A clean build and restart would clear cached files and rebuilds the project with the latest changes, resolving issues from stale configurations or dependency conflicts.
 
 ### Check dependencies:
 
-Ensure Log4j is correctly listed in your project dependencies.  You can check the missing Log4j dependency in your Maven project in the following ways:
+Ensure Log4j is correctly listed in your project dependencies. You can check the missing Log4j dependency in your Maven project in the following ways:
 
 - Check `pom.xml` File:
-    - Open your `pom.xml` and look for the Log4j dependency under the `<dependencies>` section.
-    - If it’s missing, you need to add it:
-    
-    ```xml
-    <dependency>
-        <groupId>log4j</groupId>
-        <artifactId>log4j</artifactId>
-        <version>1.2.17</version> <!-- Reference version indicated -->
-    </dependency>
-    ```
-    
+  - Open your `pom.xml` and look for the Log4j dependency under the `<dependencies>` section.
+  - If it’s missing, you need to add it:
+  ```xml
+  <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+      <version>1.2.17</version> <!-- Reference version indicated -->
+  </dependency>
+  ```
 - Run Dependency Tree Command:
-    - Use the command to view the dependency tree and confirm that Log4j is included:
-    
-    ```
-    mvn dependency:tree | grep log4j
-    ```
-    
+  - Use the command to view the dependency tree and confirm that Log4j is included:
+  ```
+  mvn dependency:tree | grep log4j
+  ```
 
 You can also follow the same steps to ensure that the Log4j dependency is present in your Gradle project as well:
 
 - Check `build.gradle` File:
-    - Open your `build.gradle` file and look for the Log4j dependency in the `dependencies` section.
-    - If it’s missing, add it as follows:
-    
-    ```groovy
-    dependencies {
-        implementation 'log4j:log4j:1.2.17' // Reference version indicated
-    }
-    ```
-    
+  - Open your `build.gradle` file and look for the Log4j dependency in the `dependencies` section.
+  - If it’s missing, add it as follows:
+  ```groovy
+  dependencies {
+      implementation 'log4j:log4j:1.2.17' // Reference version indicated
+  }
+  ```
 - Run Dependency Tree Command:
-    - Use the command to view the dependency tree and confirm that Log4j is included:
-    
-    ```bash
-    gradle dependencies --configuration runtimeClasspath | grep log4j
-    ```
-    
+  - Use the command to view the dependency tree and confirm that Log4j is included:
+  ```bash
+  gradle dependencies --configuration runtimeClasspath | grep log4j
+  ```
 
 ### Verify classpath:
 
@@ -180,18 +179,14 @@ Verifying the classpath is essential to ensure that the necessary libraries, lik
 If you're running a Java application directly, you can print the classpath using the following methods:
 
 - Command Line:
-    - When running a Java application, you can print the classpath by including `verbose:class` in the JVM options. This will print out all classes loaded by the JVM, including their location.
-        
-        ```
-        java -verbose:class -cp classpath com.package.MainClass
-        ```
-        
-    - Alternatively, you can print the classpath using a simple Java command:
-        
-        ```
-        java -cp . -classpath "classpath/*" com.package.MainClass
-        ```
-        
+  - When running a Java application, you can print the classpath by including `verbose:class` in the JVM options. This will print out all classes loaded by the JVM, including their location.
+    ```
+    java -verbose:class -cp classpath com.package.MainClass
+    ```
+  - Alternatively, you can print the classpath using a simple Java command:
+    ```
+    java -cp . -classpath "classpath/*" com.package.MainClass
+    ```
 
 Note: For more complex scenarios, it’s better to use a debugger to inspect the classpath at runtime, which can help identify classloading issues and verify that all required libraries are correctly included.
 
@@ -241,45 +236,41 @@ Command Line Execution:
 
 - Place the `log4j.jar` file in a directory, say `lib/`.
 - When running your Java application, specify the classpath using the `cp` option:
-    
-    ```
-    java -cp .;lib/log4j.jar com.example.MainClass
-    ```
-    
-    - On Windows, use `;` as the separator, and on UNIX-based systems like Linux or macOS, use `:`.
-    
-    ```
-    java -cp .;lib/log4j.jar com.example.MainClass
-    ```
-    
+  ```
+  java -cp .;lib/log4j.jar com.example.MainClass
+  ```
+  - On Windows, use `;` as the separator, and on UNIX-based systems like Linux or macOS, use `:`.
+  ```
+  java -cp .;lib/log4j.jar com.example.MainClass
+  ```
 
 ### Configuring build path in IDEs like Eclipse and IntelliJ IDEA
 
 - Eclipse:
-    - Right-click on your project and select `Properties`.
-    - Go to `Java Build Path` > `Libraries`.
-    - Click `Add External JARs...` and navigate to the directory where `log4j.jar` is located.
-    - Add the JAR file, and it will appear under the `Libraries` section of the build path.
-    - Optional: Under `Order and Export`, ensure that `log4j.jar` is checked if you want it to be included in the runtime classpath.
+  - Right-click on your project and select `Properties`.
+  - Go to `Java Build Path` > `Libraries`.
+  - Click `Add External JARs...` and navigate to the directory where `log4j.jar` is located.
+  - Add the JAR file, and it will appear under the `Libraries` section of the build path.
+  - Optional: Under `Order and Export`, ensure that `log4j.jar` is checked if you want it to be included in the runtime classpath.
 - IntelliJ IDEA:
-    - Open the `Project Structure` dialog (`Ctrl+Alt+Shift+S` or `Cmd+;` on macOS).
-    - Go to `Modules` > `Dependencies`.
-    - Click on the `+` sign, select `JARs or directories...`, and add the `log4j.jar` file.
-    - Ensure the scope is set to `Compile` or `Runtime`, depending on your needs.
+  - Open the `Project Structure` dialog (`Ctrl+Alt+Shift+S` or `Cmd+;` on macOS).
+  - Go to `Modules` > `Dependencies`.
+  - Click on the `+` sign, select `JARs or directories...`, and add the `log4j.jar` file.
+  - Ensure the scope is set to `Compile` or `Runtime`, depending on your needs.
 
 ### Checking for conflicting log4j versions in the project structure
 
 - ClassPath Inspection :Print the classpath during runtime to check which version of Log4j is being used:`System.out.println(System.getProperty("java.class.path"));`
 - Handling Conflicts:
-    - If conflicts arise (e.g., `NoClassDefFoundError`), ensure that only the required version of Log4j is present by removing the conflicting versions from the classpath or IDE configuration.
-    - Consider using a dependency manager like Ant or Gradle to manage dependencies and avoid conflicts, even in non-Maven projects.
+  - If conflicts arise (e.g., `NoClassDefFoundError`), ensure that only the required version of Log4j is present by removing the conflicting versions from the classpath or IDE configuration.
+  - Consider using a dependency manager like Ant or Gradle to manage dependencies and avoid conflicts, even in non-Maven projects.
 
 ## Advanced Solutions for Persistent NoClassDefFoundError Issues
 
 If the error persists, try these advanced techniques:
 
-1. Use JClassLib: This bytecode viewer can help inspect class files and their dependencies. 
-Look at the `Constant Pool` and method references to see which class it tries to load. This can help identify the missing class.
+1. Use JClassLib: This bytecode viewer can help inspect class files and their dependencies.
+   Look at the `Constant Pool` and method references to see which class it tries to load. This can help identify the missing class.
 2. Implement custom ClassLoaders: Create a custom ClassLoader to diagnose loading issues:
 
 ```java
@@ -305,6 +296,7 @@ We can have the following commands due to their different purposes:
 - `Xbootclasspath`: Specifies the bootstrap classpath, useful for adding classes to the core Java runtime.
 - `Djava.class.path`: Sets the application classpath, ensuring all required libraries are included for the application.
 - `Xverify:none`: Disables bytecode verification (use with caution), which can sometimes bypass class loading issues caused by verification errors.
+
 1. Debug classpath issues: Use the java command with -cp option to explicitly set the classpath:
 
 ```bash
@@ -381,4 +373,4 @@ This could be due to version conflicts, corrupted JAR files, or classloader issu
 
 ### Can upgrading or downgrading log4j version solve the NoClassDefFoundError?
 
-Yes, sometimes. If you're using an incompatible Log4j version, upgrading or downgrading to a compatible version can resolve the error. However, ensure the new version is compatible with your Java version and other dependencies.
\ No newline at end of file
+Yes, sometimes. If you're using an incompatible Log4j version, upgrading or downgrading to a compatible version can resolve the error. However, ensure the new version is compatible with your Java version and other dependencies.
diff --git a/data/guides/classcastexception-org-slf4j-impl-log4jloggeradapter-cannot-be-cast-to-ch-qos-logback-classic-logger.mdx b/data/guides/classcastexception-org-slf4j-impl-log4jloggeradapter-cannot-be-cast-to-ch-qos-logback-classic-logger.mdx
index e7ffa38fd..c93acce48 100644
--- a/data/guides/classcastexception-org-slf4j-impl-log4jloggeradapter-cannot-be-cast-to-ch-qos-logback-classic-logger.mdx
+++ b/data/guides/classcastexception-org-slf4j-impl-log4jloggeradapter-cannot-be-cast-to-ch-qos-logback-classic-logger.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Fix ClassCastException - SLF4J to Logback Conversion
-slug: classcastexception-org-slf4j-impl-log4jloggeradapter-cannot-be-cast-to-ch-qos-logback-classic-logger
 date: 2024-10-03
 tags: [logging, faq]
 authors: [niyati_thakkar]
 description: Learn how to diagnose and fix the ClassCastException when converting from SLF4J to Logback in Java projects. Step-by-step guide with best practices.
-keywords: [ClassCastException, SLF4J, Logback, Java logging, dependency conflicts, classpath configuration, logging frameworks]
-
+keywords:
+  [
+    ClassCastException,
+    SLF4J,
+    Logback,
+    Java logging,
+    dependency conflicts,
+    classpath configuration,
+    logging frameworks,
+  ]
 ---
 
 Java developers often encounter unexpected exceptions that can bring their applications to a halt. One such perplexing error is the ClassCastException when converting from SLF4J to Logback. This issue typically manifests as "org.slf4j.impl.Log4jLoggerAdapter cannot be cast to ch.qos.logback.classic.Logger". It's a common stumbling block that can frustrate even seasoned programmers. In this comprehensive guide, we'll unravel the mystery behind this exception, explore its root causes, and provide you with practical solutions to resolve it effectively.
@@ -44,21 +50,19 @@ Solution:
 
 - Inspect Dependencies: Use tools like `mvn dependency:tree` (for Maven) or `gradle dependencies` (for Gradle) to identify conflicting dependencies.
 - Exclude Conflicting Libraries: In your `pom.xml` (Maven) or `build.gradle` (Gradle), exclude older or conflicting versions. For example, in Maven:
-    
-    ```xml
-    <dependency>
-        <groupId>some.group</groupId>
-        <artifactId>some-artifact</artifactId>
-        <exclusions>
-            <exclusion>
-                <groupId>org.slf4j</groupId>
-                <artifactId>slf4j-log4j12</artifactId>
-            </exclusion>
-        </exclusions>
-    </dependency>
-    
-    ```
-    
+  ```xml
+  <dependency>
+      <groupId>some.group</groupId>
+      <artifactId>some-artifact</artifactId>
+      <exclusions>
+          <exclusion>
+              <groupId>org.slf4j</groupId>
+              <artifactId>slf4j-log4j12</artifactId>
+          </exclusion>
+      </exclusions>
+  </dependency>
+
+  ```
 - Ensure Correct Versions: After excluding conflicts, ensure you are using compatible versions of SLF4J and Logback.
 
 ### Version Mismatch:
@@ -71,21 +75,19 @@ Solution:
 
 - Check Version Compatibility: Ensure that SLF4J and Logback versions are compatible by checking their <a href="https://www.slf4j.org/manual.html" rel="noopener noreferrer nofollow" target="_blank">documentation or release notes</a>. For instance, SLF4J 1.7.x is compatible with Logback 1.2.x.
 - Update Dependencies: If needed, update your `pom.xml` or `build.gradle` to use compatible versions:
-    
-    ```xml
-    <dependency>
-        <groupId>org.slf4j</groupId>
-        <artifactId>slf4j-api</artifactId>
-        <version>1.7.36</version> <!-- Compatible version -->
-    </dependency>
-    <dependency>
-        <groupId>ch.qos.logback</groupId>
-        <artifactId>logback-classic</artifactId>
-        <version>1.2.11</version> <!-- Compatible version -->
-    </dependency>
-    
-    ```
-    
+  ```xml
+  <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.36</version> <!-- Compatible version -->
+  </dependency>
+  <dependency>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+      <version>1.2.11</version> <!-- Compatible version -->
+  </dependency>
+
+  ```
 
 ### Multiple SLF4J Bindings:
 
@@ -96,46 +98,37 @@ Having multiple SLF4J bindings in your classpath (e.g., `slf4j-log4j12.jar` and
 Solution:
 
 - Identify Multiple Bindings: Check for multiple SLF4J bindings in your project. You can search for SLF4J-related JARs in your build path or run `mvn dependency:tree` or `gradle dependencies` to identify all SLF4J bindings.
-SLF4J will issue a runtime warning if multiple bindings are detected. Check the console output for messages like:
-    
-    ```
-    SLF4J: Class path contains multiple SLF4J bindings.
-    ```
-    
+  SLF4J will issue a runtime warning if multiple bindings are detected. Check the console output for messages like:
+      ```
+      SLF4J: Class path contains multiple SLF4J bindings.
+      ```
 - Remove Unnecessary Bindings: Exclude the unwanted SLF4J binding (such as `slf4j-log4j12`) from your dependencies. For example, in Maven:
-    - In Maven, you can use the following to exclude or limit the scope of conflicting bindings, 
+  - In Maven, you can use the following to exclude or limit the scope of conflicting bindings,
     If you want to keep a dependency for development but not package it in production, you can use the `provided` scope:
-        
         ```xml
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-log4j12</artifactId>
             <scope>provided</scope> <!-- This keeps it available only for specific environments like containers, or testing -->
         </dependency>
-        
-        ```
-        
-    - If the binding is not required at all, it's better to exclude it entirely from your project using an exclusion rule like this:
-        
-        ```xml
-        <dependency>
-            <groupId>some.library</groupId>
-            <artifactId>some-library-dependency</artifactId>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.slf4j</groupId>
-                    <artifactId>slf4j-log4j12</artifactId> <!-- Exclude the conflicting SLF4J binding -->
-                </exclusion>
-            </exclusions>
-        </dependency>
-        
+
         ```
-        
-        This approach ensures that only the correct SLF4J binding (`logback-classic.jar`) is retained, preventing runtime conflicts.
-        
-    
-    You should only keep the `logback-classic.jar` binding for Logback.
-    
+  - If the binding is not required at all, it's better to exclude it entirely from your project using an exclusion rule like this:
+    ```xml
+    <dependency>
+        <groupId>some.library</groupId>
+        <artifactId>some-library-dependency</artifactId>
+        <exclusions>
+            <exclusion>
+                <groupId>org.slf4j</groupId>
+                <artifactId>slf4j-log4j12</artifactId> <!-- Exclude the conflicting SLF4J binding -->
+            </exclusion>
+        </exclusions>
+    </dependency>
+
+    ```
+    This approach ensures that only the correct SLF4J binding (`logback-classic.jar`) is retained, preventing runtime conflicts.
+  You should only keep the `logback-classic.jar` binding for Logback.
 
 ### Incorrect Configuration:
 
@@ -147,51 +140,42 @@ Solution:
 
 - Check for proper configuration files: Ensure you have a valid `logback.xml` or `logback-test.xml` in your classpath. This file should define your loggers, appenders, and log levels.
 - Review your SLF4J binding: Verify that SLF4J is properly bound to Logback by confirming that only `logback-classic.jar` is present and correctly configured.
-    
-    To verify SLF4J is bound to Logback:
-    
-    1. Check for `logback-classic.jar` in your classpath (e.g., in Maven/Gradle dependencies dependencies `(pom.xml/build.gradle)`)for the following:
-        - Maven:
-            
-            ```xml
-            <dependency>
-              <groupId>ch.qos.logback</groupId>
-              <artifactId>logback-classic</artifactId>
-              <version>VERSION</version>
-            </dependency>
-            ```
-            
-        - Gradle:
-            
-            ```
-            implementation 'ch.qos.logback:logback-classic:VERSION'
-            ```
-            
-    2. Look for SLF4J binding confirmation at startup. You should see:
-        
-        ```makefile
-        SLF4J: Found binding in [logback-classic.jar]
-        ```
-        
-    3. Ensure no conflicting bindings (e.g., `slf4j-simple`, `slf4j-log4j`) are in the classpath.
+  To verify SLF4J is bound to Logback:
+  1. Check for `logback-classic.jar` in your classpath (e.g., in Maven/Gradle dependencies dependencies `(pom.xml/build.gradle)`)for the following:
+     - Maven:
+       ```xml
+       <dependency>
+         <groupId>ch.qos.logback</groupId>
+         <artifactId>logback-classic</artifactId>
+         <version>VERSION</version>
+       </dependency>
+       ```
+     - Gradle:
+       ```
+       implementation 'ch.qos.logback:logback-classic:VERSION'
+       ```
+  2. Look for SLF4J binding confirmation at startup. You should see:
+
+     ```makefile
+     SLF4J: Found binding in [logback-classic.jar]
+     ```
+
+  3. Ensure no conflicting bindings (e.g., `slf4j-simple`, `slf4j-log4j`) are in the classpath.
 - Sample `logback.xml` configuration:
-    
-    ```xml
-    <configuration>
-      <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-          <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-      </appender>
-    
-      <root level="debug">
-        <appender-ref ref="STDOUT" />
-      </root>
-    </configuration>
-    ```
-    
-    The pattern `%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n` formats the log output by displaying the timestamp, log level (padded to 5 characters), logger name (up to 36 characters), and the actual log message, followed by a new line. This ensures a clean and readable log structure.
-    
+  ```xml
+  <configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+      <encoder>
+        <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+      </encoder>
+    </appender>
+
+    <root level="debug">
+      <appender-ref ref="STDOUT" />
+    </root>
+  </configuration>
+  ```
+  The pattern `%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n` formats the log output by displaying the timestamp, log level (padded to 5 characters), logger name (up to 36 characters), and the actual log message, followed by a new line. This ensures a clean and readable log structure.
 
 ## Step-by-Step Guide to Diagnose the ClassCastException
 
@@ -218,17 +202,15 @@ Exception in thread "main" java.lang.ClassCastException: org.slf4j.impl.Log4jLog
 Multiple logging libraries or bindings in your classpath can cause conflicts. Use Maven or Gradle to inspect your dependencies:
 
 - List your project’s dependencies: This will help you see if multiple logging implementations are included (e.g., `slf4j-log4j12.jar` alongside `logback-classic.jar`).
-    
-    ```bash
-    
-    # For Maven
-    mvn dependency:tree
-    
-    # For Gradle
-    gradle dependencies
-    
-    ```
-    
+  ```bash
+
+  # For Maven
+  mvn dependency:tree
+
+  # For Gradle
+  gradle dependencies
+
+  ```
 - Check for multiple SLF4J bindings: The output should show if both `slf4j-log4j12` (Log4j binding for SLF4J) and `logback-classic` are present. You should only have one SLF4J binding.
 
 Example Maven Output:
@@ -248,54 +230,48 @@ When a transitive dependency brings in a different version of SLF4J or Logback,
 
 - Verify versions: Ensure that the versions of SLF4J and Logback are compatible. SLF4J 1.7.x should be used with Logback 1.2.x for most applications. Mismatched versions can cause runtime issues.
 - Enforce versioning with dependency management: Use Maven or Gradle’s dependency management features to enforce consistent versions across your project.
-    - In Gradle, using `strict version constraints` or `resolutionStrategy` ensures a specific version is used, avoiding conflicts.
-        
-        Example: Enforcing Versions in Gradle
-        
-        ```
-        gradle
-        Copy code
-        dependencies {
-            implementation('ch.qos.logback:logback-classic:1.2.3') {
-                because 'Ensuring version compatibility with SLF4J'
-            }
-            implementation('org.slf4j:slf4j-api:1.7.30') {
-                because 'Compatible with Logback 1.2.x'
-            }
+  - In Gradle, using `strict version constraints` or `resolutionStrategy` ensures a specific version is used, avoiding conflicts.
+    Example: Enforcing Versions in Gradle
+    ```
+    gradle
+    Copy code
+    dependencies {
+        implementation('ch.qos.logback:logback-classic:1.2.3') {
+            because 'Ensuring version compatibility with SLF4J'
         }
-        
-        configurations.all {
-            resolutionStrategy {
-                force 'ch.qos.logback:logback-classic:1.2.3'
-                force 'org.slf4j:slf4j-api:1.7.30'
-            }
+        implementation('org.slf4j:slf4j-api:1.7.30') {
+            because 'Compatible with Logback 1.2.x'
         }
-        
-        ```
-        
-    - In Maven, the `dependencyManagement` section allows you to enforce consistent versions across all modules, overriding any transitive dependencies.
-        
-        Example: Enforcing Versions in Maven
-        
-        ```xml
-        <dependencyManagement>
-          <dependencies>
-            <dependency>
-              <groupId>ch.qos.logback</groupId>
-              <artifactId>logback-classic</artifactId>
-              <version>1.2.3</version>
-            </dependency>
-            <dependency>
-              <groupId>org.slf4j</groupId>
-              <artifactId>slf4j-api</artifactId>
-              <version>1.7.30</version>
-            </dependency>
-          </dependencies>
-        </dependencyManagement>
-        ```
-        
+    }
 
-To find the latest compatible versions of <a href="https://www.slf4j.org/" rel="noopener noreferrer nofollow" target="_blank">SLF4J</a> and <a href="https://logback.qos.ch/" rel="noopener noreferrer nofollow" target="_blank">Logback</a> refer to other official websites. 
+    configurations.all {
+        resolutionStrategy {
+            force 'ch.qos.logback:logback-classic:1.2.3'
+            force 'org.slf4j:slf4j-api:1.7.30'
+        }
+    }
+
+    ```
+  - In Maven, the `dependencyManagement` section allows you to enforce consistent versions across all modules, overriding any transitive dependencies.
+    Example: Enforcing Versions in Maven
+    ```xml
+    <dependencyManagement>
+      <dependencies>
+        <dependency>
+          <groupId>ch.qos.logback</groupId>
+          <artifactId>logback-classic</artifactId>
+          <version>1.2.3</version>
+        </dependency>
+        <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>slf4j-api</artifactId>
+          <version>1.7.30</version>
+        </dependency>
+      </dependencies>
+    </dependencyManagement>
+    ```
+
+To find the latest compatible versions of <a href="https://www.slf4j.org/" rel="noopener noreferrer nofollow" target="_blank">SLF4J</a> and <a href="https://logback.qos.ch/" rel="noopener noreferrer nofollow" target="_blank">Logback</a> refer to other official websites.
 
 ### Verify the Classpath
 
@@ -352,96 +328,95 @@ Example of Temporary Debug Configuration in `logback.xml`:
 Once you've identified the cause, here's how to fix it:
 
 1. Update Versions: Ensure you're using compatible versions of SLF4J and Logback. For example:
-    
-    ```xml
-    <dependency>
-        <groupId>org.slf4j</groupId>
-        <artifactId>slf4j-api</artifactId>
-        <version>1.7.32</version>
-    </dependency>
-    <dependency>
-        <groupId>ch.qos.logback</groupId>
-        <artifactId>logback-classic</artifactId>
-        <version>1.2.6</version>
-    </dependency>
-    
-    ```
-    
+
+   ```xml
+   <dependency>
+       <groupId>org.slf4j</groupId>
+       <artifactId>slf4j-api</artifactId>
+       <version>1.7.32</version>
+   </dependency>
+   <dependency>
+       <groupId>ch.qos.logback</groupId>
+       <artifactId>logback-classic</artifactId>
+       <version>1.2.6</version>
+   </dependency>
+
+   ```
+
 2. Remove Conflicts: Eliminate conflicting logging implementations from your classpath. For instance, exclude log4j if you're using Logback:
-    
-    ```xml
-    <dependency>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter</artifactId>
-        <exclusions>
-            <exclusion>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-starter-logging</artifactId>
-            </exclusion>
-        </exclusions>
-    </dependency>
-    
-    ```
-    
+
+   ```xml
+   <dependency>
+       <groupId>org.springframework.boot</groupId>
+       <artifactId>spring-boot-starter</artifactId>
+       <exclusions>
+           <exclusion>
+               <groupId>org.springframework.boot</groupId>
+               <artifactId>spring-boot-starter-logging</artifactId>
+           </exclusion>
+       </exclusions>
+   </dependency>
+
+   ```
+
 3. Configure SLF4J Binding: Ensure you have the correct SLF4J binding for Logback in your classpath. For example, SLF4J 1.0.7 is compatible with Logback 1.3.0-alpha5.
-    
-    ```xml
-    <dependencies>
-            <!-- SLF4J API -->
-            <dependency>
-                <groupId>org.slf4j</groupId>
-                <artifactId>slf4j-api</artifactId>
-                <version>1.0.7</version>
-            </dependency>
-    
-            <!-- Logback Classic (SLF4J binding) -->
-            <dependency>
-                <groupId>ch.qos.logback</groupId>
-                <artifactId>logback-classic</artifactId>
-                <version>1.3.0-alpha5</version>
-            </dependency>
-        </dependencies>
-    ```
-    
+
+   ```xml
+   <dependencies>
+           <!-- SLF4J API -->
+           <dependency>
+               <groupId>org.slf4j</groupId>
+               <artifactId>slf4j-api</artifactId>
+               <version>1.0.7</version>
+           </dependency>
+
+           <!-- Logback Classic (SLF4J binding) -->
+           <dependency>
+               <groupId>ch.qos.logback</groupId>
+               <artifactId>logback-classic</artifactId>
+               <version>1.3.0-alpha5</version>
+           </dependency>
+       </dependencies>
+   ```
+
 4. Implement Exclusions: Use build file exclusions to prevent conflicting dependencies:
-    
-    ```xml
-    <dependency>
-        <groupId>com.example</groupId>
-        <artifactId>example-library</artifactId>
-        <version>1.0.0</version>
-        <exclusions>
-            <exclusion>
-                <groupId>org.slf4j</groupId>
-                <artifactId>slf4j-log4j12</artifactId>
-            </exclusion>
-        </exclusions>
-    </dependency>
-    
-    ```
-    
+
+   ```xml
+   <dependency>
+       <groupId>com.example</groupId>
+       <artifactId>example-library</artifactId>
+       <version>1.0.0</version>
+       <exclusions>
+           <exclusion>
+               <groupId>org.slf4j</groupId>
+               <artifactId>slf4j-log4j12</artifactId>
+           </exclusion>
+       </exclusions>
+   </dependency>
+
+   ```
 
 ### Configuring Logback Correctly
 
 Proper configuration of Logback is crucial. Here's a basic setup:
 
 1. Create a `logback.xml` file in your `src/main/resources` directory:
-    
-    ```xml
-    <configuration>
-        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
-            <encoder>
-                <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-            </encoder>
-        </appender>
-    
-        <root level="INFO">
-            <appender-ref ref="CONSOLE" />
-        </root>
-    </configuration>
-    
-    ```
-    
+
+   ```xml
+   <configuration>
+       <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+           <encoder>
+               <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+           </encoder>
+       </appender>
+
+       <root level="INFO">
+           <appender-ref ref="CONSOLE" />
+       </root>
+   </configuration>
+
+   ```
+
 2. Set up appenders and loggers as needed.
 3. Specify desired log levels for different packages.
 4. Test your configuration to ensure proper logging behavior.
@@ -527,4 +502,4 @@ Logback offers several advantages:
 3. More flexible configuration options
 4. Automatic reloading of configuration files
 5. Conditional processing in configuration files
-6. Improved filter design allowing more flexible filtering options
\ No newline at end of file
+6. Improved filter design allowing more flexible filtering options
diff --git a/data/guides/claude-api-latency.mdx b/data/guides/claude-api-latency.mdx
index e9ab788c2..aa5ec4d52 100644
--- a/data/guides/claude-api-latency.mdx
+++ b/data/guides/claude-api-latency.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Reduce Claude API Latency - Tips for Optimization
-slug: claude-api-latency
 date: 2024-09-24
 tags: [monitoring]
 authors: [soumya_gupta]
 description: Discover effective strategies to reduce Claude API latency, optimize performance, and enhance user experience. Learn practical tips for faster AI interactions.
-keywords: [Claude API latency, API optimization, LLM performance, AI response time, API monitoring, prompt engineering, latency reduction]
-
+keywords:
+  [
+    Claude API latency,
+    API optimization,
+    LLM performance,
+    AI response time,
+    API monitoring,
+    prompt engineering,
+    latency reduction,
+  ]
 ---
 
 API latency can make or break the user experience of AI-powered applications. For developers working with Anthropic's Claude API, minimizing response times is crucial for creating smooth, responsive interactions. This guide explores practical strategies to reduce Claude API latency, helping you optimize your AI applications for peak performance.
@@ -24,11 +30,11 @@ Claude is an AI assistant created by Anthropic. It's designed to help with all s
 
 High latency can lead to sluggish applications, frustrated users, and increased bounce rates. Optimizing Claude API latency is essential for delivering a seamless user experience and maintaining the efficiency of your AI-driven systems.
 
-Here’s a quick guide to the official docs to <a href="https://docs.anthropic.com/en/api/getting-started" rel="noopener noreferrer nofollow" target="_blank">get you started</a>. 
+Here’s a quick guide to the official docs to <a href="https://docs.anthropic.com/en/api/getting-started" rel="noopener noreferrer nofollow" target="_blank">get you started</a>.
 
 ## Measuring Claude API Latency
 
-Before you can improve latency, you need to measure it accurately. 
+Before you can improve latency, you need to measure it accurately.
 
 - Baseline latency refers to how long the model takes to process a prompt and produce a response, excluding the rate of input and output tokens per second. It gives an overall sense of the model’s speed.
 - Time to first token (TTFT): This measures the time it takes for the model to produce the first token after the prompt is submitted. It's essential when using streaming and aiming to deliver a quick, responsive user experience.
@@ -58,13 +64,13 @@ Keep frequently used prompts or contexts in a quick, in-memory cache. This impli
 
 So, what’s prompt caching all about? It’s a technique where you save responses from Large Language Models (LLMs) for specific prompts or inputs. When the model recognizes a prompt, it retrieves the stored response. This reduces the computational effort and speeds things up.
 
-Let’s start by installing anthropic using the following command: 
+Let’s start by installing anthropic using the following command:
 
 ```python
 pip install anthropic
 ```
 
-Then, in order to access the API keys, 
+Then, in order to access the API keys,
 
 The API is made available via our web Console. You can use the Workbench to try out the API in the browser and then generate API keys in Account Settings. Use workspaces to segment your API keys and control spend by use case.
 
@@ -101,7 +107,7 @@ print(response['completion'])
 
 This example shows a simple use of prompt caching, where all logs are stored in Claude’s memory. Doing this minimizes the need to recompute the entire set of documentation for each new question, making the process more efficient.
 
-In the above code, we used the following parameters: 
+In the above code, we used the following parameters:
 
 1. `model="claude-3.5` : This parameter specifies which model to use for generating the completion
 2. `max_tokens_to_sample=1024` : This parameter determines the maximum number of tokens that the model should generate in its response upon completion (which is 1024 in this case)
@@ -110,7 +116,7 @@ In the above code, we used the following parameters:
 We’ve also used stop sequences. In text processing, it can help the model determine where to stop generating text.
 If you don’t use stop sequences, the model might generate a response that is too long or jumbled together, making it hard to interpret individual log entries.
 
-Let’s say we have the following log file, 
+Let’s say we have the following log file,
 
 ```python
 2024-09-16 12:34:56 - INFO - Starting process
@@ -120,7 +126,7 @@ Let’s say we have the following log file,
 2024-09-16 12:36:15 - ERROR - Failed to read configuration file
 ```
 
-Without stop sequences, the output will look like this: 
+Without stop sequences, the output will look like this:
 
 ```
 You are an expert AI assistant for understanding error logs. Here is the full set of logs and accompanying errors: 2024-09-15 12:34:56 - INFO - Starting process 2024-09-15 12:35:01 - ERROR - Unable to connect to database 2024-09-15 12:35:05 - INFO - Process finished successfully 2024-09-15 12:36:00 - WARNING - Memory usage is high 2024-09-15 12:36:15 - ERROR - Failed to read configuration file
@@ -150,7 +156,7 @@ Is the prompt prefix already stored in the system's cache?
 
 If so, the system pulls the cached response, reducing processing time and costs. If not, the model processes the entire prompt and stores the prefix for the next time.
 
-Here’s what happens when you request with Prompt Caching enabled: The system checks if it has recently cached the prompt prefix from a previous query. It uses the cached version to save time and resources if it finds a match. If no match is found, it processes the full prompt and then caches the prefix for future queries. 
+Here’s what happens when you request with Prompt Caching enabled: The system checks if it has recently cached the prompt prefix from a previous query. It uses the cached version to save time and resources if it finds a match. If no match is found, it processes the full prompt and then caches the prefix for future queries.
 
 Let’s say you often ask, “What are the benefits of regular exercise?” The first time you ask, the system processes it from scratch and saves that info for later. So, when you ask something similar, like “How does regular exercise help with mental health?” the system remembers the previous answer about exercise benefits and quickly pulls up the relevant details, making the whole process faster and more efficient.
 
@@ -246,7 +252,7 @@ from anthropic import AsyncAnthropic
 client = AsyncAnthropic()          # Expects env variable 'ANTHROPIC_API_KEY'
 
 async def summarize_city(country):
-		content = f"""Summarize {country} economy: 
+		content = f"""Summarize {country} economy:
 			inflation, unemployment, GDP, trends. Short/long-term industry impacts."""
     response = await client.messages.create(
         model="claude-3-haiku-20240307",
@@ -371,4 +377,4 @@ While aggressive latency optimization can potentially affect response quality, w
 
 ### What are the trade-offs between latency and context window size?
 
-Larger context windows generally increase latency due to more tokens being processed. However, they also enable more comprehensive understanding and responses. Strike a balance by providing sufficient context for accurate responses while optimizing prompt efficiency.
\ No newline at end of file
+Larger context windows generally increase latency due to more tokens being processed. However, they also enable more comprehensive understanding and responses. Strike a balance by providing sufficient context for accurate responses while optimizing prompt efficiency.
diff --git a/data/guides/cloud-native-monitoring.mdx b/data/guides/cloud-native-monitoring.mdx
index 724e8f1b7..d7f2b0ab5 100644
--- a/data/guides/cloud-native-monitoring.mdx
+++ b/data/guides/cloud-native-monitoring.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Cloud Native Monitoring - Essential Guide for DevOps Teams
-slug: cloud-native-monitoring
 date: 2024-09-18
 tags: [monitoring]
 authors: [manjunath_irukulla]
 description: Discover the essentials of cloud-native monitoring for DevOps teams. Learn about key components, best practices, and tools to optimize your cloud-based applications.
-keywords: [cloud native monitoring, DevOps, observability, microservices, distributed tracing, log aggregation, performance metrics]
-
+keywords:
+  [
+    cloud native monitoring,
+    DevOps,
+    observability,
+    microservices,
+    distributed tracing,
+    log aggregation,
+    performance metrics,
+  ]
 ---
 
 Cloud-native monitoring has become critical for DevOps teams managing modern, distributed applications. As organizations increasingly adopt microservices architectures and containerized deployments, traditional monitoring approaches fail to provide visibility and insights.
@@ -16,25 +22,25 @@ This blog explores the fundamentals of cloud-native monitoring, its importance i
 
 ## What is Cloud-Native Monitoring?
 
-Cloud-native monitoring represents one of the ways to observe and manage cloud-based, distributed environments for performance, health, and behaviour. It is designed to take care of dynamic and ever-changing cloud environments, contrary to traditional methods working in a static on-premise environment. Here’s how it stands out: 
+Cloud-native monitoring represents one of the ways to observe and manage cloud-based, distributed environments for performance, health, and behaviour. It is designed to take care of dynamic and ever-changing cloud environments, contrary to traditional methods working in a static on-premise environment. Here’s how it stands out:
 
 - Scalability: Cloud-native monitoring tools are designed to scale with your infrastructure, whether it’s an unexpected spike in traffic or the deployment of new services. The tool automatically adjusts for continuous visibility without any human intervention.
 - Distributed tracing: Applications in a complex cloud environment usually consist of microservices disseminated across several servers. Most cloud-native monitoring systems excel in tracking requests as they move through multiple services to help you have end-to-end visibility into how data travels across your architecture. This makes pinpointing issues, no matter where they occur.
 - Container-aware monitoring: As containerization becomes widely adopted, monitoring tools must be container-aware. Cloud-native monitoring solutions are built to track container-specific metrics and handle the short-lived nature of container instances. These tools provide visibility into when containers are created or destroyed, even at a high rate of change.
 - Automation: Cloud-native monitoring solutions are invested in robust automation capabilities. They are able to automatically gather data from numerous sources, analyze it in real-time, trigger alerts based on a predetermined threshold, and minimize the need to continuously have human oversight of the environment, thereby freeing your teams to focus on more strategic tasks.
 
-Core components of cloud-native monitoring rely on three major pillars: logs, metrics, and traces. Each one of them helps teams together to keep high availability and great performance in systems. 
+Core components of cloud-native monitoring rely on three major pillars: logs, metrics, and traces. Each one of them helps teams together to keep high availability and great performance in systems.
 
 - Logs: It is a detailed record of events and actions occurring within your applications and infrastructure.
-    - Use Case: They are extremely useful when an anomaly occurs and when it involves exercising post-mortem debugging and understanding the context in which something went wrong.
+  - Use Case: They are extremely useful when an anomaly occurs and when it involves exercising post-mortem debugging and understanding the context in which something went wrong.
 - Metrics: These are quantitative measurements that detail how your system is performing and behaving over a period of time. Common metrics include CPU usage, memory consumed, and latency of requests.
-    - Use Case: By tracking these, one is in a better position to notice the trend and thereby make informed decisions on how to improve one’s system performance.
+  - Use Case: By tracking these, one is in a better position to notice the trend and thereby make informed decisions on how to improve one’s system performance.
 - Traces: Traces represent a record of requests as they move through a distributed system.
-    - Use Case: They will show both the path and duration of each step of the user so that one can easily see how different services interact and where some potential bottlenecks or failures may occur.
+  - Use Case: They will show both the path and duration of each step of the user so that one can easily see how different services interact and where some potential bottlenecks or failures may occur.
 
 ## Why Cloud-Native Monitoring is Essential for DevOps Teams
 
-DevOps teams are tasked with the responsibility of ensuring that cloud-native applications run smoothly and efficiently in highly dynamic environments. However, this comes with its own set of challenges: 
+DevOps teams are tasked with the responsibility of ensuring that cloud-native applications run smoothly and efficiently in highly dynamic environments. However, this comes with its own set of challenges:
 
 - Complexity of Distributed Systems: In a cloud-native world, applications are often built using microservice architectures, where different components communicate over the network. This introduces a large number of moving parts, and that complicates diagnosis if something were to go off the rails. Traditional monitoring tools are poorly suited to making such visibility into distributed systems possible.
 - Rapid Changes: DevOps means performing continuous integration and continuous development(CI/CD). These practices give way to more frequent updates and changes within the system, which need 24/7 monitoring to ensure that new code additions don’t result in new problems. Without adequate monitoring, these rapid changes can easily cause downtime or degrade the performance.
@@ -52,11 +58,11 @@ Cloud-native monitoring provides critical capabilities that help DevOps teams ef
 
 ## The Three Pillars of Observability in Cloud Native Monitoring
 
-In cloud-native environments, achieving observability is crucial for maintaining the health, performance, and reliability of applications. Observability is built on three fundamental pillars: logs, metrics, and traces. Each pillar provides unique insights, and together they offer a comprehensive view of the system. 
+In cloud-native environments, achieving observability is crucial for maintaining the health, performance, and reliability of applications. Observability is built on three fundamental pillars: logs, metrics, and traces. Each pillar provides unique insights, and together they offer a comprehensive view of the system.
 
 ### Logs: Aggregation and Analysis
 
-Logs capture detailed information about events and actions within your systems. In cloud-native environments, where services are distributed and dynamic, effective log management is essential for maintaining control and visibility. Key practices include:  
+Logs capture detailed information about events and actions within your systems. In cloud-native environments, where services are distributed and dynamic, effective log management is essential for maintaining control and visibility. Key practices include:
 
 - Centralized Log Aggregation: Aggregation of logs in a single, searchable repository can ensure that all information is easily accessed, logs in cloud-native systems are generated mostly from multiple components across different services, containers and nodes. This is a critical requirement when one performs troubleshooting or analysis.
 - [Structured Logging](https://signoz.io/blog/structured-logs/): With a consistent log format, like JSON, for example, it becomes much easier to parse and subsequently perform automated analysis. Using structured logs, advanced searches and data filtering or correlations can be done with ease to rapidly pinpoint and resolve issues.
@@ -70,7 +76,7 @@ Effective Log Management Enables DevOps Teams To:
 
 ### Metrics: Types and Significance
 
-Metrics are quantitative and reflect the performance and behaviour of your system over time. In a cloud-native environment, monitoring the right metrics is essential for ensuring the smooth operation of applications and infrastructure. Key types of metrics include: 
+Metrics are quantitative and reflect the performance and behaviour of your system over time. In a cloud-native environment, monitoring the right metrics is essential for ensuring the smooth operation of applications and infrastructure. Key types of metrics include:
 
 - Resource Metrics: These metrics monitor the resource utilization of the system, including CPU, memory, disk and network. Resource metrics help in giving a clue on over or underutilization, which can indicate inefficiency in any manner or potential performance issues.
 - Application Metrics: These show the different ways in which the performance of an application itself is done based on request rates, response times, error rates, etc. From there, the DevOps teams use these metrics to track how effectively an application is serving its users and find new ways to serve them better.
@@ -84,9 +90,9 @@ Metrics provide valuable insights for DevOps teams:
 
 ### Traces: Distributed Tracing in Microservices
 
-In a microservices architecture, one request from a user will go through several services before coming back with a response. 
+In a microservices architecture, one request from a user will go through several services before coming back with a response.
 
-In this, [distributed tracing](https://signoz.io/distributed-tracing/) allows DevOps teams to track the path those requests take; therefore, important insights are derived about how those services are going to interact and where issues might occur. 
+In this, [distributed tracing](https://signoz.io/distributed-tracing/) allows DevOps teams to track the path those requests take; therefore, important insights are derived about how those services are going to interact and where issues might occur.
 
 Implementing effective distributed tracing involves:
 
@@ -94,7 +100,7 @@ Implementing effective distributed tracing involves:
 - Sampling: Given the volume of requests in a large system, it’s often impractical to trace every single one. Sampling allows teams to collect a representative subset of traces, which reduces data volume.
 - Visualization: Visualization tools help teams analyze trace data, making it easier to understand the flow of requests, identify latency issues, and pinpoint performance bottlenecks. These tools often provide a graphical representation of traces, showing how requests move through the system and where delays occur.
 
-Benefits for DevOps Teams: 
+Benefits for DevOps Teams:
 
 - Request Flow Visualization: Tracing provides a clear view of requests navigating through the system, revealing the sequence of service interactions.
 - Latency Identification: By analyzing the duration of each step in a trace, teams can identify services that are introducing delays and prioritize them for optimization.
@@ -102,11 +108,11 @@ Benefits for DevOps Teams:
 
 ## Key Components of an Effective Cloud-Native Monitoring Strategy
 
-One of the most important complete cloud-native monitoring strategies will be essential in ensuring your applications are performing optimally, reliably, and securely within dynamic cloud environments. Accomplishing this requires looking at a comprehensive approach from several different key areas, including: 
+One of the most important complete cloud-native monitoring strategies will be essential in ensuring your applications are performing optimally, reliably, and securely within dynamic cloud environments. Accomplishing this requires looking at a comprehensive approach from several different key areas, including:
 
 ### Infrastructure Monitoring
 
-The underlying infrastructure forms the basis of your cloud-native applications, which have to be monitored constantly for stability and efficiency. The key areas include: 
+The underlying infrastructure forms the basis of your cloud-native applications, which have to be monitored constantly for stability and efficiency. The key areas include:
 
 - Kubernetes Monitoring: Kubernetes works as one of the most widely used cloud-native environments for container orchestration. Monitoring Kubernetes involves monitoring cluster health, the status of pods, and the utilization of resources across nodes. This gives the basis needed to identify impending resource contention, failed pods, or node failures before they affect application performance.
 - Container Monitoring: Containers are the basis of cloud-native applications. Monitoring their performance and resource usage, such as CPU and memory usage, alongside life cycle events-creation, deletion, and scaling of containers provides a clear view that helps identify issues such as overutilization of resources or container crashes.
@@ -114,7 +120,7 @@ The underlying infrastructure forms the basis of your cloud-native applications,
 
 ### Application Performance Monitoring (APM)
 
-APM is all about ensuring that your apps provide a good user experience that your apps provide a good user experience smooth and responsive. That requires monitoring at various levels in the application stack: 
+APM is all about ensuring that your apps provide a good user experience that your apps provide a good user experience smooth and responsive. That requires monitoring at various levels in the application stack:
 
 - Code-Level Visibility: With [APM tools](https://signoz.io/blog/open-source-apm-tools/), you’ll find out exactly which part of your application code performs badly to pinpoint which functions or queries slow down a system. Knowing the exact parts of code that are inefficient will allow developers to optimize those aspects of the code that, when modified, would have the largest positive impact on general performance.
 - Transaction Tracing: As a request travels between various services in a distributed application, transaction tracing allows tracking these requests end to end. This helps find out where things slow down and know how different components of your facility contribute to the response time of an application.
@@ -122,7 +128,7 @@ APM is all about ensuring that your apps provide a good user experience that you
 
 ### Network Monitoring and Security
 
-The backbone of any distributed system is the network, and performance and security will be most important. Key aspects of network monitoring involve:  
+The backbone of any distributed system is the network, and performance and security will be most important. Key aspects of network monitoring involve:
 
 - Network Performance: It would be appropriate to observe network latency, throughput and packet loss to maintain application responsiveness and ensuring proper data flow across services. Network bottlenecks and outages can be caused that result in slow response times or complete outages. This warrants real-time monitoring and alerts to find problems to be addressed.
 - Security Monitoring: Applications are getting distributed, and hence the attack surface expands. Security monitoring can be described as detecting and alerting on potential threats coming through unauthorized access attempts, data breaches, or anomalies in network traffic showing malicious activities. Integrating security into your monitoring strategy helps identify incidents sooner and mitigates them sooner.
@@ -130,7 +136,7 @@ The backbone of any distributed system is the network, and performance and secur
 
 ### User Experience and Business Metrics
 
-The key to connecting technical performance with business outcomes is understanding the real impact of monitoring efforts: 
+The key to connecting technical performance with business outcomes is understanding the real impact of monitoring efforts:
 
 - Real User Monitoring (RUM): RUM tools monitor real users in interaction with an application by measuring the actual experiences with an application. It captures the time it takes to load pages, speed for transactions, and errors that occur while users interact with an application, hence giving insight into how your application performs from the user’s perspective.
 - Business Key Performance Indicator(KPI) Tracking: Associating key business performance indicators with application performance metrics, such as conversion rates, revenue, or user engagement, will establish the business value of your monitoring effects. By associating KPIs with technical changes, you can be sure that technical enhancements will have real business outcomes.
@@ -138,69 +144,80 @@ The key to connecting technical performance with business outcomes is understand
 
 ## Best Practices for Implementing Cloud Native Monitoring
 
-Your strategy to cloud-native monitoring should be implemented in a manner that will render it not only effective but also substantial and capable of evolving towards meeting modern applications’ needs. In the end, consider the following best practices: 
+Your strategy to cloud-native monitoring should be implemented in a manner that will render it not only effective but also substantial and capable of evolving towards meeting modern applications’ needs. In the end, consider the following best practices:
 
 - Adopt a Data-Driven Approach: Decision-making should be backed by tangible data rather than assumptions. This involves:
-    - Always Collect Data: Ensure that relevant metrics, logs, and traces are constantly collected and processed.
-    - Actionable Insights: Focus on generating insights that directly inform operational decisions and lead to measurable improvements.
-    - Feedback Loops: Use monitoring data to create feedback loops, allowing teams to refine processes, optimize performance, and reduce downtime.
+  - Always Collect Data: Ensure that relevant metrics, logs, and traces are constantly collected and processed.
+  - Actionable Insights: Focus on generating insights that directly inform operational decisions and lead to measurable improvements.
+  - Feedback Loops: Use monitoring data to create feedback loops, allowing teams to refine processes, optimize performance, and reduce downtime.
 - Automation of Alerts: This will create automation for alerts on critical issues that need immediate attention. For known issues, this could be threshold-based alerts for unexpected behaviours and anomaly detection.
-    - Auto-Scaling and Self-Healing: Take full advantage of cloud-native capabilities in areas such as auto-scaling to dynamically change resource levels based on demand. Establish self-healing processes whereby any failures can be handled through automated restarts of services and our routing of traffic to healthy instances with no human intervention.
+  - Auto-Scaling and Self-Healing: Take full advantage of cloud-native capabilities in areas such as auto-scaling to dynamically change resource levels based on demand. Establish self-healing processes whereby any failures can be handled through automated restarts of services and our routing of traffic to healthy instances with no human intervention.
 - Leverage AI and Machine Learning: AI and machine learning can enhance monitoring by providing deeper insights and proactive management:
-    - Anomaly Detection: AI-powered anomaly detection identifies unusual patterns in metrics, logs, and traces that indicate potential problems early enough for teams to take action before things get worse.
-    - Predictive Analytics: Utilize machine learning models to forecast trends such as resource utilization or predicted failures. This proactive approach helps in planning and preventing issues well in advance before impacting users.
+  - Anomaly Detection: AI-powered anomaly detection identifies unusual patterns in metrics, logs, and traces that indicate potential problems early enough for teams to take action before things get worse.
+  - Predictive Analytics: Utilize machine learning models to forecast trends such as resource utilization or predicted failures. This proactive approach helps in planning and preventing issues well in advance before impacting users.
 - Scalability and cost-effectiveness: Monitoring should not scale into an unaffordable proposition:
-    - Scalable Solutions: The monitoring solutions should scale with your infrastructure. Ensure the monitoring solution can scale with your environment effectively.
-    - Data Retention Policies: Set up policy-driven data retention for monitoring data, finding a good balance between the length of historical data and costs. Consider moving older data to lower-cost tiered storage solutions.
-    - Sampling Techniques: Utilize sampling techniques in the ease of high-volume data sources. This reduces the volume of data that needs to be captured without necessarily losing significant insights. In this way, it controls costs and maintains data processing within manageable capacity.
+  - Scalable Solutions: The monitoring solutions should scale with your infrastructure. Ensure the monitoring solution can scale with your environment effectively.
+  - Data Retention Policies: Set up policy-driven data retention for monitoring data, finding a good balance between the length of historical data and costs. Consider moving older data to lower-cost tiered storage solutions.
+  - Sampling Techniques: Utilize sampling techniques in the ease of high-volume data sources. This reduces the volume of data that needs to be captured without necessarily losing significant insights. In this way, it controls costs and maintains data processing within manageable capacity.
 - Develop an Observability Culture: Observability should permeate into the organizational culture and not just be a technical requirement.
-    - Instrument Code Meaningfully: Encourage developers to instrument their code with meaningful logs, metrics, and trace points so that they might ensure data will be there when problems occur. Facilitate collaboration around monitoring data between the development and operation teams. This helps in spreading knowledge and hence enhancing incident response and continuous improvement.
-    - Regular Reviews and Training: Regular review of practices for monitoring, with ongoing training of teams in the latest tools and techniques.
+  - Instrument Code Meaningfully: Encourage developers to instrument their code with meaningful logs, metrics, and trace points so that they might ensure data will be there when problems occur. Facilitate collaboration around monitoring data between the development and operation teams. This helps in spreading knowledge and hence enhancing incident response and continuous improvement.
+  - Regular Reviews and Training: Regular review of practices for monitoring, with ongoing training of teams in the latest tools and techniques.
 
 ## Tools and Technologies for Cloud-Native Monitoring
 
-Selecting the right tools is crucial for effective cloud-native monitoring. The following categories cover a range of options, from open-source solutions to cloud provider offerings and third-party platforms:  
+Selecting the right tools is crucial for effective cloud-native monitoring. The following categories cover a range of options, from open-source solutions to cloud provider offerings and third-party platforms:
 
 ### Open-source Solutions
 
-
-Open-source tools offer flexibility and community-driven innovation, making them popular choices for cloud-native monitoring. 
+Open-source tools offer flexibility and community-driven innovation, making them popular choices for cloud-native monitoring.
 
 - Prometheus: Prometheus is a leading open-source monitoring system designed for reliability and scalability. It excels at collecting, storing, and queuing metrics data, making it an essential tool for monitoring cloud-native applications.
-    - Key Features: Time-series data collection, powerful query language (PromQL), and extensive alerting capabilities.
-    - Use Cases: Ideal for monitoring metrics in Kubernetes environments, service-level monitoring and alerting based on threshold breaches.
+  - Key Features: Time-series data collection, powerful query language (PromQL), and extensive alerting capabilities.
+  - Use Cases: Ideal for monitoring metrics in Kubernetes environments, service-level monitoring and alerting based on threshold breaches.
 - Grafana: Grafana is a widely used visualization tool that integrates seamlessly with Prometheus and other data sources. It allows you to create custom dashboards to visualize metrics and logs, making it easier to monitor system performance.
-    - Key Features: Versatile visualization options, custom dashboards, and alerting integration.
-    - Use Cases: Creating real-time dashboards for system monitoring, visualizing metrics from multiple sources, and analyzing historical data.
+  - Key Features: Versatile visualization options, custom dashboards, and alerting integration.
+  - Use Cases: Creating real-time dashboards for system monitoring, visualizing metrics from multiple sources, and analyzing historical data.
 - Jaeger: Jaeger is an open-source distributed tracing system used for monitoring and troubleshooting complex, microservice-based architectures. It helps trace requests across multiple services, providing insights into system behaviour and performance.
-    - Key Features: Distributed [context propagation](https://signoz.io/blog/opentelemetry-context-propagation/), root cause analysis, and service dependency analysis.
-    - Use Cases: Tracing the flow of requests across microservices, identifying latency bottlenecks, and improving service performance.
+  - Key Features: Distributed [context propagation](https://signoz.io/blog/opentelemetry-context-propagation/), root cause analysis, and service dependency analysis.
+  - Use Cases: Tracing the flow of requests across microservices, identifying latency bottlenecks, and improving service performance.
 
 ### Cloud Provider Solutions
 
-The big cloud providers have developed integrated monitoring tools that are designed to work seamlessly within their respective ecosystems. These include: 
+The big cloud providers have developed integrated monitoring tools that are designed to work seamlessly within their respective ecosystems. These include:
 
-<Figure src="/img/guides/2024/09/cloud-native-monitoring-2469a908-4c9e-416e-9002-3616f5de82da.webp" alt="CloudWatch (Image courtesy of Amazon Web Services)" caption="CloudWatch (Image courtesy of Amazon Web Services)" />
+<Figure
+  src="/img/guides/2024/09/cloud-native-monitoring-2469a908-4c9e-416e-9002-3616f5de82da.webp"
+  alt="CloudWatch (Image courtesy of Amazon Web Services)"
+  caption="CloudWatch (Image courtesy of Amazon Web Services)"
+/>
 
 - AWS CloudWatch: AWS CloudWatch provides monitoring and observability for AWS resources and applications. AWS CloudWatch collects and traces, metrics, logs and events, giving you a comprehensive view of AWS infrastructure and applications.
-    - Key features: Real-time monitoring, custom metrics, log analytics, and automated actions based on predefined thresholds.
-    - Use Cases: Monitoring of AWS resources, such as EC2 instances, RDS databases, and Lambda functions, setting up alarms and automated responses.
+  - Key features: Real-time monitoring, custom metrics, log analytics, and automated actions based on predefined thresholds.
+  - Use Cases: Monitoring of AWS resources, such as EC2 instances, RDS databases, and Lambda functions, setting up alarms and automated responses.
 
-<Figure src="/img/guides/2024/09/cloud-native-monitoring-download_(1).webp" alt="Azure Monitor (Image courtesy of Microsoft Azure)" caption="Azure Monitor (Image courtesy of Microsoft Azure)" />
+<Figure
+  src="/img/guides/2024/09/cloud-native-monitoring-download_(1).webp"
+  alt="Azure Monitor (Image courtesy of Microsoft Azure)"
+  caption="Azure Monitor (Image courtesy of Microsoft Azure)"
+/>
 
 - Azure Monitor: Azure is an all-encompassing monitoring application. It offers complete stack monitoring, diagnostics, and analytics that support teams in keeping health and performance within Azure-based environments.
-    - Key Features: Application insights, log analytics, deep integration with other Azure services.
-    - Use Case: Monitor Azure Virtual Machines, databases, and applications, analyze telemetry data for insight and troubleshooting.
+  - Key Features: Application insights, log analytics, deep integration with other Azure services.
+  - Use Case: Monitor Azure Virtual Machines, databases, and applications, analyze telemetry data for insight and troubleshooting.
 
-<Figure src="/img/guides/2024/09/cloud-native-monitoring-63cd391d-821b-4ab7-9583-a43bd547de54.webp" alt="Google Cloud Monitoring (Image courtesy of Google Cloud Provider)" caption="Google Cloud Monitoring (Image courtesy of Google Cloud Provider)" />
+<Figure
+  src="/img/guides/2024/09/cloud-native-monitoring-63cd391d-821b-4ab7-9583-a43bd547de54.webp"
+  alt="Google Cloud Monitoring (Image courtesy of Google Cloud Provider)"
+  caption="Google Cloud Monitoring (Image courtesy of Google Cloud Provider)"
+/>
 
 - Google Cloud Monitoring: Google Cloud Monitoring provides observability into Google Cloud resources and hybrid environments. Monitoring, logging, and diagnostics are provided to maintain service reliability and performance.
-    - Key Features: Integration of monitoring and logging, [SLO monitoring](https://signoz.io/guides/slo-monitoring/), and advanced level of alerting.
-    - Use Cases: Monitoring of Google Cloud resources, including compute engines, Kubernetes engines, big queries, etc.; creation of dashboards and alerts with proactive management.
+  - Key Features: Integration of monitoring and logging, [SLO monitoring](https://signoz.io/guides/slo-monitoring/), and advanced level of alerting.
+  - Use Cases: Monitoring of Google Cloud resources, including compute engines, Kubernetes engines, big queries, etc.; creation of dashboards and alerts with proactive management.
 
 ### Third-party Platforms
 
-Third-party platforms provide a more complete cross-cloud monitoring solution integrated with cloud-native environments. Of course, most of the third-party platforms give substantial additional value beyond plain, vanilla monitoring:  
+Third-party platforms provide a more complete cross-cloud monitoring solution integrated with cloud-native environments. Of course, most of the third-party platforms give substantial additional value beyond plain, vanilla monitoring:
 
 - Cross-Cloud Compatibility: Monitor across multiple cloud and hybrid environments with ease to manage diverse infrastructures.
 - Advanced Analytics and AI-Driven Insights: Many of them provide AI-driven anomaly detection, predictive analytics, and in-depth reporting to drive informed decisions within teams.
@@ -208,7 +225,7 @@ Third-party platforms provide a more complete cross-cloud monitoring solution in
 
 Factors to Consider When Selecting Monitoring Tools:
 
-Choosing the right monitoring tools requires careful consideration of your specific needs and environment. Key factors include: 
+Choosing the right monitoring tools requires careful consideration of your specific needs and environment. Key factors include:
 
 - Compatibility with your Existing Stack: Ensure the tool integrates well with your current technologies, including cloud providers, container orchestration platforms, and application frameworks.
 - Scalability and Performance: The tool should scale efficiently with your infrastructure, handling increased data volumes and complexity without compromising performance.
@@ -218,11 +235,11 @@ Choosing the right monitoring tools requires careful consideration of your speci
 
 ## Implementing Cloud Native Monitoring with SigNoz
 
-[SigNoz](https://signoz.io/docs/introduction/) is an open-source cloud-native monitoring platform that empowers DevOps teams with robust observability capabilities. It provides a comprehensive solution that brings together metrics, traces, and logs into a unified interface, enabling teams to monitor, troubleshoot, and optimize their cloud-native applications effectively. 
+[SigNoz](https://signoz.io/docs/introduction/) is an open-source cloud-native monitoring platform that empowers DevOps teams with robust observability capabilities. It provides a comprehensive solution that brings together metrics, traces, and logs into a unified interface, enabling teams to monitor, troubleshoot, and optimize their cloud-native applications effectively.
 
 <GetStartedSigNoz />
 
-Key Features: 
+Key Features:
 
 - [Unified Observability](https://signoz.io/unified-observability/): SigNoz combines metrics, traces, and logs into a single platform, offering a cohesive view of your application’s performance. This integration reduces the need to switch between multiple tools, allowing for faster diagnosis and resolution of issues.
 - Auto-Instrumentation: It supports auto-instrumentation for popular frameworks and languages, meaning you can start capturing critical data with minimal code changes. This makes it easier to adopt observability best practices without significant overhead.
@@ -233,59 +250,45 @@ SigNoz offers both cloud and open-source versions, allowing teams to choose the
 
 ## Overcoming Common Challenges in Cloud-Native Monitoring
 
-Implementing cloud-native monitoring can be complex, and DevOps teams often encounter several challenges. Addressing these challenges effectively is crucial for maintaining the performance, security, and scalability of cloud-native applications. 
+Implementing cloud-native monitoring can be complex, and DevOps teams often encounter several challenges. Addressing these challenges effectively is crucial for maintaining the performance, security, and scalability of cloud-native applications.
 
 - Data Volume and Retention: Cloud-native environments generate voluminous amounts of data, and the balance between retaining insights and managing storage costs can be overwhelming.
-    
-    Solutions: 
-    
-    - Intelligent Sampling Strategies: Employ techniques of sampling to collect representative subsets of data, hence decreasing the volume of data ingested while maintaining the data one would want later for insights. For example, adaptive sampling can serve to regulate the dynamics of data collection based on the activities of a system.
-    - Tier Storage Solutions: Tier storage solutions store the most recent data, which is required more frequently, in higher-speed, higher-cost solutions for quicker access. In contrast, the older the data, the lower the speed and cost of the solution it can go on. Using multiple such segregations will balance the cost with performance.
+  Solutions:
+  - Intelligent Sampling Strategies: Employ techniques of sampling to collect representative subsets of data, hence decreasing the volume of data ingested while maintaining the data one would want later for insights. For example, adaptive sampling can serve to regulate the dynamics of data collection based on the activities of a system.
+  - Tier Storage Solutions: Tier storage solutions store the most recent data, which is required more frequently, in higher-speed, higher-cost solutions for quicker access. In contrast, the older the data, the lower the speed and cost of the solution it can go on. Using multiple such segregations will balance the cost with performance.
 - Multi-Cloud and Hybrid Environments: Monitoring across multiple cloud providers or hybrid environments introduces complexity due to the differing tools, APIs, and data formats used by each platform.
-    
-    Solutions: 
-    
-    - Choose Cross-Cloud Compatible Tools: Select monitoring solutions that are designed to work seamlessly across different cloud platforms and on-premises environments. This ensures consistent monitoring and observability across your entire infrastructure.
-    - Implement Consistent Tagging and Naming Conventions: Standardize the tagging and naming of resources across environments. This consistency simplifies monitoring, reporting, and troubleshooting, making it easier to correlate data across different platforms.
+  Solutions:
+  - Choose Cross-Cloud Compatible Tools: Select monitoring solutions that are designed to work seamlessly across different cloud platforms and on-premises environments. This ensures consistent monitoring and observability across your entire infrastructure.
+  - Implement Consistent Tagging and Naming Conventions: Standardize the tagging and naming of resources across environments. This consistency simplifies monitoring, reporting, and troubleshooting, making it easier to correlate data across different platforms.
 - Security and Compliance: Ensuring the security of monitoring data and meeting compliance requirements are critical in cloud environments, especially when dealing with sensitive information.
-    
-    Solutions:  
-    
-    - Ensure Data Encryption In Transit and At Rest: Protect your monitoring data by encrypting it both as it travels over the network and when it is stored. This prevents unauthorized access and ensures data integrity.
-    - Implement Role-Based Access Control (RBAC) for monitoring tools: Use RBAC to restrict access to monitoring tools and data based on user roles. This minimizes the risk of data breaches and ensures that only authorized personnel can view or modify monitoring configurations.
-    - Maintain Audit Logs For Compliance Reporting: Keep detailed logs of access, these logs are essential for compliance with regulatory requirements and can help in forensic analysis in the event of a security incident.
+  Solutions:
+  - Ensure Data Encryption In Transit and At Rest: Protect your monitoring data by encrypting it both as it travels over the network and when it is stored. This prevents unauthorized access and ensures data integrity.
+  - Implement Role-Based Access Control (RBAC) for monitoring tools: Use RBAC to restrict access to monitoring tools and data based on user roles. This minimizes the risk of data breaches and ensures that only authorized personnel can view or modify monitoring configurations.
+  - Maintain Audit Logs For Compliance Reporting: Keep detailed logs of access, these logs are essential for compliance with regulatory requirements and can help in forensic analysis in the event of a security incident.
 - Balancing Coverage and Overhead: Extensive monitoring can introduce overhead, affecting application performance and increasing operational costs.
-    - Use Lightweight Monitoring Agents and SDKs: Choose monitoring agents that are optimized for minimal resource usage. Lightweight agents reduce the impact on application performance while still providing essential monitoring data.
-    - Implement Adaptive Sampling Techniques: Adaptive sampling allows you to adjust the amount of data collected based on the current system state. By sampling less during periods of low activity, you can overhead without sacrificing visibility during critical times.
+  - Use Lightweight Monitoring Agents and SDKs: Choose monitoring agents that are optimized for minimal resource usage. Lightweight agents reduce the impact on application performance while still providing essential monitoring data.
+  - Implement Adaptive Sampling Techniques: Adaptive sampling allows you to adjust the amount of data collected based on the current system state. By sampling less during periods of low activity, you can overhead without sacrificing visibility during critical times.
 
 ## Future Trends in Cloud-Native Monitoring
 
-As the landscape of cloud-native monitoring continues to advance, several key trends are shaping the future of how DevOps teams approach observability and system management. 
+As the landscape of cloud-native monitoring continues to advance, several key trends are shaping the future of how DevOps teams approach observability and system management.
 
 - AIOps integration: Artificial Intelligence for IT Operations (AIOps) is poised to become a cornerstone in cloud-native monitoring by leveraging AI and machine learning to enhance the monitoring process.
-    
-    Impact: 
-    
-    - AIOps will enable automated analysis of monitoring data, identifying patterns, anomalies, and potential issues before they escalate. This reduces the need for manual intervention and allows teams to focus on more strategic tasks.
-    - AI-driven insights can trigger automated responses, such as scaling resources or applying patches, helping to resolve issues proactively and minimizing downtime.
+  Impact:
+  - AIOps will enable automated analysis of monitoring data, identifying patterns, anomalies, and potential issues before they escalate. This reduces the need for manual intervention and allows teams to focus on more strategic tasks.
+  - AI-driven insights can trigger automated responses, such as scaling resources or applying patches, helping to resolve issues proactively and minimizing downtime.
 - Shift-left monitoring: The shift-left movement, emphasizing processes being brought in earlier, continues down the software development life cycle, and monitoring is no exception.
-    
-    Impact: 
-    
-    - Teams detect performance and reliability issues during development and testing, reducing the chances of finding such issues in production.
-    - Continuous feedback loops from shift-left monitoring enable better-informed development decisions, which result in an application that is more robust and reliable.
+  Impact:
+  - Teams detect performance and reliability issues during development and testing, reducing the chances of finding such issues in production.
+  - Continuous feedback loops from shift-left monitoring enable better-informed development decisions, which result in an application that is more robust and reliable.
 - GitOps and Infrastructure as Code (IaC): This is a trend where, with the increased use of GitOps and Infrastructure as Code practices, monitoring configurations are now managed more and more as code.
-    
-    Impact: 
-    
-    - Treating the monitoring configuration as code will let the monitoring configurations as code will let the teams apply version control and consistency to track changes between different environments. This reduces the chances of configuration drift and makes rollbacks quite easy.
-    - Application code should deploy monitoring configurations so that observability follows an identical treatment during all the stages of a deployment pipeline.
+  Impact:
+  - Treating the monitoring configuration as code will let the monitoring configurations as code will let the teams apply version control and consistency to track changes between different environments. This reduces the chances of configuration drift and makes rollbacks quite easy.
+  - Application code should deploy monitoring configurations so that observability follows an identical treatment during all the stages of a deployment pipeline.
 - Standardization: Open standards, such as Open Telemetry, are driving cloud-native monitoring to be even more interoperable and less proprietary.
-    
-    Impact:
-    
-    - Seamlessly working across any given monitoring tool means teams can create a monitoring stack best suited to their needs rather than necessarily being loyal to one vendor.
-    - Because of standardized protocols and formats, it enables an organization to change their monitoring tooling or new tooling with a minimum amount of rework, thus creating an agile and adaptable monitoring strategy.
+  Impact:
+  - Seamlessly working across any given monitoring tool means teams can create a monitoring stack best suited to their needs rather than necessarily being loyal to one vendor.
+  - Because of standardized protocols and formats, it enables an organization to change their monitoring tooling or new tooling with a minimum amount of rework, thus creating an agile and adaptable monitoring strategy.
 
 ## Key Takeaways
 
@@ -298,13 +301,13 @@ As the landscape of cloud-native monitoring continues to advance, several key tr
 
 ### What are the main differences between traditional and cloud-native monitoring?
 
-| Aspect | Traditional Monitoring | Cloud Native Monitoring |
-| --- | --- | --- |
-| Scalability | Limited ability to scale, often requires manual intervention. | Automatically scales with the dynamic nature of cloud environments. |
-| Observability | Primarily focused on basic metrics and logs. | Integrates logs, metrics, and traces for comprehensive observability. |
-| Tracing | Limited or no support for distributed tracing. | Built-in distributed tracing to track requests across microservices. |
-| Automation | Often requires manual setup and maintenance. | Includes automated data collection, analysis, and alerting. |
-| Environment Compatibility | Designed for static, on-premise environments. | Specifically designed for dynamic, cloud-native environments. |
+| Aspect                    | Traditional Monitoring                                        | Cloud Native Monitoring                                               |
+| ------------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------- |
+| Scalability               | Limited ability to scale, often requires manual intervention. | Automatically scales with the dynamic nature of cloud environments.   |
+| Observability             | Primarily focused on basic metrics and logs.                  | Integrates logs, metrics, and traces for comprehensive observability. |
+| Tracing                   | Limited or no support for distributed tracing.                | Built-in distributed tracing to track requests across microservices.  |
+| Automation                | Often requires manual setup and maintenance.                  | Includes automated data collection, analysis, and alerting.           |
+| Environment Compatibility | Designed for static, on-premise environments.                 | Specifically designed for dynamic, cloud-native environments.         |
 
 ### How does cloud-native monitoring improve DevOps practices?
 
@@ -319,12 +322,12 @@ Cloud-native monitoring enhances DevOps practices by:
 
 When selecting monitoring tools, consider:
 
-1. Compatibility: Ensure the tool is compatible with your existing technology stack and can integrate seamlessly with your systems. 
-2. Scalability: The tool should be capable of handling your current and future data volume as your infrastructure grows. 
-3. Ease of Use: Look for intuitive interfaces and customization options that allow for easy setup and management. 
-4. Cost and Licensing: Evaluate the cost model and ensure it aligns with your budget while delivering value. 
-5. Integration: Check for integrations with your CI/CD pipeline and other DevOps tools to streamline workflows. 
-6. Multi-Cloud Support: If applicable, ensure the tool supports multi-cloud or hybrid environments for broader coverage. 
+1. Compatibility: Ensure the tool is compatible with your existing technology stack and can integrate seamlessly with your systems.
+2. Scalability: The tool should be capable of handling your current and future data volume as your infrastructure grows.
+3. Ease of Use: Look for intuitive interfaces and customization options that allow for easy setup and management.
+4. Cost and Licensing: Evaluate the cost model and ensure it aligns with your budget while delivering value.
+5. Integration: Check for integrations with your CI/CD pipeline and other DevOps tools to streamline workflows.
+6. Multi-Cloud Support: If applicable, ensure the tool supports multi-cloud or hybrid environments for broader coverage.
 
 ### How can organizations ensure cost-effective cloud native monitoring at scale?
 
@@ -335,4 +338,4 @@ Approach to Effective Monitoring without Overspending:
 - Leverage Native Services: Leverage your cloud provider's native monitoring services where applicable. You may find highly integrated options that are more cost-effective.
 - Regular Strategy Review: This could be a continuous process to be performed immediately to weed out any inefficiency in the monitoring strategy and adapt it to evolving needs. In other words, this may imply immediate scaling up or scaling down actions to teams collaborating on the tasks.
 - Auto-Scaling: Apply auto-scaling to monitoring infrastructure where it will only consume resources if needed.
-- Managed Solutions: Draw upon [managed monitoring](https://signoz.io/guides/managed-prometheus/) solutions that reduce operational overhead and may offer better cost efficiency.
\ No newline at end of file
+- Managed Solutions: Draw upon [managed monitoring](https://signoz.io/guides/managed-prometheus/) solutions that reduce operational overhead and may offer better cost efficiency.
diff --git a/data/guides/codahale-metrics-using-timed-metrics-annotation-in-plain-java.mdx b/data/guides/codahale-metrics-using-timed-metrics-annotation-in-plain-java.mdx
index 0885c1582..9695f6f8d 100644
--- a/data/guides/codahale-metrics-using-timed-metrics-annotation-in-plain-java.mdx
+++ b/data/guides/codahale-metrics-using-timed-metrics-annotation-in-plain-java.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Use @Timed Metrics in Java with Codahale Metrics
-slug: codahale-metrics-using-timed-metrics-annotation-in-plain-java
 date: 2024-10-03
 tags: [faq]
 authors: [niyati_thakkar]
 description: Learn how to implement and optimize @Timed metrics in Java using Codahale Metrics. Boost your application's performance monitoring capabilities.
-keywords: [Codahale Metrics, Timed annotation, Java performance monitoring, MetricRegistry, Dropwizard Metrics, Java observability, SigNoz integration]
-
+keywords:
+  [
+    Codahale Metrics,
+    Timed annotation,
+    Java performance monitoring,
+    MetricRegistry,
+    Dropwizard Metrics,
+    Java observability,
+    SigNoz integration,
+  ]
 ---
 
 Performance monitoring is crucial for maintaining robust Java applications. Enter Codahale Metrics — a powerful library that simplifies the process of gathering and reporting performance data. At the heart of this toolkit lies the @Timed annotation, a simple yet effective way to measure method execution times. This article delves into the intricacies of using @Timed metrics in plain Java, providing the knowledge to enhance your application's observability.
@@ -16,7 +22,10 @@ Performance monitoring is crucial for maintaining robust Java applications. Ente
 
 Codahale Metrics, which is now maintained as part of [Dropwizard Metrics](https://signoz.io/guides/dropwizard-metrics-meters-vs-timers/), is a Java library designed to capture and report various application metrics. It offers a suite of annotations and classes that make performance monitoring a breeze.
 
-<a href="https://www.dropwizard.io/en/stable/" rel="noopener noreferrer nofollow" target="_blank">Dropwizard</a> is a framework built to provide production-ready features, such as application metrics, health checks, and configuration management, making it a robust solution for modern Java applications.
+<a href="https://www.dropwizard.io/en/stable/" rel="noopener noreferrer nofollow" target="_blank">
+  Dropwizard
+</a> is a framework built to provide production-ready features, such as application metrics, health
+checks, and configuration management, making it a robust solution for modern Java applications.
 
 The @Timed annotation is a key component of this library. When applied to a method, it automatically tracks:
 
@@ -41,35 +50,29 @@ Compared to other metric annotations:
 
 The true power of Codahale Metrics is in its ability to integrate with a variety of metric reporting systems, allowing you to visualize, log, and analyze these metrics in real time or periodically. Here's how `@Timed` metrics can be integrated with some popular reporting systems:
 
-1. JMX (Java Management Extensions):
-JMX is a built-in feature for monitoring Java applications. By exposing metrics through JMX, you can track method timings via tools like JConsole or VisualVM.
-    
-    ```java
-    JmxReporter reporter = JmxReporter.forRegistry(metricRegistry).build();
-    reporter.start();
-    ```
-    
-2. SLF4J (Simple Logging Facade for Java):
-`@Timed` can integrate with SLF4J, allowing you to print timing data to your application logs at a specified interval.
-    
-    ```java
-    Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
-        .outputTo(LoggerFactory.getLogger("metrics"))
-        .build();
-    reporter.start(1, TimeUnit.MINUTES);
-    ```
-    
-3. Graphite:
-For those looking to visualize metrics over time, Graphite is a popular choice. The `GraphiteReporter` class allows you to send timing metrics (collected via `@Timed`) to a Graphite server.
-    
-    ```java
-    final Graphite graphite = new Graphite(new InetSocketAddress("graphite.example.com", 2003));
-    final GraphiteReporter reporter = GraphiteReporter.forRegistry(metricRegistry)
-        .prefixedWith("myApp")
-        .build(graphite);
-    reporter.start(1, TimeUnit.MINUTES);
-    ```
-    
+1.  JMX (Java Management Extensions):
+    JMX is a built-in feature for monitoring Java applications. By exposing metrics through JMX, you can track method timings via tools like JConsole or VisualVM.
+        ```java
+        JmxReporter reporter = JmxReporter.forRegistry(metricRegistry).build();
+        reporter.start();
+        ```
+2.  SLF4J (Simple Logging Facade for Java):
+    `@Timed` can integrate with SLF4J, allowing you to print timing data to your application logs at a specified interval.
+        ```java
+        Slf4jReporter reporter = Slf4jReporter.forRegistry(metricRegistry)
+            .outputTo(LoggerFactory.getLogger("metrics"))
+            .build();
+        reporter.start(1, TimeUnit.MINUTES);
+        ```
+3.  Graphite:
+    For those looking to visualize metrics over time, Graphite is a popular choice. The `GraphiteReporter` class allows you to send timing metrics (collected via `@Timed`) to a Graphite server.
+        ```java
+        final Graphite graphite = new Graphite(new InetSocketAddress("graphite.example.com", 2003));
+        final GraphiteReporter reporter = GraphiteReporter.forRegistry(metricRegistry)
+            .prefixedWith("myApp")
+            .build(graphite);
+        reporter.start(1, TimeUnit.MINUTES);
+        ```
 
 ## Implementing Timer in Plain Java
 
@@ -117,7 +120,7 @@ public class TimerExample {
             performTask();
         } finally {
 		        // Stop the timer
-            context.stop();  
+            context.stop();
         }
 
         wait5Seconds();
@@ -135,7 +138,7 @@ public class TimerExample {
         // Simulate some work with a sleep
         try {
 		        // Simulate task taking 2 seconds
-            Thread.sleep(2000);  
+            Thread.sleep(2000);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
         }
@@ -154,35 +157,37 @@ public class TimerExample {
 
 The above code returns the output as follows:
 
-<Figure src="/img/guides/2024/10/codahale-metrics-using-timed-metrics-annotation-in-plain-java-image.webp" alt="Measuring Method Execution Time with Timer" caption="Measuring Method Execution Time with Timer" />
+<Figure
+  src="/img/guides/2024/10/codahale-metrics-using-timed-metrics-annotation-in-plain-java-image.webp"
+  alt="Measuring Method Execution Time with Timer"
+  caption="Measuring Method Execution Time with Timer"
+/>
 
 ### Configuring the MetricRegistry
 
 The MetricRegistry is the central component that manages all your metrics. Here's how to set it up and use it effectively:
 
-1. Create a singleton MetricRegistry:
-Making the `MetricRegistry` a singleton ensures that all metrics are centralized and consistent across your application. This design prevents multiple instances of the registry from existing, which could lead to fragmented or inaccurate metrics.
-    
-    ```java
-    public class MetricRegistryHolder {
-        private static final MetricRegistry REGISTRY = new MetricRegistry();
-    
-        public static MetricRegistry getRegistry() {
-            return REGISTRY;
+1.  Create a singleton MetricRegistry:
+    Making the `MetricRegistry` a singleton ensures that all metrics are centralized and consistent across your application. This design prevents multiple instances of the registry from existing, which could lead to fragmented or inaccurate metrics.
+        ```java
+        public class MetricRegistryHolder {
+            private static final MetricRegistry REGISTRY = new MetricRegistry();
+
+            public static MetricRegistry getRegistry() {
+                return REGISTRY;
+            }
         }
-    }
-    
-    ```
-    
-2. Register metrics programmatically (useful for dynamic metrics):
-    
+
+        ```
+2.  Register metrics programmatically (useful for dynamic metrics):
+
     ```java
     Timer timer = MetricRegistryHolder.getRegistry().timer("processTime");
-    
+
     ```
-    
-3. Integrate with reporting systems:
-    
+
+3.  Integrate with reporting systems:
+
     ```java
     ConsoleReporter reporter = ConsoleReporter.forRegistry(MetricRegistryHolder.getRegistry())
         .convertRatesTo(TimeUnit.SECONDS)
@@ -190,11 +195,14 @@ Making the `MetricRegistry` a singleton ensures that all metrics are centralized
         .build();
     reporter.start(1, TimeUnit.MINUTES);
     ```
-    
 
 This setup prints metrics to the console every minute. Consider JMX, Graphite, or other more robust reporting options for production use.
 
-<Figure src="/img/guides/2024/10/codahale-metrics-using-timed-metrics-annotation-in-plain-java-image%201.webp" alt="Configuring MagicRegistry and integrating reporter" caption="Configuring MagicRegistry and integrating reporter" />
+<Figure
+  src="/img/guides/2024/10/codahale-metrics-using-timed-metrics-annotation-in-plain-java-image%201.webp"
+  alt="Configuring MagicRegistry and integrating reporter"
+  caption="Configuring MagicRegistry and integrating reporter"
+/>
 
 ## Usage of @Timed annotation in Spring Boot Application
 
@@ -321,94 +329,91 @@ public class MyService {
 }
 ```
 
-1. Testing Metrics with @Timed
-Unit tests can be written to verify that the `@Timed` annotation is properly capturing metrics. This can be done by asserting the number of times a method has been called and the time taken.
-    
-    ```java
-    @RunWith(SpringRunner.class)
-    @SpringBootTest
-    public class MyServiceTest {
-    	@Autowired
-    	private MetricRegistry metricRegistry;
-    	
-    	@Autowired
-    	private MyService myService;
-    	
-    	@Test
-    	public void testTimedAnnotation() {
-    	    Timer timer = metricRegistry.timer("myService.myMethod");
-    	
-    	    // Call the method
-    	    myService.myMethod();
-    	
-    	    // Assert that the method was timed
-    	    assertEquals(1, timer.getCount());
-    	
-    	    // Optionally, check that the timing is within a reasonable range
-    	    assertTrue(timer.getSnapshot().getMean() > 0);
-    	}
-    }
-    ```
-    
-    This test ensures that the `@Timed` annotation is functioning correctly, capturing the execution time and invocation count of the annotated method.
-    
+1.  Testing Metrics with @Timed
+    Unit tests can be written to verify that the `@Timed` annotation is properly capturing metrics. This can be done by asserting the number of times a method has been called and the time taken.
+        ```java
+        @RunWith(SpringRunner.class)
+        @SpringBootTest
+        public class MyServiceTest {
+        	@Autowired
+        	private MetricRegistry metricRegistry;
+
+        	@Autowired
+        	private MyService myService;
+
+        	@Test
+        	public void testTimedAnnotation() {
+        	    Timer timer = metricRegistry.timer("myService.myMethod");
+
+        	    // Call the method
+        	    myService.myMethod();
+
+        	    // Assert that the method was timed
+        	    assertEquals(1, timer.getCount());
+
+        	    // Optionally, check that the timing is within a reasonable range
+        	    assertTrue(timer.getSnapshot().getMean() > 0);
+        	}
+        }
+        ```
+
+        This test ensures that the `@Timed` annotation is functioning correctly, capturing the execution time and invocation count of the annotated method.
 
 ## Advanced Usage of @Timed Metrics
 
 To truly master @Timed metrics, explore these advanced techniques:
 
 1. Customize metric names and descriptions:
-    
-    ```java
-    @Timed(name = "processOrder", absolute = true, description = "Time taken to process an order")
-    public void processOrder(Order order) {
-        // Method implementation
-    }
-    ```
-    
-    The `absolute = true` flag in the `@Timed` annotation ensures the metric name is used exactly as provided, without including the class name as a prefix. This is helpful when you want concise, globally unique metric names, especially in large applications
-    
+
+   ```java
+   @Timed(name = "processOrder", absolute = true, description = "Time taken to process an order")
+   public void processOrder(Order order) {
+       // Method implementation
+   }
+   ```
+
+   The `absolute = true` flag in the `@Timed` annotation ensures the metric name is used exactly as provided, without including the class name as a prefix. This is helpful when you want concise, globally unique metric names, especially in large applications
+
 2. Apply @Timed to abstract classes:
-    
-    ```java
-    public abstract class BaseService {
-        @Timed(name = "baseOperation")
-        public abstract void performOperation();
-    }
-    
-    ```
-    
-    Concrete implementations will inherit this timed metric.
-    
+
+   ```java
+   public abstract class BaseService {
+       @Timed(name = "baseOperation")
+       public abstract void performOperation();
+   }
+
+   ```
+
+   Concrete implementations will inherit this timed metric.
+
 3. Use @Timed with RESTful services:
-    
-    ```java
-    @Path("/users")
-    public class UserResource {
-        @GET
-        @Path("/{id}")
-        @Timed(name = "getUserById")
-        public Response getUserById(@PathParam("id") String id) {
-            // Method implementation
-        }
-    }
-    
-    ```
-    
+
+   ```java
+   @Path("/users")
+   public class UserResource {
+       @GET
+       @Path("/{id}")
+       @Timed(name = "getUserById")
+       public Response getUserById(@PathParam("id") String id) {
+           // Method implementation
+       }
+   }
+
+   ```
+
 4. Combine @Timed with other metric types:
-    
-    ```java
-    public class OrderService {
-        @Timed
-        @Metered(name = "orderProcessingRate")
-        @ExceptionMetered(name = "orderProcessingExceptions")
-        public void processOrder(Order order) {
-            // Method implementation
-        }
-    }
-    
-    ```
-    
+
+   ```java
+   public class OrderService {
+       @Timed
+       @Metered(name = "orderProcessingRate")
+       @ExceptionMetered(name = "orderProcessingExceptions")
+       public void processOrder(Order order) {
+           // Method implementation
+       }
+   }
+
+   ```
 
 This approach provides a comprehensive view of the method's performance, throughput, and error rate.
 
@@ -417,16 +422,16 @@ This approach provides a comprehensive view of the method's performance, through
 @Timed metrics offer a wealth of data. Here's how to make sense of it:
 
 1. Key performance indicators:
-    - Mean execution time: Average performance
-    - 95th percentile: Insight into worst-case scenarios
-    - Throughput: Calls per second
+   - Mean execution time: Average performance
+   - 95th percentile: Insight into worst-case scenarios
+   - Throughput: Calls per second
 2. Visualization techniques:
-    - Histograms: Display distribution of execution times
-    - Time-series graphs: Show performance trends over time
+   - Histograms: Display distribution of execution times
+   - Time-series graphs: Show performance trends over time
 3. Making data-driven decisions:
-    - Identify performance bottlenecks by comparing @Timed metrics across different methods
-    - Set performance budgets based on 95th-percentile execution times
-    - Trigger alerts when execution times exceed predefined thresholds
+   - Identify performance bottlenecks by comparing @Timed metrics across different methods
+   - Set performance budgets based on 95th-percentile execution times
+   - Trigger alerts when execution times exceed predefined thresholds
 
 ## Enhancing Observability with SigNoz Cloud
 
@@ -504,17 +509,17 @@ By integrating your `@Timed` metrics with SigNoz Cloud, you gain:
 To get the most out of @Timed metrics in a production environment:
 
 1. Balance granularity and performance:
-    - Apply @Timed to key business operations and potential bottlenecks
-    - Avoid timing every method, which can lead to a metric explosion
+   - Apply @Timed to key business operations and potential bottlenecks
+   - Avoid timing every method, which can lead to a metric explosion
 2. Handle high-throughput scenarios:
-    - Use sampling to reduce the volume of timing data in high-traffic applications
-    - Consider using histograms with configurable reservoir sizes
+   - Use sampling to reduce the volume of timing data in high-traffic applications
+   - Consider using histograms with configurable reservoir sizes
 3. Implement alerting:
-    - Set up alerts for sudden increases in average execution time
-    - Use percentile-based alerting to catch performance degradation affecting a subset of users
+   - Set up alerts for sudden increases in average execution time
+   - Use percentile-based alerting to catch performance degradation affecting a subset of users
 4. Evolve your metrics strategy:
-    - Regularly review and update your @Timed metrics based on application changes
-    - Remove or consolidate metrics that no longer provide valuable insights
+   - Regularly review and update your @Timed metrics based on application changes
+   - Remove or consolidate metrics that no longer provide valuable insights
 
 By following these practices, you'll create a robust performance monitoring system that grows with your application.
 
@@ -551,4 +556,4 @@ ConsoleReporter reporter = ConsoleReporter.forRegistry(registry)
 
 ```
 
-This example excludes all metrics whose names start with "excluded".
\ No newline at end of file
+This example excludes all metrics whose names start with "excluded".
diff --git a/data/guides/configure-prometheus-to-use-non-default-port.mdx b/data/guides/configure-prometheus-to-use-non-default-port.mdx
index 87178088b..8589f4b89 100644
--- a/data/guides/configure-prometheus-to-use-non-default-port.mdx
+++ b/data/guides/configure-prometheus-to-use-non-default-port.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Change Prometheus Port - A Step-by-Step Guide
-slug: configure-prometheus-to-use-non-default-port
 date: 2024-12-05
 tags: [prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to configure Prometheus to use a non-default port with this comprehensive guide. Enhance security and resolve conflicts step-by-step.
-keywords: [Prometheus, port configuration, monitoring, security, DevOps, system administration, network setup, observability]
-
+keywords:
+  [
+    Prometheus,
+    port configuration,
+    monitoring,
+    security,
+    DevOps,
+    system administration,
+    network setup,
+    observability,
+  ]
 ---
 
 Prometheus, a powerful open-source monitoring and alerting toolkit, plays a crucial role in modern DevOps practices. By default, Prometheus operates on port 9090, but there are compelling reasons to change this setting. Whether you're aiming to enhance security, comply with organizational policies, or resolve port conflicts, this guide will walk you through the process of configuring Prometheus to use a non-default port.
@@ -16,7 +23,11 @@ Prometheus, a powerful open-source monitoring and alerting toolkit, plays a cruc
 
 Prometheus serves as a robust monitoring solution, collecting and storing time series data as metrics. It scrapes metrics from configured targets at given intervals, evaluates rule expressions, displays results, and can trigger alerts when specified conditions are met.
 
-<Figure src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image.webp" alt="Default Prometheus port in 9090" caption="Default Prometheus port in 9090" />
+<Figure
+  src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image.webp"
+  alt="Default Prometheus port in 9090"
+  caption="Default Prometheus port in 9090"
+/>
 
 By default, Prometheus listens on port 9090 for incoming connections. This port is where you access the web interface and where other services connect to scrape metrics. However, using the default port can pose security risks and may conflict with other applications in your infrastructure.
 
@@ -79,19 +90,22 @@ prometheus --config.file=prometheus.yml --web.listen-address=0.0.0.0:8080
 To ensure the port change was successful:
 
 1. Use `netstat` or `ss` to check the listening port:
-    
-    ```bash
-    sudo netstat -tuln | grep prometheus
-    ```
-    
+
+   ```bash
+   sudo netstat -tuln | grep prometheus
+   ```
+
 2. Access the Prometheus web interface using the new port:
-    
-    ```
-    <http://your-server-ip:8080>
-    ```
-    
 
-<Figure src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%201.webp" alt="Changing Prometheus port" caption="Changing Prometheus port" />
+   ```
+   <http://your-server-ip:8080>
+   ```
+
+<Figure
+  src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%201.webp"
+  alt="Changing Prometheus port"
+  caption="Changing Prometheus port"
+/>
 
 If you encounter issues, check the Prometheus logs:
 
@@ -105,30 +119,29 @@ When Prometheus or its monitored services operate on non-default ports, you need
 
 1. Open `prometheus.yml` and locate the `scrape_configs` section.
 2. Update target ports as needed:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'node_exporter'
-        static_configs:
-          - targets: ['localhost:9100']
-      - job_name: 'custom_service'
-        static_configs:
-          - targets: ['service-host:8000']
-    ```
-    
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'node_exporter'
+       static_configs:
+         - targets: ['localhost:9100']
+     - job_name: 'custom_service'
+       static_configs:
+         - targets: ['service-host:8000']
+   ```
+
 3. For secured endpoints, add authentication:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'secure_service'
-        scheme: https
-        basic_auth:
-          username: 'user'
-          password: 'password'
-        static_configs:
-          - targets: ['secure-service:8443']
-    ```
-    
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'secure_service'
+       scheme: https
+       basic_auth:
+         username: 'user'
+         password: 'password'
+       static_configs:
+         - targets: ['secure-service:8443']
+   ```
 
 ## Impact on Prometheus Ecosystem
 
@@ -137,9 +150,9 @@ Changing Prometheus's default port impacts its integration with other tools and
 1. Update Grafana: Grafana relies on Prometheus as a data source. After changing the Prometheus port, update the Grafana configuration to point to the new port:
 2. Adjust Alertmanager: If Alertmanager is configured to communicate with Prometheus, update its configuration.
 3. Review custom scripts: Custom scripts or tools that [query Prometheus](https://signoz.io/guides/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api/) using its old port need to be updated. These may include:
-    - Automation scripts fetching metrics.
-    - Applications using Prometheus APIs.
-    - CI/CD pipelines with Prometheus integrations.
+   - Automation scripts fetching metrics.
+   - Applications using Prometheus APIs.
+   - CI/CD pipelines with Prometheus integrations.
 4. Update documentation: A port change affects everyone using Prometheus. Clear communication and updated documentation are crucial.
 
 ## Monitoring Prometheus with SigNoz
@@ -154,13 +167,21 @@ While Prometheus is a powerful tool for time-series data collection and monitori
 
 1. Unified Observability: SigNoz provides a centralized platform for monitoring metrics, logs, and traces, giving you a holistic view of your systems alongside Prometheus data.
 2. Enhanced Troubleshooting: With distributed tracing and log correlation, SigNoz helps to troubleshoot issues quickly by linking metrics with the corresponding logs and traces, making root cause analysis more efficient.
-    
-    <Figure src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%202.webp" alt="Enhanced Troubleshooting with distributed tracing and log correlation" caption="Enhanced Troubleshooting with distributed tracing and log correlation" />
-    
+
+   <Figure
+     src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%202.webp"
+     alt="Enhanced Troubleshooting with distributed tracing and log correlation"
+     caption="Enhanced Troubleshooting with distributed tracing and log correlation"
+   />
+
 3. Real-Time Alerting and Dashboards: SigNoz offers powerful real-time alerting and custom dashboards, allowing you to set up complex alerting rules that notify you about system anomalies, complementing the capabilities of Prometheus.
-    
-    <Figure src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%203.webp" alt="Custom Dashboards in SigNoz" caption="Custom Dashboards in SigNoz" />
-    
+
+   <Figure
+     src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%203.webp"
+     alt="Custom Dashboards in SigNoz"
+     caption="Custom Dashboards in SigNoz"
+   />
+
 4. Open-Source and Extensible: SigNoz is fully open-source, providing flexibility to integrate it with other tools and customize it to fit your monitoring needs, all while avoiding the vendor lock-in.
 
 ### Configuring SigNoz Cloud to Monitor Prometheus on a New Port
@@ -168,65 +189,65 @@ While Prometheus is a powerful tool for time-series data collection and monitori
 To monitor Prometheus in SigNoz Cloud, you need to install the [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) and configure it to scrape Prometheus metrics. Follow these steps:
 
 1. Install the OpenTelemetry Collector
-    
-    If you haven’t already set up the OpenTelemetry Collector, refer to the [guide on installing the OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/). Ensure that it is installed and connected to your SigNoz Cloud instance.
-    
+
+   If you haven’t already set up the OpenTelemetry Collector, refer to the [guide on installing the OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/). Ensure that it is installed and connected to your SigNoz Cloud instance.
+
 2. Set Up the Prometheus Receiver
-    
-    Once the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) is installed, configure it to scrape Prometheus metrics. Edit your `otel-collector-config.yaml` file and add a Prometheus receiver configuration:
-    
-    - New Job:
-        
-        ```yaml
-        receivers:
-          prometheus:
-            config:
-              scrape_configs:
-                - job_name: 'prometheus'
-                  static_configs:
-                    - targets: ['localhost:8080'] #update your port here
-        ```
-        
-    - Existing Job:
-        
-        ```yaml
-        - job_name: "otel-collector"
-          scrape_interval: 30s
-          static_configs:
-            - targets: ["otel-collector:8889", "localhost:31000"] #update the prometheus port 
-        ```
-        
+
+   Once the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) is installed, configure it to scrape Prometheus metrics. Edit your `otel-collector-config.yaml` file and add a Prometheus receiver configuration:
+
+   - New Job:
+     ```yaml
+     receivers:
+       prometheus:
+         config:
+           scrape_configs:
+             - job_name: 'prometheus'
+               static_configs:
+                 - targets: ['localhost:8080'] #update your port here
+     ```
+   - Existing Job:
+     ```yaml
+     - job_name: 'otel-collector'
+       scrape_interval: 30s
+       static_configs:
+         - targets: ['otel-collector:8889', 'localhost:31000'] #update the prometheus port
+     ```
+
 3. Connect to SigNoz Cloud
-    
-    Update the exporter section of the configuration to send metrics to your SigNoz Cloud endpoint. Replace `<cloud-instance-url>` and `<SIGNOZ_INGESTION_KEY>` with your SigNoz Cloud details:
-    
-    ```yaml
-    exporters:
-      otlp:
-        endpoint: <cloud-instance-url>
-        tls:
-          insecure: false
-        headers:
-          "signoz-ingestion-key": <SIGNOZ_INGESTION_KEY>
-          
-    service:
-      pipelines:
-        metrics:
-          receivers: [prometheus]
-          processors: [batch, resourcedetection]
-          exporters: [otlp] 
-    ```
-    
+
+   Update the exporter section of the configuration to send metrics to your SigNoz Cloud endpoint. Replace `<cloud-instance-url>` and `<SIGNOZ_INGESTION_KEY>` with your SigNoz Cloud details:
+
+   ```yaml
+   exporters:
+     otlp:
+       endpoint: <cloud-instance-url>
+       tls:
+         insecure: false
+       headers:
+         'signoz-ingestion-key': <SIGNOZ_INGESTION_KEY>
+
+   service:
+     pipelines:
+       metrics:
+         receivers: [prometheus]
+         processors: [batch, resourcedetection]
+         exporters: [otlp]
+   ```
+
 4. Apply Changes
-    
-    Restart the OpenTelemetry Collector to apply the new configuration
-    
+
+   Restart the OpenTelemetry Collector to apply the new configuration
+
 5. Verify Configuration in SigNoz Cloud
-    
-    Log in to your SigNoz Cloud dashboard and check for Prometheus metrics to ensure the metrics are being scraped and sent successfully.
-    
-    <Figure src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%204.webp" alt="Verify Configuration in SigNoz Cloud" caption="Verify Configuration in SigNoz Cloud" />
-    
+
+   Log in to your SigNoz Cloud dashboard and check for Prometheus metrics to ensure the metrics are being scraped and sent successfully.
+
+   <Figure
+     src="/img/guides/2024/12/configure-prometheus-to-use-non-default-port-image%204.webp"
+     alt="Verify Configuration in SigNoz Cloud"
+     caption="Verify Configuration in SigNoz Cloud"
+   />
 
 By combining Prometheus with SigNoz, you can elevate your monitoring and observability strategy, ensuring better performance, security, and reliability for your systems.
 
@@ -267,4 +288,4 @@ When exposing Prometheus on a new port:
 1. Use firewall rules to restrict access to trusted IP addresses.
 2. Implement TLS encryption for data in transit.
 3. Set up authentication mechanisms like basic auth or more advanced solutions.
-4. Regularly audit access logs and monitor for unusual activity on the new port.
\ No newline at end of file
+4. Regularly audit access logs and monitor for unusual activity on the new port.
diff --git a/data/guides/container-monitoring.mdx b/data/guides/container-monitoring.mdx
index 303b72d7c..449955eec 100644
--- a/data/guides/container-monitoring.mdx
+++ b/data/guides/container-monitoring.mdx
@@ -1,20 +1,17 @@
 ---
-
 title: Top 10 Container Monitoring Tools for DevOps in 2025
-slug: container-monitoring
 date: 2025-01-02
 tags: [monitoring]
 authors: [nitin_gouda]
 description: Discover the best container monitoring tools for DevOps in 2024. Learn about key features, selection criteria, and best practices for implementation.
 keywords: [container monitoring, DevOps tools, Prometheus, Grafana, Datadog, Dynatrace, SigNoz]
-
 ---
 
 Container monitoring has become a critical component of modern DevOps practices. As organizations increasingly adopt containerized applications and microservices architectures, the need for robust monitoring solutions has never been more pressing. This article explores the top 10 container monitoring tools for DevOps in 2024, providing insights into their features, benefits, and how to choose the right one for your needs.
 
 ## What is Container Monitoring and Why is it Important for DevOps?
 
-As containerized applications become the backbone of modern infrastructure, reliable container monitoring is crucial, especially with increasing complexity. For DevOps professionals, choosing the right monitoring solution is vital to ensure performance, security, and scalability. Container monitoring involves tracking the performance, health, and resource usage of these applications, offering real-time visibility into the dynamic environments where containers operate. 
+As containerized applications become the backbone of modern infrastructure, reliable container monitoring is crucial, especially with increasing complexity. For DevOps professionals, choosing the right monitoring solution is vital to ensure performance, security, and scalability. Container monitoring involves tracking the performance, health, and resource usage of these applications, offering real-time visibility into the dynamic environments where containers operate.
 
 Container monitoring is important for the following reasons:
 
@@ -74,13 +71,21 @@ Cons:
 - Newer Platform with Evolving Features: As a relatively new entrant, it may still be developing some features and could lack the maturity found in more established tools.
 - Limited Enterprise-Level Support: It may not provide the extensive support and dedicated services that larger organizations might require, potentially making it less suitable for enterprise-level deployments.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
-To learn more about [SigNoz](https://signoz.io/blog/opentelemetry-docker/#monitoring-with-signoz-dashboard). 
+To learn more about [SigNoz](https://signoz.io/blog/opentelemetry-docker/#monitoring-with-signoz-dashboard).
 
 ### 2. Prometheus & Grafana
 
-<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">Prometheus</a> and <a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> together create a robust open-source solution for container monitoring:
+<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Prometheus
+</a> and <a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a> together create a robust open-source solution for container monitoring:
 
 Prometheus: A time-series database that specializes in metrics collection and alerting. It efficiently stores and queries metrics data over time, providing insights into system performance and health.
 
@@ -104,11 +109,18 @@ Cons:
 - Steep Learning Curve: Advanced features and PromQL can be complex to master, requiring a deeper understanding of the system.
 - Requires Additional Tools for Log Management: Prometheus focuses on metrics, so additional tools are needed for comprehensive log management and analysis.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%201.webp" alt="Grafana Dashboard" caption="Grafana Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%201.webp"
+  alt="Grafana Dashboard"
+  caption="Grafana Dashboard"
+/>
 
 ### 3. Datadog
 
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> is a versatile cloud-based monitoring platform designed to support complex containerized environments:
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a> is a versatile cloud-based monitoring platform designed to support complex containerized
+environments:
 
 Key Features:
 
@@ -128,11 +140,18 @@ Cons:
 - Can Be Expensive: Pricing can be high for large-scale or enterprise-level deployments, potentially making it less suitable for smaller teams or budgets.
 - Occasional Data Lag: Some users have reported delays in data visibility, which can affect real-time monitoring effectiveness.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%202.webp" alt="DataDog DashBoard" caption="DataDog DashBoard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%202.webp"
+  alt="DataDog DashBoard"
+  caption="DataDog DashBoard"
+/>
 
 ### 4. Dynatrace
 
-<a href="https://www.dynatrace.com/" rel="noopener noreferrer nofollow" target="_blank">Dynatrace</a> provides an advanced, AI-driven monitoring solution designed for comprehensive application performance management:
+<a href="https://www.dynatrace.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Dynatrace
+</a> provides an advanced, AI-driven monitoring solution designed for comprehensive application
+performance management:
 
 Key Features:
 
@@ -152,11 +171,18 @@ Cons:
 - Complex Pricing Structure: The pricing model can be intricate, which may make it challenging to estimate costs accurately.
 - Resource-Intensive: The platform's comprehensive features and AI capabilities may require significant resources, potentially impacting performance.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%203.webp" alt="Dynatrace Dashboard" caption="Dynatrace Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%203.webp"
+  alt="Dynatrace Dashboard"
+  caption="Dynatrace Dashboard"
+/>
 
 ### 5. Sematext
 
-<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">Sematext</a> offers an integrated solution for both monitoring and log management, catering to a variety of deployment needs:
+<a href="https://sematext.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Sematext
+</a> offers an integrated solution for both monitoring and log management, catering to a variety of
+deployment needs:
 
 Key Features:
 
@@ -176,11 +202,18 @@ Cons:
 - Limited Advanced Analytics: It may lack some of the more sophisticated analytical capabilities found in other, more established tools.
 - Smaller Community: It has a smaller user community compared to some of the more widely adopted monitoring solutions, which can affect the availability of support and resources.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%204.webp" alt="Sematext Dashboard" caption="Sematext Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%204.webp"
+  alt="Sematext Dashboard"
+  caption="Sematext Dashboard"
+/>
 
 ### 6. New Relic
 
-<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">New Relic</a> delivers an all-encompassing observability platform with robust capabilities for container monitoring:
+<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a> delivers an all-encompassing observability platform with robust capabilities for container
+monitoring:
 
 Key Features:
 
@@ -200,11 +233,19 @@ Cons:
 - Complex Pricing Structure: Pricing can be intricate and may become costly depending on the scale of deployment.
 - Steep Learning Curve: Some users may find the platform challenging to master initially, particularly when configuring advanced features.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%205.webp" alt="New Relic Dashboard" caption="New Relic Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%205.webp"
+  alt="New Relic Dashboard"
+  caption="New Relic Dashboard"
+/>
 
 ### 7. Elastic Observability
 
-<a href="https://www.elastic.co/" rel="noopener noreferrer nofollow" target="_blank">Elastic Observability</a>, integrated within the Elastic Stack, offers comprehensive container monitoring along with log management and application performance monitoring (APM):
+<a href="https://www.elastic.co/" rel="noopener noreferrer nofollow" target="_blank">
+  Elastic Observability
+</a>
+, integrated within the Elastic Stack, offers comprehensive container monitoring along with log
+management and application performance monitoring (APM):
 
 Key Features:
 
@@ -224,11 +265,18 @@ Cons:
 - Resource-Intensive: Can be demanding on resources, particularly in large-scale deployments.
 - Requires Expertise: Setting up and maintaining the platform effectively often requires specialized knowledge and skills.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%206.webp" alt="Elastic Dashboard" caption="Elastic Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%206.webp"
+  alt="Elastic Dashboard"
+  caption="Elastic Dashboard"
+/>
 
 ### 8. Instana
 
-<a href="https://www.ibm.com/products/instana" rel="noopener noreferrer nofollow" target="_blank">Instana</a> provides automated Application Performance Monitoring (APM) specifically designed for microservices and containerized applications:
+<a href="https://www.ibm.com/products/instana" rel="noopener noreferrer nofollow" target="_blank">
+  Instana
+</a> provides automated Application Performance Monitoring (APM) specifically designed for
+microservices and containerized applications:
 
 Key Features:
 
@@ -248,11 +296,17 @@ Cons:
 - Limited Customization: Fewer customization options compared to some other tools, which may limit flexibility.
 - Focus on APM: Primarily targets APM, so additional tools might be necessary for a full-spectrum monitoring solution.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%207.webp" alt="Instana Dashboard" caption="Instana Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%207.webp"
+  alt="Instana Dashboard"
+  caption="Instana Dashboard"
+/>
 
 ### 9. Splunk
 
-<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">Splunk</a> offers a comprehensive platform for monitoring, logging, and security analytics:
+<a href="https://www.splunk.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Splunk
+</a> offers a comprehensive platform for monitoring, logging, and security analytics:
 
 Key Features:
 
@@ -272,11 +326,17 @@ Cons:
 - Can Be Expensive: Costs can add up significantly with high data volumes and extensive usage.
 - Steep Learning Curve: Advanced features and configurations can be complex to learn and implement.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%208.webp" alt="Splunk Dashboard" caption="Splunk Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%208.webp"
+  alt="Splunk Dashboard"
+  caption="Splunk Dashboard"
+/>
 
 ### 10. Zabbix
 
-<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">Zabbix</a> is an open-source monitoring solution with strong support for containers:
+<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Zabbix
+</a> is an open-source monitoring solution with strong support for containers:
 
 Key Features:
 
@@ -296,7 +356,11 @@ Cons:
 - User Interface Can Feel Dated: The interface may appear less modern compared to some newer tools.
 - Setup and Configuration Can Be Complex: Initial setup and configuration can be challenging and time-consuming.
 
-<Figure src="/img/guides/2024/08/container-monitoring-image%209.webp" alt="Zabbix Dashboard" caption="Zabbix Dashboard" />
+<Figure
+  src="/img/guides/2024/08/container-monitoring-image%209.webp"
+  alt="Zabbix Dashboard"
+  caption="Zabbix Dashboard"
+/>
 
 ## Key Features to Look for in Container Monitoring Tools
 
@@ -387,4 +451,4 @@ Container monitoring offers crucial insights into resource usage, enabling teams
 3. Optimize container sizing and resource allocation
 4. Make data-driven decisions for scaling infrastructure or applications
 
-These insights empower DevOps teams to maximize resource efficiency and enhance capacity planning.
\ No newline at end of file
+These insights empower DevOps teams to maximize resource efficiency and enhance capacity planning.
diff --git a/data/guides/context-deadline-exceeded-prometheus.mdx b/data/guides/context-deadline-exceeded-prometheus.mdx
index 2432598a9..39b205d53 100644
--- a/data/guides/context-deadline-exceeded-prometheus.mdx
+++ b/data/guides/context-deadline-exceeded-prometheus.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Fix "Context Deadline Exceeded" Errors in Prometheus
-slug: context-deadline-exceeded-prometheus
 date: 2024-09-06
 tags: [faq, prometheus]
 authors: [simran_kumari]
 description: Learn how to diagnose, fix, and prevent "Context Deadline Exceeded" errors in Prometheus. Optimize your monitoring setup for reliable metrics collection.
-keywords: [Prometheus, Context Deadline Exceeded, monitoring, metrics, timeout errors, scraping, observability]
-
+keywords:
+  [
+    Prometheus,
+    Context Deadline Exceeded,
+    monitoring,
+    metrics,
+    timeout errors,
+    scraping,
+    observability,
+  ]
 ---
 
 Running into "Context Deadline Exceeded" errors in Prometheus? You're not alone. This pesky error pops up when Prometheus can’t scrape metrics from a target in time, leading to gaps in your data and potential monitoring blind spots. But don't worry—this guide is here to help you understand why it happens and, more importantly, how to fix it.
@@ -18,7 +24,11 @@ What Is a "Context Deadline Exceeded" Error?
 
 In Prometheus, a "Context Deadline Exceeded" error occurs when the server tries to scrape metrics from a target but runs out of time. Prometheus has a set time limit (defined by `scrape_timeout`), and if it doesn’t get the data before that clock runs out, it throws this error and moves on.
 
-<Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image.webp" alt="Prometheus: Context Deadline Exceeded Error" caption="Prometheus: Context Deadline Exceeded Error" />
+<Figure
+  src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image.webp"
+  alt="Prometheus: Context Deadline Exceeded Error"
+  caption="Prometheus: Context Deadline Exceeded Error"
+/>
 
 Impact on Monitoring and Data Collection: When these errors occur, they can have a significant impact:
 
@@ -48,57 +58,83 @@ You’ll typically see this error in a few situations:
 Effective troubleshooting starts with proper diagnosis. Here's how to identify and analyze "Context Deadline Exceeded" errors in your Prometheus setup:
 
 1. Check the Prometheus UI:
-    - Navigate to the "Targets" page in the Prometheus web interface
-        
-        <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%201.webp" alt="Navigate to the Targets section in the Prometheus Web Interface" caption="Navigate to the Targets section in the Prometheus Web Interface" />
-        
-    - Look for targets marked as "down" with error messages containing "context deadline exceeded"
-        
-        <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%202.webp" alt="Look for ContextDeadline Error in targets that are down" caption="Look for ContextDeadline Error in targets that are down" />
-        
+   - Navigate to the "Targets" page in the Prometheus web interface
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%201.webp"
+       alt="Navigate to the Targets section in the Prometheus Web Interface"
+       caption="Navigate to the Targets section in the Prometheus Web Interface"
+     />
+   - Look for targets marked as "down" with error messages containing "context deadline exceeded"
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%202.webp"
+       alt="Look for ContextDeadline Error in targets that are down"
+       caption="Look for ContextDeadline Error in targets that are down"
+     />
 2. Analyze Prometheus logs:
-    - Examine Prometheus server logs for entries containing "context deadline exceeded"
-    - Note the affected targets and the frequency of these errors
+   - Examine Prometheus server logs for entries containing "context deadline exceeded"
+   - Note the affected targets and the frequency of these errors
 3. Use Prometheus debug endpoints:
-    - Access the `/debug/pprof` endpoint on your Prometheus server
-    - Look for goroutines stuck in scrape operations
-        
-        <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%203.webp" alt="Accessing the /debug/pprof endpoint on Prometheus server" caption="Accessing the /debug/pprof endpoint on Prometheus server" />
-        
-        You will notice a lot of data, which may appear difficult to read.
-        
-        <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%204.webp" alt="" caption="" />Let’s decode it one by one :
-        
-        - There are 31 goroutines active at the time of the profile capture.
-            
-            <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-276bcb1e-d88f-479d-83eb-028068902545.webp" alt="" caption="" />- Blocked Goroutines (3 instances)
-            
-            <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-546fc198-8399-4937-96bc-c106bf46cef6.webp" alt="" caption="" />- "3 @ ..." indicates that 3 different goroutines are executing the same code path at this specific point in time.
-            - The goroutines are stuck waiting for network-related operations.
-                - `internal/poll.runtime_pollWait`: Waiting for I/O events on a file descriptor.
-                - `internal/poll.FD.Read`: Reading data from a file descriptor, typically a network socket.
-                - `*net/http.(connReader).Read*`: Indicates that this goroutine is part of an HTTP request handler and is reading data.
-                - `*net/http.(conn).serve*`: This suggests that the goroutine is handling an HTTP request.
-        - Discovery Manager Goroutines (2 instances)
-            
-            <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-20ac5d3d-d07c-4efc-aab3-ad29d37ac46b.webp" alt="" caption="" />- These goroutines are involved in Prometheus's discovery manager, which handles service discovery for targets.
-            - The `discovery/legacymanager.Manager.sender` function is related to sending target discovery updates.
-        
-        From above, we can figure out that the goroutine is stuck waiting for network-related operations. Hinting at network-related issues while trying to read data.
-        
-        <aside>
-        💡
-        
-        To observe clear changes during a context deadline exceeded scenario, you'd typically see more goroutines stuck in network I/O or waiting for timeout conditions, especially around the HTTP client or scraping logic. The `goroutine profile` would show more instances of these goroutines waiting on `net/http` or `context` functions.
-        
-        </aside>
-        
+   - Access the `/debug/pprof` endpoint on your Prometheus server
+   - Look for goroutines stuck in scrape operations
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%203.webp"
+       alt="Accessing the /debug/pprof endpoint on Prometheus server"
+       caption="Accessing the /debug/pprof endpoint on Prometheus server"
+     />
+     You will notice a lot of data, which may appear difficult to read.
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%204.webp"
+       alt=""
+       caption=""
+     />
+     Let’s decode it one by one : - There are 31 goroutines active at the time of the profile
+     capture.
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-276bcb1e-d88f-479d-83eb-028068902545.webp"
+       alt=""
+       caption=""
+     />
+     - Blocked Goroutines (3 instances)
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-546fc198-8399-4937-96bc-c106bf46cef6.webp"
+       alt=""
+       caption=""
+     />
+     - "3 @ ..." indicates that 3 different goroutines are executing the same code path at this
+     specific point in time. - The goroutines are stuck waiting for network-related operations. -
+     `internal/poll.runtime_pollWait`: Waiting for I/O events on a file descriptor. -
+     `internal/poll.FD.Read`: Reading data from a file descriptor, typically a network socket. -
+     `*net/http.(connReader).Read*`: Indicates that this goroutine is part of an HTTP request
+     handler and is reading data. - `*net/http.(conn).serve*`: This suggests that the goroutine is
+     handling an HTTP request. - Discovery Manager Goroutines (2 instances)
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-20ac5d3d-d07c-4efc-aab3-ad29d37ac46b.webp"
+       alt=""
+       caption=""
+     />
+     - These goroutines are involved in Prometheus's discovery manager, which handles service
+     discovery for targets. - The `discovery/legacymanager.Manager.sender` function is related to
+     sending target discovery updates. From above, we can figure out that the goroutine is stuck
+     waiting for network-related operations. Hinting at network-related issues while trying to read
+     data.
+     <aside>
+       💡 To observe clear changes during a context deadline exceeded scenario, you'd typically see
+       more goroutines stuck in network I/O or waiting for timeout conditions, especially around the
+       HTTP client or scraping logic. The `goroutine profile` would show more instances of these
+       goroutines waiting on `net/http` or `context` functions.
+     </aside>
 4. Leverage external tools:
-    - Use network diagnostic tools like `ping` or `traceroute` to check connectivity. For example, sending GET requests to the server throws an error, hinting at something wrong on the target app’s end.
-        
-        <Figure src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%205.webp" alt="Checking target sever for Context Deadline Exceeded Errors" caption="Checking target sever for Context Deadline Exceeded Errors" />
-        
-    - Employ monitoring tools like [SigNoz](https://signoz.io/) to gain deeper insights into your infrastructure.
+   - Use network diagnostic tools like `ping` or `traceroute` to check connectivity. For example, sending GET requests to the server throws an error, hinting at something wrong on the target app’s end.
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/context-deadline-exceeded-prometheus-image%205.webp"
+       alt="Checking target sever for Context Deadline Exceeded Errors"
+       caption="Checking target sever for Context Deadline Exceeded Errors"
+     />
+   - Employ monitoring tools like [SigNoz](https://signoz.io/) to gain deeper insights into your infrastructure.
 
 By systematically investigating these areas, you can pinpoint the root causes of your timeout errors and take appropriate action.
 
@@ -107,57 +143,57 @@ By systematically investigating these areas, you can pinpoint the root causes of
 Proper configuration is key to mitigating "Context Deadline Exceeded" errors. Here are essential steps to optimize your Prometheus setup:
 
 1. Adjust global scrape_timeout settings:
-    
-    ```yaml
-    global:
-      scrape_timeout: 15s
-    ```
-    
-    Increase this value if you consistently see timeout errors across multiple targets.
-    
+
+   ```yaml
+   global:
+     scrape_timeout: 15s
+   ```
+
+   Increase this value if you consistently see timeout errors across multiple targets.
+
 2. Fine-tune job-specific settings:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'example-job'
-        scrape_interval: 30s
-        scrape_timeout: 20s
-    ```
-    
-    Tailor these settings to the specific needs of each job or target group.
-    
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'example-job'
+       scrape_interval: 30s
+       scrape_timeout: 20s
+   ```
+
+   Tailor these settings to the specific needs of each job or target group.
+
 3. Implement relabeling:
-    
-    ```yaml
-    relabel_configs:
-      - source_labels: [__address__]
-        target_label: __param_target
-      - source_labels: [__param_target]
-        target_label: instance
-      - target_label: __address__
-        replacement: prometheus-proxy:9090
-    ```
-    
-    Use relabeling to optimize scrape configurations and route requests through a proxy if needed.
-    
+
+   ```yaml
+   relabel_configs:
+     - source_labels: [__address__]
+       target_label: __param_target
+     - source_labels: [__param_target]
+       target_label: instance
+     - target_label: __address__
+       replacement: prometheus-proxy:9090
+   ```
+
+   Use relabeling to optimize scrape configurations and route requests through a proxy if needed.
+
 4. Balance scrape frequency and resource usage:
-Avoid setting overly aggressive scrape intervals that might overwhelm your targets or Prometheus itself.
+   Avoid setting overly aggressive scrape intervals that might overwhelm your targets or Prometheus itself.
 
 ### Best Practices for Prometheus Configuration
 
 To maintain a robust Prometheus setup, adhere to these best practices:
 
 1. Fine-Tune Scrape Intervals and Timeouts
-    - Scrape Intervals: Your `scrape_interval` determines how often Prometheus pulls metrics from targets. A balance is key—set it too short, and you risk overwhelming your system; too long, and you might miss critical data. Typically, a 15 to 30-second interval works well, but for slower or less critical systems, consider a longer interval to reduce load.
-    - Scrape Timeouts: Set the `scrape_timeout` just below the `scrape_interval`. This ensures that if a target is slow, Prometheus doesn’t get stuck waiting and can move on to the next target. For example, with a 15-second interval, a timeout of 10-12 seconds is usually ideal.
+   - Scrape Intervals: Your `scrape_interval` determines how often Prometheus pulls metrics from targets. A balance is key—set it too short, and you risk overwhelming your system; too long, and you might miss critical data. Typically, a 15 to 30-second interval works well, but for slower or less critical systems, consider a longer interval to reduce load.
+   - Scrape Timeouts: Set the `scrape_timeout` just below the `scrape_interval`. This ensures that if a target is slow, Prometheus doesn’t get stuck waiting and can move on to the next target. For example, with a 15-second interval, a timeout of 10-12 seconds is usually ideal.
 2. Use Relabeling to Filter Metrics
-    - Prometheus can scrape a vast amount of data, but not all of it is useful.
-    - Use relabeling rules to filter out unnecessary metrics before they’re stored. This reduces the load on Prometheus and the chances of encountering timeout errors.
+   - Prometheus can scrape a vast amount of data, but not all of it is useful.
+   - Use relabeling rules to filter out unnecessary metrics before they’re stored. This reduces the load on Prometheus and the chances of encountering timeout errors.
 3. Distribute Load with Service Discovery
-    - Leverage service discovery to dynamically manage your targets, especially in environments that change frequently (like Kubernetes). This allows Prometheus to efficiently update and manage scrape targets, reducing the chance of overloading the system.
+   - Leverage service discovery to dynamically manage your targets, especially in environments that change frequently (like Kubernetes). This allows Prometheus to efficiently update and manage scrape targets, reducing the chance of overloading the system.
 4. Implement High Availability (HA)
-    - Running multiple Prometheus instances in a high-availability setup can help distribute the scraping load and prevent any single instance from becoming a bottleneck.
-    - HA setups also provide redundancy, ensuring that monitoring continues even if one instance goes down.
+   - Running multiple Prometheus instances in a high-availability setup can help distribute the scraping load and prevent any single instance from becoming a bottleneck.
+   - HA setups also provide redundancy, ensuring that monitoring continues even if one instance goes down.
 
 By following these guidelines, you can create a more resilient and efficient [Prometheus monitoring system](https://signoz.io/guides/what-is-prometheus-for-monitoring/).
 
@@ -166,17 +202,17 @@ By following these guidelines, you can create a more resilient and efficient [Pr
 While Prometheus configuration is crucial, optimizing target systems can significantly reduce the occurrence of timeout errors:
 
 1. Improve target system performance:
-    - Allocate sufficient resources to metric collection processes
-    - Optimize database queries or API calls that generate metrics
+   - Allocate sufficient resources to metric collection processes
+   - Optimize database queries or API calls that generate metrics
 2. Implement caching mechanisms:
-    - Cache frequently accessed metrics to reduce computation time during scrapes
-    - Use tools like TSDB or Redis for efficient metric caching
+   - Cache frequently accessed metrics to reduce computation time during scrapes
+   - Use tools like TSDB or Redis for efficient metric caching
 3. Optimize network connectivity:
-    - Ensure low-latency network paths between Prometheus and targets
-    - Consider using Prometheus Federation to bring scraping closer to targets
+   - Ensure low-latency network paths between Prometheus and targets
+   - Consider using Prometheus Federation to bring scraping closer to targets
 4. Scale resources for complex metric endpoints:
-    - Horizontally scale services that expose resource-intensive metrics
-    - Consider breaking down complex metric endpoints into multiple, simpler endpoints
+   - Horizontally scale services that expose resource-intensive metrics
+   - Consider breaking down complex metric endpoints into multiple, simpler endpoints
 
 By addressing performance bottlenecks on target systems, you can significantly reduce the likelihood of timeout errors.
 
@@ -185,23 +221,24 @@ By addressing performance bottlenecks on target systems, you can significantly r
 For more complex monitoring setups, consider these advanced techniques:
 
 1. Use Prometheus Pushgateway:
-    - Ideal for batch jobs or unreliable targets
-    - Allows targets to [push metrics](https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/) to an intermediate gateway
-    
-    ```yaml
-    push_config:
-      endpoint: "http://pushgateway:9091/metrics"
-    ```
-    
+
+   - Ideal for batch jobs or unreliable targets
+   - Allows targets to [push metrics](https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/) to an intermediate gateway
+
+   ```yaml
+   push_config:
+     endpoint: 'http://pushgateway:9091/metrics'
+   ```
+
 2. Implement circuit breakers:
-    - Use tools like Hystrix or resilience4j to handle temporary failures
-    - Prevent cascading failures due to unresponsive targets
+   - Use tools like Hystrix or resilience4j to handle temporary failures
+   - Prevent cascading failures due to unresponsive targets
 3. Leverage specialized exporters:
-    - Offload metric collection processing to dedicated exporters
-    - Use efficient data formats like Protocol Buffers for faster serialization
+   - Offload metric collection processing to dedicated exporters
+   - Use efficient data formats like Protocol Buffers for faster serialization
 4. Employ load balancing:
-    - Distribute scrape requests across multiple instances of high-volume targets
-    - Use DNS-based load balancing or dedicated load balancers
+   - Distribute scrape requests across multiple instances of high-volume targets
+   - Use DNS-based load balancing or dedicated load balancers
 
 These techniques can help you build a more resilient monitoring infrastructure capable of handling complex and high-volume metric collection scenarios.
 
@@ -210,27 +247,27 @@ These techniques can help you build a more resilient monitoring infrastructure c
 Proactive monitoring of your Prometheus setup is essential for maintaining its health:
 
 1. Set up alerts for persistent timeout errors:
-    
-    ```yaml
-    - alert: PersistentScrapeTimeout
-      expr: rate(prometheus_target_scrapes_exceeded_sample_limit_total[5m]) > 0
-      for: 15m
-      labels:
-        severity: warning
-      annotations:
-        summary: "Persistent scrape timeouts detected"
-        description: "Target {{ $labels.instance }} is experiencing consistent scrape timeouts."
-    ```
-    
+
+   ```yaml
+   - alert: PersistentScrapeTimeout
+     expr: rate(prometheus_target_scrapes_exceeded_sample_limit_total[5m]) > 0
+     for: 15m
+     labels:
+       severity: warning
+     annotations:
+       summary: 'Persistent scrape timeouts detected'
+       description: 'Target {{ $labels.instance }} is experiencing consistent scrape timeouts.'
+   ```
+
 2. Create dashboards to visualize scrape performance:
-    - Monitor scrape duration trends
-    - Track the number of successful vs. failed scrapes
+   - Monitor scrape duration trends
+   - Track the number of successful vs. failed scrapes
 3. Implement SLOs for scrape success rates:
-    - Set targets for scrape success percentages
-    - Use error budgets to guide improvement efforts
+   - Set targets for scrape success percentages
+   - Use error budgets to guide improvement efforts
 4. Correlate timeout errors with system metrics:
-    - Look for patterns between timeouts and CPU, memory, or network usage
-    - Use this data to inform scaling decisions or performance optimizations
+   - Look for patterns between timeouts and CPU, memory, or network usage
+   - Use this data to inform scaling decisions or performance optimizations
 
 By implementing comprehensive monitoring and alerting for your Prometheus infrastructure, you can catch and address issues before they impact your overall monitoring effectiveness.
 
@@ -275,4 +312,4 @@ Use network diagnostic tools to check connectivity and latency. If network metri
 
 ### Is it possible to have different timeout settings for different targets?
 
-Yes, Prometheus allows you to set different `scrape_timeout` values for each job in the `scrape_configs` section of your configuration file.
\ No newline at end of file
+Yes, Prometheus allows you to set different `scrape_timeout` values for each job in the `scrape_configs` section of your configuration file.
diff --git a/data/guides/crontab-logs.mdx b/data/guides/crontab-logs.mdx
index 80b8ffa55..56c7eab8a 100644
--- a/data/guides/crontab-logs.mdx
+++ b/data/guides/crontab-logs.mdx
@@ -1,11 +1,20 @@
 ---
-title: "Crontab Logs: Location and How to Read Them [2025]"
-slug: "crontab-logs"
-date: "2025-09-01"
+title: 'Crontab Logs: Location and How to Read Them [2025]'
+date: '2025-09-01'
 tags: [linux, logging]
 authors: [simran_kumari]
-description: "Complete guide to finding, reading, and monitoring crontab logs across different Linux distributions. Learn log locations, debugging techniques, and best practices for cron job management."
-keywords: [crontab logs, cron logs, cronjob, linux logs, system logs, cron debugging, scheduled tasks, log monitoring]
+description: 'Complete guide to finding, reading, and monitoring crontab logs across different Linux distributions. Learn log locations, debugging techniques, and best practices for cron job management.'
+keywords:
+  [
+    crontab logs,
+    cron logs,
+    cronjob,
+    linux logs,
+    system logs,
+    cron debugging,
+    scheduled tasks,
+    log monitoring,
+  ]
 ---
 
 Cron jobs handle critical automation in Unix-like systems: from database backups to log rotation, yet they fail silently by design. When a scheduled task stops working, you might not discover the failure until days later, potentially causing data loss or system degradation.
@@ -31,6 +40,7 @@ grep CRON /var/log/syslog
 />
 
 For recent activity with timestamps:
+
 ```bash
 grep CRON /var/log/syslog | tail -20
 ```
@@ -44,6 +54,7 @@ tail -f /var/log/cron
 ```
 
 View specific time ranges:
+
 ```bash
 grep "$(date '+%b %d')" /var/log/cron
 ```
@@ -79,6 +90,7 @@ Jul 23 10:15:01 server CRON[12345]: (root) CMD (/usr/local/bin/backup.sh)
 ```
 
 This confirms the job started but provides no information about:
+
 - Whether the script succeeded or failed
 - What output the script generated
 - How long execution took
@@ -148,6 +160,7 @@ exit $EXIT_CODE
 ```
 
 Use in crontab:
+
 ```bash
 0 2 * * * /usr/local/bin/cron-logger.sh /usr/local/bin/backup.sh
 ```
@@ -191,6 +204,7 @@ Cron runs with a stripped-down environment. Debug by capturing the environment:
 ```
 
 Common solution—explicitly set PATH:
+
 ```bash
 PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 0 2 * * * /usr/local/bin/backup.sh
@@ -242,6 +256,7 @@ journalctl -u cron -f  # Use 'crond' or 'cronie' if that's your service name
 ```
 
 **For traditional cron (RHEL/CentOS):**
+
 ```bash
 # Edit /etc/sysconfig/crond
 CRONDARGS="-x ext,sch,proc,pars,load,misc,test"
@@ -328,6 +343,7 @@ Built on ClickHouse, SigNoz delivers exceptionally fast log querying and analysi
 
 **Proactive Alerting:**
 Set up alerts based on cron job patterns such as:
+
 - Jobs that haven't executed within expected schedules
 - Failed jobs based on exit codes or error messages
 - Unusual execution durations indicating performance issues
@@ -337,20 +353,21 @@ Set up alerts based on cron job patterns such as:
 Unlike traditional [log management tools](https://signoz.io/blog/open-source-log-management/), SigNoz combines logs, metrics, and distributed traces in a single platform. This enables you to correlate cron job issues with system performance metrics, application errors, or infrastructure problems.
 
 **Example [OpenTelemetry Collector Configuration](https://signoz.io/blog/opentelemetry-collector-complete-guide/) for Cron Logs:**
+
 ```yaml
 receivers:
   syslog:
     tcp:
-      endpoint: "0.0.0.0:5140"
+      endpoint: '0.0.0.0:5140'
   filelog:
-    include: [ "/var/log/cron-jobs.log" ]
+    include: ['/var/log/cron-jobs.log']
 
 processors:
   batch:
 
 exporters:
   otlp:
-    endpoint: "https://ingest.{region}.signoz.cloud:443"
+    endpoint: 'https://ingest.{region}.signoz.cloud:443'
 
 service:
   pipelines:
@@ -360,7 +377,7 @@ service:
       exporters: [otlp]
 ```
 
-You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features. 
+You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features.
 
 Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
@@ -375,7 +392,7 @@ Effective cron job management requires understanding these fundamental principle
 - **System logs show execution, not results** - Default logs only confirm jobs started, not whether they succeeded
 - **Custom logging is mandatory** - Implement output redirection and [structured logging](https://signoz.io/blog/structured-logs/) for meaningful monitoring
 - **Environment differences cause most failures** - Cron's minimal environment often breaks scripts that work interactively
-- **[Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) prevents incidents** - Set up alerting before jobs fail, not after discovering problems  
+- **[Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) prevents incidents** - Set up alerting before jobs fail, not after discovering problems
 - **Centralized solutions scale effectively** - Use log management platforms for production environments with multiple servers
 
 Implementing these practices transforms cron job management from reactive troubleshooting to proactive system reliability.
@@ -424,4 +441,4 @@ Individual crontabs: `/var/spool/cron/crontabs/username` (Debian) or `/var/spool
 
 ---
 
-*Enhance your system administration skills with our guides on [log management](https://signoz.io/docs/userguide/logs/) and [collecting system logs](https://signoz.io/docs/userguide/collecting_syslogs/).*
+_Enhance your system administration skills with our guides on [log management](https://signoz.io/docs/userguide/logs/) and [collecting system logs](https://signoz.io/docs/userguide/collecting_syslogs/)._
diff --git a/data/guides/database-monitoring.mdx b/data/guides/database-monitoring.mdx
index ad011270a..2184659d8 100644
--- a/data/guides/database-monitoring.mdx
+++ b/data/guides/database-monitoring.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: Database Monitoring 101 - Essential Guide for Performance
-slug: database-monitoring
 date: 2024-08-07
 tags: [monitoring]
 authors: [eromosele]
 description: Learn essential database monitoring strategies to optimize performance, prevent issues, and ensure business continuity. Discover key metrics and tools for effective monitoring.
-keywords: [database monitoring,performance optimization,database metrics,monitoring tools, query analysis,proactive monitoring]
-
+keywords:
+  [
+    database monitoring,
+    performance optimization,
+    database metrics,
+    monitoring tools,
+    query analysis,
+    proactive monitoring,
+  ]
 ---
 
 Database performance can make or break your application. Slow queries, resource bottlenecks, and unexpected downtime can frustrate users and impact your bottom line. How do you ensure your databases run smoothly and efficiently? The answer lies in effective database monitoring.
@@ -41,52 +46,56 @@ Understanding common performance problems is key to effective monitoring. Here a
 To maintain optimal performance and ensure your database operates efficiently, it's crucial to focus on these critical metrics:
 
 1. Query Response Time:
-    
-    The time it takes for a database to execute a query and return results.
-    
-    - Importance: Directly impacts user experience and application performance.
-    - Measurement: Usually in milliseconds (ms) or seconds (s).
-    - Example: If a query typically takes 100ms but suddenly spikes to 500ms, it could indicate an issue.
-    - Action items: Optimize slow queries, index frequently accessed data, or upgrade hardware if necessary.
+
+   The time it takes for a database to execute a query and return results.
+
+   - Importance: Directly impacts user experience and application performance.
+   - Measurement: Usually in milliseconds (ms) or seconds (s).
+   - Example: If a query typically takes 100ms but suddenly spikes to 500ms, it could indicate an issue.
+   - Action items: Optimize slow queries, index frequently accessed data, or upgrade hardware if necessary.
+
 2. Throughput:
-    
-    The number of queries or transactions the database can process in a given time period.
-    
-    - Importance: Indicates the database's capacity to handle workload.
-    - Measurement: Often expressed as queries per second (QPS) or transactions per second (TPS).
-    - Example: A system handling 1000 QPS during peak hours but struggling at 1200 QPS might need optimization.
-    - Action items: Load balancing, query optimization, or scaling resources to handle increased demand.
+
+   The number of queries or transactions the database can process in a given time period.
+
+   - Importance: Indicates the database's capacity to handle workload.
+   - Measurement: Often expressed as queries per second (QPS) or transactions per second (TPS).
+   - Example: A system handling 1000 QPS during peak hours but struggling at 1200 QPS might need optimization.
+   - Action items: Load balancing, query optimization, or scaling resources to handle increased demand.
+
 3. Resource Usage:
-    
-    The utilization of system resources like CPU, memory, and disk I/O.
-    
-    - Importance: Helps identify bottlenecks and capacity issues.
-    - Measurement:
-        - CPU: Percentage of utilization
-        - Memory: Amount used vs. total available
-        - Disk I/O: Read/write operations per second
-    - Example: Consistently high CPU usage (e.g., >80%) might indicate the need for query optimization or hardware upgrades.
-    - Action items: Optimize resource-intensive queries, add more RAM, or upgrade to faster storage solutions.
+
+   The utilization of system resources like CPU, memory, and disk I/O.
+
+   - Importance: Helps identify bottlenecks and capacity issues.
+   - Measurement:
+     - CPU: Percentage of utilization
+     - Memory: Amount used vs. total available
+     - Disk I/O: Read/write operations per second
+   - Example: Consistently high CPU usage (e.g., >80%) might indicate the need for query optimization or hardware upgrades.
+   - Action items: Optimize resource-intensive queries, add more RAM, or upgrade to faster storage solutions.
+
 4. Cache Performance:
-    
-    Efficiency of the database's caching mechanisms.
-    
-    - Importance: Good caching reduces disk I/O and improves query performance.
-    - Measurement:
-        - Cache hit ratio: Percentage of requests served from cache
-        - Buffer pool efficiency: How effectively memory is used for caching
-    - Example: A cache hit ratio of 95% is generally good; if it drops to 70%, investigate the cause.
-    - Action items: Adjust cache size, optimize query patterns to improve cache utilization.
+
+   Efficiency of the database's caching mechanisms.
+
+   - Importance: Good caching reduces disk I/O and improves query performance.
+   - Measurement:
+     - Cache hit ratio: Percentage of requests served from cache
+     - Buffer pool efficiency: How effectively memory is used for caching
+   - Example: A cache hit ratio of 95% is generally good; if it drops to 70%, investigate the cause.
+   - Action items: Adjust cache size, optimize query patterns to improve cache utilization.
+
 5. Transaction Logs:
-    
-    Records of database transactions and changes.
-    
-    - Importance: Critical for data integrity, recovery, and replication.
-    - Measurement:
-        - Log growth rate: How quickly transaction logs are filling up
-        - Replication lag: Delay between primary and secondary servers in replicated setups
-    - Example: If log growth suddenly increases from 1GB/hour to 5GB/hour, it could indicate unusual activity or issues.
-    - Action items: Monitor log space, optimize log backup frequency, investigate causes of increased log activity.
+
+   Records of database transactions and changes.
+
+   - Importance: Critical for data integrity, recovery, and replication.
+   - Measurement:
+     - Log growth rate: How quickly transaction logs are filling up
+     - Replication lag: Delay between primary and secondary servers in replicated setups
+   - Example: If log growth suddenly increases from 1GB/hour to 5GB/hour, it could indicate unusual activity or issues.
+   - Action items: Monitor log space, optimize log backup frequency, investigate causes of increased log activity.
 
 By consistently monitoring these metrics, you can:
 
@@ -129,7 +138,7 @@ It involves examining the execution plans of database queries to identify ineffi
 
 ### Trend Analysis and Predictive Monitoring Techniques
 
-Trend analysis involves examining historical performance data to identify patterns and predict future behavior. 
+Trend analysis involves examining historical performance data to identify patterns and predict future behavior.
 
 - Historical Data Analysis: By reviewing past performance metrics, you can identify trends that indicate normal operation and deviations that may signal emerging problems.
 - Forecasting Future Performance: Predictive models can project future performance based on historical data, helping you anticipate and mitigate issues before they impact users.
@@ -164,36 +173,25 @@ Keeping your databases performing well is crucial for any data-driven business.
 To configure metrics and logs collection for a Postgres server, you need the following:
 
 - Ensure that the Postgres server is running a supported version
-    
-    Postgres versions 9.6+ are supported.
-    
-    You can use the following SQL statement to determine the server version
-    
-    ```bash
-    SELECT version();
-    ```
-    
+  Postgres versions 9.6+ are supported.
+  You can use the following SQL statement to determine the server version
+  ```bash
+  SELECT version();
+  ```
 - If collecting metrics, ensure that there is a Postgres user with the required permissions
-    
-    To create a monitoring user for Postgres versions 10+, run:
-    
-    ```bash
-    create user monitoring with password '<PASSWORD>';
-    grant pg_monitor to monitoring;
-    grant SELECT ON pg_stat_database to monitoring;
-    ```
-    
-    To create a monitoring user for Postgres versions >= 9.6 and \<10, run:
-    
-    ```bash
-    create user monitoring with password '<PASSWORD>';
-    grant SELECT ON pg_stat_database to monitoring;
-    ```
-    
+  To create a monitoring user for Postgres versions 10+, run:
+  ```bash
+  create user monitoring with password '<PASSWORD>';
+  grant pg_monitor to monitoring;
+  grant SELECT ON pg_stat_database to monitoring;
+  ```
+  To create a monitoring user for Postgres versions >= 9.6 and \<10, run:
+  ```bash
+  create user monitoring with password '<PASSWORD>';
+  grant SELECT ON pg_stat_database to monitoring;
+  ```
 - Ensure that an [OTEL collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) is running in your deployment environment
-    
-    If needed, please [install an OTEL Collector](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/), if already installed, ensure that the collector version is v0.116.0 or newer.
-    
+  If needed, please [install an OTEL Collector](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/), if already installed, ensure that the collector version is v0.116.0 or newer.
 
 ### Collect Postgres Metrics
 
@@ -215,7 +213,7 @@ receivers:
     # The password used to access the postgres instance
     password: ${env:POSTGRESQL_PASSWORD}
     # The list of databases for which the receiver will attempt to collect statistics. If an empty list is provided, the receiver will attempt to collect statistics for all non-template databases
-    databases: 
+    databases:
       - <YOUR DATABASE 1>
       - <YOUR DATABASE 2>
     # # Defines the network to use for connecting to the server. Valid Values are `tcp` or `unix`
@@ -239,18 +237,18 @@ processors:
   # see https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/resourcedetectionprocessor#resource-detection-processor
   resourcedetection/system:
     # add additional detectors if needed
-    detectors: ["system"]
+    detectors: ['system']
     system:
-      hostname_sources: ["os"]
+      hostname_sources: ['os']
 
 exporters:
   # export to SigNoz cloud
   otlp/postgres:
-    endpoint: "${env:OTLP_DESTINATION_ENDPOINT}"
+    endpoint: '${env:OTLP_DESTINATION_ENDPOINT}'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "${env:SIGNOZ_INGESTION_KEY}"
+      'signoz-ingestion-key': '${env:SIGNOZ_INGESTION_KEY}'
 
   # export to local collector
   # otlp/postgres:
@@ -291,7 +289,11 @@ export SIGNOZ_INGESTION_KEY="<your-signoz-ingestion-key>"
 
 Replace `{region}` with the region where you have your SigNoz cloud account and `<your-signoz-ingestion-key>` with your account ingestion key. You can find these values in your SigNoz account. Go to Settings > Ingestion Settings.
 
-<Figure src="/img/guides/2024/08/database-monitoring-Untitled.webp" alt="You can find ingestion details in the SigNoz dashboard" caption="You can find ingestion details in the SigNoz dashboard" />
+<Figure
+  src="/img/guides/2024/08/database-monitoring-Untitled.webp"
+  alt="You can find ingestion details in the SigNoz dashboard"
+  caption="You can find ingestion details in the SigNoz dashboard"
+/>
 
 Step 3: Start the Collector
 
@@ -307,13 +309,21 @@ Once the above setup is done, you will be able to access the metrics in the SigN
 
 PostgreSQL Metrics
 
-<Figure src="/img/guides/2024/08/database-monitoring-Untitled%201.webp" alt="SigNoz Panel PostgreSQL Metrics to add on Dashboard" caption="SigNoz Panel PostgreSQL Metrics to add on Dashboard" />
+<Figure
+  src="/img/guides/2024/08/database-monitoring-Untitled%201.webp"
+  alt="SigNoz Panel PostgreSQL Metrics to add on Dashboard"
+  caption="SigNoz Panel PostgreSQL Metrics to add on Dashboard"
+/>
 
 If you want to [get started](https://signoz.io/docs/userguide/hostmetrics/) quickly with PostgreSQL monitoring, you can [load](https://github.com/SigNoz/dashboards/tree/main/postgresql) this JSON  dashboard config in the SigNoz dashboard UI.
 
 PostgreSQL Basic Metrics Dashboard
 
-<Figure src="/img/guides/2024/08/database-monitoring-Untitled%202.webp" alt="SigNoz PostgreSQL Dashboard" caption="SigNoz PostgreSQL Dashboard" />
+<Figure
+  src="/img/guides/2024/08/database-monitoring-Untitled%202.webp"
+  alt="SigNoz PostgreSQL Dashboard"
+  caption="SigNoz PostgreSQL Dashboard"
+/>
 
 You can also create alerts on any metric. Learn how to create alerts [here](https://signoz.io/docs/userguide/alerts-management/).
 
@@ -350,4 +360,4 @@ Yes, database monitoring provides valuable insights into resource utilization tr
 
 ### What are the security implications of database monitoring?
 
-While monitoring is crucial for identifying security threats, it's important to implement monitoring practices that don't compromise data privacy. Ensure your monitoring tools and processes comply with relevant security standards and regulations.
\ No newline at end of file
+While monitoring is crucial for identifying security threats, it's important to implement monitoring practices that don't compromise data privacy. Ensure your monitoring tools and processes comply with relevant security standards and regulations.
diff --git a/data/guides/datadog-apm.mdx b/data/guides/datadog-apm.mdx
index 8ab4071ac..0cecf9d38 100644
--- a/data/guides/datadog-apm.mdx
+++ b/data/guides/datadog-apm.mdx
@@ -1,20 +1,28 @@
 ---
-title: "Datadog APM: A Deep Dive on Limitations and an Open Source Alternative"
-slug: datadog-apm
+title: 'Datadog APM: A Deep Dive on Limitations and an Open Source Alternative'
 date: 2025-10-09
 tags: [apm, datadog]
 authors: [yuvraj]
 description: "Explore Datadog APM's pricing, trace sampling, and vendor lock-in challenges, and discover how an open-source alternative like SigNoz with OpenTelemetry offers a better solution."
-keywords: [datadog apm, datadog pricing, opentelemetry, signoz, application performance monitoring, datadog alternative]
+keywords:
+  [
+    test,
+    datadog apm,
+    datadog pricing,
+    opentelemetry,
+    signoz,
+    application performance monitoring,
+    datadog alternative,
+  ]
 ---
 
 Datadog APM is one of the most well-known solutions on the market. With its polished UI, extensive auto-instrumentation capabilities, and tightly integrated alerting and SLO features, it's a common choice for teams looking for a powerful, all-in-one platform. It promises deep visibility into your services, helping you trace requests across distributed systems and pinpoint bottlenecks.
 
 However, as applications scale and teams mature, many engineers start asking critical questions:
 
-* _Why is our Datadog bill so unpredictable and high?_
-* _Are we missing important data because of trace sampling?_
-* _Are we locked into a proprietary agent that limits our flexibility?_
+- _Why is our Datadog bill so unpredictable and high?_
+- _Are we missing important data because of trace sampling?_
+- _Are we locked into a proprietary agent that limits our flexibility?_
 
 If these questions sound familiar, you're not alone. In this guide, we'll do a deep dive into <a href="https://www.datadoghq.com/product/apm/" rel="noreferrer nofollow" target="_blank">Datadog APM</a>, exploring its key challenges and how you can achieve the same, or better, results with OpenTelemetry and SigNoz, an open-source alternative available as a fully-managed cloud service.
 
@@ -30,7 +38,11 @@ As costs scale with volume, a medium-sized environment with around 100 hosts can
 
 A quick search for 'Datadog billing' on Reddit reveals numerous threads from developers frustrated with its pricing:
 
-<Figure src="/img/guides/2025/10/datadog-apm-datadog-pricing-reddit.webp" alt="Datadog pricing posts on Reddit" caption="Datadog pricing posts on Reddit" />
+<Figure
+  src="/img/guides/2025/10/datadog-apm-datadog-pricing-reddit.webp"
+  alt="Datadog pricing posts on Reddit"
+  caption="Datadog pricing posts on Reddit"
+/>
 
 ### Challenge #2: The Sampling Dilemma
 
@@ -42,8 +54,11 @@ This becomes particularly painful during incident response. When you're hunting
 
 In the datadog UI below, you can see the controls where teams are asked to set sampling rates, effectively deciding which data they are willing to lose to manage their bill:
 
-<Figure src="/img/guides/2025/10/datadog-apm-datadog-sampling.webp" alt="Datadog sampling controls" caption="Datadog sampling controls (source: Datadog)" />
-
+<Figure
+  src="/img/guides/2025/10/datadog-apm-datadog-sampling.webp"
+  alt="Datadog sampling controls"
+  caption="Datadog sampling controls (source: Datadog)"
+/>
 
 ### Challenge #3: Datadog's Proprietary Agent & Vendor Lock-In
 
@@ -77,9 +92,9 @@ This is precisely the gap that an OpenTelemetry-native APM like SigNoz is built
 
 [SigNoz](https://signoz.io/application-performance-monitoring/) is an all-in-one observability platform built to work natively with OpenTelemetry. Here’s how it directly solves the challenges of both proprietary tools and a complex DIY setup:
 
-* **Solution to Cost:** Because SigNoz is open-source, you avoid expensive licensing fees. You have full control over your resources and predictable pricing based on the data you choose to store. For those who don't want to self-host can use [SigNoz cloud which can bring 70-80% pricing reduction in observability costs](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/).
-* **Solution to Sampling:** SigNoz is built to handle high volumes of data, allowing you to capture 100% of your traces without aggressive sampling. You get the full context needed to troubleshoot any issue.
-* **Solution to Lock-In:** SigNoz is OpenTelemetry-native. You instrument your code once with open-source libraries, giving you the freedom to send your data to any backend, now or in the future.
+- **Solution to Cost:** Because SigNoz is open-source, you avoid expensive licensing fees. You have full control over your resources and predictable pricing based on the data you choose to store. For those who don't want to self-host can use [SigNoz cloud which can bring 70-80% pricing reduction in observability costs](https://signoz.io/blog/pricing-comparison-signoz-vs-datadog-vs-newrelic-vs-grafana/).
+- **Solution to Sampling:** SigNoz is built to handle high volumes of data, allowing you to capture 100% of your traces without aggressive sampling. You get the full context needed to troubleshoot any issue.
+- **Solution to Lock-In:** SigNoz is OpenTelemetry-native. You instrument your code once with open-source libraries, giving you the freedom to send your data to any backend, now or in the future.
 
 ### 5-Minute Tutorial: Instrumenting a Node.js App with OpenTelemetry & SigNoz
 
@@ -91,7 +106,6 @@ Here’s how you can instrument a simple Node.js Express application to send dat
 
 First, install the necessary OpenTelemetry packages in your project directory.
 
-
 ```bash
 npm install --save @opentelemetry/api @opentelemetry/auto-instrumentations-node
 ```
@@ -124,9 +138,14 @@ You'll need to replace the following placeholders:
 
 That's it! With your application running, generate some traffic by hitting its API endpoints a few times. After a moment, navigate to your SigNoz UI. You'll see your service appear in the **Services** tab, and you can explore 100% of your traces in the **Traces** tab, complete with RED metrics and detailed flamegraphs.
 
-<Figure src="/img/guides/2025/10/datadog-apm-signoz-apm.webp" alt="SigNoz APM" caption="SigNoz APM" />
+<Figure
+  src="/img/guides/2025/10/datadog-apm-signoz-apm.webp"
+  alt="SigNoz APM"
+  caption="SigNoz APM"
+/>
 
 Beyond APM and Tracing that you've just enabled, SigNoz is a full-stack observability platform. You can also send **logs** and **infrastructure metrics**, and even set up specialized monitoring for **APIs**, **message queues**, and **LLM-powered applications**, giving you a unified view of your entire system.
+
 ## Get Started with SigNoz
 
 You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a [30-day free trial account](https://signoz.io/pricing/) with access to all features.
@@ -137,7 +156,7 @@ Those who have the expertise to manage SigNoz themselves or just want to start w
 
 ### Ready to Make the Switch?
 
-Moving from Datadog to an OpenTelemetry-native platform gives you full control over your data while cutting costs. To make the transition as seamless as possible, we've created a comprehensive migration guide. 
+Moving from Datadog to an OpenTelemetry-native platform gives you full control over your data while cutting costs. To make the transition as seamless as possible, we've created a comprehensive migration guide.
 
 It provides a step-by-step plan for transitioning all your key signals—metrics, traces, and logs—with practical instructions for handling custom DogStatsD metrics and importing pre-built dashboards.
 
@@ -162,4 +181,4 @@ You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for in
 
 ¹For example, if you run **100 APM hosts**, list pricing puts the **platform portion at roughly \$3,500/month** (100 × \$35/host on annual APM Pro), **before** usage. You’ll then pay **APM Ingested Spans (per-GB)** and **Indexed Spans (per 1M spans, 15–30 day options)**, which can materially increase spend depending on traffic and retention choices. ([source: Datadog](https://www.datadoghq.com/pricing/list/))
 
-²By default, Datadog uses **head-based sampling** with a target of about **10 traces/second per Agent**, and an additional **error-trace sampling target of ~10 errors/second per Agent**. These are **remotely configurable** on Agent 7.42+ and can be tuned in the UI via **Ingestion Controls**, **Retention Filters** (for “keep errors/slow endpoints”), and **Adaptive Sampling** to retain important traces without ingesting everything. The trade-off between cost and completeness still exists, but Datadog provides controls to bias retention toward the traces you care about. ([source: Datadog](https://docs.datadoghq.com/tracing/guide/ingestion_sampling_use_cases/))
\ No newline at end of file
+²By default, Datadog uses **head-based sampling** with a target of about **10 traces/second per Agent**, and an additional **error-trace sampling target of ~10 errors/second per Agent**. These are **remotely configurable** on Agent 7.42+ and can be tuned in the UI via **Ingestion Controls**, **Retention Filters** (for “keep errors/slow endpoints”), and **Adaptive Sampling** to retain important traces without ingesting everything. The trade-off between cost and completeness still exists, but Datadog provides controls to bias retention toward the traces you care about. ([source: Datadog](https://docs.datadoghq.com/tracing/guide/ingestion_sampling_use_cases/))
diff --git a/data/guides/default-logging-file-for-spring-boot-application.mdx b/data/guides/default-logging-file-for-spring-boot-application.mdx
index 6fbf07fdd..87af90e86 100644
--- a/data/guides/default-logging-file-for-spring-boot-application.mdx
+++ b/data/guides/default-logging-file-for-spring-boot-application.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Configure Default Log Files - Spring Boot Logging
-slug: default-logging-file-for-spring-boot-application
 date: 2024-08-30
 tags: [faq]
 authors: [niyati_thakkar]
 description: Learn how to configure default log files in Spring Boot applications. Explore logging best practices, file management, and advanced techniques for effective application monitoring.
-keywords: [Spring Boot logging, log file configuration, application monitoring, Java logging, DevOps, log management, SigNoz]
-
+keywords:
+  [
+    test,
+    Spring Boot logging,
+    log file configuration,
+    application monitoring,
+    Java logging,
+    DevOps,
+    log management,
+    SigNoz,
+  ]
 ---
 
 Spring Boot's logging capabilities are essential for effective application monitoring and troubleshooting. However, many developers struggle with configuring log files properly, often relying on console output alone. This comprehensive guide will walk you through the process of setting up and managing default log files in your Spring Boot application, ensuring you have the tools necessary for robust application monitoring and maintenance.
@@ -41,7 +48,11 @@ public class DemoApplication {
 }
 ```
 
-<Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-Screenshot_2024-08-25_132022.webp" alt="Understanding Spring Boot's Default Logging Behavior" caption="Understanding Spring Boot's Default Logging Behavior" />
+<Figure
+  src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-Screenshot_2024-08-25_132022.webp"
+  alt="Understanding Spring Boot's Default Logging Behavior"
+  caption="Understanding Spring Boot's Default Logging Behavior"
+/>
 
 Some of the observations that can be drawn are:
 
@@ -77,30 +88,37 @@ To move beyond default console-only logging, we can use configuration files to c
 To set up logging in a Spring Boot application, you can make use of the `application.properties` file. Here's a step-by-step guide:
 
 1. Open Your `application.properties` File:
-    - This file is typically located in the `src/main/resources` directory of your Spring Boot project.
+   - This file is typically located in the `src/main/resources` directory of your Spring Boot project.
 2. Add the Following Properties to configure the file name, location, and log level:
-    
-    ```
-    # Application name
-    spring.application.name=demo
-    
-    # Global log level
-    logging.level.root=ERROR
-    
-    # Base log file name
-    logging.file.name=./logs/demofile.log
-    ```
-    
-    <Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-Screenshot_2024-08-28_220037.webp" alt="Console Output" caption="Console Output" />
-    
-    <Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-image.webp" alt="This is the output we will get after running the application, in this `demofile.log`." caption="This is the output we will get after running the application, in this `demofile.log`." />
-    
-    - `spring.application.name=demo`: Sets the application name.
-    - `logging.file.name=./logs/demofile.log`: Creates a log file named `demofile.log` in the logs directory.
-    - `logging.level.root=ERROR`: Limits logs to errors only, reducing log clutter.
-    
-    After running the application, you’ll see `demofile.log` in the project directory, containing only error-level logs.
-    
+
+   ```
+   # Application name
+   spring.application.name=demo
+
+   # Global log level
+   logging.level.root=ERROR
+
+   # Base log file name
+   logging.file.name=./logs/demofile.log
+   ```
+
+   <Figure
+     src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-Screenshot_2024-08-28_220037.webp"
+     alt="Console Output"
+     caption="Console Output"
+   />
+
+   <Figure
+     src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-image.webp"
+     alt="This is the output we will get after running the application, in this `demofile.log`."
+     caption="This is the output we will get after running the application, in this `demofile.log`."
+   />
+
+   - `spring.application.name=demo`: Sets the application name.
+   - `logging.file.name=./logs/demofile.log`: Creates a log file named `demofile.log` in the logs directory.
+   - `logging.level.root=ERROR`: Limits logs to errors only, reducing log clutter.
+
+   After running the application, you’ll see `demofile.log` in the project directory, containing only error-level logs.
 
 ### Implementing Rolling File Appenders with Logback
 
@@ -132,13 +150,17 @@ Explanation of Configuration:
 
 - `logging.file.name`: Sets the base filename and location for log files (e.g., `demofile.log`).
 - `logging.logback.rollingpolicy`: Controls how log files are rotated:
-    - `file-name-pattern`: Defines the format for rolled file names (`%d{yyyy-MM-dd}` creates daily files).
-    - `max-file-size`: Maximum size for each log file (e.g., 10MB). A new file is created when reached.
-    - `total-size-cap`: Total size limit for all log files (e.g., 1GB). Older files are deleted if exceeded.
-    - `max-history`: Maximum number of log files to keep (e.g., 7 days). Older files were deleted to maintain this limit.
-    - `clean-history-on-start`: Clears old log files exceeding limits on application startup (disable in production!).
-
-<Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-5bb57452-de7f-4549-9f61-78bd101a9761.webp" alt="Implementing Rolling File Appenders with Logback" caption="Implementing Rolling File Appenders with Logback" />
+  - `file-name-pattern`: Defines the format for rolled file names (`%d{yyyy-MM-dd}` creates daily files).
+  - `max-file-size`: Maximum size for each log file (e.g., 10MB). A new file is created when reached.
+  - `total-size-cap`: Total size limit for all log files (e.g., 1GB). Older files are deleted if exceeded.
+  - `max-history`: Maximum number of log files to keep (e.g., 7 days). Older files were deleted to maintain this limit.
+  - `clean-history-on-start`: Clears old log files exceeding limits on application startup (disable in production!).
+
+<Figure
+  src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-5bb57452-de7f-4549-9f61-78bd101a9761.webp"
+  alt="Implementing Rolling File Appenders with Logback"
+  caption="Implementing Rolling File Appenders with Logback"
+/>
 
 In the above example, we have set the log file rolling policy to create a new file every minute for demonstration.
 
@@ -152,7 +174,11 @@ logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread/%X{userId}] %-7leve
 
 This modified log pattern adds milliseconds to the timestamp, combines thread and user ID info, uses a wider log level field for alignment, shortens the logger name for compactness, and includes the filename and line number to trace log entries precisely.
 
-<Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-image%201.webp" alt="Customizing Log Format and Patterns" caption="Customizing Log Format and Patterns" />
+<Figure
+  src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-image%201.webp"
+  alt="Customizing Log Format and Patterns"
+  caption="Customizing Log Format and Patterns"
+/>
 
 Consistent log formatting ensures that logs are easy to read, analyze, and parse, making debugging and monitoring more efficient.
 
@@ -248,163 +274,169 @@ Configuring Logging using `logback.xml`
 To set up logging in a Spring Boot application using `logback.xml`, follow these steps:
 
 1. Create a `logback.xml` File
-    - Place this file in the `src/main/resources` directory of your Spring Boot project.
+   - Place this file in the `src/main/resources` directory of your Spring Boot project.
 2. Add the Following Configuration:
-    
-    ```xml
-    <configuration>
-        <appender name="FILE" class="ch.qos.logback.core.FileAppender">
-            <file>myapp2.log</file>
-            <encoder>
-                <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-            </encoder>
-        </appender>
-    
-        <root level="DEBUG">
-            <appender-ref ref="FILE" />
-        </root>
-    </configuration>
-    ```
-    
-    - `<file>myapp2.log</file>`: Specifies the log file name.
-    - `<root level="ERROR">`: Sets the root log level to `DEBUG`, so DEBUG and higher level logs are captured.
-    - The pattern for the file appender formats each log entry to include the date and time, log level, logger name (up to 36 characters), and the log message and ends with a newline for clarity and readability in the log file.
+
+   ```xml
+   <configuration>
+       <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+           <file>myapp2.log</file>
+           <encoder>
+               <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+           </encoder>
+       </appender>
+
+       <root level="DEBUG">
+           <appender-ref ref="FILE" />
+       </root>
+   </configuration>
+   ```
+
+   - `<file>myapp2.log</file>`: Specifies the log file name.
+   - `<root level="ERROR">`: Sets the root log level to `DEBUG`, so DEBUG and higher level logs are captured.
+   - The pattern for the file appender formats each log entry to include the date and time, log level, logger name (up to 36 characters), and the log message and ends with a newline for clarity and readability in the log file.
+
 3. Modify logging as follows:
-    
-    We will use slf4j to use Logback for logging.
-    
-    ```java
-    package com.example.demo;
-    
-    import org.slf4j.Logger;
-    import org.slf4j.LoggerFactory;
-    import org.springframework.boot.SpringApplication;
-    import org.springframework.boot.autoconfigure.SpringBootApplication;
-    
-    @SpringBootApplication
-    public class DemoApplication {
-    
-        private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
-    
-        public static void main(String[] args) {
-            SpringApplication.run(DemoApplication.class, args);
-            
-            // Log messages using SLF4J
-            logger.error("error log");   
-            logger.warn("warning log");  
-            logger.info("info log");     
-            logger.debug("debug log");   
-            logger.trace("trace log");   
-        }
-    }
-    
-    ```
-    
-    <Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-d1fc62b5-2feb-4840-89e4-da7f9b02d3a1.webp" alt="Configuring Logging using `logback.xml`" caption="Configuring Logging using `logback.xml`" />
-    
-    After running the application, `myapp2.log` will be created in the base directory, containing debug and higher-level logs in the specified format.
-    
+
+   We will use slf4j to use Logback for logging.
+
+   ```java
+   package com.example.demo;
+
+   import org.slf4j.Logger;
+   import org.slf4j.LoggerFactory;
+   import org.springframework.boot.SpringApplication;
+   import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+   @SpringBootApplication
+   public class DemoApplication {
+
+       private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
+
+       public static void main(String[] args) {
+           SpringApplication.run(DemoApplication.class, args);
+
+           // Log messages using SLF4J
+           logger.error("error log");
+           logger.warn("warning log");
+           logger.info("info log");
+           logger.debug("debug log");
+           logger.trace("trace log");
+       }
+   }
+
+   ```
+
+   <Figure
+     src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-d1fc62b5-2feb-4840-89e4-da7f9b02d3a1.webp"
+     alt="Configuring Logging using `logback.xml`"
+     caption="Configuring Logging using `logback.xml`"
+   />
+
+   After running the application, `myapp2.log` will be created in the base directory, containing debug and higher-level logs in the specified format.
+
 4. Implementing Conditional Logging Based on Profiles
-    
-    We can configure Logback to apply different logging configurations based on the active Spring profile using the `<springProfile>` tag. This allows you to define separate logging behaviors for development, testing, and production environments.
-    
-    Example `logback-spring.xml`:
-    
-    ```xml
-    <configuration>
-    
-        <!-- Default profile: logs INFO level and higher to the console -->
-        <springProfile name="default">
-            <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
-                <encoder>
-                    <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-                </encoder>
-            </appender>
-    
-            <root level="INFO">
-                <appender-ref ref="CONSOLE" />
-            </root>
-        </springProfile>
-    
-        <!-- Development profile: logs DEBUG level and higher to the console -->
-        <springProfile name="dev">
-            <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
-                <encoder>
-                    <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-                </encoder>
-            </appender>
-    
-            <root level="DEBUG">
-                <appender-ref ref="CONSOLE" />
-            </root>
-        </springProfile>
-    
-        <!-- Production profile: logs WARN level and higher to a file -->
-        <springProfile name="prod">
-            <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-                <file>logs/app.log</file>
-                <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-                    <fileNamePattern>logs/app.%d{yyyy-MM-dd}.log</fileNamePattern>
-                    <maxHistory>30</maxHistory>
-                </rollingPolicy>
-                <encoder>
-                    <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-                </encoder>
-            </appender>
-    
-            <root level="WARN">
-                <appender-ref ref="FILE" />
-            </root>
-        </springProfile>
-    
-    </configuration>
-    
-    ```
-    
-    Explanation:
-    
-    - Default Profile: Logs `INFO` level and above to the console.
-    - Development Profile (`dev`): Logs `DEBUG` level and above to the console, useful for detailed debugging during development.
-    - Production Profile (`prod`): Logs `WARN` level and above to a file, reducing verbosity and focusing on more critical issues in production.
+
+   We can configure Logback to apply different logging configurations based on the active Spring profile using the `<springProfile>` tag. This allows you to define separate logging behaviors for development, testing, and production environments.
+
+   Example `logback-spring.xml`:
+
+   ```xml
+   <configuration>
+
+       <!-- Default profile: logs INFO level and higher to the console -->
+       <springProfile name="default">
+           <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+               <encoder>
+                   <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+               </encoder>
+           </appender>
+
+           <root level="INFO">
+               <appender-ref ref="CONSOLE" />
+           </root>
+       </springProfile>
+
+       <!-- Development profile: logs DEBUG level and higher to the console -->
+       <springProfile name="dev">
+           <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+               <encoder>
+                   <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+               </encoder>
+           </appender>
+
+           <root level="DEBUG">
+               <appender-ref ref="CONSOLE" />
+           </root>
+       </springProfile>
+
+       <!-- Production profile: logs WARN level and higher to a file -->
+       <springProfile name="prod">
+           <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+               <file>logs/app.log</file>
+               <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+                   <fileNamePattern>logs/app.%d{yyyy-MM-dd}.log</fileNamePattern>
+                   <maxHistory>30</maxHistory>
+               </rollingPolicy>
+               <encoder>
+                   <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+               </encoder>
+           </appender>
+
+           <root level="WARN">
+               <appender-ref ref="FILE" />
+           </root>
+       </springProfile>
+
+   </configuration>
+
+   ```
+
+   Explanation:
+
+   - Default Profile: Logs `INFO` level and above to the console.
+   - Development Profile (`dev`): Logs `DEBUG` level and above to the console, useful for detailed debugging during development.
+   - Production Profile (`prod`): Logs `WARN` level and above to a file, reducing verbosity and focusing on more critical issues in production.
+
 5. Utilizing Logback's Built-In Filtering Mechanisms
-    
-    Logback allows you to apply filters to loggers or appenders to fine-tune what gets logged. For instance, you might want to exclude `DEBUG` level logs from being written to a file while still logging `INFO` and higher levels.
-    
-    Example `logback-spring.xml`:
-    
-    ```xml
-    <configuration>
-    
-        <!-- File Appender with a Level Filter -->
-        <appender name="FILTERED_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-            <file>logs/filtered-app.log</file>
-            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-                <fileNamePattern>logs/filtered-app.%d{yyyy-MM-dd}.log</fileNamePattern>
-                <maxHistory>30</maxHistory>
-            </rollingPolicy>
-            <encoder>
-                <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-            </encoder>
-    
-            <!-- Exclude DEBUG logs from being written to this file -->
-            <filter class="ch.qos.logback.classic.filter.LevelFilter">
-                <level>DEBUG</level>
-                <onMatch>DENY</onMatch>
-                <onMismatch>ACCEPT</onMismatch>
-            </filter>
-        </appender>
-    
-        <root level="DEBUG">
-            <appender-ref ref="FILTERED_FILE" />
-        </root>
-    </configuration>
-    
-    ```
-    
-    Explanation:
-    
-    - File Appender with Filtering: The appender writes logs to `logs/filtered-app.log`, but it excludes `DEBUG`-level logs.
-    - The filter is applied using `<filter class="ch.qos.logback.classic.filter.LevelFilter">`, where `onMatch="DENY"` prevents `DEBUG` logs from being recorded in the file.
+
+   Logback allows you to apply filters to loggers or appenders to fine-tune what gets logged. For instance, you might want to exclude `DEBUG` level logs from being written to a file while still logging `INFO` and higher levels.
+
+   Example `logback-spring.xml`:
+
+   ```xml
+   <configuration>
+
+       <!-- File Appender with a Level Filter -->
+       <appender name="FILTERED_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+           <file>logs/filtered-app.log</file>
+           <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+               <fileNamePattern>logs/filtered-app.%d{yyyy-MM-dd}.log</fileNamePattern>
+               <maxHistory>30</maxHistory>
+           </rollingPolicy>
+           <encoder>
+               <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+           </encoder>
+
+           <!-- Exclude DEBUG logs from being written to this file -->
+           <filter class="ch.qos.logback.classic.filter.LevelFilter">
+               <level>DEBUG</level>
+               <onMatch>DENY</onMatch>
+               <onMismatch>ACCEPT</onMismatch>
+           </filter>
+       </appender>
+
+       <root level="DEBUG">
+           <appender-ref ref="FILTERED_FILE" />
+       </root>
+   </configuration>
+
+   ```
+
+   Explanation:
+
+   - File Appender with Filtering: The appender writes logs to `logs/filtered-app.log`, but it excludes `DEBUG`-level logs.
+   - The filter is applied using `<filter class="ch.qos.logback.classic.filter.LevelFilter">`, where `onMatch="DENY"` prevents `DEBUG` logs from being recorded in the file.
 
 ### Implementing Multiple Log Files
 
@@ -579,31 +611,34 @@ To get started with SigNoz:
 Once [SigNoz](https://signoz.io/docs/introduction/) is set up, configure your Spring Boot application to send logs to SigNoz:
 
 1. Setting Up SigNoz
-    
-    We have two options: we can use SigNoz cloud or self-host SigNoz.
-    
-    <GetStartedSigNoz />
-    
+
+   We have two options: we can use SigNoz cloud or self-host SigNoz.
+
+   <GetStartedSigNoz />
+
 2. Downloading [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Java Agent JAR
-    
-    ```
-    wget <https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar>
-    ```
-    
+
+   ```
+   wget <https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar>
+   ```
+
 3. Running the application with environment variable for collecting logs
-    
-    ```
-    OTEL_LOGS_EXPORTER=otlp \\
-    OTEL_RESOURCE_ATTRIBUTES=service.name=spring-boot-app
-    OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key="7XXXXX7-6XXxX-45ff-9XX1-3bXxXXf9cdc3" \\
-    OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.in.signoz.cloud:443 \\
-    java -javaagent:java-agent/opentelemetry-javaagent.jar -jar target/*.jar
-    ```
-    
+
+   ```
+   OTEL_LOGS_EXPORTER=otlp \\
+   OTEL_RESOURCE_ATTRIBUTES=service.name=spring-boot-app
+   OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key="7XXXXX7-6XXxX-45ff-9XX1-3bXxXXf9cdc3" \\
+   OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.in.signoz.cloud:443 \\
+   java -javaagent:java-agent/opentelemetry-javaagent.jar -jar target/*.jar
+   ```
 
 The Logs tab in SigNoz is used to see the logs of our Spring Boot application
 
-<Figure src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-opentelemetry-spring-boot-logs-apply-filter.webp" alt="Logs tab in SigNoz, Spring Boot Application" caption="Logs tab in SigNoz, Spring Boot Application" />
+<Figure
+  src="/img/guides/2024/08/default-logging-file-for-spring-boot-application-opentelemetry-spring-boot-logs-apply-filter.webp"
+  alt="Logs tab in SigNoz, Spring Boot Application"
+  caption="Logs tab in SigNoz, Spring Boot Application"
+/>
 
 With this setup, you can leverage SigNoz's powerful features for log analysis and correlation, enhancing your application's observability.
 
@@ -612,27 +647,27 @@ With this setup, you can leverage SigNoz's powerful features for log analysis an
 Even with proper configuration, you might encounter logging issues. Here are some common problems and their solutions:
 
 1. Missing log files:
-    - By default, Signoz logs only to the console, so no log files will be generated unless explicitly configured.
-    - Using the deprecated `logging.file` property instead of the correct current properties may prevent logs from being written to a file.
-    - Providing an incorrect or non-existent file path can lead to missing log files.
-    - Ensure the application has the necessary write permissions for the specified log directory.
-    - Verify that the application has enough available disk space to write the log files.
+   - By default, Signoz logs only to the console, so no log files will be generated unless explicitly configured.
+   - Using the deprecated `logging.file` property instead of the correct current properties may prevent logs from being written to a file.
+   - Providing an incorrect or non-existent file path can lead to missing log files.
+   - Ensure the application has the necessary write permissions for the specified log directory.
+   - Verify that the application has enough available disk space to write the log files.
 2. Incorrect log levels:
-    - Verify your logging configuration in `application.properties` or `logback-spring.xml`
-    - Setting `logging.level.root=DEBUG` increases the verbosity of all logs, even if other log levels are set lower. This ensures that all messages, including debug information, are captured for troubleshooting.
+   - Verify your logging configuration in `application.properties` or `logback-spring.xml`
+   - Setting `logging.level.root=DEBUG` increases the verbosity of all logs, even if other log levels are set lower. This ensures that all messages, including debug information, are captured for troubleshooting.
 3. Performance issues related to logging:
-    - Each log statement adds overhead, increasing latency and resource use in microservices.
-    - Large volumes of logs require efficient storage and can add network overhead in distributed systems.
-    - Inappropriate log levels and verbosity can degrade performance; adjust as needed.
-    - Benchmark, profile, and use distributed tracing to measure logging's impact and identify bottlenecks.
-    - Implement asynchronous logging to reduce the impact on response times.
-    - Use log aggregation, compression, and dynamic logging configuration to optimize performance and storage.
+   - Each log statement adds overhead, increasing latency and resource use in microservices.
+   - Large volumes of logs require efficient storage and can add network overhead in distributed systems.
+   - Inappropriate log levels and verbosity can degrade performance; adjust as needed.
+   - Benchmark, profile, and use distributed tracing to measure logging's impact and identify bottlenecks.
+   - Implement asynchronous logging to reduce the impact on response times.
+   - Use log aggregation, compression, and dynamic logging configuration to optimize performance and storage.
 4. Log file permission problems:
-    - If the issue occurs during testing, consider maintaining a separate configuration file specifically for testing. This allows you to generate a separate log file tailored for the testing environment.
-    - When running multiple modules on the same server, you can distinguish log files by including the process ID (PID) in the log file names. This ensures that each module logs separately.
-    - The issue might also stem from missing permissions or incorrect path specifications. Ensure the log file paths are correct and that the application has the necessary permissions to write to the specified locations. Use `chmod` to adjust file permissions if needed.
+   - If the issue occurs during testing, consider maintaining a separate configuration file specifically for testing. This allows you to generate a separate log file tailored for the testing environment.
+   - When running multiple modules on the same server, you can distinguish log files by including the process ID (PID) in the log file names. This ensures that each module logs separately.
+   - The issue might also stem from missing permissions or incorrect path specifications. Ensure the log file paths are correct and that the application has the necessary permissions to write to the specified locations. Use `chmod` to adjust file permissions if needed.
 
-By addressing these common issues, you can ensure your Spring Boot application's logging system operates smoothly and effectively. 
+By addressing these common issues, you can ensure your Spring Boot application's logging system operates smoothly and effectively.
 
 ## FAQs
 
@@ -654,4 +689,4 @@ Yes, you can configure multiple log files using a custom `logback-spring.xml` co
 
 ### How can I implement log rotation in Spring Boot?
 
-Use the `logging.logback.rollingpolicy.*` properties in your `application.properties` file to configure log rotation. For more advanced rotation policies, use a custom `logback-spring.xml` configuration.
\ No newline at end of file
+Use the `logging.logback.rollingpolicy.*` properties in your `application.properties` file to configure log rotation. For more advanced rotation policies, use a custom `logback-spring.xml` configuration.
diff --git a/data/guides/devops-monitoring-tools.mdx b/data/guides/devops-monitoring-tools.mdx
index 889ba6be9..09c1fa1d9 100644
--- a/data/guides/devops-monitoring-tools.mdx
+++ b/data/guides/devops-monitoring-tools.mdx
@@ -1,37 +1,44 @@
 ---
-
 title: Top 15 DevOps Monitoring Tools for Efficient Workflows in 2025
-slug: devops-monitoring-tools
 date: 2025-01-02
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover the top 15 DevOps monitoring tools for 2024. Learn how to choose and implement the right solution for efficient workflows and improved performance.
-keywords: [DevOps monitoring, performance tools, application monitoring, infrastructure monitoring, observability, SigNoz, open-source monitoring]
-
+keywords:
+  [
+    DevOps monitoring,
+    performance tools,
+    application monitoring,
+    infrastructure monitoring,
+    observability,
+    SigNoz,
+    open-source monitoring,
+  ]
 ---
+
 DevOps monitoring technologies are critical for ensuring the efficiency and reliability of software delivery pipelines. As more firms adopt DevOps approaches, the need for effective monitoring solutions grows. This article reviews the top 15 DevOps monitoring tools for 2024, outlining their important features and providing advice on how to choose the best tool for your unique requirements.
 
 ## Quick Comparison of Top DevOps Monitoring Tools
 
 To help you quickly grasp the key features and differences among the top 15 DevOps monitoring tools, a comparison table has been provided below.
 
-| Tool | Type | Infrastructure Monitoring | Application Monitoring | Log Management | Alerting | Pricing Model |
-| --- | --- | --- | --- | --- | --- | --- |
-| SigNoz | Open-source, Full-stack monitoring | Yes | Yes | Yes | Yes | Free (Self-hosted), Paid (Cloud) |
-| Prometheus | Open-source Monitoring | Yes | No | No | Yes | Free (Self-hosted) |
-| Grafana | Open-source Visualization | Yes | Yes | No | Yes | Free (Open-source), Paid (Cloud) |
-| Datadog | Cloud-based, Full-stack monitoring | Yes | Yes | Yes | Yes | Subscription-based |
-| New Relic | Cloud-based, Full-stack observability | Yes | Yes | Yes | Yes | Subscription-based |
-| Vultr | Cloud Infrastructure Provider | Yes | No | No | Yes | Pay-as-you-go |
-| Linode (Akamai Connected Cloud) | Cloud Infrastructure Provider | Yes | No | No | No | Pay-as-you-go |
-| AWS | Cloud Infrastructure & Services | Yes | Yes | Yes | Yes | Pay-as-you-go, Subscription-based |
-| GCP | Cloud Infrastructure & Services | Yes | Yes | Yes | Yes | Pay-as-you-go, Subscription-based |
-| Azure | Cloud Infrastructure & Services | Yes | Yes | Yes | Yes | Pay-as-you-go, Subscription-based |
-| Kamatera | Cloud Infrastructure Provider | Yes | No | No | Yes | Pay-as-you-go |
-| Hostwinds | Managed Cloud Hosting | Yes | No | No | Yes | Subscription-based |
-| OVHcloud | Cloud Infrastructure Provider | Yes | No | No | Yes | Pay-as-you-go |
-| Hetzner Cloud | Cloud Infrastructure Provider | Yes | No | No | Yes | Pay-as-you-go |
-| Cloudways | Managed Cloud Hosting | Yes | No | No | Yes | Subscription-based |
+| Tool                            | Type                                  | Infrastructure Monitoring | Application Monitoring | Log Management | Alerting | Pricing Model                     |
+| ------------------------------- | ------------------------------------- | ------------------------- | ---------------------- | -------------- | -------- | --------------------------------- |
+| SigNoz                          | Open-source, Full-stack monitoring    | Yes                       | Yes                    | Yes            | Yes      | Free (Self-hosted), Paid (Cloud)  |
+| Prometheus                      | Open-source Monitoring                | Yes                       | No                     | No             | Yes      | Free (Self-hosted)                |
+| Grafana                         | Open-source Visualization             | Yes                       | Yes                    | No             | Yes      | Free (Open-source), Paid (Cloud)  |
+| Datadog                         | Cloud-based, Full-stack monitoring    | Yes                       | Yes                    | Yes            | Yes      | Subscription-based                |
+| New Relic                       | Cloud-based, Full-stack observability | Yes                       | Yes                    | Yes            | Yes      | Subscription-based                |
+| Vultr                           | Cloud Infrastructure Provider         | Yes                       | No                     | No             | Yes      | Pay-as-you-go                     |
+| Linode (Akamai Connected Cloud) | Cloud Infrastructure Provider         | Yes                       | No                     | No             | No       | Pay-as-you-go                     |
+| AWS                             | Cloud Infrastructure & Services       | Yes                       | Yes                    | Yes            | Yes      | Pay-as-you-go, Subscription-based |
+| GCP                             | Cloud Infrastructure & Services       | Yes                       | Yes                    | Yes            | Yes      | Pay-as-you-go, Subscription-based |
+| Azure                           | Cloud Infrastructure & Services       | Yes                       | Yes                    | Yes            | Yes      | Pay-as-you-go, Subscription-based |
+| Kamatera                        | Cloud Infrastructure Provider         | Yes                       | No                     | No             | Yes      | Pay-as-you-go                     |
+| Hostwinds                       | Managed Cloud Hosting                 | Yes                       | No                     | No             | Yes      | Subscription-based                |
+| OVHcloud                        | Cloud Infrastructure Provider         | Yes                       | No                     | No             | Yes      | Pay-as-you-go                     |
+| Hetzner Cloud                   | Cloud Infrastructure Provider         | Yes                       | No                     | No             | Yes      | Pay-as-you-go                     |
+| Cloudways                       | Managed Cloud Hosting                 | Yes                       | No                     | No             | Yes      | Subscription-based                |
 
 Now let's dive deep into what DevOps monitoring involves and explore each tool in detail.
 
@@ -73,386 +80,491 @@ So far we have discussed monitoring and its importance in terms of DevOps. Let u
 
 ### 1. SigNoz (Open-Source, Full-stack Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image.webp" alt="SigNoz" caption="SigNoz" /> 
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image.webp"
+  alt="SigNoz"
+  caption="SigNoz"
+/>{' '}
 
-[SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability platform designed to help you monitor and debug your applications. SigNoz is designed with a focus on providing visibility into the performance of your infrastructure and applications.  
+[SigNoz](https://signoz.io/) is an open-source application performance monitoring (APM) and observability platform designed to help you monitor and debug your applications. SigNoz is designed with a focus on providing visibility into the performance of your infrastructure and applications.
 
 - Key Features:
-    - Ingest Data: Ingest data from 50+ sources — send your data and start monitoring.
-    - Distributed Tracing: It tracks requests as they flow through services, providing deep insights into the performance of your microservices architecture.
-    - Metrics Monitoring: It collects and visualizes system metrics like CPU, memory, and disk usage in real-time.
-    - Log Management: It centralizes log data for easier troubleshooting and analysis.
-    - Correlated Signals: Correlated logs, metrics and traces for much richer context while debugging.
-        
-        <Figure src="/img/guides/2024/08/devops-monitoring-tools-image%201.webp" alt="image.webp" caption="image.webp" />
-        
-    - Custom Dashboards: It allows for personalized views of your data, making it easier to monitor key metrics.
-    - SigNoz Cloud: It offers a quick and easy deployment process with managed hosting and it also eliminates the need for on-premise setup.
+  - Ingest Data: Ingest data from 50+ sources — send your data and start monitoring.
+  - Distributed Tracing: It tracks requests as they flow through services, providing deep insights into the performance of your microservices architecture.
+  - Metrics Monitoring: It collects and visualizes system metrics like CPU, memory, and disk usage in real-time.
+  - Log Management: It centralizes log data for easier troubleshooting and analysis.
+  - Correlated Signals: Correlated logs, metrics and traces for much richer context while debugging.
+    {' '}
+    <Figure
+      src="/img/guides/2024/08/devops-monitoring-tools-image%201.webp"
+      alt="image.webp"
+      caption="image.webp"
+    />
+  - Custom Dashboards: It allows for personalized views of your data, making it easier to monitor key metrics.
+  - SigNoz Cloud: It offers a quick and easy deployment process with managed hosting and it also eliminates the need for on-premise setup.
 - Best For:
-    - It is best suited for organizations looking for a comprehensive, cost-effective, and open-source alternative to proprietary APM solutions with a native [opentelemetry](https://signoz.io/blog/what-is-opentelemetry/) support.
+  - It is best suited for organizations looking for a comprehensive, cost-effective, and open-source alternative to proprietary APM solutions with a native [opentelemetry](https://signoz.io/blog/what-is-opentelemetry/) support.
 - Community Support:
-    - It is an emerging tool, and SigNoz has a growing community. It has active forums, GitHub issues, and documentation, and a <a href="https://signoz.io/slack/" rel="noopener noreferrer nofollow" target="_blank">slack community</a> of over 4000+ people.
+  - It is an emerging tool, and SigNoz has a growing community. It has active forums, GitHub issues, and documentation, and a <a href="https://signoz.io/slack/" rel="noopener noreferrer nofollow" target="_blank">slack community</a> of over 4000+ people.
 - Performance:
-    - SigNoz performs well in monitoring and tracing, especially for microservices architectures. However, as with any newer tool, it may have performance limitations in extremely large or complex environments.
+  - SigNoz performs well in monitoring and tracing, especially for microservices architectures. However, as with any newer tool, it may have performance limitations in extremely large or complex environments.
 - Pricing:
-    - Being open-source, SigNoz is free to use, but costs can accrue from the infrastructure needed to run it. SigNoz Cloud offers a managed service with pricing tiers based on usage.
+  - Being open-source, SigNoz is free to use, but costs can accrue from the infrastructure needed to run it. SigNoz Cloud offers a managed service with pricing tiers based on usage.
 - Common Problems:
-    - SigNoz does not have the same out of the box support like other costly proprietary solutions.
+  - SigNoz does not have the same out of the box support like other costly proprietary solutions.
 
 ### 2. Prometheus (Open-Source, System Monitoring and Alerting)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%202.webp" alt="Prometheus" caption="Prometheus (credits: prometheus.io)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%202.webp"
+  alt="Prometheus"
+  caption="Prometheus (credits: prometheus.io)"
+/>
 
-
-<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">Prometheus</a> is a leading open-source monitoring and alerting toolkit, primarily designed for reliability and scalability. It’s widely used in the DevOps community for collecting and querying metrics from various systems, and it integrates seamlessly with cloud-native architectures.
+<a href="https://prometheus.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Prometheus
+</a> is a leading open-source monitoring and alerting toolkit, primarily designed for reliability
+and scalability. It’s widely used in the DevOps community for collecting and querying metrics from
+various systems, and it integrates seamlessly with cloud-native architectures.
 
 - Key Features:
-    - Multidimensional Data Model: It allows capturing rich, high-dimensional data for detailed analysis.
-    - PromQL: It is a powerful query language for aggregating and analyzing time-series data.
-    - Built-in Alerting: It supports defining alerting rules and sending notifications based on metric thresholds.
-    - Service Discovery: It automatically discovers targets from cloud providers, Kubernetes, and more.
-    - Wide Ecosystem: Prometheus supports a vast array of exporters, enabling monitoring for virtually any system or application.
+  - Multidimensional Data Model: It allows capturing rich, high-dimensional data for detailed analysis.
+  - PromQL: It is a powerful query language for aggregating and analyzing time-series data.
+  - Built-in Alerting: It supports defining alerting rules and sending notifications based on metric thresholds.
+  - Service Discovery: It automatically discovers targets from cloud providers, Kubernetes, and more.
+  - Wide Ecosystem: Prometheus supports a vast array of exporters, enabling monitoring for virtually any system or application.
 - Best For:
-    - It is best suited for organizations seeking a highly scalable and reliable monitoring solution, particularly for containerized and microservices architectures.
+  - It is best suited for organizations seeking a highly scalable and reliable monitoring solution, particularly for containerized and microservices architectures.
 - Community Support:
-    - Prometheus has a large and active community, with comprehensive documentation, forums, and numerous tutorials available. The community also contributes to a wide array of exporters and integrations.
+  - Prometheus has a large and active community, with comprehensive documentation, forums, and numerous tutorials available. The community also contributes to a wide array of exporters and integrations.
 - Performance:
-    - It is known for its robustness and ability to handle large-scale systems with high performance. However, storage can become a challenge in very large setups, often requiring integration with long-term storage solutions.
+  - It is known for its robustness and ability to handle large-scale systems with high performance. However, storage can become a challenge in very large setups, often requiring integration with long-term storage solutions.
 - Pricing:
-    - As an open-source tool, Prometheus is free to use. Costs are associated with the infrastructure required to run Prometheus and any additional tools for long-term storage or high availability.
+  - As an open-source tool, Prometheus is free to use. Costs are associated with the infrastructure required to run Prometheus and any additional tools for long-term storage or high availability.
 - Common Problems:
-    - It has a steep learning curve, especially in mastering PromQL and configuring alerting rules. Apart from this, handling [high cardinality metrics](https://signoz.io/blog/high-cardinality-data/) can lead to performance issues.
+  - It has a steep learning curve, especially in mastering PromQL and configuring alerting rules. Apart from this, handling [high cardinality metrics](https://signoz.io/blog/high-cardinality-data/) can lead to performance issues.
 - Potential Drawback:
-    - Prometheus is not a “plug-and-play” solution; it requires significant setup and maintenance and may need additional tools for long-term storage and scaling.
+  - Prometheus is not a “plug-and-play” solution; it requires significant setup and maintenance and may need additional tools for long-term storage and scaling.
 
 ### 3. Grafana (Open-Source, Visualization and Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%203.webp" alt="Grafana" caption="Grafana (credits: grafana)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%203.webp"
+  alt="Grafana"
+  caption="Grafana (credits: grafana)"
+/>
 
-<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> is a versatile open-source platform for monitoring and observability. It’s primarily known for its powerful and flexible dashboard capabilities, allowing users to visualize data from various sources in a unified interface.
+<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a> is a versatile open-source platform for monitoring and observability. It’s primarily known for
+its powerful and flexible dashboard capabilities, allowing users to visualize data from various
+sources in a unified interface.
 
 - Key Features:
-    - Customizable Dashboards: It supports a wide range of visualization types, from time-series graphs to heatmaps.
-    - Data Source Flexibility: It integrates with a variety of data sources, including Prometheus, Elasticsearch, and InfluxDB.
-    - Alerting: It allows setting up alerts that trigger when metrics meet specific conditions.
-    - Plugin Ecosystem: A large community-driven plugin ecosystem that extends Grafana’s capabilities with additional visualizations, data sources, and tools.
+  - Customizable Dashboards: It supports a wide range of visualization types, from time-series graphs to heatmaps.
+  - Data Source Flexibility: It integrates with a variety of data sources, including Prometheus, Elasticsearch, and InfluxDB.
+  - Alerting: It allows setting up alerts that trigger when metrics meet specific conditions.
+  - Plugin Ecosystem: A large community-driven plugin ecosystem that extends Grafana’s capabilities with additional visualizations, data sources, and tools.
 - Best For:
-    - It is best suited for organizations looking to build custom dashboards tailored to their unique needs.
+  - It is best suited for organizations looking to build custom dashboards tailored to their unique needs.
 - Community Support:
-    - Grafana has a vast community with extensive resources, including forums, official documentation, and a marketplace of plugins. It’s widely adopted, which means there’s a wealth of knowledge and third-party support available.
+  - Grafana has a vast community with extensive resources, including forums, official documentation, and a marketplace of plugins. It’s widely adopted, which means there’s a wealth of knowledge and third-party support available.
 - Performance:
-    - It generally performs well, though it can become resource-intensive when handling very large datasets or complex dashboards.
+  - It generally performs well, though it can become resource-intensive when handling very large datasets or complex dashboards.
 - Pricing:
-    - Grafana is free as an open-source tool, but there are enterprise offerings with advanced features, support, and managed hosting.
+  - Grafana is free as an open-source tool, but there are enterprise offerings with advanced features, support, and managed hosting.
 - Common Problems:
-    - Complexity in configuring data sources and designing dashboards for beginners. Performance issues can arise with complex queries or when displaying data from multiple sources in real time.
+  - Complexity in configuring data sources and designing dashboards for beginners. Performance issues can arise with complex queries or when displaying data from multiple sources in real time.
 - Potential Drawback:
-    - While it excels at visualization, Grafana is not a full-stack monitoring solution. It often needs to be paired with other tools for a complete monitoring setup.
+  - While it excels at visualization, Grafana is not a full-stack monitoring solution. It often needs to be paired with other tools for a complete monitoring setup.
 
 ### 4. Datadog (SaaS, Full-Stack Monitoring and Security)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%204.webp" alt="Datadog" caption="Datadog (credits: datadoghq)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%204.webp"
+  alt="Datadog"
+  caption="Datadog (credits: datadoghq)"
+/>
 
-
-<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">Datadog</a> is a cloud-native, SaaS-based monitoring and security platform that provides full-stack observability for infrastructure, applications, and logs. It’s designed to offer comprehensive monitoring capabilities in a single, easy-to-use platform.
+<a href="https://www.datadoghq.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Datadog
+</a> is a cloud-native, SaaS-based monitoring and security platform that provides full-stack
+observability for infrastructure, applications, and logs. It’s designed to offer comprehensive
+monitoring capabilities in a single, easy-to-use platform.
 
 - Key Features:
-    - Infrastructure Monitoring: It monitors cloud environments, on-premises systems, and hybrid setups.
-    - Application Performance Monitoring (APM): It tracks application performance with distributed tracing and real-time analytics.
-    - Log Management: It collects, searches, and analyzes logs with powerful querying capabilities.
-    - Security Monitoring: It detects security threats across your environment with real-time alerting.
-    - AI-powered Anomaly Detection: It uses machine learning to detect unusual patterns in your metrics and logs.
+  - Infrastructure Monitoring: It monitors cloud environments, on-premises systems, and hybrid setups.
+  - Application Performance Monitoring (APM): It tracks application performance with distributed tracing and real-time analytics.
+  - Log Management: It collects, searches, and analyzes logs with powerful querying capabilities.
+  - Security Monitoring: It detects security threats across your environment with real-time alerting.
+  - AI-powered Anomaly Detection: It uses machine learning to detect unusual patterns in your metrics and logs.
 - Best For:
-    - It is best suited for organizations looking for a comprehensive, easy-to-use monitoring solution with extensive cloud and on-premises integration.
+  - It is best suited for organizations looking for a comprehensive, easy-to-use monitoring solution with extensive cloud and on-premises integration.
 - Community Support:
-    - Datadog has strong support through its extensive documentation, customer support, and an active user community. There are also numerous integrations and third-party tools available.
+  - Datadog has strong support through its extensive documentation, customer support, and an active user community. There are also numerous integrations and third-party tools available.
 - Performance:
-    - Datadog is known for its high performance and reliability, though the sheer volume of data it can process might require careful management to avoid high costs.
+  - Datadog is known for its high performance and reliability, though the sheer volume of data it can process might require careful management to avoid high costs.
 - Pricing:
-    - Datadog operates on a SaaS pricing model, with costs scaling based on the number of hosts, containers, and the volume of logs and metrics processed. Pricing can become expensive as you scale, especially with multiple modules in use.
+  - Datadog operates on a SaaS pricing model, with costs scaling based on the number of hosts, containers, and the volume of logs and metrics processed. Pricing can become expensive as you scale, especially with multiple modules in use.
 - Common Problems:
-    - The pricing model can be complex and costly for large environments. Additionally, some users report that while Datadog is feature-rich, it can be overwhelming to configure and navigate.
+  - The pricing model can be complex and costly for large environments. Additionally, some users report that while Datadog is feature-rich, it can be overwhelming to configure and navigate.
 - Potential Drawback:
-    - Cost can quickly escalate, particularly for larger organizations with extensive monitoring needs. Additionally, being a SaaS solution, there’s less flexibility compared to open-source tools.
+  - Cost can quickly escalate, particularly for larger organizations with extensive monitoring needs. Additionally, being a SaaS solution, there’s less flexibility compared to open-source tools.
 
 ### 5. New Relic (SaaS, Full-Stack Observability)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%205.webp" alt="New Relic" caption="New Relic (credits: newrelic)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%205.webp"
+  alt="New Relic"
+  caption="New Relic (credits: newrelic)"
+/>
 
-<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">New Relic</a> offers a full-stack observability platform that provides real-time performance insights across applications, infrastructure, and logs. It’s designed to help organizations monitor and improve their software performance, delivering deep visibility into the health of their systems.
+<a href="https://newrelic.com/" rel="noopener noreferrer nofollow" target="_blank">
+  New Relic
+</a> offers a full-stack observability platform that provides real-time performance insights across
+applications, infrastructure, and logs. It’s designed to help organizations monitor and improve
+their software performance, delivering deep visibility into the health of their systems.
 
 - Key Features:
-    - Full-Stack Observability: It monitors applications, infrastructure, logs, and more within a unified platform.
-    - Distributed Tracing: It provides end-to-end visibility into application performance, helping to identify and resolve issues quickly.
-    - AI-driven Insights: It utilized AI to detect anomalies and provide insights into performance issues.
-    - Custom Dashboards and Alerts: It allow creating custom views and alerts based on performance metrics.
-    - Real-time Performance Metrics: It delivers real-time analytics and reporting, supporting data-driven decision-making.
+  - Full-Stack Observability: It monitors applications, infrastructure, logs, and more within a unified platform.
+  - Distributed Tracing: It provides end-to-end visibility into application performance, helping to identify and resolve issues quickly.
+  - AI-driven Insights: It utilized AI to detect anomalies and provide insights into performance issues.
+  - Custom Dashboards and Alerts: It allow creating custom views and alerts based on performance metrics.
+  - Real-time Performance Metrics: It delivers real-time analytics and reporting, supporting data-driven decision-making.
 - Best For:
-    - It is best suited for enterprises that need a comprehensive observability solution with advanced analytics and AI-driven insights.
+  - It is best suited for enterprises that need a comprehensive observability solution with advanced analytics and AI-driven insights.
 - Community Support:
-    - New Relic has a strong community and customer support, with extensive documentation, forums, and a wide range of integrations. The platform is widely adopted, providing ample resources for learning and troubleshooting.
+  - New Relic has a strong community and customer support, with extensive documentation, forums, and a wide range of integrations. The platform is widely adopted, providing ample resources for learning and troubleshooting.
 - Performance:
-    - It is known for its robust performance and scalability, New Relic can handle large environments with complex monitoring needs. However, it can be resource-intensive, especially with extensive data collection.
+  - It is known for its robust performance and scalability, New Relic can handle large environments with complex monitoring needs. However, it can be resource-intensive, especially with extensive data collection.
 - Pricing:
-    - New Relic follows a usage-based pricing model, which can become expensive depending on the volume of data ingested and the number of users. There are also various tiers offering different levels of service.
+  - New Relic follows a usage-based pricing model, which can become expensive depending on the volume of data ingested and the number of users. There are also various tiers offering different levels of service.
 - Common Problems:
-    - Complexity in navigating the platform, especially for new users. The cost can become prohibitive for larger environments, and some users report challenges in customizing the platform to their specific needs.
+  - Complexity in navigating the platform, especially for new users. The cost can become prohibitive for larger environments, and some users report challenges in customizing the platform to their specific needs.
 - Potential Drawback:
-    - High cost, particularly as you scale and use more features. The platform’s depth and complexity might also require a steep learning curve for new users.
+  - High cost, particularly as you scale and use more features. The platform’s depth and complexity might also require a steep learning curve for new users.
 
 ### 6. Vultr (Cloud Infrastructure, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%206.webp" alt="Vultr" caption="Vultr (credits: vultr)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%206.webp"
+  alt="Vultr"
+  caption="Vultr (credits: vultr)"
+/>
 
-<a href="https://www.vultr.com/" rel="noopener noreferrer nofollow" target="_blank">Vultr</a> provides cloud infrastructure services, including computing, storage, and networking. It offers a built-in monitoring solution that allows users to track the performance of their instances and applications deployed on Vultr's cloud.
+<a href="https://www.vultr.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Vultr
+</a> provides cloud infrastructure services, including computing, storage, and networking. It offers
+a built-in monitoring solution that allows users to track the performance of their instances and
+applications deployed on Vultr's cloud.
 
 - Key Features:
-    - Real-Time Monitoring: It tracks CPU, memory, and disk usage of instances in real-time.
-    - Automated Alerts: It sends notifications when resources exceed defined thresholds.
-    - Customizable Dashboards: It allows users to create personalized views of their infrastructure.
-    - Integration with Third-Party Tools: It can be integrated with other monitoring tools like Prometheus or Grafana for advanced analytics.
+  - Real-Time Monitoring: It tracks CPU, memory, and disk usage of instances in real-time.
+  - Automated Alerts: It sends notifications when resources exceed defined thresholds.
+  - Customizable Dashboards: It allows users to create personalized views of their infrastructure.
+  - Integration with Third-Party Tools: It can be integrated with other monitoring tools like Prometheus or Grafana for advanced analytics.
 - Best For:
-    - It is best suited for users who have deployed their infrastructure on Vultr and need an integrated monitoring solution.
-    - Suited for small to medium-sized businesses looking for a straightforward cloud monitoring service.
+  - It is best suited for users who have deployed their infrastructure on Vultr and need an integrated monitoring solution.
+  - Suited for small to medium-sized businesses looking for a straightforward cloud monitoring service.
 - Community Support:
-    - Vultr has a growing community, with support through forums, documentation, and a support ticket system. However, it's less extensive than some larger platforms.
+  - Vultr has a growing community, with support through forums, documentation, and a support ticket system. However, it's less extensive than some larger platforms.
 - Performance:
-    - It performs well for monitoring cloud instances but may be limited in features compared to dedicated monitoring tools. Suitable for basic monitoring needs.
+  - It performs well for monitoring cloud instances but may be limited in features compared to dedicated monitoring tools. Suitable for basic monitoring needs.
 - Pricing:
-    - Monitoring is included as part of the Vultr cloud service, with costs based on the cloud resources used. Additional costs might arise if integrating with third-party tools.
+  - Monitoring is included as part of the Vultr cloud service, with costs based on the cloud resources used. Additional costs might arise if integrating with third-party tools.
 - Common Problems:
-    - Some users may find the built-in monitoring capabilities too basic, requiring additional tools for more detailed analysis. There can also be limitations in scaling and customization.
+  - Some users may find the built-in monitoring capabilities too basic, requiring additional tools for more detailed analysis. There can also be limitations in scaling and customization.
 - Potential Drawback:
-    - It is limited to Vultr’s ecosystem, making it less versatile for multi-cloud or on-premises environments.
+  - It is limited to Vultr’s ecosystem, making it less versatile for multi-cloud or on-premises environments.
 
 ### 7. Linode (Cloud Infrastructure, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%207.webp" alt="Linode" caption="Linode (credits: linode)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%207.webp"
+  alt="Linode"
+  caption="Linode (credits: linode)"
+/>
 
-
-<a href="https://www.linode.com/" rel="noopener noreferrer nofollow" target="_blank">Linode</a> is now part of Akamai Connected Cloud and offers cloud computing services along with integrated monitoring solutions. Users can monitor the performance and health of their virtual machines and applications directly from the Linode platform.
+<a href="https://www.linode.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Linode
+</a> is now part of Akamai Connected Cloud and offers cloud computing services along with integrated
+monitoring solutions. Users can monitor the performance and health of their virtual machines and
+applications directly from the Linode platform.
 
 - Key Features:
-    - Resource Monitoring: It tracks the usage of CPU, memory, and network resources on Linode instances.
-    - Automatic Alerts: It provides notifications when resource usage exceeds defined limits.
-    - API Access: It enables users to programmatically access monitoring data for automation and integration.
-    - Multi-Cloud Integration: It allows monitoring across Linode and other cloud platforms for hybrid setups.
+  - Resource Monitoring: It tracks the usage of CPU, memory, and network resources on Linode instances.
+  - Automatic Alerts: It provides notifications when resource usage exceeds defined limits.
+  - API Access: It enables users to programmatically access monitoring data for automation and integration.
+  - Multi-Cloud Integration: It allows monitoring across Linode and other cloud platforms for hybrid setups.
 - Best For:
-    - It is best suited for small to medium-sized businesses using Linode for cloud services and looking for a simple, integrated monitoring solution.
-    - It is also suited for developers and startups who need affordable cloud infrastructure with built-in monitoring.
+  - It is best suited for small to medium-sized businesses using Linode for cloud services and looking for a simple, integrated monitoring solution.
+  - It is also suited for developers and startups who need affordable cloud infrastructure with built-in monitoring.
 - Community Support:
-    - Linode has a strong and active community, with extensive documentation, forums, and support. As part of Akamai, additional resources are available for broader cloud solutions.
+  - Linode has a strong and active community, with extensive documentation, forums, and support. As part of Akamai, additional resources are available for broader cloud solutions.
 - Performance:
-    - It provides reliable performance for monitoring Linode instances, though it may lack the depth and granularity offered by more specialized monitoring tools.
+  - It provides reliable performance for monitoring Linode instances, though it may lack the depth and granularity offered by more specialized monitoring tools.
 - Pricing:
-    - Monitoring is included with Linode’s services, making it cost-effective. Additional costs might apply for more advanced features or third-party integrations.
+  - Monitoring is included with Linode’s services, making it cost-effective. Additional costs might apply for more advanced features or third-party integrations.
 - Common Problems:
-    - Some users may find the monitoring features limited in comparison to standalone tools. Scaling and customizability might also be concerns for larger deployments.
+  - Some users may find the monitoring features limited in comparison to standalone tools. Scaling and customizability might also be concerns for larger deployments.
 - Potential Drawback:
-    - Primarily tied to Linode’s ecosystem, which might not be ideal for users with multi-cloud or diverse infrastructure needs.
+  - Primarily tied to Linode’s ecosystem, which might not be ideal for users with multi-cloud or diverse infrastructure needs.
 
 ### 8. AWS or Amazon Web Services (Cloud Infrastructure, Full-stack Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%208.webp" alt="AWS" caption="AWS (credits: aws.amazon)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%208.webp"
+  alt="AWS"
+  caption="AWS (credits: aws.amazon)"
+/>
 
-<a href="https://aws.amazon.com/" rel="noopener noreferrer nofollow" target="_blank">AWS</a> offers a comprehensive suite of monitoring services, including Amazon CloudWatch, AWS X-Ray, and AWS CloudTrail. These tools provide extensive monitoring, logging, and tracing capabilities for applications and infrastructure deployed on AWS.
+<a href="https://aws.amazon.com/" rel="noopener noreferrer nofollow" target="_blank">
+  AWS
+</a> offers a comprehensive suite of monitoring services, including Amazon CloudWatch, AWS X-Ray,
+and AWS CloudTrail. These tools provide extensive monitoring, logging, and tracing capabilities for
+applications and infrastructure deployed on AWS.
 
 - Key Features:
-    - Amazon CloudWatch: It provides monitoring for AWS resources and applications, including metrics, logs, and events.
-    - AWS X-Ray: It offers distributed tracing for microservices applications, helping to identify performance bottlenecks.
-    - AWS CloudTrail: It tracks user activity and API usage across your AWS environment, enhancing security and compliance.
-    - Integration with AWS Services: It can seamlessly integrate with other AWS services for comprehensive monitoring and automation.
+  - Amazon CloudWatch: It provides monitoring for AWS resources and applications, including metrics, logs, and events.
+  - AWS X-Ray: It offers distributed tracing for microservices applications, helping to identify performance bottlenecks.
+  - AWS CloudTrail: It tracks user activity and API usage across your AWS environment, enhancing security and compliance.
+  - Integration with AWS Services: It can seamlessly integrate with other AWS services for comprehensive monitoring and automation.
 - Best For:
-    - It is best suited for enterprises and developers deeply integrated with the AWS ecosystem, seeking a full-stack monitoring solution tailored for AWS.
+  - It is best suited for enterprises and developers deeply integrated with the AWS ecosystem, seeking a full-stack monitoring solution tailored for AWS.
 - Community Support:
-    - AWS has a vast and active community, with extensive documentation, forums, user groups, and support options. Third-party support and resources are also widely available.
+  - AWS has a vast and active community, with extensive documentation, forums, user groups, and support options. Third-party support and resources are also widely available.
 - Performance:
-    - It is known for high performance and scalability, and AWS’s monitoring tools are robust enough to handle large-scale, complex environments. However, managing and optimizing these tools can require expertise.
+  - It is known for high performance and scalability, and AWS’s monitoring tools are robust enough to handle large-scale, complex environments. However, managing and optimizing these tools can require expertise.
 - Pricing:
-    - [AWS monitoring tools](https://signoz.io/comparisons/aws-monitoring-tools/) follow a pay-as-you-go model, with costs based on the number of metrics, logs, and traces collected. Costs can rise significantly with extensive usage.
+  - [AWS monitoring tools](https://signoz.io/comparisons/aws-monitoring-tools/) follow a pay-as-you-go model, with costs based on the number of metrics, logs, and traces collected. Costs can rise significantly with extensive usage.
 - Common Problems:
-    - Complexity in managing and configuring monitoring services, especially in large environments. Costs can also become prohibitive if not carefully managed.
+  - Complexity in managing and configuring monitoring services, especially in large environments. Costs can also become prohibitive if not carefully managed.
 - Potential Drawback:
-    - AWS’s tools are best suited for users heavily invested in the AWS ecosystem, potentially limiting flexibility in multi-cloud or hybrid environments.
+  - AWS’s tools are best suited for users heavily invested in the AWS ecosystem, potentially limiting flexibility in multi-cloud or hybrid environments.
 
 ### 9. GCP or Google Cloud Platform (Cloud Infrastructure, Full-Stack Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%209.webp" alt="Google Cloud Platform" caption="Google Cloud Platform (credits: cloud.google)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%209.webp"
+  alt="Google Cloud Platform"
+  caption="Google Cloud Platform (credits: cloud.google)"
+/>
 
-
-<a href="https://cloud.google.com/" rel="noopener noreferrer nofollow" target="_blank">Google Cloud Platform</a> provides integrated monitoring, logging, and tracing solutions through services like Google Cloud Monitoring, Cloud Logging, and Cloud Trace. These tools offer comprehensive visibility into the performance and health of applications and infrastructure hosted on GCP.
+<a href="https://cloud.google.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Google Cloud Platform
+</a> provides integrated monitoring, logging, and tracing solutions through services like Google
+Cloud Monitoring, Cloud Logging, and Cloud Trace. These tools offer comprehensive visibility into
+the performance and health of applications and infrastructure hosted on GCP.
 
 - Key Features:
-    - Google Cloud Monitoring: It monitors the performance of GCP resources and applications with real-time metrics and dashboards.
-    - Cloud Logging: It provides [centralized log management](https://signoz.io/blog/centralized-logging/) for better troubleshooting and analysis.
-    - Cloud Trace: It offers distributed tracing for applications, helping to identify latency issues and optimize performance.
-    - Integration with GCP Services: It works seamlessly with other GCP services for a cohesive monitoring experience.
+  - Google Cloud Monitoring: It monitors the performance of GCP resources and applications with real-time metrics and dashboards.
+  - Cloud Logging: It provides [centralized log management](https://signoz.io/blog/centralized-logging/) for better troubleshooting and analysis.
+  - Cloud Trace: It offers distributed tracing for applications, helping to identify latency issues and optimize performance.
+  - Integration with GCP Services: It works seamlessly with other GCP services for a cohesive monitoring experience.
 - Best For:
-    - It is best suited for organizations using Google Cloud as their primary cloud provider, needing integrated monitoring solutions that align with GCP’s services.
+  - It is best suited for organizations using Google Cloud as their primary cloud provider, needing integrated monitoring solutions that align with GCP’s services.
 - Community Support:
-    - GCP has a strong community, with extensive documentation, support forums, and a large ecosystem of third-party tools and integrations. Google’s developer resources also provide extensive learning materials.
+  - GCP has a strong community, with extensive documentation, support forums, and a large ecosystem of third-party tools and integrations. Google’s developer resources also provide extensive learning materials.
 - Performance:
-    - GCP’s monitoring tools are designed for high performance and scalability, making them suitable for both small-scale and enterprise-level environments.
+  - GCP’s monitoring tools are designed for high performance and scalability, making them suitable for both small-scale and enterprise-level environments.
 - Pricing:
-    - Pricing is based on the volume of metrics, logs, and traces collected. GCP offers competitive pricing, but costs can increase with extensive monitoring needs.
+  - Pricing is based on the volume of metrics, logs, and traces collected. GCP offers competitive pricing, but costs can increase with extensive monitoring needs.
 - Common Problems:
-    - Complexity in configuring and managing monitoring services, especially in large or multi-cloud environments. Users may also face challenges in balancing costs with the level of monitoring required.
+  - Complexity in configuring and managing monitoring services, especially in large or multi-cloud environments. Users may also face challenges in balancing costs with the level of monitoring required.
 - Potential Drawback:
-    - Best suited for GCP environments, with limited versatility in multi-cloud or on-premises setups.
+  - Best suited for GCP environments, with limited versatility in multi-cloud or on-premises setups.
 
 ### 10. Microsoft Azure (Cloud Infrastructure, Full-Stack Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2010.webp" alt="Azure" caption="Azure (credits: azure.microsoft)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2010.webp"
+  alt="Azure"
+  caption="Azure (credits: azure.microsoft)"
+/>
 
-<a href="https://azure.microsoft.com/" rel="noopener noreferrer nofollow" target="_blank">Microsoft Azure</a> provides comprehensive monitoring and management tools through services like Azure Monitor, Azure Log Analytics, and Azure Application Insights. These tools enable users to monitor the performance and health of their applications and infrastructure hosted on Azure.
+<a href="https://azure.microsoft.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Microsoft Azure
+</a> provides comprehensive monitoring and management tools through services like Azure Monitor,
+Azure Log Analytics, and Azure Application Insights. These tools enable users to monitor the
+performance and health of their applications and infrastructure hosted on Azure.
 
 - Key Features:
-    - Azure Monitor: It offers full-stack monitoring across Azure resources, with real-time metrics, alerts, and dashboards.
-    - Azure Log Analytics: It centralizes log management and enables powerful querying and analytics.
-    - [Azure Application Insights](https://signoz.io/guides/azure-app-insights/): It provides application performance monitoring, including distributed tracing and user behaviour analysis.
-    - Integration with Azure Services: It can be integrated seamlessly with other Azure services, offering a unified monitoring experience.
+  - Azure Monitor: It offers full-stack monitoring across Azure resources, with real-time metrics, alerts, and dashboards.
+  - Azure Log Analytics: It centralizes log management and enables powerful querying and analytics.
+  - [Azure Application Insights](https://signoz.io/guides/azure-app-insights/): It provides application performance monitoring, including distributed tracing and user behaviour analysis.
+  - Integration with Azure Services: It can be integrated seamlessly with other Azure services, offering a unified monitoring experience.
 - Best For:
-    - It is best suited for enterprises and developers using Microsoft Azure as their primary cloud provider, and looking for integrated monitoring solutions.
+  - It is best suited for enterprises and developers using Microsoft Azure as their primary cloud provider, and looking for integrated monitoring solutions.
 - Community Support:
-    - Azure has a vast and active community, with comprehensive documentation, forums, user groups, and extensive support options. Third-party integrations and tools are also widely available.
+  - Azure has a vast and active community, with comprehensive documentation, forums, user groups, and extensive support options. Third-party integrations and tools are also widely available.
 - Performance:
-    - Azure’s monitoring tools are designed for high performance, with the ability to scale across large environments. However, like other cloud providers, optimizing performance can require expertise.
+  - Azure’s monitoring tools are designed for high performance, with the ability to scale across large environments. However, like other cloud providers, optimizing performance can require expertise.
 - Pricing:
-    - Azure monitoring tools follow a pay-as-you-go model, with costs based on the volume of data processed. Pricing is competitive, but costs can increase with extensive usage.
+  - Azure monitoring tools follow a pay-as-you-go model, with costs based on the volume of data processed. Pricing is competitive, but costs can increase with extensive usage.
 - Common Problems:
-    - Complexity in managing and configuring monitoring services, particularly in large-scale environments. Costs can become significant if not carefully managed.
+  - Complexity in managing and configuring monitoring services, particularly in large-scale environments. Costs can become significant if not carefully managed.
 - Potential Drawback:
-    - Best suited for Azure-centric environments, which might limit flexibility in multi-cloud or hybrid setups.
+  - Best suited for Azure-centric environments, which might limit flexibility in multi-cloud or hybrid setups.
 
 ### 11. Kamatera (Cloud Infrastructure, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2011.webp" alt="Kamaters" caption="Kamaters (credits: kamatera)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2011.webp"
+  alt="Kamaters"
+  caption="Kamaters (credits: kamatera)"
+/>
 
-<a href="https://www.kamatera.com/" rel="noopener noreferrer nofollow" target="_blank">Kamatera</a> offers cloud infrastructure services, including cloud servers, storage, and networking. It provides built-in monitoring solutions to track the performance and health of resources deployed on the Kamatera cloud platform.
+<a href="https://www.kamatera.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Kamatera
+</a> offers cloud infrastructure services, including cloud servers, storage, and networking. It
+provides built-in monitoring solutions to track the performance and health of resources deployed on
+the Kamatera cloud platform.
 
 - Key Features:
-    - Real-Time Monitoring: It tracks CPU, memory, disk, and network usage of cloud instances in real-time.
-    - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
-    - Customizable Dashboards: It allows users to create personalized views of their infrastructure.
-    - API Access: It enables integration with third-party monitoring tools for advanced analytics.
+  - Real-Time Monitoring: It tracks CPU, memory, disk, and network usage of cloud instances in real-time.
+  - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
+  - Customizable Dashboards: It allows users to create personalized views of their infrastructure.
+  - API Access: It enables integration with third-party monitoring tools for advanced analytics.
 - Best For:
-    - It is best suited for small to medium-sized businesses using Kamatera for cloud infrastructure need a simple, integrated monitoring solution. It is also ideal for users looking for affordable cloud services with basic monitoring capabilities.
+  - It is best suited for small to medium-sized businesses using Kamatera for cloud infrastructure need a simple, integrated monitoring solution. It is also ideal for users looking for affordable cloud services with basic monitoring capabilities.
 - Community Support:
-    - Kamatera’s community is smaller compared to larger cloud providers, but it offers solid documentation, forums, and support channels for users.
+  - Kamatera’s community is smaller compared to larger cloud providers, but it offers solid documentation, forums, and support channels for users.
 - Performance:
-    - It is suitable for monitoring cloud instances, though it may lack the advanced features and scalability of dedicated monitoring tools. Best for basic monitoring needs.
+  - It is suitable for monitoring cloud instances, though it may lack the advanced features and scalability of dedicated monitoring tools. Best for basic monitoring needs.
 - Pricing:
-    - Monitoring is included with Kamatera’s services, making it cost-effective. Additional costs might arise if integrating with third-party tools.
+  - Monitoring is included with Kamatera’s services, making it cost-effective. Additional costs might arise if integrating with third-party tools.
 - Common Problems:
-    - Some users may find the built-in monitoring features too basic, requiring additional tools for more detailed analysis. Scaling and customizability might also be concerns for larger deployments.
+  - Some users may find the built-in monitoring features too basic, requiring additional tools for more detailed analysis. Scaling and customizability might also be concerns for larger deployments.
 - Potential Drawback:
-    - It is limited to Kamatera’s ecosystem which makes it less versatile for multi-cloud or on-premises environments.
+  - It is limited to Kamatera’s ecosystem which makes it less versatile for multi-cloud or on-premises environments.
 
 ### 12. Hostwinds (Cloud Infrastructure, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2012.webp" alt="Hostwinds" caption="Hostwinds (credits: hostwinds)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2012.webp"
+  alt="Hostwinds"
+  caption="Hostwinds (credits: hostwinds)"
+/>
 
-
-<a href="https://www.hostwinds.com/" rel="noopener noreferrer nofollow" target="_blank">Hostwinds</a> provides cloud hosting services with built-in monitoring tools. These tools help users track the performance and health of their virtual servers and applications hosted on the Hostwinds platform.
+<a href="https://www.hostwinds.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Hostwinds
+</a> provides cloud hosting services with built-in monitoring tools. These tools help users track
+the performance and health of their virtual servers and applications hosted on the Hostwinds
+platform.
 
 - Key Features:
-    - Resource Monitoring: It tracks CPU, memory, disk, and network usage of cloud instances.
-    - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
-    - Custom Dashboards: It allows users to create personalized views and reports of their infrastructure.
-    - Third-Party Integration: It can be integrated with other monitoring tools for advanced analytics.
+  - Resource Monitoring: It tracks CPU, memory, disk, and network usage of cloud instances.
+  - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
+  - Custom Dashboards: It allows users to create personalized views and reports of their infrastructure.
+  - Third-Party Integration: It can be integrated with other monitoring tools for advanced analytics.
 - Best For:
-    - It is best suited for small to medium-sized businesses using Hostwinds for cloud hosting and needing basic monitoring capabilities. It is also ideal for users looking for affordable hosting services with integrated monitoring.
+  - It is best suited for small to medium-sized businesses using Hostwinds for cloud hosting and needing basic monitoring capabilities. It is also ideal for users looking for affordable hosting services with integrated monitoring.
 - Community Support:
-    - Hostwinds has a smaller community compared to larger cloud providers, but it offers decent documentation and support channels.
+  - Hostwinds has a smaller community compared to larger cloud providers, but it offers decent documentation and support channels.
 - Performance:
-    - Adequate for monitoring cloud instances, though it may lack the depth and scalability of more specialized tools. Best for straightforward monitoring needs.
+  - Adequate for monitoring cloud instances, though it may lack the depth and scalability of more specialized tools. Best for straightforward monitoring needs.
 - Pricing:
-    - Monitoring is included as part of the Hostwinds service, with costs primarily based on the cloud resources used. Additional costs may apply for more advanced features or integrations.
+  - Monitoring is included as part of the Hostwinds service, with costs primarily based on the cloud resources used. Additional costs may apply for more advanced features or integrations.
 - Common Problems:
-    - Some users may find the built-in monitoring features too basic, requiring third-party tools for more detailed analysis. There can also be limitations in customization and scalability.
+  - Some users may find the built-in monitoring features too basic, requiring third-party tools for more detailed analysis. There can also be limitations in customization and scalability.
 - Potential Drawback:
-    - Primarily tied to Hostwinds’ ecosystem, which may limit versatility for users with multi-cloud or on-premises needs.
+  - Primarily tied to Hostwinds’ ecosystem, which may limit versatility for users with multi-cloud or on-premises needs.
 
 ### 13. OVHcloud (Cloud Infrastructure, Full-Stack Monitoring)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2013.webp" alt="OVHcoud" caption="OVHcoud (credits: ovhcloud)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2013.webp"
+  alt="OVHcoud"
+  caption="OVHcoud (credits: ovhcloud)"
+/>
 
-<a href="https://www.ovhcloud.com/en-in/" rel="noopener noreferrer nofollow" target="_blank">OVHcloud</a> provides cloud infrastructure services along with integrated monitoring solutions. Users can monitor the performance and health of their cloud resources, including servers, storage, and networking.
+<a href="https://www.ovhcloud.com/en-in/" rel="noopener noreferrer nofollow" target="_blank">
+  OVHcloud
+</a> provides cloud infrastructure services along with integrated monitoring solutions. Users can
+monitor the performance and health of their cloud resources, including servers, storage, and
+networking.
 
 - Key Features:
-    - Resource Monitoring: It tracks CPU, memory, disk, and network usage across cloud instances.
-    - Automated Alerts: It notifies users when resource usage exceeds predefined thresholds.
-    - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
-    - API Access: It enables integration with third-party monitoring tools for advanced analytics.
+  - Resource Monitoring: It tracks CPU, memory, disk, and network usage across cloud instances.
+  - Automated Alerts: It notifies users when resource usage exceeds predefined thresholds.
+  - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
+  - API Access: It enables integration with third-party monitoring tools for advanced analytics.
 - Best For:
-    - It is best suited for enterprises and businesses using OVHcloud for cloud infrastructure that needs comprehensive monitoring solutions. It can also be used by users looking for a European-based cloud provider with robust monitoring capabilities.
+  - It is best suited for enterprises and businesses using OVHcloud for cloud infrastructure that needs comprehensive monitoring solutions. It can also be used by users looking for a European-based cloud provider with robust monitoring capabilities.
 - Community Support:
-    - OVHcloud has a strong community, with extensive documentation, forums, and support channels. It’s particularly popular in Europe, offering local resources and support.
+  - OVHcloud has a strong community, with extensive documentation, forums, and support channels. It’s particularly popular in Europe, offering local resources and support.
 - Performance:
-    - OVHcloud’s monitoring tools perform well for monitoring large and complex environments. However, optimizing and scaling the tools may require additional expertise.
+  - OVHcloud’s monitoring tools perform well for monitoring large and complex environments. However, optimizing and scaling the tools may require additional expertise.
 - Pricing:
-    - Monitoring is included with OVHcloud services, with costs based on the volume of resources used. Additional costs may apply for advanced features or third-party integrations.
+  - Monitoring is included with OVHcloud services, with costs based on the volume of resources used. Additional costs may apply for advanced features or third-party integrations.
 - Common Problems:
-    - Some users may find the platform complex to manage, particularly when configuring monitoring for large deployments. There may also be limitations in customization and scalability.
+  - Some users may find the platform complex to manage, particularly when configuring monitoring for large deployments. There may also be limitations in customization and scalability.
 - Potential Drawback:
-    - It is primarily suited for OVHcloud environments, which might limit flexibility for users with multi-cloud or hybrid setups.
+  - It is primarily suited for OVHcloud environments, which might limit flexibility for users with multi-cloud or hybrid setups.
 
 ### 14. Hetzner Cloud (Cloud Infrastructure, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2014.webp" alt="Hetzner Cloud" caption="Hetzner Cloud (credits: hetzner)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2014.webp"
+  alt="Hetzner Cloud"
+  caption="Hetzner Cloud (credits: hetzner)"
+/>
 
-
-<a href="https://www.hetzner.com/cloud/" rel="noopener noreferrer nofollow" target="_blank">Hetzner Cloud</a> offers cloud infrastructure services along with built-in monitoring solutions. Users can monitor the performance and health of their virtual servers and applications hosted on Hetzner’s platform.
+<a href="https://www.hetzner.com/cloud/" rel="noopener noreferrer nofollow" target="_blank">
+  Hetzner Cloud
+</a> offers cloud infrastructure services along with built-in monitoring solutions. Users can
+monitor the performance and health of their virtual servers and applications hosted on Hetzner’s
+platform.
 
 - Key Features:
-    - Resource Monitoring: It tracks CPU, memory, disk, and network usage across cloud instances.
-    - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
-    - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
-    - API Access: It provides integration with third-party monitoring tools for advanced analytics.
+  - Resource Monitoring: It tracks CPU, memory, disk, and network usage across cloud instances.
+  - Automated Alerts: It sends notifications when resource usage exceeds predefined thresholds.
+  - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
+  - API Access: It provides integration with third-party monitoring tools for advanced analytics.
 - Best For:
-    - It is best suited for small to medium-sized businesses using Hetzner Cloud for hosting and needing basic monitoring capabilities. It can also be used by users looking for affordable cloud services with integrated monitoring.
+  - It is best suited for small to medium-sized businesses using Hetzner Cloud for hosting and needing basic monitoring capabilities. It can also be used by users looking for affordable cloud services with integrated monitoring.
 - Community Support:
-    - Hetzner has a dedicated community, particularly strong in Europe, with solid documentation, forums, and support channels. It’s known for its affordability and reliability.
+  - Hetzner has a dedicated community, particularly strong in Europe, with solid documentation, forums, and support channels. It’s known for its affordability and reliability.
 - Performance:
-    - Adequate for monitoring cloud instances, though it may lack the depth and granularity of more specialized tools. Best for straightforward monitoring needs.
+  - Adequate for monitoring cloud instances, though it may lack the depth and granularity of more specialized tools. Best for straightforward monitoring needs.
 - Pricing:
-    - Monitoring is included with Hetzner Cloud services, making it cost-effective. Additional costs might arise for advanced features or third-party integrations.
+  - Monitoring is included with Hetzner Cloud services, making it cost-effective. Additional costs might arise for advanced features or third-party integrations.
 - Common Problems:
-    - Some users may find the monitoring features too basic, requiring additional tools for more detailed analysis. There can also be limitations in customization and scalability.
+  - Some users may find the monitoring features too basic, requiring additional tools for more detailed analysis. There can also be limitations in customization and scalability.
 - Potential Drawback:
-    - Primarily tied to Hetzner’s ecosystem, it is less versatile for multi-cloud or on-premises environments.
+  - Primarily tied to Hetzner’s ecosystem, it is less versatile for multi-cloud or on-premises environments.
 
 ### 15. Cloudways (Managed Cloud Hosting, Monitoring as a Service)
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2015.webp" alt="Cloudways" caption="Cloudways (credits: cloudways)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2015.webp"
+  alt="Cloudways"
+  caption="Cloudways (credits: cloudways)"
+/>
 
-<a href="https://www.cloudways.com/en/" rel="noopener noreferrer nofollow" target="_blank">Cloudways</a> provides managed cloud hosting services with integrated monitoring tools. The platform simplifies cloud hosting by managing infrastructure while offering monitoring solutions to track the performance and health of hosted applications.
+<a href="https://www.cloudways.com/en/" rel="noopener noreferrer nofollow" target="_blank">
+  Cloudways
+</a> provides managed cloud hosting services with integrated monitoring tools. The platform
+simplifies cloud hosting by managing infrastructure while offering monitoring solutions to track the
+performance and health of hosted applications.
 
 - Key Features:
-    - Resource Monitoring: It tracks CPU, memory, disk, and network usage across hosted applications.
-    - Real-Time Alerts: It sends notifications when resource usage exceeds predefined thresholds.
-    - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
-    - Integration with Third-Party Tools: It can be integrated with advanced monitoring tools for more detailed analytics.
+  - Resource Monitoring: It tracks CPU, memory, disk, and network usage across hosted applications.
+  - Real-Time Alerts: It sends notifications when resource usage exceeds predefined thresholds.
+  - Customizable Dashboards: It allows users to create personalized views and reports of their infrastructure.
+  - Integration with Third-Party Tools: It can be integrated with advanced monitoring tools for more detailed analytics.
 - Best For:
-    - It is best suited for businesses and developers looking for managed cloud hosting with integrated monitoring capabilities. It can also be used by users who prefer a hands-off approach to cloud infrastructure management while maintaining visibility into performance.
+  - It is best suited for businesses and developers looking for managed cloud hosting with integrated monitoring capabilities. It can also be used by users who prefer a hands-off approach to cloud infrastructure management while maintaining visibility into performance.
 - Community Support:
-    - Cloudways has a supportive community, with comprehensive documentation, forums, and a robust knowledge base. It’s particularly favoured by developers and small businesses.
+  - Cloudways has a supportive community, with comprehensive documentation, forums, and a robust knowledge base. It’s particularly favoured by developers and small businesses.
 - Performance:
-    - Provides reliable performance for monitoring hosted applications, though the level of detail may not match standalone monitoring tools. Best for users seeking managed services.
+  - Provides reliable performance for monitoring hosted applications, though the level of detail may not match standalone monitoring tools. Best for users seeking managed services.
 - Pricing:
-    - Monitoring is included with Cloudways’ managed hosting plans, with costs based on the selected plan. Pricing is competitive, but additional costs may apply for third-party integrations.
+  - Monitoring is included with Cloudways’ managed hosting plans, with costs based on the selected plan. Pricing is competitive, but additional costs may apply for third-party integrations.
 - Common Problems:
-    - Some users may find the built-in monitoring features limited, requiring additional tools for more comprehensive analysis. There can also be challenges in customizing and scaling monitoring capabilities.
+  - Some users may find the built-in monitoring features limited, requiring additional tools for more comprehensive analysis. There can also be challenges in customizing and scaling monitoring capabilities.
 - Potential Drawback:
-    - Primarily suited for users who want managed hosting, which might limit flexibility for those needing more control over their infrastructure and monitoring solutions.
+  - Primarily suited for users who want managed hosting, which might limit flexibility for those needing more control over their infrastructure and monitoring solutions.
 
 ## Lesser-Known DevOps Monitoring Tools
 
@@ -460,46 +572,71 @@ The DevOps tools that we have discussed above are industry leaders but several l
 
 ### 1. Netdata (Open-source, Real-time monitoring)
 
-<a href="https://www.netdata.cloud/" rel="noopener noreferrer nofollow" target="_blank">Netdata</a> offers real-time performance and health monitoring for systems and applications. It provides detailed insights with minimal resource consumption.
+<a href="https://www.netdata.cloud/" rel="noopener noreferrer nofollow" target="_blank">
+  Netdata
+</a> offers real-time performance and health monitoring for systems and applications. It provides
+detailed insights with minimal resource consumption.
 
 - Key Features: High-frequency data collection, real-time monitoring, easy setup.
 - Best For: Small to medium businesses looking for real-time insights without heavy resource overhead.
 - Drawbacks: Limited long-term data retention and historical analysis.
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2016.webp" alt="Netdata" caption="Netdata (credits: netdata.cloud)" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2016.webp"
+  alt="Netdata"
+  caption="Netdata (credits: netdata.cloud)"
+/>
 
 ### 2. Cabot (Open-source, Monitoring and Alerting)
 
-<a href="https://www.cabotsolutions.com/" rel="noopener noreferrer nofollow" target="_blank">Cabot</a> is a self-hosted monitoring and alerting platform that provides status checks, metrics monitoring, and alerts via multiple channels.
+<a href="https://www.cabotsolutions.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Cabot
+</a> is a self-hosted monitoring and alerting platform that provides status checks, metrics
+monitoring, and alerts via multiple channels.
 
 - Key Features: Integration with various data sources, customizable alerts, self-hosted.
 - Best For: Teams that need a simple, self-hosted alerting solution.
 - Drawbacks: Not as feature-rich or scalable as more prominent monitoring solutions.
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2017.webp" alt="Catbot" caption="Catbot (credits: cabotsolutions)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2017.webp"
+  alt="Catbot"
+  caption="Catbot (credits: cabotsolutions)"
+/>
 
 ### 3. Thanos (Open-source, Distributed monitoring)
 
-<a href="https://thanos.io/" rel="noopener noreferrer nofollow" target="_blank">Thanos</a> extends Prometheus into a globally scalable, long-term monitoring solution with multi-cloud and cross-cluster support.
+<a href="https://thanos.io/" rel="noopener noreferrer nofollow" target="_blank">
+  Thanos
+</a> extends Prometheus into a globally scalable, long-term monitoring solution with multi-cloud and
+cross-cluster support.
 
 - Key Features: Prometheus compatibility, scalability, global view of metrics.
 - Best For: Organizations already using Prometheus looking for scalability and long-term storage.
 - Drawbacks: Complexity in setup and management.
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2018.webp" alt="Thanos" caption="Thanos (credits: thanos.io)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2018.webp"
+  alt="Thanos"
+  caption="Thanos (credits: thanos.io)"
+/>
 
 ### 4. Uptime Kuma (Open-source, Uptime monitoring)
 
-<a href="https://uptime.kuma.pet/" rel="noopener noreferrer nofollow" target="_blank">Uptime Kuma</a> is a self-hosted monitoring tool for website and service uptime. It is lightweight and easy to set up, providing simple and effective monitoring.
+<a href="https://uptime.kuma.pet/" rel="noopener noreferrer nofollow" target="_blank">
+  Uptime Kuma
+</a> is a self-hosted monitoring tool for website and service uptime. It is lightweight and easy to
+set up, providing simple and effective monitoring.
 
 - Key Features: Uptime monitoring, customizable notifications, simple dashboard.
 - Best For: Small businesses or developers needing basic uptime monitoring.
 - Drawbacks: Limited uptime monitoring, lacks advanced features like metrics or log management.
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2019.webp" alt="Uptime Kuma" caption="Uptime Kuma (credits: uptime.kuma.pet)" />
-
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2019.webp"
+  alt="Uptime Kuma"
+  caption="Uptime Kuma (credits: uptime.kuma.pet)"
+/>
 
 ## How to Choose the Right DevOps Monitoring Tool
 
@@ -525,7 +662,11 @@ To completely use the possibilities of your chosen monitoring technology, follow
 
 [SigNoz](https://signoz.io/) with native support for opentelemetry offers an effective alternative to old proprietary monitoring tools, providing a feature-rich, open-source platform geared to modern DevOps requirements.
 
-<Figure src="/img/guides/2024/08/devops-monitoring-tools-image%2020.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/guides/2024/08/devops-monitoring-tools-image%2020.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 Some of the key features of SigNoz include:
 
diff --git a/data/guides/divide-two-metrics-in-prometheus.mdx b/data/guides/divide-two-metrics-in-prometheus.mdx
index fcd081fa7..3ce3c420b 100644
--- a/data/guides/divide-two-metrics-in-prometheus.mdx
+++ b/data/guides/divide-two-metrics-in-prometheus.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Divide Metrics in Prometheus - A Step-by-Step Guide
-slug: divide-two-metrics-in-prometheus
 date: 2024-12-26
 tags: [faq, Prometheus]
 authors: [adil_shaikh]
 description: Learn how to divide metrics in Prometheus with our comprehensive guide. Master PromQL, handle label matching, and optimize your monitoring workflows.
-keywords: [Prometheus metrics, PromQL, metric division, data analysis, monitoring, observability, Grafana, SigNoz]
-
+keywords:
+  [
+    Prometheus metrics,
+    PromQL,
+    metric division,
+    data analysis,
+    monitoring,
+    observability,
+    Grafana,
+    SigNoz,
+  ]
 ---
 
 Metric division is a powerful technique in Prometheus for deriving meaningful insights from time series data. It allows you to compare metrics on different scales, calculate rates and efficiency metrics, and identify trends and anomalies. This blog post will explore the concept of metric division in Prometheus, its importance for data analysis and monitoring, common use cases, step-by-step guide for performing division, advanced techniques, visualization in Grafana, and real-world examples.
@@ -43,39 +50,31 @@ rate(http_response_time_seconds_sum[1m]) / rate(http_response_time_seconds_count
 ### Key Steps for Metric Division
 
 1. Identify Your Metrics
-    - Ensure both metrics exist and are being collected
-    - Verify metrics are compatible for division
-    - Check that units and scales make sense together
+   - Ensure both metrics exist and are being collected
+   - Verify metrics are compatible for division
+   - Check that units and scales make sense together
 2. Handle Labels
-    - Use `ignoring()` to exclude irrelevant labels:
-        
-        ```
-        metric_a / ignoring(status_code, handler) metric_b
-        ```
-        
-    - Use `on()` to specify which labels to match:
-        
-        ```
-        metric_a / on(service, environment) metric_b
-        ```
-        
+   - Use `ignoring()` to exclude irrelevant labels:
+     ```
+     metric_a / ignoring(status_code, handler) metric_b
+     ```
+   - Use `on()` to specify which labels to match:
+     ```
+     metric_a / on(service, environment) metric_b
+     ```
 3. Avoid Common Pitfalls
-    - Prevent division by zero using `clamp_min`:
-        
-        ```
-        metric_a / clamp_min(metric_b, 1)
-        ```
-        
-    - Aggregate high-cardinality metrics before division:
-        
-        ```
-        sum without(instance, pod) (metric_a) / sum without(instance, pod) (metric_b)
-        ```
-        
+   - Prevent division by zero using `clamp_min`:
+     ```
+     metric_a / clamp_min(metric_b, 1)
+     ```
+   - Aggregate high-cardinality metrics before division:
+     ```
+     sum without(instance, pod) (metric_a) / sum without(instance, pod) (metric_b)
+     ```
 4. Optimize Performance
-    - Use recording rules for frequently used calculations
-    - Apply appropriate time windows
-    - Aggregate data before division when possible
+   - Use recording rules for frequently used calculations
+   - Apply appropriate time windows
+   - Aggregate data before division when possible
 
 ### Best Practices
 
@@ -121,70 +120,69 @@ Metric division is essential for transforming raw metrics into more insightful d
 Dividing metrics in Prometheus provides significant advantages for system administrators, developers, and DevOps teams, helping them gain deeper insights and make data-driven decisions. Below are some common use cases where dividing metrics proves invaluable:
 
 1. Error Rate Analysis
-    
-    Dividing error counts by total requests helps you quantify error rates and prioritize fixes. This includes HTTP errors, application exceptions, and failed transactions.
-    
-    Example: Monitor the percentage of HTTP errors in your web service:
-    
-    ```bash
-    # HTTP Error Rate
-    sum(rate(response_status{status=~"4..|5.."}[5m])) / sum(rate(http_requests_total[5m])) * 100
-    ```
-    
-    This query calculates the percentage of requests resulting in 4xx or 5xx status codes over a 5-minute window by dividing the number of error responses (status codes 4xx and 5xx) by the total number of HTTP requests.
-    
+
+   Dividing error counts by total requests helps you quantify error rates and prioritize fixes. This includes HTTP errors, application exceptions, and failed transactions.
+
+   Example: Monitor the percentage of HTTP errors in your web service:
+
+   ```bash
+   # HTTP Error Rate
+   sum(rate(response_status{status=~"4..|5.."}[5m])) / sum(rate(http_requests_total[5m])) * 100
+   ```
+
+   This query calculates the percentage of requests resulting in 4xx or 5xx status codes over a 5-minute window by dividing the number of error responses (status codes 4xx and 5xx) by the total number of HTTP requests.
+
 2. Resource Utilization Insights
-    
-    By dividing used resources by total capacity, you can calculate utilization percentages for CPU, memory, or disk. This helps in optimizing resource allocation and identifying overutilized or underutilized nodes.
-    
-    Example: Calculate the memory utilization percentage for each node:
-    
-    ```bash
-    # Memory Usage
-    (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100
-    ```
-    
-    This query calculates the percentage of memory in use by subtracting available memory from total memory and then dividing by the total memory.
-    
+
+   By dividing used resources by total capacity, you can calculate utilization percentages for CPU, memory, or disk. This helps in optimizing resource allocation and identifying overutilized or underutilized nodes.
+
+   Example: Calculate the memory utilization percentage for each node:
+
+   ```bash
+   # Memory Usage
+   (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100
+   ```
+
+   This query calculates the percentage of memory in use by subtracting available memory from total memory and then dividing by the total memory.
+
 3. Throughput Evaluation
-    
-    Dividing metrics like request counts or response times helps measure system efficiency, assess performance bottlenecks, and ensure the system can handle traffic spikes.
-    
-    Example: Calculate the average response time per request:
-    
-    ```bash
-    # Average Response Time
-    rate(http_response_time_seconds_sum[1m]) / rate(http_response_time_seconds_count[1m])
-    ```
-    
-    This query divides the total response time sum by the number of requests to compute the average response time per request.
-    
+
+   Dividing metrics like request counts or response times helps measure system efficiency, assess performance bottlenecks, and ensure the system can handle traffic spikes.
+
+   Example: Calculate the average response time per request:
+
+   ```bash
+   # Average Response Time
+   rate(http_response_time_seconds_sum[1m]) / rate(http_response_time_seconds_count[1m])
+   ```
+
+   This query divides the total response time sum by the number of requests to compute the average response time per request.
+
 4. Service-Level Objective (SLO) Monitoring
-    
-    Tracking SLO compliance, such as availability or latency thresholds, often requires dividing successful operations by total operations to measure service reliability.
-    
-    Example: Calculate service availability percentage:
-    
-    ```bash
-    # Availability Percentage
-    sum(rate(http_requests_total{status=~"2..|3.."}[5m])) / sum(rate(http_requests_total[5m])) * 100
-    ```
-    
-    This query calculates the percentage of requests resulting in successful 2xx or 3xx status codes over the total number of requests. This metric helps ensure your service meets uptime and reliability goals.
-    
+
+   Tracking SLO compliance, such as availability or latency thresholds, often requires dividing successful operations by total operations to measure service reliability.
+
+   Example: Calculate service availability percentage:
+
+   ```bash
+   # Availability Percentage
+   sum(rate(http_requests_total{status=~"2..|3.."}[5m])) / sum(rate(http_requests_total[5m])) * 100
+   ```
+
+   This query calculates the percentage of requests resulting in successful 2xx or 3xx status codes over the total number of requests. This metric helps ensure your service meets uptime and reliability goals.
+
 5. Trend Analysis and Forecasting
-    
-    Dividing metrics over time enables the identification of usage patterns and trends. This helps in proactive scaling and planning for future capacity needs.
-    
-    Example: Track storage utilization trends over time:
-    
-    ```bash
-    # Storage Utilization Percentage
-    (node_filesystem_size_bytes - node_filesystem_free_bytes) / node_filesystem_size_bytes * 100
-    ```
-    
-    This query computes the percentage of used storage capacity for filesystems. Monitoring this over time reveals usage patterns, enabling you to anticipate when additional capacity will be required.
-    
+
+   Dividing metrics over time enables the identification of usage patterns and trends. This helps in proactive scaling and planning for future capacity needs.
+
+   Example: Track storage utilization trends over time:
+
+   ```bash
+   # Storage Utilization Percentage
+   (node_filesystem_size_bytes - node_filesystem_free_bytes) / node_filesystem_size_bytes * 100
+   ```
+
+   This query computes the percentage of used storage capacity for filesystems. Monitoring this over time reveals usage patterns, enabling you to anticipate when additional capacity will be required.
 
 PromQL, Prometheus Query Language, enables users to manipulate and [analyze metrics](https://signoz.io/blog/metrics-explorer/) with ease. It supports operations like dividing metrics to calculate rates, percentages, and averages, as sown above. PromQL’s flexibility allows for complex computations and the creation of meaningful insights, making it a crucial tool for effective monitoring and troubleshooting.
 
@@ -204,13 +202,13 @@ By covering these prerequisites, you’ll be better equipped to perform metric d
 Dividing metrics in Prometheus is a useful operation to calculate ratios, rates, and averages. Follow these steps to successfully divide two metrics:
 
 1. Identify the Metrics:
-Determine which metrics you want to divide. These could be counters, gauges, or other time series data that make sense for your use case.
+   Determine which metrics you want to divide. These could be counters, gauges, or other time series data that make sense for your use case.
 2. Use the Division Operator:
-In PromQL, use the division operator (`/`) to divide the two metrics. The syntax for division in Prometheus is straightforward but requires careful handling of labels.
+   In PromQL, use the division operator (`/`) to divide the two metrics. The syntax for division in Prometheus is straightforward but requires careful handling of labels.
 3. Handle Label Matching and Vector Operations:
-Metrics may come with different labels. Ensure that the labels match between the two metrics, or use the `on()` or `ignoring()` modifiers to align them correctly.
+   Metrics may come with different labels. Ensure that the labels match between the two metrics, or use the `on()` or `ignoring()` modifiers to align them correctly.
 4. Normalize Data If Needed:
-Depending on the metrics, you may need to apply functions like `rate()` or `avg()` to normalize data before dividing, especially when working with counters or histograms.
+   Depending on the metrics, you may need to apply functions like `rate()` or `avg()` to normalize data before dividing, especially when working with counters or histograms.
 
 Example
 
@@ -222,116 +220,125 @@ sum(http_requests_total) / sum(http_request_duration_seconds_sum)
 
 This query divides the total number of HTTP requests by the sum of their durations, giving you the average request rate.
 
-<Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image.webp" alt="Average request rate: HTTP requests divided by total duration" caption="Average request rate: HTTP requests divided by total duration" />
+<Figure
+  src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image.webp"
+  alt="Average request rate: HTTP requests divided by total duration"
+  caption="Average request rate: HTTP requests divided by total duration"
+/>
 
 ### Handling Label Inconsistencies
 
 When dividing metrics with different label sets, there are several important considerations and techniques:
 
 1. Label Matching Modifiers
-    
-    When the metrics you're dividing have different labels, you can use the `ignoring()` or `on()` clauses in PromQL to control how labels are matched during the division
-    
-    - `ignoring()`: This modifier excludes specific labels from being considered during the division. For example:
-        
-        ```
-        rate(http_requests_total[5m]) 
-        / 
-        ignoring(status_code, handler) 
-        rate(http_request_duration_seconds_sum[5m])
-        ```
-        
-    - `on()`: This modifier ensures that only specific labels are used for matching between the metrics. For example:
-        
-        ```
-        rate(http_requests_total[5m])
-        /
-        on(service, environment)
-        rate(http_request_duration_seconds_sum[5m])
-        ```
-        
+
+   When the metrics you're dividing have different labels, you can use the `ignoring()` or `on()` clauses in PromQL to control how labels are matched during the division
+
+   - `ignoring()`: This modifier excludes specific labels from being considered during the division. For example:
+     ```
+     rate(http_requests_total[5m])
+     /
+     ignoring(status_code, handler)
+     rate(http_request_duration_seconds_sum[5m])
+     ```
+   - `on()`: This modifier ensures that only specific labels are used for matching between the metrics. For example:
+     ```
+     rate(http_requests_total[5m])
+     /
+     on(service, environment)
+     rate(http_request_duration_seconds_sum[5m])
+     ```
+
 2. Handling High Cardinality
-    
-    High cardinality in [metric labels](https://signoz.io/guides/what-are-prometheus-labels/) (e.g., having many unique `instance` or `pod` labels) can complicate the division process. To address this:
-    
-    - Aggregate Labels Before Division: To manage high cardinality, it's advisable to aggregate metrics by labels like `instance` or `pod` before performing operations. Using the `sum()` or `avg()` functions with the `without()` modifier excludes high-cardinality labels. For example:
-        
-        ```bash
-        sum without(instance, pod) (rate(http_requests_total[5m]))
-        /
-        sum without(instance, pod) (rate(http_request_duration_seconds_count[5m]))
-        ```
-        
-    - Recording Rules: Implementing recording rules to pre-[aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/) can help reduce high cardinality before performing operations. This strategy improves query performance and simplifies complex metric calculations
-    - Label Matchers: Use label matchers to filter out specific values of labels that are irrelevant to the division. This helps focus the division on the most relevant metric subsets.
+
+   High cardinality in [metric labels](https://signoz.io/guides/what-are-prometheus-labels/) (e.g., having many unique `instance` or `pod` labels) can complicate the division process. To address this:
+
+   - Aggregate Labels Before Division: To manage high cardinality, it's advisable to aggregate metrics by labels like `instance` or `pod` before performing operations. Using the `sum()` or `avg()` functions with the `without()` modifier excludes high-cardinality labels. For example:
+     ```bash
+     sum without(instance, pod) (rate(http_requests_total[5m]))
+     /
+     sum without(instance, pod) (rate(http_request_duration_seconds_count[5m]))
+     ```
+   - Recording Rules: Implementing recording rules to pre-[aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/) can help reduce high cardinality before performing operations. This strategy improves query performance and simplifies complex metric calculations
+   - Label Matchers: Use label matchers to filter out specific values of labels that are irrelevant to the division. This helps focus the division on the most relevant metric subsets.
+
 3. Grouping and Aggregation Strategies
-    
-    To ensure the division provides meaningful results:
-    
-    - Group by Relevant Labels: Grouping by labels such as `service` and `endpoint` ensures that the division reflects metrics at the appropriate level of granularity. For example:
-        
-        ```bash
-        # Before aggregating and dividing, ensure these labels exist in both metrics
-        sum by (service, endpoint) (rate(http_requests_total[5m]))
-        /
-        sum by (service, endpoint) (rate(http_request_duration_seconds_sum[5m]))
-        ```
-        
-    - Use `without()` to Exclude Irrelevant Labels: The `without()` modifier excludes unnecessary labels (like `instance` or `pod`) from the aggregation, which helps in reducing noise and focusing on the most critical metrics.
-    - Consistent Aggregation: Ensure that the aggregation method is applied consistently across both the numerator and the denominator. For example, if you’re summing `http_requests_total`, you should apply the same aggregation to `http_request_duration_seconds_sum`.
-    - Recording Rules for Complex Aggregations: When dealing with complex aggregation logic, use recording rules to pre-aggregate metrics before division. This reduces query complexity and improves performance, especially in large-scale environments.
+
+   To ensure the division provides meaningful results:
+
+   - Group by Relevant Labels: Grouping by labels such as `service` and `endpoint` ensures that the division reflects metrics at the appropriate level of granularity. For example:
+     ```bash
+     # Before aggregating and dividing, ensure these labels exist in both metrics
+     sum by (service, endpoint) (rate(http_requests_total[5m]))
+     /
+     sum by (service, endpoint) (rate(http_request_duration_seconds_sum[5m]))
+     ```
+   - Use `without()` to Exclude Irrelevant Labels: The `without()` modifier excludes unnecessary labels (like `instance` or `pod`) from the aggregation, which helps in reducing noise and focusing on the most critical metrics.
+   - Consistent Aggregation: Ensure that the aggregation method is applied consistently across both the numerator and the denominator. For example, if you’re summing `http_requests_total`, you should apply the same aggregation to `http_request_duration_seconds_sum`.
+   - Recording Rules for Complex Aggregations: When dealing with complex aggregation logic, use recording rules to pre-aggregate metrics before division. This reduces query complexity and improves performance, especially in large-scale environments.
 
 ## Advanced Techniques for Metric Division
 
 Here are some advanced methods for metric division in Prometheus:
 
 1. Implementing Complex Calculations:
-    
-    Advanced monitoring requires deriving actionable insights from raw metrics. By combining multiple [PromQL functions](https://signoz.io/guides/promql-cheat-sheet/), we can compute nuanced metrics, such as latency distributions or error-weighted durations, offering deeper performance analysis.
-    
-    ```jsx
-    sum(rate(http_request_duration_seconds_bucket{le="2.5"}[5m])) / sum(rate(http_requests_total[5m]))
-    ```
-    
-    This computes the ratio of requests with latency ≤2.5 seconds to the total requests. It's useful for identifying the proportion of slow responses within the system.
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%201.webp" alt="Ratio of requests with latency ≤2.5s to total requests" caption="Ratio of requests with latency ≤2.5s to total requests" />
-    
+
+   Advanced monitoring requires deriving actionable insights from raw metrics. By combining multiple [PromQL functions](https://signoz.io/guides/promql-cheat-sheet/), we can compute nuanced metrics, such as latency distributions or error-weighted durations, offering deeper performance analysis.
+
+   ```jsx
+   sum(rate(http_request_duration_seconds_bucket{le="2.5"}[5m])) / sum(rate(http_requests_total[5m]))
+   ```
+
+   This computes the ratio of requests with latency ≤2.5 seconds to the total requests. It's useful for identifying the proportion of slow responses within the system.
+
+   <Figure
+     src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%201.webp"
+     alt="Ratio of requests with latency ≤2.5s to total requests"
+     caption="Ratio of requests with latency ≤2.5s to total requests"
+   />
+
 2. Use Subqueries for Time-based Comparisons:
-    
-    A subquery allows you to perform a query on data over a specific time range and then use the result of that query within another query. This enables time-based comparisons without needing separate queries
-    
-    ```jsx
-    avg_over_time(rate(http_requests_total[5m])[15m:1m]) / avg_over_time(rate(http_requests_total[5m])[1h:5m])
-    ```
-    
-    Here’s how it works:
-    
-    - `avg_over_time(rate(http_requests_total[1m])[15m:1m])`: Calculates the average rate of requests over a 15-minute window, with a resolution of 1 minute.
-    - `avg_over_time(rate(http_requests_total[5m])[1h:5m])`: Calculates the long-term rate using the same 5m sampling for comparison
-    - Division (`/`): Indicates whether the recent rate is steady compared to the long-term rate.
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%202.webp" alt="15-minute avg request rate vs 1-hour rate for traffic stability" caption="15-minute avg request rate vs 1-hour rate for traffic stability" />
-    
+
+   A subquery allows you to perform a query on data over a specific time range and then use the result of that query within another query. This enables time-based comparisons without needing separate queries
+
+   ```jsx
+   avg_over_time(rate(http_requests_total[5m])[15m:1m]) / avg_over_time(rate(http_requests_total[5m])[1h:5m])
+   ```
+
+   Here’s how it works:
+
+   - `avg_over_time(rate(http_requests_total[1m])[15m:1m])`: Calculates the average rate of requests over a 15-minute window, with a resolution of 1 minute.
+   - `avg_over_time(rate(http_requests_total[5m])[1h:5m])`: Calculates the long-term rate using the same 5m sampling for comparison
+   - Division (`/`): Indicates whether the recent rate is steady compared to the long-term rate.
+
+   <Figure
+     src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%202.webp"
+     alt="15-minute avg request rate vs 1-hour rate for traffic stability"
+     caption="15-minute avg request rate vs 1-hour rate for traffic stability"
+   />
+
 3. Apply Mathematical Functions to Division Results:
-    
-    In monitoring systems, it’s essential to track the rate of HTTP requests to assess system performance. However, the raw output can often be fractional, making it harder to interpret. Applying mathematical functions like `ceil()` makes these metrics more actionable.
-    
-    ```jsx
-    ceil(rate(http_requests_total{code="200",method="get"}[5m]))
-    ```
-    
-    This PromQL query calculates the rate of successful HTTP GET requests (with a 200 status code) over the last 5 minutes. The `rate()` function computes the per-second average of requests, and the `ceil()` function rounds up the result to the nearest whole number. This helps users monitor the traffic of successful GET requests, providing insights into the system's performance in real-time.
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%203.webp" alt="Rounding up requests per second for precise performance analysis." caption="Rounding up requests per second for precise performance analysis." />
-    
+
+   In monitoring systems, it’s essential to track the rate of HTTP requests to assess system performance. However, the raw output can often be fractional, making it harder to interpret. Applying mathematical functions like `ceil()` makes these metrics more actionable.
+
+   ```jsx
+   ceil(rate(http_requests_total{code="200",method="get"}[5m]))
+   ```
+
+   This PromQL query calculates the rate of successful HTTP GET requests (with a 200 status code) over the last 5 minutes. The `rate()` function computes the per-second average of requests, and the `ceil()` function rounds up the result to the nearest whole number. This helps users monitor the traffic of successful GET requests, providing insights into the system's performance in real-time.
+
+   <Figure
+     src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%203.webp"
+     alt="Rounding up requests per second for precise performance analysis."
+     caption="Rounding up requests per second for precise performance analysis."
+   />
 
 4. Handling Division by Zero (for Success Rate Calculation)
 
 You might want to calculate the success rate of HTTP requests, but it's possible that there are no errors or no requests during certain periods, resulting in division by zero. You can safely handle this with `clamp_min` to avoid `+Inf` or division errors.
 
 ```jsx
-sum(rate(http_requests_total{code="200",method="get"}[5m])) 
+sum(rate(http_requests_total{code="200",method="get"}[5m]))
 / clamp_min(sum(rate(http_requests_total{method="get"}[5m])), 1)
 ```
 
@@ -341,107 +348,126 @@ sum(rate(http_requests_total{code="200",method="get"}[5m]))
 
 This ensures that even if there are no requests, the denominator is set to 1, avoiding the risk of a `+Inf` result.
 
-<Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%204.webp" alt="Success rate calculation with zero-division protection using clamp_min" caption="Success rate calculation with zero-division protection using clamp_min" />
+<Figure
+  src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%204.webp"
+  alt="Success rate calculation with zero-division protection using clamp_min"
+  caption="Success rate calculation with zero-division protection using clamp_min"
+/>
 
 ## Visualizing Divided Metrics in Grafana
 
 To retrieve data from Prometheus, Grafana must first establish a connection to the [Prometheus data](https://signoz.io/guides/how-does-grafana-get-data-from-prometheus/) source. This process includes several steps:
 
 1. Set up Prometheus as a Data Source in Grafana
-    - Navigate to Connections → Data Sources → Add data source in the left side panel.
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%205.webp" alt="Adding a data source in Grafana" caption="Adding a data source in Grafana" />
-        
-    - Enter the Prometheus server URL in the configuration field.
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%206.webp" alt="Enter Prometheus server URL in the config field" caption="Enter Prometheus server URL in the config field" />
-        
-    - Configure authentication settings (if required).
-    - Click "Save & Test" to verify the connection
+   - Navigate to Connections → Data Sources → Add data source in the left side panel.
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%205.webp"
+       alt="Adding a data source in Grafana"
+       caption="Adding a data source in Grafana"
+     />
+   - Enter the Prometheus server URL in the configuration field.
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%206.webp"
+       alt="Enter Prometheus server URL in the config field"
+       caption="Enter Prometheus server URL in the config field"
+     />
+   - Configure authentication settings (if required).
+   - Click "Save & Test" to verify the connection
 2. Create a New Dashboard and Panel
-    - Navigate to Dashboards → New Dashboard → Click on the Add Visualization button
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%207.webp" alt="Create a new dashboard and add a visualization" caption="Create a new dashboard and add a visualization" />
-        
-    - Select Prometheus from the data source dropdown
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%208.webp" alt="Select Prometheus as the data source" caption="Select Prometheus as the data source" />
-        
-    - Choose the appropriate visualization type
+   - Navigate to Dashboards → New Dashboard → Click on the Add Visualization button
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%207.webp"
+       alt="Create a new dashboard and add a visualization"
+       caption="Create a new dashboard and add a visualization"
+     />
+   - Select Prometheus from the data source dropdown
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%208.webp"
+       alt="Select Prometheus as the data source"
+       caption="Select Prometheus as the data source"
+     />
+   - Choose the appropriate visualization type
 3. Input Your PromQL Expression
-    - In the query editor, enter your metric division expression. For example, to calculate the average request duration:
-        
-        ```
-        sum(rate(http_requests_total[5m])) / sum(rate(http_request_duration_seconds_sum[5m]))
-        ```
-        
-        The query calculates the average request duration by dividing the total number of HTTP requests over 5 minutes by the total duration of those requests over the same period.
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%209.webp" alt="Visualizing the 5-minute error rate." caption="Visualizing the 5-minute error rate." />
-        
+   - In the query editor, enter your metric division expression. For example, to calculate the average request duration:
+     ```
+     sum(rate(http_requests_total[5m])) / sum(rate(http_request_duration_seconds_sum[5m]))
+     ```
+     The query calculates the average request duration by dividing the total number of HTTP requests over 5 minutes by the total duration of those requests over the same period.
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%209.webp"
+       alt="Visualizing the 5-minute error rate."
+       caption="Visualizing the 5-minute error rate."
+     />
 4. Configure Visualization Options
-    - Set appropriate units for divided metrics (e.g., percentages, ratios)
-    - Configure panel display options (legend, axes, thresholds)
-    - Use appropriate graph types (Time series for trends, Gauge for current ratios)
-        
-        <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2010.webp" alt="Enhance Visualization with Histogram Transformation for Performance Trends" caption="Enhance Visualization with Histogram Transformation for Performance Trends" />
-        
-    - Apply Grafana transformations when needed:
-        - Reduce: For aggregating time series data
-        - Join: For combining multiple queries
-        - Group By: For organizing data by labels
-    - Set meaningful thresholds and color schemes to highlight important values
+   - Set appropriate units for divided metrics (e.g., percentages, ratios)
+   - Configure panel display options (legend, axes, thresholds)
+   - Use appropriate graph types (Time series for trends, Gauge for current ratios)
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2010.webp"
+       alt="Enhance Visualization with Histogram Transformation for Performance Trends"
+       caption="Enhance Visualization with Histogram Transformation for Performance Trends"
+     />
+   - Apply Grafana transformations when needed:
+     - Reduce: For aggregating time series data
+     - Join: For combining multiple queries
+     - Group By: For organizing data by labels
+   - Set meaningful thresholds and color schemes to highlight important values
 
 ## Monitoring and Alerting with Divided Metrics
 
 Monitoring and alerting based on divided metrics—such as error rates, request latencies, or throughput ratios—provide crucial insights into system performance. These metrics highlight proportional issues that raw, individual metrics may not capture, enabling proactive detection and faster resolution of incidents. Here’s how to set up and optimize alerting with divided metrics:
 
 1. Setting Up Alerting Rules Based on Divided Metric Thresholds
-    
-    To set up alerting rules, start by defining a Prometheus query that calculates the divided metric you're interested in. For example, to monitor the error rate as a percentage of total requests, you can use the following PromQL query:
-    
-    ```jsx
-    rate(error_count[5m]) / rate(total_requests[5m])
-    ```
-    
-    Once you have your query, proceed by creating an alerting rule in the Prometheus configuration. This rule will trigger an alert based on the value of the divided metric exceeding a specified threshold. For instance, you could set an alert if the error rate exceeds 1%, as shown in the following example:
-    
-    ```jsx
-    groups:
-    - name: MetricDivisionAlert
-      rules:
-      - alert: HighErrorRate
-        expr: (rate(error_count[5m]) / rate(total_requests[5m])) > 0.01
-        for: 2m
-        labels:
-          severity: critical
-        annotations:
-          summary: "High error rate detected"
-          description: "The error rate has exceeded 1%."
-    ```
-    
-    This configuration ensures that the alert is triggered if the error rate remains above 1% for at least 2 minutes, which helps avoid false positives caused by transient spikes.
-    
+
+   To set up alerting rules, start by defining a Prometheus query that calculates the divided metric you're interested in. For example, to monitor the error rate as a percentage of total requests, you can use the following PromQL query:
+
+   ```jsx
+   rate(error_count[5m]) / rate(total_requests[5m])
+   ```
+
+   Once you have your query, proceed by creating an alerting rule in the Prometheus configuration. This rule will trigger an alert based on the value of the divided metric exceeding a specified threshold. For instance, you could set an alert if the error rate exceeds 1%, as shown in the following example:
+
+   ```jsx
+   groups:
+   - name: MetricDivisionAlert
+     rules:
+     - alert: HighErrorRate
+       expr: (rate(error_count[5m]) / rate(total_requests[5m])) > 0.01
+       for: 2m
+       labels:
+         severity: critical
+       annotations:
+         summary: "High error rate detected"
+         description: "The error rate has exceeded 1%."
+   ```
+
+   This configuration ensures that the alert is triggered if the error rate remains above 1% for at least 2 minutes, which helps avoid false positives caused by transient spikes.
+
 2. Using Recording Rules to Pre-Compute Complex Divisions
-    
-    Use recording rules in Prometheus to store pre-computed results for frequently queried divided metrics. This improves query performance and reduces computational overhead.
-    
-    Below is an example of a recording rule that computes the average request duration over 5 minutes:
-    
-    ```jsx
-    groups:  
-    - name: divided_metrics  
-      rules:  
-      - record: job:average_request_duration:rate5m  
-        expr: sum(rate(http_requests_total[5m])) / sum(rate(http_request_duration_seconds_sum[5m]))  
-    ```
-    
-    Once the metric is recorded, you can directly reference it in your alerting rules to trigger alerts based on pre-computed values:
-    
-    ```bash
-    expr: job:average_request_duration:rate5m > 2  
-    ```
-    
+
+   Use recording rules in Prometheus to store pre-computed results for frequently queried divided metrics. This improves query performance and reduces computational overhead.
+
+   Below is an example of a recording rule that computes the average request duration over 5 minutes:
+
+   ```jsx
+   groups:
+   - name: divided_metrics
+     rules:
+     - record: job:average_request_duration:rate5m
+       expr: sum(rate(http_requests_total[5m])) / sum(rate(http_request_duration_seconds_sum[5m]))
+   ```
+
+   Once the metric is recorded, you can directly reference it in your alerting rules to trigger alerts based on pre-computed values:
+
+   ```bash
+   expr: job:average_request_duration:rate5m > 2
+   ```
 
 ### Best Practices for Alert Sensitivity and Avoiding False Positives
 
@@ -449,11 +475,11 @@ To ensure that your alerts are meaningful and actionable, follow these best prac
 
 1. Use Appropriate Lookback Windows: Select the right time window for your alerts. Shorter windows (e.g., `1m`) are suitable for real-time alerts, while longer windows (e.g., `5m`) help smooth out temporary spikes and prevent false positives.
 2. Use the `for` Clause: Add a `for` clause to ensure that alerts are only triggered if a condition persists for a defined duration. This helps avoid alerting on transient issues or brief spikes:
-    
-    ```bash
-    for: 2m
-    ```
-    
+
+   ```bash
+   for: 2m
+   ```
+
 3. Tune Thresholds Based on Historical Data: Adjust alert thresholds by analyzing historical data to ensure alerts are triggered appropriately. Fine-tuning thresholds helps avoid both false positives and missed alerts.
 
 ### Integrating Alerts with Notification Systems
@@ -467,13 +493,13 @@ Integrating Prometheus alerts with notification systems ensures that you receive
 Example Alertmanager Configuration for Slack:
 
 ```jsx
-receivers:  
-- name: 'slack-alerts'  
-  slack_configs:  
-  - send_resolved: true  
-    channel: '#alerts'  
-    username: 'Prometheus'  
-    text: '{{ range .Alerts }}{{ .Annotations.summary }}\n{{ .Annotations.description }}\n{{ end }}'  
+receivers:
+- name: 'slack-alerts'
+  slack_configs:
+  - send_resolved: true
+    channel: '#alerts'
+    username: 'Prometheus'
+    text: '{{ range .Alerts }}{{ .Annotations.summary }}\n{{ .Annotations.description }}\n{{ end }}'
     api_url: 'https://hooks.slack.com/services/your/slack/webhook/url'
 ```
 
@@ -486,64 +512,64 @@ Dividing metrics in Prometheus can provide valuable insights but may impact quer
 To improve the efficiency of queries involving divided metrics, consider the following strategies:
 
 - Reduce Unnecessary Labels: Avoid using high-cardinality labels (like unique IDs or timestamps) unless absolutely necessary. Use relabeling to drop unnecessary labels before metrics are stored.
-    
-    ```bash
-    metric_relabel_configs:
-      - action: labeldrop
-        regex: (id|timestamp|session_id)
-    ```
-    
+  ```bash
+  metric_relabel_configs:
+    - action: labeldrop
+      regex: (id|timestamp|session_id)
+  ```
 - Aggregation Before Division: Use functions like `rate()`, `sum()`, or `avg()` to aggregate metrics before division.
 - Limit Time Range: Query only the time range needed for your analysis. Longer ranges increase both computation time and memory usage.
+
 1. Cache Frequently Divided Metrics
-    
-    In high-query environments, dividing metrics with every query can slow response times. Caching frequently divided metrics can improve performance by:
-    
-    - Reducing Redundant Calculations: Caching ensures division operations are only calculated once, reducing load and speeding up subsequent queries.
-    - Offloading Work: Caching lets Prometheus focus on tasks like data collection, while serving precomputed results for common queries.
-    - Faster Responses: Cached results are quickly retrieved, eliminating the need for repeated calculations.
+
+   In high-query environments, dividing metrics with every query can slow response times. Caching frequently divided metrics can improve performance by:
+
+   - Reducing Redundant Calculations: Caching ensures division operations are only calculated once, reducing load and speeding up subsequent queries.
+   - Offloading Work: Caching lets Prometheus focus on tasks like data collection, while serving precomputed results for common queries.
+   - Faster Responses: Cached results are quickly retrieved, eliminating the need for repeated calculations.
+
 2. Use Recording Rules
-    
-    Recording rules in Prometheus allow you to precompute and store frequently used metric divisions, reducing the computational load during queries. 
-    
-    ```bash
-    rules:
-      - record: :http_request_success_ratio:5m
-        expr: sum(rate(http_requests_success[5m])) / sum(rate(http_requests_total[5m]))
-    ```
-    
-    This strategy can significantly improve performance by:
-    
-    - Precomputing Divisions: Recording rules calculate and store divisions ahead of time, simplifying queries and reducing execution time.
-    - Reducing Load: Precomputed results lower the need for repeated calculations, helping manage query load.
-    - Improved Efficiency: Using stored metric divisions speeds up queries, as real-time calculation is no longer required.
+
+   Recording rules in Prometheus allow you to precompute and store frequently used metric divisions, reducing the computational load during queries.
+
+   ```bash
+   rules:
+     - record: :http_request_success_ratio:5m
+       expr: sum(rate(http_requests_success[5m])) / sum(rate(http_requests_total[5m]))
+   ```
+
+   This strategy can significantly improve performance by:
+
+   - Precomputing Divisions: Recording rules calculate and store divisions ahead of time, simplifying queries and reducing execution time.
+   - Reducing Load: Precomputed results lower the need for repeated calculations, helping manage query load.
+   - Improved Efficiency: Using stored metric divisions speeds up queries, as real-time calculation is no longer required.
 
 ## Troubleshooting Common Issues in Metric Division
 
 When working with metric division in Prometheus, several issues can arise that affect query results or performance. Here are some common issues and how to address them:
 
 1. "No Data" Results in Divided Queries:
-    - Issue: When dividing two metrics, you might receive "no data" as a result, even if both metrics return valid data when queried individually.
-    - Resolution:
-        - Verify that the queried metrics exist within the selected time range.
-        - Check if the data source is correctly configured and actively scraping metrics.
-        - If one of the metrics returns zero for any value, dividing by zero will result in "no data." Check for zero values in both metrics.
-2. Timestamp Mismatches between Metrics: 
-    - Issue: Metrics can have mismatched timestamps, meaning the data points from each metric do not align on the same time scale, leading to division errors or discrepancies.
-    - Resolution:
-        - Use the `rate()` or `irate()` function to normalize counters over time.
-        - Ensure time series are aligned by applying the `offset` modifier or aligning query ranges.
-3. Label Conflicts: 
-    - Issue: If the two metrics being divided have different or conflicting label sets, the division operation might fail or produce inaccurate results.
-    - Resolution:
-        - Use `ignoring()` or `on()` modifiers in PromQL to handle differences in label sets.
-        - Ensure that relevant labels match across the metrics being divided.
+   - Issue: When dividing two metrics, you might receive "no data" as a result, even if both metrics return valid data when queried individually.
+   - Resolution:
+     - Verify that the queried metrics exist within the selected time range.
+     - Check if the data source is correctly configured and actively scraping metrics.
+     - If one of the metrics returns zero for any value, dividing by zero will result in "no data." Check for zero values in both metrics.
+2. Timestamp Mismatches between Metrics:
+   - Issue: Metrics can have mismatched timestamps, meaning the data points from each metric do not align on the same time scale, leading to division errors or discrepancies.
+   - Resolution:
+     - Use the `rate()` or `irate()` function to normalize counters over time.
+     - Ensure time series are aligned by applying the `offset` modifier or aligning query ranges.
+3. Label Conflicts:
+   - Issue: If the two metrics being divided have different or conflicting label sets, the division operation might fail or produce inaccurate results.
+   - Resolution:
+     - Use `ignoring()` or `on()` modifiers in PromQL to handle differences in label sets.
+     - Ensure that relevant labels match across the metrics being divided.
 4. Scalar and Vector Mismatches in Division Operations:
-    - Issue: Dividing a scalar (single value) by a vector (multiple values) or vice versa can lead to unexpected results or errors in Prometheus queries.
-    - Resolution:
-        - Reduce cardinality by aggregating labels before performing the division.
-        - Use recording rules to precompute frequently used queries for faster results.
-        - Consider whether the operation makes sense mathematically and adjust the query accordingly
+   - Issue: Dividing a scalar (single value) by a vector (multiple values) or vice versa can lead to unexpected results or errors in Prometheus queries.
+   - Resolution:
+     - Reduce cardinality by aggregating labels before performing the division.
+     - Use recording rules to precompute frequently used queries for faster results.
+     - Consider whether the operation makes sense mathematically and adjust the query accordingly
 
 ## Enhancing Observability with SigNoz
 
@@ -556,31 +582,34 @@ SigNoz integrates seamlessly with Prometheus by leveraging the [OpenTelemetry co
 Here’s how SigNoz enhances your Prometheus setup:
 
 - Native PromQL support
-    
-    With SigNoz, you can leverage PromQL directly within the SigNoz platform. This feature allows you to perform metric divisions and calculations with ease. Whether you're interested in tracking error rates, resource utilization, or throughput, you can calculate these metrics directly from the [query builder](https://signoz.io/blog/query-builder-v5/) with just a few clicks.
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2011.webp" alt="Leveraging PromQL Query for custom dashboard generation" caption="Leveraging PromQL Query for custom dashboard generation" />
-    
+  With SigNoz, you can leverage PromQL directly within the SigNoz platform. This feature allows you to perform metric divisions and calculations with ease. Whether you're interested in tracking error rates, resource utilization, or throughput, you can calculate these metrics directly from the [query builder](https://signoz.io/blog/query-builder-v5/) with just a few clicks.
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2011.webp"
+    alt="Leveraging PromQL Query for custom dashboard generation"
+    caption="Leveraging PromQL Query for custom dashboard generation"
+  />
 - Visualizing Divided Metrics
-    
-    SigNoz provides an intuitive and powerful visual interface that allows you to display and analyze your divided metrics easily. Visualizing key performance indicators (KPIs) in a unified platform makes it simple to track trends, identify anomalies, and respond quickly to potential issues.
-    
-    Example Query for Metric Division in SigNoz
-    
-    ```jsx
-    system_cpu_load_average_5m / system_cpu_load_average_1m
-    ```
-    
-    This query calculates the ratio of the 5-minute average CPU load to the 1-minute average CPU load, helping you assess whether the system's load is increasing or stabilizing over time. By comparing longer-term trends (5 minutes) with short-term fluctuations (1 minute), you can gain valuable insights into your system's performance.
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2012.webp" alt="Tracking CPU Load Trends: 5-Min vs. 1-Min Average Ratio" caption="Tracking CPU Load Trends: 5-Min vs. 1-Min Average Ratio" /> 
-    
+  SigNoz provides an intuitive and powerful visual interface that allows you to display and analyze your divided metrics easily. Visualizing key performance indicators (KPIs) in a unified platform makes it simple to track trends, identify anomalies, and respond quickly to potential issues.
+  Example Query for Metric Division in SigNoz
+  ```jsx
+  system_cpu_load_average_5m / system_cpu_load_average_1m
+  ```
+  This query calculates the ratio of the 5-minute average CPU load to the 1-minute average CPU load, helping you assess whether the system's load is increasing or stabilizing over time. By comparing longer-term trends (5 minutes) with short-term fluctuations (1 minute), you can gain valuable insights into your system's performance.
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2012.webp"
+    alt="Tracking CPU Load Trends: 5-Min vs. 1-Min Average Ratio"
+    caption="Tracking CPU Load Trends: 5-Min vs. 1-Min Average Ratio"
+  />
 - Proactive Alerts Based on Divided Metrics
-    
-    Similarly, you can create alerts based on the same query provided, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) of system performance. By setting custom thresholds on divided metrics, SigNoz ensures you’re notified of potential issues before they impact your system. For more information on configuring custom metric alerts, refer to the [Official SigNoz documentation](https://signoz.io/docs/alerts-management/metrics-based-alerts/?utm_source=product&utm_medium=alert-creation-page).
-    
-    <Figure src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2013.webp" alt="Custom Alerts Based on PromQL Queries for CPU Load Monitoring" caption="Custom Alerts Based on PromQL Queries for CPU Load Monitoring" />
-    
+  Similarly, you can create alerts based on the same query provided, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) of system performance. By setting custom thresholds on divided metrics, SigNoz ensures you’re notified of potential issues before they impact your system. For more information on configuring custom metric alerts, refer to the [Official SigNoz documentation](https://signoz.io/docs/alerts-management/metrics-based-alerts/?utm_source=product&utm_medium=alert-creation-page).
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/divide-two-metrics-in-prometheus-image%2013.webp"
+    alt="Custom Alerts Based on PromQL Queries for CPU Load Monitoring"
+    caption="Custom Alerts Based on PromQL Queries for CPU Load Monitoring"
+  />
 
 <GetStartedSigNoz />
 
@@ -629,4 +658,4 @@ Absolutely. Metric division is valuable for capacity planning. You can:
 2. Project future needs based on historical growth rates.
 3. Determine efficiency metrics to optimize resource allocation.
 
-For example, to forecast CPU needs, you might divide the rate of increase in CPU usage by the rate of increase in workload to estimate future requirements.
\ No newline at end of file
+For example, to forecast CPU needs, you might divide the rate of increase in CPU usage by the rate of increase in workload to estimate future requirements.
diff --git a/data/guides/django-logging.mdx b/data/guides/django-logging.mdx
index cc5d3f8a9..e19df7a39 100644
--- a/data/guides/django-logging.mdx
+++ b/data/guides/django-logging.mdx
@@ -1,199 +1,208 @@
 ---
-
 title: Django Logging - Complete Guide to Python Django Logging
-slug: django-logging
 date: 2024-07-22
 tags: [logging]
 authors: [sushant_gaurav]
 description: Learn how to set up and optimize logging in Django applications. Discover configurations, best practices, and advanced techniques for effective logging and monitoring.
-keywords: [django logging, django logging example, django logging best practices, django logging to file, django logging formatter]
-
+keywords:
+  [
+    django logging,
+    django logging example,
+    django logging best practices,
+    django logging to file,
+    django logging formatter,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Django Logging - Complete Guide to Python Django Logging",
-    "alternativeHeadline": "Master Django logging - Learn setup, configuration, and advanced features for efficient, structured logging",
-    "author": {
-      "@type": "Person",
-      "name": "Sushant Gaurav"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-22T00:00:00Z",
-    "dateModified": "2024-07-22T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/django-logging/"
-    },
-    "description": "Learn how to set up and optimize logging in Django applications. Discover configurations, best practices, and advanced techniques for effective logging and monitoring.",
-    "keywords": "django logging, django logging example, django logging best practices, django logging to file, django logging formatter",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Django Logging",
-        "description": "A comprehensive guide to logging in Django applications"
-      },
-      {
-        "@type": "Thing",
-        "name": "Python",
-        "description": "A high-level programming language"
-      },
-      {
-        "@type": "Thing",
-        "name": "Logging",
-        "description": "The process of recording application events and errors"
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Django",
-        "applicationCategory": "Web Framework"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is Django Logging?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Django Logging is a mechanism provided by the Django module to record events and errors during the execution of a web application."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I log messages at different severity levels in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can use logger methods like logger.debug(), logger.info(), logger.warning(), logger.error(), and logger.critical() to log different severity levels in Django."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I set up different logging handlers in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Define handlers in the LOGGING configuration in settings.py and assign them to loggers."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I log database queries in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can enable the Django django.db.backends logger in the LOGGING configuration to log database queries in the Django application."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I log errors and exceptions in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can use the logger.error() and logger.exception() methods to capture and log exceptions in the Django application."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I filter logs by severity or other criteria in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can use the logging filters in the LOGGING configuration to include or exclude specific log messages."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I use Django logging with third-party libraries?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can configure logging for third-party libraries by including their loggers in the LOGGING configuration."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I benchmark the performance of logging in Django?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "We can use performance logging middleware and third-party tools like SigNoz to measure and analyze the impact of logging in our application."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Where can I find the documentation and examples for Django logging?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Refer to the official Django documentation and various online guides, articles, and tutorials for good examples and explanations."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Use Django Logging",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Django",
-          "text": "Install Django using pip: pip install django"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Create a Django Project",
-          "text": "Create a new Django project using django-admin startproject myproject"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Logging in settings.py",
-          "text": "Update the LOGGING configuration in settings.py to set up logging"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Import and Use Logging",
-          "text": "Import the logging module and use it in your Django views or models"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Set Up File Handlers",
-          "text": "Configure file handlers in settings.py to direct logs to files"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Implement Rotating File Handlers",
-          "text": "Use RotatingFileHandler to manage log file sizes and backups"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Log Requests and Responses in Middleware",
-          "text": "Create custom middleware to log request and response data"
-        }
-      ]
-    }
-  }) }}
-/>
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Django Logging - Complete Guide to Python Django Logging',
+        alternativeHeadline:
+          'Master Django logging - Learn setup, configuration, and advanced features for efficient, structured logging',
+        author: {
+          '@type': 'Person',
+          name: 'Sushant Gaurav',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-22T00:00:00Z',
+        dateModified: '2024-07-22T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/django-logging/',
+        },
+        description:
+          'Learn how to set up and optimize logging in Django applications. Discover configurations, best practices, and advanced techniques for effective logging and monitoring.',
+        keywords:
+          'django logging, django logging example, django logging best practices, django logging to file, django logging formatter',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Django Logging',
+            description: 'A comprehensive guide to logging in Django applications',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Python',
+            description: 'A high-level programming language',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logging',
+            description: 'The process of recording application events and errors',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Django',
+            applicationCategory: 'Web Framework',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is Django Logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Django Logging is a mechanism provided by the Django module to record events and errors during the execution of a web application.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I log messages at different severity levels in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can use logger methods like logger.debug(), logger.info(), logger.warning(), logger.error(), and logger.critical() to log different severity levels in Django.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I set up different logging handlers in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Define handlers in the LOGGING configuration in settings.py and assign them to loggers.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I log database queries in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can enable the Django django.db.backends logger in the LOGGING configuration to log database queries in the Django application.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I log errors and exceptions in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can use the logger.error() and logger.exception() methods to capture and log exceptions in the Django application.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I filter logs by severity or other criteria in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can use the logging filters in the LOGGING configuration to include or exclude specific log messages.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I use Django logging with third-party libraries?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can configure logging for third-party libraries by including their loggers in the LOGGING configuration.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I benchmark the performance of logging in Django?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'We can use performance logging middleware and third-party tools like SigNoz to measure and analyze the impact of logging in our application.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where can I find the documentation and examples for Django logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Refer to the official Django documentation and various online guides, articles, and tutorials for good examples and explanations.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Django Logging',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Django',
+              text: 'Install Django using pip: pip install django',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Django Project',
+              text: 'Create a new Django project using django-admin startproject myproject',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Logging in settings.py',
+              text: 'Update the LOGGING configuration in settings.py to set up logging',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Import and Use Logging',
+              text: 'Import the logging module and use it in your Django views or models',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up File Handlers',
+              text: 'Configure file handlers in settings.py to direct logs to files',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Rotating File Handlers',
+              text: 'Use RotatingFileHandler to manage log file sizes and backups',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Log Requests and Responses in Middleware',
+              text: 'Create custom middleware to log request and response data',
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
 In web applications, logging is quite important as it helps in monitoring and debugging our application. Django is a popular web framework of Python that provides us with a lot of robust logging capabilities which can help the developers to keep track of application behaviour and issues.
@@ -264,8 +273,8 @@ Explanation:
 - `disable_existing_loggers`: It keeps the existing loggers enabled (hence set to `False`).
 - `handlers`: Handlers are used to define how log messages are handled. The `console` handler directs messages to the console with a logging level of `DEBUG` and uses `logging.StreamHandler` to stream the logs. We can change the logging level here as well according to the use case.
 - `loggers`: It specifies the loggers. The Django logger:
-    - It uses the `console` handler which is defined earlier.
-    - It sets its logging level to the value of the `DJANGO_LOG_LEVEL` environment variable, with the default value of `DEBUG` if the variable is not set.
+  - It uses the `console` handler which is defined earlier.
+  - It sets its logging level to the value of the `DJANGO_LOG_LEVEL` environment variable, with the default value of `DEBUG` if the variable is not set.
 
 This simple yet effective setup ensures that all log messages from our Django application are sent to the console.
 
@@ -337,13 +346,13 @@ LOGGING = {
 Explanation:
 
 - `formatters`: Here we are defining the format of log messages.
-    - `verbose`: The `verbose` Django [logging formatter](https://signoz.io/guides/what-is-pythons-default-logging-formatter/#example-of-a-simple-logging-formatter) includes detailed information in the log messages. Detailed information includes the log level, timestamp, module name, and the actual log message. This format is specified using the string formatting style of Python.
-    - `simple`: The `simple` Django logging formatter is more straightforward and includes only the log level and the log message.
+  - `verbose`: The `verbose` Django [logging formatter](https://signoz.io/guides/what-is-pythons-default-logging-formatter/#example-of-a-simple-logging-formatter) includes detailed information in the log messages. Detailed information includes the log level, timestamp, module name, and the actual log message. This format is specified using the string formatting style of Python.
+  - `simple`: The `simple` Django logging formatter is more straightforward and includes only the log level and the log message.
 - `handlers`: Handlers are used to determine where the log messages are to be displayed or stored.
-    - `file`: The `file` handler writes the log messages to a file named `debug.log`. It captures all messages with a `DEBUG` level or higher and formats them using the `verbose` formatter. The `class` is set here to `logging.FileHandler`, which directs the generated logs to a file.
-    - `console`: The `console` handler streams log messages to the console. It uses the `simple` Django logging formatter and the `logging.StreamHandler` class to output logs to the standard output stream.
+  - `file`: The `file` handler writes the log messages to a file named `debug.log`. It captures all messages with a `DEBUG` level or higher and formats them using the `verbose` formatter. The `class` is set here to `logging.FileHandler`, which directs the generated logs to a file.
+  - `console`: The `console` handler streams log messages to the console. It uses the `simple` Django logging formatter and the `logging.StreamHandler` class to output logs to the standard output stream.
 - `loggers`: The `loggers` section defines the loggers for the application.
-    - `django`: Here the `django` logger is configured to use both the `file` and `console` handlers. It will capture all messages at the `DEBUG` level or higher. So, every log message from Django will be written to both the `debug.log` file and to the console.
+  - `django`: Here the `django` logger is configured to use both the `file` and `console` handlers. It will capture all messages at the `DEBUG` level or higher. So, every log message from Django will be written to both the `debug.log` file and to the console.
 
 Example:
 
@@ -393,9 +402,7 @@ INFO 2024-07-01 12:34:56.789 views Custom logging view was called
 ```
 
 - Note:
-    
-    This is a sample code, you can utilize it in your project as per your use case.
-    
+  This is a sample code, you can utilize it in your project as per your use case.
 
 ### Logging to Files
 
@@ -466,9 +473,7 @@ DEBUG 2024-07-01 12:34:56.789 views File logging view was called
 ```
 
 - Note:
-    
-    This is a sample code, you can utilize it in your project as per your use case. 
-    
+  This is a sample code, you can utilize it in your project as per your use case.
 
 Rotating File Handlers for Log File Management
 
@@ -561,9 +566,7 @@ DEBUG Console logging view was called
 ```
 
 - Note:
-    
-    This is a sample code, you can utilize it in your project as per your use case. 
-    
+  This is a sample code, you can utilize it in your project as per your use case.
 
 ### Sending Logs to Monitoring Services
 
@@ -753,11 +756,11 @@ Explanation:
 - `post_save`: It is a built-in Django signal that is sent at the end of the save method of a model.
 - `receiver`: `receiver` is a decorator that is used to register a function as a signal receiver.
 - `@receiver(post_save, sender='myapp.MyModel')`: The `receiver` decorator registers the `log_model_save` function as a receiver for `post_save` signals from the `MyModel` model in the `myapp` application.
-- `def log_model_save(sender, instance, created, kwargs)`**: It defines the function that will be called when the signal is sent.
-    - `sender`: It is the model class that sends the signal.
-    - `instance`: The actual instance of the model that was saved.
-    - `created`: A boolean indicating whether a new record was created (True) or an existing record was updated (False).
-    - `*kwargs`: Additional keyword arguments.
+- `def log_model_save(sender, instance, created, kwargs)`\*\*: It defines the function that will be called when the signal is sent.
+  - `sender`: It is the model class that sends the signal.
+  - `instance`: The actual instance of the model that was saved.
+  - `created`: A boolean indicating whether a new record was created (True) or an existing record was updated (False).
+  - `*kwargs`: Additional keyword arguments.
 
 ### Exception Logging
 
@@ -845,7 +848,7 @@ Here are the key reasons why [monitoring logs](https://signoz.io/blog/log-monito
 7. Proactive maintenance
 8. Support and customer service
 
-To cover all the above major components, you can make use of tools like [SigNoz](https://signoz.io/). 
+To cover all the above major components, you can make use of tools like [SigNoz](https://signoz.io/).
 
 StructLog is easily connected with a variety of monitoring systems to improve observability. This allows you to better understand your application's behaviour and performance.
 
@@ -856,13 +859,9 @@ SigNoz is a full-stack open-source application performance monitoring and obser
 Key architecture features:
 
 - Logs, Metrics, and traces under a single dashboard
-    
-    SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
-    
+  SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
 - Native OpenTelemetry support
-    
-    SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
-    
+  SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
 
 ### Setup SigNoz
 
@@ -921,7 +920,7 @@ We can use the `logger.error()` and `logger.exception()` methods to capture and
 
 We can use the logging filters in the `LOGGING` configuration to include or exclude specific log messages.
 
-### How do I use Django logging with third-party libraries?**
+### How do I use Django logging with third-party libraries?\*\*
 
 We can configure logging for third-party libraries by including their loggers in the `LOGGING` configuration.
 
diff --git a/data/guides/docker-clear-logs.mdx b/data/guides/docker-clear-logs.mdx
index 55e9916a9..b5877f9e2 100644
--- a/data/guides/docker-clear-logs.mdx
+++ b/data/guides/docker-clear-logs.mdx
@@ -1,11 +1,24 @@
 ---
-title: "How to Clear Docker Container Logs Safely (5+ Methods and Automation)"
-slug: "docker-clear-logs"
-date: "2025-07-24"
+title: 'How to Clear Docker Container Logs Safely (5+ Methods and Automation)'
+date: '2025-07-24'
 tags: [Docker, Logging]
 authors: [nitin_gouda]
-description: "Learn 5+ safe methods to clear Docker container logs and prevent disk space issues. Includes log rotation setup, truncation commands, automation techniques, and monitoring integration."
-keywords: [Docker logs, clear Docker logs, Docker logging, truncate Docker logs, delete Docker logs, Docker log management, Docker log rotation, Docker logging drivers, automate Docker logs, Docker performance maintenance, disk space cleanup, container logs]
+description: 'Learn 5+ safe methods to clear Docker container logs and prevent disk space issues. Includes log rotation setup, truncation commands, automation techniques, and monitoring integration.'
+keywords:
+  [
+    Docker logs,
+    clear Docker logs,
+    Docker logging,
+    truncate Docker logs,
+    delete Docker logs,
+    Docker log management,
+    Docker log rotation,
+    Docker logging drivers,
+    automate Docker logs,
+    Docker performance maintenance,
+    disk space cleanup,
+    container logs,
+  ]
 ---
 
 [Docker container logs](https://signoz.io/guides/docker-view-logs/) can consume disk space rapidly and impact system performance when unmanaged. A single long-running container can generate gigabytes of log data, leading to **"No Space Left on Device"** errors that bring entire systems to a halt. This guide covers proven methods to safely clear Docker logs, implement automated rotation, and prevent future disk space issues.
@@ -16,7 +29,11 @@ Whether you're dealing with emergency disk space situations or implementing proa
 
 Docker captures all output from containerized applications through `stdout` and `stderr` streams. By default, Docker uses the `json-file` logging driver, storing logs as JSON-formatted files in `/var/lib/docker/containers/<container_id>/<container_id>-json.log` on the host system.
 
-<Figure src="/img/guides/2024/07/docker-clear-logs-Screenshot_2024-07-16_at_5.01.07_AM.webp" alt="Docker logs" caption="Docker logs growing over time can consume significant disk space" />
+<Figure
+  src="/img/guides/2024/07/docker-clear-logs-Screenshot_2024-07-16_at_5.01.07_AM.webp"
+  alt="Docker logs"
+  caption="Docker logs growing over time can consume significant disk space"
+/>
 
 ### The Problem: Uncontrolled Log Growth
 
@@ -85,23 +102,23 @@ docker run -d \
 Implement log rotation in your `docker-compose.yml` files:
 
 ```yaml
-version: "3.8"
+version: '3.8'
 services:
   web:
     image: nginx:latest
     logging:
-      driver: "local"
+      driver: 'local'
       options:
-        max-size: "10m"
-        max-file: "3"
-  
+        max-size: '10m'
+        max-file: '3'
+
   database:
     image: postgres:13
     logging:
-      driver: "local"
+      driver: 'local'
       options:
-        max-size: "20m"
-        max-file: "5"
+        max-size: '20m'
+        max-file: '5'
 ```
 
 This approach ensures consistent log management across your entire application stack.
@@ -161,21 +178,25 @@ For scenarios requiring complete log removal, deletion provides thorough cleanup
 ### Safe Deletion Process
 
 1. **Stop the container** (recommended for safety):
+
 ```bash
 docker stop container_name
 ```
 
 2. **Delete the log file**:
+
 ```bash
 rm /var/lib/docker/containers/<container_id>/<container_id>-json.log
 ```
 
 3. **Restart Docker daemon** (to recreate log file structure):
+
 ```bash
 sudo systemctl restart docker
 ```
 
 4. **Start the container**:
+
 ```bash
 docker start container_name
 ```
@@ -369,16 +390,16 @@ cleanup_large_logs() {
     find "$LOG_DIR" -name "*-json.log" -size +$MAX_SIZE -exec bash -c '
         container_id=$(basename $(dirname "$1"))
         container_name=$(docker inspect --format="{{.Name}}" "$container_id" 2>/dev/null | sed "s/^///")
-        
+
         if [ -n "$container_name" ]; then
             echo "Cleaning logs for container: $container_name ($container_id)"
-            
+
             # Create backup before cleanup
             cp "$1" "'"$BACKUP_DIR"'/$(date +%Y%m%d-%H%M%S)-$container_name.log"
-            
+
             # Truncate the log file
             truncate -s 0 "$1"
-            
+
             echo "Cleaned: $1 ($(du -h "$1" | cut -f1))"
         fi
     ' bash {} \;
@@ -424,9 +445,9 @@ check_log_sizes() {
         container_id=$(basename $(dirname "$1"))
         container_name=$(docker inspect --format="{{.Name}}" "$container_id" 2>/dev/null | sed "s/^///")
         size=$(du -h "$1" | cut -f1)
-        
+
         echo "ALERT: Container $container_name has log file size: $size"
-        
+
         # Optional: Send email alert
         # echo "Container $container_name log size exceeded threshold: $size" | mail -s "Docker Log Alert" $EMAIL
     ' bash {} \;
@@ -493,6 +514,7 @@ fi
 ### "No Space Left on Device" Errors
 
 **Immediate Solution:**
+
 ```bash
 # Quick space recovery
 sudo truncate -s 0 /var/lib/docker/containers/*/*-json.log
@@ -502,6 +524,7 @@ docker system prune -a -f
 ```
 
 **Root Cause Prevention:**
+
 - Implement log rotation configuration
 - Set up disk usage monitoring
 - Create automated cleanup scripts
@@ -511,6 +534,7 @@ docker system prune -a -f
 **Problem**: Many expect `docker restart` to clear logs, but logs persist across container restarts.
 
 **Solution**: Logs are only cleared when containers are removed and recreated:
+
 ```bash
 # This DOES NOT clear logs
 docker restart container_name
@@ -523,6 +547,7 @@ docker run [original_options] image_name
 ### Log Rotation Not Working
 
 **Verification Steps:**
+
 ```bash
 # Check Docker daemon configuration
 cat /etc/docker/daemon.json
@@ -538,12 +563,12 @@ docker run -d --log-opt max-size=1m --log-opt max-file=2 busybox sh -c 'while tr
 
 ### Log Clearing Methods Comparison
 
-| Method | Speed | Safety | Downtime | Use Case |
-|--------|-------|---------|----------|-----------|
-| Truncation | Fast | High | None | Running containers |
-| Deletion | Fast | Medium | Required | Maintenance windows |
-| Rotation | Automated | High | None | Preventive measure |
-| Driver Config | Automated | High | None | New deployments |
+| Method        | Speed     | Safety | Downtime | Use Case            |
+| ------------- | --------- | ------ | -------- | ------------------- |
+| Truncation    | Fast      | High   | None     | Running containers  |
+| Deletion      | Fast      | Medium | Required | Maintenance windows |
+| Rotation      | Automated | High   | None     | Preventive measure  |
+| Driver Config | Automated | High   | None     | New deployments     |
 
 ### Disk Space Recovery Results
 
@@ -558,11 +583,15 @@ Based on real-world implementations:
 
 SigNoz provides comprehensive [observability for Docker environments](https://signoz.io/docs/userguide/collect_docker_logs/) through advanced log management capabilities integrated with OpenTelemetry. The platform features Docker-specific log collection with automatic service detection, enhanced log processing through logspout-signoz, and real-time log analysis with correlation across metrics, logs, and traces.
 
-<Figure src="/img/guides/2025/07/docker-clear-logs-signoz-logs.webp" alt="Docker container logs in SigNoz" caption="Docker container logs in SigNoz" />
+<Figure
+  src="/img/guides/2025/07/docker-clear-logs-signoz-logs.webp"
+  alt="Docker container logs in SigNoz"
+  caption="Docker container logs in SigNoz"
+/>
 
 SigNoz offers an [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)-based approach for Docker log collection, featuring pre-configured setups for seamless integration. The platform's logspout-signoz router automatically detects service names and metadata from Docker containers, enriching logs with context for better filtering and querying capabilities.
 
-You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features. 
+You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features.
 
 Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
@@ -579,7 +608,7 @@ Effective Docker log management requires a multi-layered approach combining prev
 1. **Prevention First**: Configure log rotation using Docker's built-in drivers or docker-compose settings
 2. **Safe Cleaning**: Use truncation for running containers, deletion only during maintenance windows
 3. **Automation**: Implement scheduled cleanup scripts and monitoring alerts
-4. **Integration**: Leverage centralized logging solutions like [SigNoz](https://signoz.io/docs/introduction/) for comprehensive observability  
+4. **Integration**: Leverage centralized logging solutions like [SigNoz](https://signoz.io/docs/introduction/) for comprehensive observability
 5. **Best Practices**: Establish clear retention policies, implement structured logging, and maintain security protocols
 
 By following these practices and implementing the methods outlined in this guide, you'll maintain optimal Docker performance while ensuring log data remains available for troubleshooting and analysis when needed.
diff --git a/data/guides/docker-compose-logs.mdx b/data/guides/docker-compose-logs.mdx
index b221a1916..552a25dff 100644
--- a/data/guides/docker-compose-logs.mdx
+++ b/data/guides/docker-compose-logs.mdx
@@ -1,12 +1,12 @@
 ---
 title: Complete Guide to Docker Compose Logs
-slug: docker-compose-logs
 date: 2024-07-03
 tags: [logging]
 authors: [daniel]
 description: Docker Compose logs provide invaluable insights into the behavior of your containerized applications, providing visibility into…
 keywords: [docker, logs, logging, docker compose]
 ---
+
 Docker Compose logs provide invaluable insights into the behavior of your containerized applications, providing visibility into runtime events, errors, and system interactions. Understanding and managing these logs is vital or maintaining and troubleshooting Docker Compose environments effectively.
 
 This guide covers what you need to know about Docker Compose logs, including their use cases, how they can be accessed and best practices for optimal logging within Docker Compose environments.
diff --git a/data/guides/docker-daemon-logs.mdx b/data/guides/docker-daemon-logs.mdx
index db1181c59..b29170760 100644
--- a/data/guides/docker-daemon-logs.mdx
+++ b/data/guides/docker-daemon-logs.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Access and Understand Docker Daemon Logs
-slug: docker-daemon-logs
 date: 2024-07-31
 tags: [logging]
 authors: [aayush_sharma]
 description: Learn how to access, understand, and leverage Docker daemon logs for troubleshooting, security, and optimizing your container infrastructure.
-keywords: [docker daemon logs, container management, troubleshooting, log analysis, debugging, docker security, performance optimization]
-
+keywords:
+  [
+    docker daemon logs,
+    container management,
+    troubleshooting,
+    log analysis,
+    debugging,
+    docker security,
+    performance optimization,
+  ]
 ---
 
 Docker has revolutionized application deployment and management. At its core, the Docker daemon orchestrates container operations. Understanding [Docker daemon logs](https://signoz.io/guides/docker-daemon-logs/#reading-and-interpreting-docker-daemon-logs) is crucial for effective troubleshooting and maintaining a healthy Docker environment. This guide will walk you through accessing, interpreting, and leveraging Docker daemon logs to optimize your container infrastructure.
@@ -31,11 +37,11 @@ Docker daemon logs differ from container logs. While container logs focus on app
 
 ## Locating Docker Daemon Logs on Different Systems
 
-The location of Docker daemon logs varies depending on your operating system and Docker installation method. 
+The location of Docker daemon logs varies depending on your operating system and Docker installation method.
 
 ### Linux Systems
 
-On older Docker versions and Linux hosts, Docker daemon logs are located at the `/var/log/syslog` or `/var/log/messages` directories. For modern Linux distributions and recent Docker versions, Docker logs are stored in the journal files under `/var/log/journal`. This is because, on most modern Linux distributions using `systemd`, Docker uses the default logging settings, which typically log to the system journal managed by `systemd` (i.e., `journald`). 
+On older Docker versions and Linux hosts, Docker daemon logs are located at the `/var/log/syslog` or `/var/log/messages` directories. For modern Linux distributions and recent Docker versions, Docker logs are stored in the journal files under `/var/log/journal`. This is because, on most modern Linux distributions using `systemd`, Docker uses the default logging settings, which typically log to the system journal managed by `systemd` (i.e., `journald`).
 
 On most Linux distributions using systemd, you can access the Docker daemon logs using:
 
@@ -49,7 +55,7 @@ For systems not using systemd, check:
 /var/log/docker.log
 ```
 
-Older systems using SysVinit: 
+Older systems using SysVinit:
 
 ```bash
 /var/log/upstart/docker.log
@@ -61,17 +67,21 @@ Common Docker Daemon Log Locations on Different Linux Flavours
 - CentOS: `/var/log/messages`
 - Fedora: `/var/log/daemon.log`
 
-To identify the location where [Docker logs](https://signoz.io/guides/docker-logs-location/) are stored on your Linux system, you need to check the Docker service file. The Docker service file contains configuration details about how the Docker daemon is started and managed. On systems using `systemd`, this file is typically located at `/lib/systemd/system/docker.service`. 
+To identify the location where [Docker logs](https://signoz.io/guides/docker-logs-location/) are stored on your Linux system, you need to check the Docker service file. The Docker service file contains configuration details about how the Docker daemon is started and managed. On systems using `systemd`, this file is typically located at `/lib/systemd/system/docker.service`.
 
 To see the Docker service file content:
 
 ```jsx
-cat /lib/systemd/system/docker.service
+cat / lib / systemd / system / docker.service
 ```
 
 Look for the `ExecStart` line to see how the Docker daemon is being started.
 
-<Figure src="/img/guides/2024/07/docker-daemon-logs-Untitled.webp" alt="Docker Service Details" caption="Docker Service Details" />
+<Figure
+  src="/img/guides/2024/07/docker-daemon-logs-Untitled.webp"
+  alt="Docker Service Details"
+  caption="Docker Service Details"
+/>
 
 From the above screenshot, the `ExecStart` line in the Docker service unit file, specifically `/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock`, indicates that Docker is set up to use socket activation with `systemd`. In this setup, the Docker daemon communicates with `systemd` via the file descriptor passed (`fd://`), and `systemd` handles the activation and monitoring of the Docker service.
 
@@ -85,7 +95,11 @@ journalctl -xu docker.service
 
 The above command displays and filters the `systemd` journal logs for messages related to the Docker service, including errors.
 
-<Figure src="/img/guides/2024/07/docker-daemon-logs-Untitled%201.webp" alt="Docker daemon logs" caption="Docker daemon logs" />
+<Figure
+  src="/img/guides/2024/07/docker-daemon-logs-Untitled%201.webp"
+  alt="Docker daemon logs"
+  caption="Docker daemon logs"
+/>
 
 Non-standard installations might use different locations. Check your Docker configuration file (`/etc/docker/daemon.json`) for custom log paths.
 
@@ -99,7 +113,7 @@ Docker daemon (dockerd) logs are stored within the filesystem of the WSL2 VM tha
 
 ### macOS
 
-On macOS, the Docker Engine itself is not directly supported. However, you can use Docker on macOS through Docker Desktop. 
+On macOS, the Docker Engine itself is not directly supported. However, you can use Docker on macOS through Docker Desktop.
 
 The Docker daemon logs, tagged as dockerd on macOS, are stored at:
 
@@ -167,7 +181,11 @@ sudo dockerd --debug
 
 After running the above command you will get daemon debug logs as output, example logs:
 
-<Figure src="/img/guides/2024/07/docker-daemon-logs-Untitled%202.webp" alt="Untitled" caption="Docker Logs" />
+<Figure
+  src="/img/guides/2024/07/docker-daemon-logs-Untitled%202.webp"
+  alt="Untitled"
+  caption="Docker Logs"
+/>
 
 Note: Ensure docker is not running while fetching the daemon logs or it will throw this error:
 
@@ -209,32 +227,32 @@ The Docker daemon logs messages at various levels that indicate the severity or
 ## Troubleshooting Common Issues Using Daemon Logs
 
 1. Container startup failures:
-    - Look for "level=error" messages related to the container ID
-    - Check for resource constraints or missing dependencies
+   - Look for "level=error" messages related to the container ID
+   - Check for resource constraints or missing dependencies
 2. Network connectivity problems:
-    - Search for "network" or "connectivity" in log messages
-    - Verify Docker network configurations and firewall rules
+   - Search for "network" or "connectivity" in log messages
+   - Verify Docker network configurations and firewall rules
 3. Resource constraints:
-    - Monitor for "out of memory" or "CPU throttling" messages
-    - Adjust container resource limits or host system resources
+   - Monitor for "out of memory" or "CPU throttling" messages
+   - Adjust container resource limits or host system resources
 4. Security events:
-    - Watch for "unauthorized" or "permission denied" messages
-    - Review access controls and user permissions
+   - Watch for "unauthorized" or "permission denied" messages
+   - Review access controls and user permissions
 
 ## Best Practices for Docker Daemon Logging
 
 1. Implement log rotation to manage file sizes:
-    - Use [logrotate](https://signoz.io/guides/logrotate-linux/) on Linux systems
-    - Configure Docker to use json-file logging driver with max-size and max-file options
+   - Use [logrotate](https://signoz.io/guides/logrotate-linux/) on Linux systems
+   - Configure Docker to use json-file logging driver with max-size and max-file options
 2. Secure log files:
-    - Set appropriate file permissions (e.g., `chmod 640 /var/log/docker.log`)
-    - Use [log management tools](https://signoz.io/blog/open-source-log-management/) with access controls
+   - Set appropriate file permissions (e.g., `chmod 640 /var/log/docker.log`)
+   - Use [log management tools](https://signoz.io/blog/open-source-log-management/) with access controls
 3. Integrate with monitoring systems:
-    - Set up alerts for critical events (e.g., daemon crashes, resource exhaustion)
-    - Use tools like [SigNoz](https://signoz.io/docs/introduction/) for visualization.
+   - Set up alerts for critical events (e.g., daemon crashes, resource exhaustion)
+   - Use tools like [SigNoz](https://signoz.io/docs/introduction/) for visualization.
 4. Regularly review logs:
-    - Schedule routine log audits
-    - Look for patterns indicating potential issues or optimization opportunities
+   - Schedule routine log audits
+   - Look for patterns indicating potential issues or optimization opportunities
 
 ## Key Takeaways
 
diff --git a/data/guides/docker-logs-grep.mdx b/data/guides/docker-logs-grep.mdx
index 4c3d1dd86..f6cc1e91d 100644
--- a/data/guides/docker-logs-grep.mdx
+++ b/data/guides/docker-logs-grep.mdx
@@ -1,13 +1,21 @@
 ---
-
 title: How to Grep Docker Logs - A Quick Guide
-slug: docker-logs-grep
 date: 2024-07-30
 tags: [logging]
 authors: [bhavya_sachdeva]
 description: This guide explores using `grep` with Docker logs for efficient log analysis and troubleshooting. It covers basic and advanced techniques, and best practices for log management.
-keywords: [Docker logs, grep commands, container monitoring, log analysis, debugging containers, performance bottlenecks, DevOps tools, real-time log parsing, advanced grep techniques]
-
+keywords:
+  [
+    Docker logs,
+    grep commands,
+    container monitoring,
+    log analysis,
+    debugging containers,
+    performance bottlenecks,
+    DevOps tools,
+    real-time log parsing,
+    advanced grep techniques,
+  ]
 ---
 
 In containerized environments, efficient log analysis is crucial for maintaining application health and performance. One powerful tool for this purpose is `grep`, a command-line utility that allows users to search for specific strings within text. Combining Docker logs with `grep` can streamline troubleshooting and debugging processes by pinpointing relevant log entries quickly.
@@ -16,7 +24,7 @@ In containerized environments, efficient log analysis is crucial for maintaining
 
 Docker logs provide crucial insights into container behavior — they are a window into an application's runtime environment. Grep, a powerful text-searching tool, allows you to sift through these logs with precision. When combined, Docker logs and grep form a formidable duo for debugging and monitoring containerized applications.
 
-Why use grep with Docker logs? 
+Why use grep with Docker logs?
 
 It's simple: you can quickly pinpoint specific events, errors, or patterns within the sea of log data. This combination proves invaluable when troubleshooting issues in complex microservices architectures or monitoring application health.
 
@@ -27,7 +35,7 @@ Common use cases include:
 - Identifying performance bottlenecks
 - Auditing security-related events
 
-Let’s discuss one of the common use cases where a developer needs to track down frequent error messages in a highly active container. 
+Let’s discuss one of the common use cases where a developer needs to track down frequent error messages in a highly active container.
 
 To search for "error" in a container named "opentelemetry-signoz-sample-order-1":
 
@@ -37,7 +45,11 @@ docker logs opentelemetry-signoz-sample-order-1 | grep -i "error"
 
 This command filters the logs to only show entries containing "error," helping the developer quickly focus on potential issues.
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.04.34_AM.webp" alt="Grep error output" caption="Grep error output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.04.34_AM.webp"
+  alt="Grep error output"
+  caption="Grep error output"
+/>
 
 ## Basic Syntax for Grepping Docker Logs
 
@@ -60,7 +72,7 @@ Grep offers several options to refine your searches:
 
 1.  `-i`: Performs case-insensitive matching
 
-The `-i` flag makes the search case-insensitive, allowing you to find all instances of a specified pattern regardless of case. This is particularly useful when you're unsure of the case used in the logs or when the case might vary. Let’s say a developer is notified about recurring errors in a specific container and needs to identify these errors to begin troubleshooting quickly. 
+The `-i` flag makes the search case-insensitive, allowing you to find all instances of a specified pattern regardless of case. This is particularly useful when you're unsure of the case used in the logs or when the case might vary. Let’s say a developer is notified about recurring errors in a specific container and needs to identify these errors to begin troubleshooting quickly.
 
 ```bash
 docker logs [container_name] 2>&1 | grep -i [pattern]
@@ -70,31 +82,35 @@ docker logs [container_name] 2>&1 | grep -i [pattern]
 docker logs opentelemetry-signoz-sample-product-1> 2>&1 | grep -i error
 ```
 
-The command `docker logs [container_name] 2>&1 | grep -i [pattern]` is used to search through a Docker container's logs for a specific pattern, ignoring case differences. 
+The command `docker logs [container_name] 2>&1 | grep -i [pattern]` is used to search through a Docker container's logs for a specific pattern, ignoring case differences.
 
 - `docker logs [container_name]`: Fetches logs from the specified Docker container.
 - `2>&1`: Redirects all output (standard and error) to one stream for consistent handling.
 - `|`: Pipes the combined output to the next command.
-- `grep -i [pattern]`:  Filters the output, showing only lines that contain the specified pattern in a case-insensitive manner.
+- `grep -i [pattern]`: Filters the output, showing only lines that contain the specified pattern in a case-insensitive manner.
 
 This command is particularly useful for quickly finding errors or specific events in container logs.
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.08.05_AM.webp" alt="grep -i output" caption="grep -i output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.08.05_AM.webp"
+  alt="grep -i output"
+  caption="grep -i output"
+/>
 
 This command filters the logs to display only those containing the term "error," allowing the developer to focus on potentially critical issues without distraction.
 
 1. `-v:` Inverts the match, showing lines that don't contain the pattern
 
-The `-v` option inverts the match, showing all lines that do *not* contain the specified pattern. This is useful when you want to exclude certain messages from the logs, such as routine operations or successful executions. 
+The `-v` option inverts the match, showing all lines that do _not_ contain the specified pattern. This is useful when you want to exclude certain messages from the logs, such as routine operations or successful executions.
 
 ```bash
 docker logs [container_name] 2>&1 | grep -v [pattern]
 ```
 
 - `|`: This pipe takes the output from the previous command and passes it to the next command.
-- `grep -v [pattern]`: Filters the logs. The `v` option with `grep` inverts the match, meaning it only shows log lines that do *not* contain the word `pattern`.
+- `grep -v [pattern]`: Filters the logs. The `v` option with `grep` inverts the match, meaning it only shows log lines that do _not_ contain the word `pattern`.
 
 Let’s say a person from Ops wants to check the logs for all events except those marked as "success" to focus on potential problems. This helps focus on logs that might indicate issues by excluding those that confirm successful operations.
 
@@ -104,9 +120,13 @@ docker logs opentelemetry-signoz-sample-order-1 2>&1 | grep -v success
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.10.22_AM.webp" alt="grep -v output" caption="grep -v output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.10.22_AM.webp"
+  alt="grep -v output"
+  caption="grep -v output"
+/>
 
-*grep -v output*
+_grep -v output_
 
 1. `-n`: Displays line numbers alongside matches
 
@@ -116,7 +136,7 @@ The `-n` flag adds line numbers to the grep output. This is particularly useful
 docker logs [container_name] 2>&1 | grep -n [pattern]
 ```
 
-To know the exact location or line of “error” within the logs. This gives you the exact line number at which a particular log containing an error is located. 
+To know the exact location or line of “error” within the logs. This gives you the exact line number at which a particular log containing an error is located.
 
 ```bash
 docker logs opentelemetry-signoz-sample-order-1 2>&1 | grep -n "error"
@@ -124,7 +144,11 @@ docker logs opentelemetry-signoz-sample-order-1 2>&1 | grep -n "error"
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.13.40_AM.webp" alt="grep -n output" caption="grep -n output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.13.40_AM.webp"
+  alt="grep -n output"
+  caption="grep -n output"
+/>
 
 1. `-C`: Shows context lines before and after matches
 
@@ -146,7 +170,11 @@ This command retrieves logs from the Docker container named `opentelemetry-signo
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-834e7acc-867b-4f52-b3e4-bf2a26f858b8.webp" alt="Flag -C output" caption="Flag -C output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-834e7acc-867b-4f52-b3e4-bf2a26f858b8.webp"
+  alt="Flag -C output"
+  caption="Flag -C output"
+/>
 
 These options can be combined for more powerful searches. For instance, `-in` performs a case-insensitive search with line numbers.
 
@@ -182,7 +210,11 @@ docker logs --since 2024-07-25T18:30:00 --until 2024-07-26T18:30:00 opentelemetr
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-26_at_4.43.35_PM.webp" alt="Time based filtering output" caption="Time based filtering output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-26_at_4.43.35_PM.webp"
+  alt="Time based filtering output"
+  caption="Time based filtering output"
+/>
 
 This approach allows you to isolate the logs within a specific time window, making it easier to perform a detailed analysis without the distraction of irrelevant data. It's particularly useful for debugging transient issues that occurred at known times or reviewing system behavior during scheduled events (e.g., a new release deployment).
 
@@ -209,7 +241,11 @@ This command filters logs to find lines containing "success" and then counts the
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.21.18_AM.webp" alt="Combination of grep with another command" caption="Combination of grep with another command" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.21.18_AM.webp"
+  alt="Combination of grep with another command"
+  caption="Combination of grep with another command"
+/>
 
 1. Multiple Grep Commands
 
@@ -229,7 +265,11 @@ This command chain first filters log entries containing "error" and then exclude
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.23.33_AM.webp" alt="Multiple grep command" caption="Multiple grep command" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.23.33_AM.webp"
+  alt="Multiple grep command"
+  caption="Multiple grep command"
+/>
 
 1. Using awk for Complex Parsing
 
@@ -250,15 +290,19 @@ After filtering the logs for entries containing "success", this command uses `aw
 
 You should see a similar output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_7.56.59_AM.webp" alt="grep with awk" caption="grep with awk" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_7.56.59_AM.webp"
+  alt="grep with awk"
+  caption="grep with awk"
+/>
 
-*grep with awk*
+_grep with awk_
 
 ### Handling Multi-line Log Entries
 
-Multi-line log entries, common in complex applications, present unique challenges for analysis. They often contain crucial details that are spread across several lines, making traditional single-line grep searches inadequate. 
+Multi-line log entries, common in complex applications, present unique challenges for analysis. They often contain crucial details that are spread across several lines, making traditional single-line grep searches inadequate.
 
-Multi-line log entries require advanced techniques because important information is often not contained within a single line. 
+Multi-line log entries require advanced techniques because important information is often not contained within a single line.
 
 - For logs in JSON format, tools like `jq` become essential by making it possible to extract and filter specific data fields, making the analysis more manageable and focused.
 - These strategies are essential for maintaining an efficient workflow in environments where quick diagnostics and responses are required to ensure application reliability and performance.
@@ -268,7 +312,7 @@ Here are practical strategies and scenarios for effectively managing and analyzi
 
 1. Use Grep's Context Options
 
-Using `grep`'s context options allows you to view not just the line of interest but also the surrounding lines, which are often key to understanding the event fully. 
+Using `grep`'s context options allows you to view not just the line of interest but also the surrounding lines, which are often key to understanding the event fully.
 
 ```bash
 docker logs [container_name] 2>&1 | grep -A [num] "[pattern]"
@@ -288,7 +332,11 @@ This shows the line which contains the word product and 5 lines after it.
 
 You will see the below output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.26.41_AM.webp" alt="Grep Context Options" caption="Grep Context Options" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.26.41_AM.webp"
+  alt="Grep Context Options"
+  caption="Grep Context Options"
+/>
 
 1. Parse [JSON logs](https://signoz.io/blog/json-logs/) with jq and grep:
 
@@ -311,7 +359,11 @@ This extracts the 'message' field from JSON logs and searches for errors.
 
 You will see the below output:
 
-<Figure src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.25.07_AM.webp" alt="Docker logs output" caption="Docker logs output" />
+<Figure
+  src="/img/guides/2024/08/docker-logs-grep-Screenshot_2024-07-29_at_1.25.07_AM.webp"
+  alt="Docker logs output"
+  caption="Docker logs output"
+/>
 
 ## Best Practices and Optimization
 
@@ -320,11 +372,11 @@ To maximize the effectiveness of grepping Docker logs:
 1. Use specific search patterns to reduce false positives.
 2. Create aliases for common log search commands.
 3. Consider using `--tail` to limit the amount of log data processed:
-    
-    ```bash
-    docker logs --tail 1000 <container-name> 2>&1 | grep error
-    ```
-    
+
+   ```bash
+   docker logs --tail 1000 <container-name> 2>&1 | grep error
+   ```
+
 4. For large log files, use `zgrep` on compressed log archives.
 5. Implement log rotation to manage log file sizes and improve grep performance.
 6. Be mindful of the potential performance impact when grepping large log files on production systems.
@@ -354,7 +406,7 @@ While grep is powerful for command-line log analysis, SigNoz provides a more com
 
 <GetStartedSigNoz />
 
-Read how to send [Docker Logs to SigNoz](https://signoz.io/docs/userguide/collect_docker_logs/). 
+Read how to send [Docker Logs to SigNoz](https://signoz.io/docs/userguide/collect_docker_logs/).
 
 ## Conclusion
 
@@ -394,4 +446,3 @@ Use `docker ps` to check the status of running containers.
 ### How to use Docker service logs?
 
 Use `docker service logs [service-id]` to view logs for a specific Docker service.
-
diff --git a/data/guides/docker-logs-location.mdx b/data/guides/docker-logs-location.mdx
index 2d1c05ec9..a253873f1 100644
--- a/data/guides/docker-logs-location.mdx
+++ b/data/guides/docker-logs-location.mdx
@@ -1,11 +1,18 @@
 ---
-title: "Docker Logs Location: Where are Docker Logs Stored?"
-slug: "docker-logs-location"
-date: "2025-09-03"
+title: 'Docker Logs Location: Where are Docker Logs Stored?'
+date: '2025-09-03'
 tags: [docker, logging]
 authors: [daniel]
 description: "The command 'docker logs <container-name>' works across all platforms. Docker logs are stored in /var/lib/docker/containers/<container-id>/<container-id>-json.log on Linux and ..."
-keywords: [docker logs location, docker container logs, var lib docker containers, docker logs command, docker log files, container logging]
+keywords:
+  [
+    docker logs location,
+    docker container logs,
+    var lib docker containers,
+    docker logs command,
+    docker log files,
+    container logging,
+  ]
 ---
 
 When your Docker container crashes at 3 AM, you need to find its logs quickly. No time for guesswork or hunting through documentation—you need the exact path to those log files.
@@ -13,7 +20,7 @@ When your Docker container crashes at 3 AM, you need to find its logs quickly. N
 **Here's what you need to know immediately:**
 
 - **Linux**: `/var/lib/docker/containers/<container-id>/<container-id>-json.log`
-- **Windows**: `C:\ProgramData\docker\containers\<container-id>\<container-id>-json.log`  
+- **Windows**: `C:\ProgramData\docker\containers\<container-id>\<container-id>-json.log`
 - **macOS**: Within Docker Desktop VM, accessible via `docker logs` command
 - **Universal command**: `docker logs <container-name>` works across all platforms
 
@@ -42,12 +49,14 @@ docker inspect --format='{{.Id}}' <container-name>
 Docker generates two distinct types of logs:
 
 **Container Logs** capture your application's stdout/stderr output:
+
 - Application messages and errors
-- Debug information  
+- Debug information
 - Runtime events
 - Performance metrics
 
 **Daemon Logs** record Docker engine events:
+
 - Container lifecycle operations
 - Image management activities
 - Network configuration changes
@@ -114,7 +123,7 @@ With Docker Desktop using WSL2, logs are actually within the WSL2 VM:
 
 **Daemon Logs:** Available in Windows Event Viewer under Applications and Services Logs → Docker.
 
-### macOS Systems  
+### macOS Systems
 
 Docker Desktop runs containers inside a Linux VM. Logs are within:
 
@@ -128,7 +137,7 @@ Docker Desktop runs containers inside a Linux VM. Logs are within:
 # Docker daemon logs
 tail -f ~/Library/Containers/com.docker.docker/Data/log/vm/dockerd.log
 
-# Container runtime logs  
+# Container runtime logs
 tail -f ~/Library/Containers/com.docker.docker/Data/log/vm/containerd.log
 ```
 
@@ -210,11 +219,11 @@ services:
   web:
     image: nginx
     logging:
-      driver: "json-file"
+      driver: 'json-file'
       options:
-        max-size: "10m"
-        max-file: "3"
-        compress: "true"
+        max-size: '10m'
+        max-file: '3'
+        compress: 'true'
 ```
 
 ### Emergency Cleanup
@@ -225,7 +234,7 @@ When logs have already consumed too much space:
 # Find largest log files
 find /var/lib/docker/containers/ -name "*json.log" -exec du -h {} \; | sort -hr
 
-# Truncate logs for running containers (use carefully)  
+# Truncate logs for running containers (use carefully)
 sudo truncate -s 0 /var/lib/docker/containers/*/*-json.log
 
 # Remove logs for stopped containers
@@ -265,7 +274,7 @@ Integrate with systemd journal:
 
 ```json
 {
-  "log-driver": "journald", 
+  "log-driver": "journald",
   "log-opts": {
     "tag": "{{.ImageName}}/{{.Name}}"
   }
@@ -345,15 +354,17 @@ While direct log access works for debugging, production environments need scalab
   caption="SigNoz Dashboard provides comprehensive log management capabilities"
 />
 
-**Integration Benefits**: 
+**Integration Benefits**:
+
 - Pre-configured setup with ready-to-use `docker-compose.yaml` files
 - Enhanced log organization using logspout-[signoz](https://signoz.io/docs/introduction/) for automatic service labeling
 - Correlation with metrics and traces for complete [container observability](https://signoz.io/guides/container-monitoring/)
 - Efficient storage using ClickHouse columnar database
 
 **Production Features**:
+
 - Live tail logging across multiple containers
-- Custom dashboards for Docker log analytics  
+- Custom dashboards for Docker log analytics
 - Anomaly detection for proactive issue identification
 - Advanced retention and archiving policies
 
@@ -376,7 +387,7 @@ While direct log access works for debugging, production environments need scalab
 SigNoz simplifies Docker log collection through:
 
 1. **Environment configuration** with `OTEL_COLLECTOR_ENDPOINT` and ingestion keys
-2. **Automated collection** via OpenTelemetry receivers 
+2. **Automated collection** via OpenTelemetry receivers
 3. **Enhanced metadata** through logspout-signoz integration
 
 You can get started by following the [Docker logs collection guide](https://signoz.io/docs/userguide/collect_docker_logs/) in the SigNoz documentation.
diff --git a/data/guides/docker-logs-tail.mdx b/data/guides/docker-logs-tail.mdx
index ea4595b7f..7a45c1a87 100644
--- a/data/guides/docker-logs-tail.mdx
+++ b/data/guides/docker-logs-tail.mdx
@@ -1,11 +1,22 @@
 ---
-title: "Docker Logs Tail: How to Live Tail Docker Logs"
-slug: "docker-logs-tail"
-date: "2025-09-03"
+title: 'Docker Logs Tail: How to Live Tail Docker Logs'
+date: '2025-09-03'
 tags: [docker, logging]
 authors: [nitin_gouda]
 description: "Stream real-time logs with the follow flag: 'docker logs -f <container_id_or_name>'. Limit initial output to prevent overwhelming your terminal..."
-keywords: [tail docker logs, docker logs tail, docker logs follow, container log monitoring, docker logging, log tailing, real-time logs, docker troubleshooting, container debugging, SigNoz]
+keywords:
+  [
+    tail docker logs,
+    docker logs tail,
+    docker logs follow,
+    container log monitoring,
+    docker logging,
+    log tailing,
+    real-time logs,
+    docker troubleshooting,
+    container debugging,
+    SigNoz,
+  ]
 ---
 
 When containers fail or behave unexpectedly, real-time log access becomes your first line of defense. Docker's native logging provides the foundation, but understanding its capabilities, limitations, and performance characteristics is crucial for effective troubleshooting and monitoring in production environments.
@@ -20,12 +31,12 @@ Docker captures application output streams (`stdout` and `stderr`) through confi
 
 Different logging drivers have varying performance characteristics and `docker logs` compatibility:
 
-| Driver | Performance | docker logs Support | Use Case |
-|--------|-------------|-------------------|-----------|
-| json-file | Good for small files, degrades with size | ✅ Full support | Development, small deployments |
-| syslog | Low overhead, network dependent | ❌ Use syslog tools | System integration |
-| journald | Moderate overhead, structured | ✅ Supported | systemd environments |
-| fluentd | Network overhead, async | ❌ Use Fluentd interface | Production aggregation |
+| Driver    | Performance                              | docker logs Support      | Use Case                       |
+| --------- | ---------------------------------------- | ------------------------ | ------------------------------ |
+| json-file | Good for small files, degrades with size | ✅ Full support          | Development, small deployments |
+| syslog    | Low overhead, network dependent          | ❌ Use syslog tools      | System integration             |
+| journald  | Moderate overhead, structured            | ✅ Supported             | systemd environments           |
+| fluentd   | Network overhead, async                  | ❌ Use Fluentd interface | Production aggregation         |
 
 The choice of logging driver directly impacts both performance and available tooling for log access.
 
@@ -74,6 +85,7 @@ docker logs -f --since 30m --tail 50 <container_id>
 ```
 
 **Supported time formats:**
+
 - Relative: `5m`, `2h`, `1d`
 - RFC3339: `2025-07-23T10:00:00Z`
 - Unix timestamps: `1642780800`
@@ -133,12 +145,14 @@ Docker's linear search mechanism causes significant performance degradation with
 **Solutions**:
 
 1. **Use time-based filtering instead of line counting**:
+
    ```bash
    # Instead of: docker logs --tail 10000 <container>
    # Use: docker logs --since 30m <container>
    ```
 
 2. **Configure log rotation at container level**:
+
    ```bash
    docker run --log-opt max-size=50m --log-opt max-file=5 nginx
    ```
@@ -180,6 +194,7 @@ lsof | grep docker | wc -l
 **Symptoms**: `docker logs --tail` hangs indefinitely.
 
 **Diagnosis**:
+
 ```bash
 # Check container status
 docker ps -a | grep <container_id>
@@ -192,6 +207,7 @@ docker logs --tail 1 <container_id>
 ```
 
 **Solutions**:
+
 - Restart [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) if persistent: `sudo systemctl restart docker`
 - Check filesystem space and permissions
 - Verify container hasn't been manually modified
@@ -199,11 +215,13 @@ docker logs --tail 1 <container_id>
 ### Missing Log Entries
 
 **Common causes**:
+
 - Application logging to files instead of stdout/stderr
 - TTY allocation race conditions
 - Logging driver rate limiting
 
 **Diagnostic steps**:
+
 ```bash
 # Check if app logs to files
 docker exec <container> find / -name "*.log" 2>/dev/null
@@ -225,6 +243,7 @@ docker inspect <container> | jq '.[0].HostConfig.LogConfig.Type'
 ```
 
 **Alternative access methods**:
+
 - **syslog**: `journalctl -f CONTAINER_NAME=<name>`
 - **journald**: `journalctl -fu docker.service`
 - **fluentd**: Access through Fluentd aggregation interface
@@ -263,13 +282,13 @@ Create `otel-collector-config.yaml`:
 ```yaml
 receivers:
   tcplog/docker:
-    listen_address: "0.0.0.0:2255"
+    listen_address: '0.0.0.0:2255'
     operators:
       - type: regex_parser
         regex: '^<([0-9]+)>[0-9]+ (?P<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?) (?P<container_id>\\S+) (?P<container_name>\\S+) [0-9]+ - -( (?P<body>.*))?'
         timestamp:
           parse_from: attributes.timestamp
-          layout: "%Y-%m-%dT%H:%M:%S.%LZ"
+          layout: '%Y-%m-%dT%H:%M:%S.%LZ'
       - type: move
         from: attributes["body"]
         to: body
@@ -285,7 +304,7 @@ exporters:
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": ${env:SIGNOZ_INGESTION_KEY}
+      'signoz-ingestion-key': ${env:SIGNOZ_INGESTION_KEY}
 
 service:
   pipelines:
@@ -307,17 +326,17 @@ services:
     image: signoz/signoz-otel-collector:v0.111.42
     container_name: signoz-otel-collector
     command:
-      - "--config=/etc/otel-collector-config.yaml"
+      - '--config=/etc/otel-collector-config.yaml'
     volumes:
       - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
     env_file:
       - ./.env
     ports:
-      - "4317:4317"
-      - "4318:4318"
+      - '4317:4317'
+      - '4318:4318'
 
   logspout:
-    image: "gliderlabs/logspout:v3.2.14"
+    image: 'gliderlabs/logspout:v3.2.14'
     container_name: signoz-logspout
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
@@ -336,7 +355,11 @@ docker compose up -d
 
 Access your SigNoz dashboard to view centralized logs with advanced filtering, search, and correlation capabilities.
 
-<Figure src="/img/guides/2024/07/docker-logs-tail-image1.webp" alt="SigNoz cloud dashboard to view logs" caption="SigNoz cloud dashboard to view logs" />
+<Figure
+  src="/img/guides/2024/07/docker-logs-tail-image1.webp"
+  alt="SigNoz cloud dashboard to view logs"
+  caption="SigNoz cloud dashboard to view logs"
+/>
 
 ### Production Monitoring Features
 
diff --git a/data/guides/docker-view-logs.mdx b/data/guides/docker-view-logs.mdx
index fbe2efeff..aa509b89f 100644
--- a/data/guides/docker-view-logs.mdx
+++ b/data/guides/docker-view-logs.mdx
@@ -1,11 +1,20 @@
 ---
-title: "How to View Docker Container Logs - A Complete Step-by-Step Guide"
-slug: "docker-view-logs"
-date: "2025-09-02"
+title: 'How to View Docker Container Logs - A Complete Step-by-Step Guide'
+date: '2025-09-02'
 tags: [docker, logging]
 authors: [bhavya_sachdeva]
 description: "The most basic command retrieves all available logs: 'docker logs test-nginx'. You can use either container names or IDs."
-keywords: [docker logs, container logging, docker troubleshooting, log analysis, docker commands, container monitoring, log rotation, docker logging drivers]
+keywords:
+  [
+    docker logs,
+    container logging,
+    docker troubleshooting,
+    log analysis,
+    docker commands,
+    container monitoring,
+    log rotation,
+    docker logging drivers,
+  ]
 ---
 
 Docker containers generate critical telemetry data through their logs, but accessing and analyzing this information efficiently can be challenging without the right approach. Whether you're debugging a failing deployment, monitoring application performance, or investigating security incidents, understanding Docker's logging capabilities is fundamental to maintaining healthy containerized systems.
@@ -42,7 +51,11 @@ The most basic command retrieves all available logs:
 docker logs test-nginx
 ```
 
-<Figure src="/img/guides/2025/07/docker-view-logs-view-all-container-logs.webp" alt="Docker Logs Command" caption="View all container logs" />
+<Figure
+  src="/img/guides/2025/07/docker-view-logs-view-all-container-logs.webp"
+  alt="Docker Logs Command"
+  caption="View all container logs"
+/>
 
 You can use either container names or IDs:
 
@@ -58,7 +71,11 @@ For active monitoring, use the `--follow` flag to stream logs as they're generat
 docker logs --follow test-nginx
 ```
 
-<Figure src="/img/guides/2025/07/docker-view-logs-live-logs.webp" alt="Docker Logs Command" caption="Real-time log streaming" />
+<Figure
+  src="/img/guides/2025/07/docker-view-logs-live-logs.webp"
+  alt="Docker Logs Command"
+  caption="Real-time log streaming"
+/>
 
 This is essential for troubleshooting active issues or monitoring deployments. Press Ctrl+C to stop streaming.
 
@@ -252,9 +269,9 @@ services:
     logging:
       driver: local
       options:
-        max-size: "15m"
-        max-file: "7"
-        compress: "true"
+        max-size: '15m'
+        max-file: '7'
+        compress: 'true'
 ```
 
 ## Production Best Practices
@@ -301,14 +318,16 @@ Configure appropriate rotation balancing retention needs with storage:
 
 ```javascript
 // Example structured logging
-console.log(JSON.stringify({
-  timestamp: new Date().toISOString(),
-  level: 'info',
-  service: 'web-api',
-  message: 'User authentication successful',
-  userId: 'user123',
-  requestId: 'req-456'
-}));
+console.log(
+  JSON.stringify({
+    timestamp: new Date().toISOString(),
+    level: 'info',
+    service: 'web-api',
+    message: 'User authentication successful',
+    userId: 'user123',
+    requestId: 'req-456',
+  })
+)
 ```
 
 **Implement correlation**: Use correlation IDs to connect related log entries across containers.
@@ -332,24 +351,31 @@ SigNoz offers comprehensive log management built on OpenTelemetry standards, pro
 SigNoz collects [Docker logs](https://signoz.io/guides/docker-logs-location/) through a pre-configured setup using the OpenTelemetry Collector:
 
 1. **Clone the repository**:
+
 ```bash
 git clone https://github.com/SigNoz/docker-container-logs
 ```
 
 2. **Configure environment variables** in the `.env` file:
+
 ```
 OTEL_COLLECTOR_ENDPOINT=ingest.<region>.signoz.cloud:443
 SIGNOZ_INGESTION_KEY=<your-ingestion-key>
 ```
 
 3. **Start the collector**:
+
 ```bash
 docker compose up -d
 ```
 
 This setup automatically forwards all Docker container logs to SigNoz with minimal configuration changes to your existing deployments.
 
-<Figure src="/img/guides/2025/07/docker-view-logs-signoz.webp" alt="Docker Logs Command" caption="Docker container logs in SigNoz" />
+<Figure
+  src="/img/guides/2025/07/docker-view-logs-signoz.webp"
+  alt="Docker Logs Command"
+  caption="Docker container logs in SigNoz"
+/>
 
 ### Advanced Capabilities
 
@@ -362,7 +388,7 @@ This setup automatically forwards all Docker container logs to SigNoz with minim
 
 SigNoz provides comprehensive [log management capabilities](https://signoz.io/log-management/) with its advanced [query builder](https://signoz.io/docs/userguide/query-builder/) for Docker environments. The platform offers fast log ingestion, correlation with metrics and traces, and powerful visualization features.
 
-You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features. 
+You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features.
 
 Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
diff --git a/data/guides/does-kubernetes-use-prometheus.mdx b/data/guides/does-kubernetes-use-prometheus.mdx
index 571028fbc..53645a714 100644
--- a/data/guides/does-kubernetes-use-prometheus.mdx
+++ b/data/guides/does-kubernetes-use-prometheus.mdx
@@ -1,157 +1,160 @@
 ---
-
 title: Does Kubernetes use Prometheus?
-slug: does-kubernetes-use-prometheus
 date: 2024-07-15
 tags: [faq]
 authors: [daniel]
 description: Prometheus can be configured to scrape metrics from Kubernetes resources, enabling detailed insights into the performance and health of the applications and infrastructure within the cluster.
-keywords: [monitoring,Kubernetes,Prometheus,metrics]
-
+keywords: [monitoring, Kubernetes, Prometheus, metrics]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Does Kubernetes use Prometheus?",
-    "alternativeHeadline": "Understanding the Role of Prometheus in Monitoring Kubernetes",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-15T00:00:00Z",
-    "dateModified": "2024-07-15T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/does-kubernetes-use-prometheus/"
-    },
-    "description": "Prometheus can be configured to scrape metrics from Kubernetes resources, enabling detailed insights into the performance and health of the applications and infrastructure within the cluster.",
-    "keywords": "monitoring, Kubernetes, Prometheus, metrics",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Kubernetes",
-        "description": "An open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The process of observing and checking the behavior and outputs of a system."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Does Kubernetes use Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "No, Kubernetes does not inherently use Prometheus, but Prometheus is often deployed alongside Kubernetes to provide robust monitoring and alerting capabilities."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus is a robust open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, allowing users to query and analyze the data using its powerful query language, PromQL."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is Kubernetes?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Does Kubernetes use Prometheus?',
+        alternativeHeadline: 'Understanding the Role of Prometheus in Monitoring Kubernetes',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How does Kubernetes use Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Kubernetes leverages Prometheus for monitoring and observability. Prometheus integrates deeply with Kubernetes to collect, store, and analyze metrics, providing insights into the performance and health of Kubernetes clusters and applications running on them."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What are the benefits of using Prometheus with Kubernetes?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The benefits include service discovery, a pull-based model, a multi-dimensional data model, scalability, and the use of exporters. These features enable effective monitoring and alerting in dynamic Kubernetes environments."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Use Prometheus with Kubernetes",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Deploy Prometheus",
-          "text": "Deploy Prometheus in your Kubernetes cluster using Helm or custom manifests."
+        datePublished: '2024-07-15T00:00:00Z',
+        dateModified: '2024-07-15T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/does-kubernetes-use-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Service Discovery",
-          "text": "Set up Prometheus service discovery to automatically detect Kubernetes resources."
+        description:
+          'Prometheus can be configured to scrape metrics from Kubernetes resources, enabling detailed insights into the performance and health of the applications and infrastructure within the cluster.',
+        keywords: 'monitoring, Kubernetes, Prometheus, metrics',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Scrape Metrics",
-          "text": "Configure Prometheus to scrape metrics from Kubernetes components and applications."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes',
+            description:
+              'An open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The process of observing and checking the behavior and outputs of a system.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Does Kubernetes use Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'No, Kubernetes does not inherently use Prometheus, but Prometheus is often deployed alongside Kubernetes to provide robust monitoring and alerting capabilities.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus is a robust open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, allowing users to query and analyze the data using its powerful query language, PromQL.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does Kubernetes use Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Kubernetes leverages Prometheus for monitoring and observability. Prometheus integrates deeply with Kubernetes to collect, store, and analyze metrics, providing insights into the performance and health of Kubernetes clusters and applications running on them.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the benefits of using Prometheus with Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The benefits include service discovery, a pull-based model, a multi-dimensional data model, scalability, and the use of exporters. These features enable effective monitoring and alerting in dynamic Kubernetes environments.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Up Alerting",
-          "text": "Integrate Prometheus with Alertmanager to manage alerts."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Prometheus with Kubernetes',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Deploy Prometheus',
+              text: 'Deploy Prometheus in your Kubernetes cluster using Helm or custom manifests.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Service Discovery',
+              text: 'Set up Prometheus service discovery to automatically detect Kubernetes resources.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Scrape Metrics',
+              text: 'Configure Prometheus to scrape metrics from Kubernetes components and applications.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Alerting',
+              text: 'Integrate Prometheus with Alertmanager to manage alerts.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize Metrics',
+              text: 'Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize Metrics",
-          "text": "Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 No, Kubernetes does not inherently use Prometheus, but Prometheus is often deployed alongside Kubernetes to provide robust monitoring and alerting capabilities. Kubernetes, being a dynamic environment where resources are constantly created, modified, and destroyed, poses significant challenges in tracking system health and performance metrics. Prometheus addresses these challenges effectively by providing powerful monitoring capabilities tailored to such dynamic environments.
@@ -162,7 +165,7 @@ Prometheus is a robust open-source monitoring and alerting toolkit. It is design
 
 ## What is Kubernetes?
 
-Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. 
+Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.
 
 ## How does Kubernetes use Prometheus?
 
@@ -192,7 +195,7 @@ Kubernetes components (like the kubelet) and many applications running on Kubern
 
 Collecting Kubernetes cluster metrics data using Prometheus is essential for understanding your cluster's health and performance. While Prometheus excels at data collection, its limited UI can make in-depth analysis and visualization challenging. A dedicated monitoring and visualization tool like [SigNoz](https://signoz.io/docs/introduction/) is a good choice for getting insights from your metrics data.
 
-SigNoz is an open-source observability platform designed to help you monitor your applications and infrastructure. It provides metrics monitoring, distributed tracing, and log management in a unified platform. 
+SigNoz is an open-source observability platform designed to help you monitor your applications and infrastructure. It provides metrics monitoring, distributed tracing, and log management in a unified platform.
 
 Why use SigNoz?
 
diff --git a/data/guides/dropwizard-metrics-meters-vs-timers.mdx b/data/guides/dropwizard-metrics-meters-vs-timers.mdx
index 9dce6ce75..85e565fa6 100644
--- a/data/guides/dropwizard-metrics-meters-vs-timers.mdx
+++ b/data/guides/dropwizard-metrics-meters-vs-timers.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: What is the Difference between DropWizard Metrics - Meters vs Timers
-slug: dropwizard-metrics-meters-vs-timers
 date: 2024-11-07
 tags: [faq]
 authors: [nilesh_sinha]
 description: Explore the key differences between DropWizard Metrics Meters and Timers, their use cases, and implementation strategies for effective application monitoring.
-keywords: [DropWizard Metrics, Meters, Timers, Java monitoring, application performance, metrics implementation, SigNoz integration]
-
+keywords:
+  [
+    DropWizard Metrics,
+    Meters,
+    Timers,
+    Java monitoring,
+    application performance,
+    metrics implementation,
+    SigNoz integration,
+  ]
 ---
 
 DropWizard Metrics provides powerful tools for monitoring Java applications, with Meters and Timers being two essential components. These metrics offer distinct approaches to measuring application performance, each with its own strengths and use cases. Understanding the differences between Meters and Timers is crucial for developers and DevOps professionals seeking to implement effective monitoring strategies. This article delves into the specifics of DropWizard Metrics Meters vs Timers, their implementation, and how to choose the right metric for your needs.
@@ -23,198 +29,197 @@ The library's popularity stems from its simplicity and effectiveness in providin
 DropWizard Metrics provides five core [metric types](https://signoz.io/docs/metrics-management/types-and-aggregation/) that serve distinct purposes, ensuring comprehensive and accurate application performance monitoring. Each metric type helps developers track different aspects of their application:
 
 1. Gauges: A gauge is the simplest type of metric that measures a single value at a specific point in time, making it suitable for tracking instantaneous values like memory usage, queue size, or the number of active threads.
-    
-    Example of a Gauge:
-    
-    ```java
-    package org.example;
-    
-    import com.codahale.metrics.MetricRegistry;
-    
-    import java.util.LinkedList;
-    import java.util.Queue;
-    
-    public class Main {
-        public static void main(String[] args) {
-    
-    				MetricRegistry metrics = new MetricRegistry();
-    				Queue<String> queue = new LinkedList<>();
-    				
-    				// Register a gauge metric that monitors the queue size
-    				metrics.register("queue-size", (Gauge<Integer>) queue::size);
-    				
-    				// Simulate adding elements to the queue
-    				queue.add("Request 1");
-    				queue.add("Request 2");
-    				
-    				// Output: Should display the current size of the queue
-    				System.out.println("Queue size: " + metrics.getGauges().get("queue-size").getValue());
-           }
-    }
-    ```
-    
-    Here, the `queue-size` gauge tracks the number of items in a queue. Every time the gauge is called, it returns the current queue size. This is useful for monitoring data structures, like queues, that may vary in size as tasks are added or removed.
-    
-    Output:
-    
-    ```java
-    Queue size: 2
-    ```
-    
+
+   Example of a Gauge:
+
+   ```java
+   package org.example;
+
+   import com.codahale.metrics.MetricRegistry;
+
+   import java.util.LinkedList;
+   import java.util.Queue;
+
+   public class Main {
+       public static void main(String[] args) {
+
+   				MetricRegistry metrics = new MetricRegistry();
+   				Queue<String> queue = new LinkedList<>();
+
+   				// Register a gauge metric that monitors the queue size
+   				metrics.register("queue-size", (Gauge<Integer>) queue::size);
+
+   				// Simulate adding elements to the queue
+   				queue.add("Request 1");
+   				queue.add("Request 2");
+
+   				// Output: Should display the current size of the queue
+   				System.out.println("Queue size: " + metrics.getGauges().get("queue-size").getValue());
+          }
+   }
+   ```
+
+   Here, the `queue-size` gauge tracks the number of items in a queue. Every time the gauge is called, it returns the current queue size. This is useful for monitoring data structures, like queues, that may vary in size as tasks are added or removed.
+
+   Output:
+
+   ```java
+   Queue size: 2
+   ```
+
 2. Counters: A counter is a metric that only increments or decrements, tracking a count of how many times an event has occurred. It’s useful for counting things like the number of requests received, the number of errors, or the number of tasks completed.
-    
-    Example of a Counter:
-    
-    ```java
-    package org.example;
-    
-    import com.codahale.metrics.*;
-    
-    public class Main {
-        public static void main(String[] args){
-    
-            MetricRegistry metrics = new MetricRegistry();
-           // Create a counter metric to track the number of processed requests
-            Counter requestCounter = metrics.counter("requests");
-    
-            // Increment the counter to simulate receiving requests
-            requestCounter.inc();  // Increment by 1
-            requestCounter.inc(3); // Increment by 3
-    
-            // Output: Should display the total number of requests
-            System.out.println("Total requests: " + requestCounter.getCount());
-           }
-    }
-    ```
-    
-    The counter named `requests` track how many requests have been processed. Calling `inc()` increments the counter by 1, and `inc(3)` adds 3 to the counter. Counters are useful for counting discrete events, like user logins or API calls.
-    
-    Output:
-    
-    ```java
-    Total requests: 4
-    ```
-    
+
+   Example of a Counter:
+
+   ```java
+   package org.example;
+
+   import com.codahale.metrics.*;
+
+   public class Main {
+       public static void main(String[] args){
+
+           MetricRegistry metrics = new MetricRegistry();
+          // Create a counter metric to track the number of processed requests
+           Counter requestCounter = metrics.counter("requests");
+
+           // Increment the counter to simulate receiving requests
+           requestCounter.inc();  // Increment by 1
+           requestCounter.inc(3); // Increment by 3
+
+           // Output: Should display the total number of requests
+           System.out.println("Total requests: " + requestCounter.getCount());
+          }
+   }
+   ```
+
+   The counter named `requests` track how many requests have been processed. Calling `inc()` increments the counter by 1, and `inc(3)` adds 3 to the counter. Counters are useful for counting discrete events, like user logins or API calls.
+
+   Output:
+
+   ```java
+   Total requests: 4
+   ```
+
 3. Histograms: A histogram measures the statistical distribution of a set of values, tracking metrics like the minimum, maximum, median, percentiles, and standard deviation. It is preferred for measuring sizes and latency, like response times or the sizes of payloads, to understand the range and distribution of values.
-    
-    Example of a Histogram:
-    
-    ```java
-    package org.example;
-    
-    import com.codahale.metrics.*;
-    
-    public class Main {
-        public static void main(String[] args) {
-    
-            MetricRegistry metrics = new MetricRegistry();
-            
-            // Create a histogram metric to track response sizes
-            Histogram responseSizes = metrics.histogram("response-sizes");
-    
-            // Update the histogram with various response sizes (in bytes)
-            responseSizes.update(500);   // Response 1
-            responseSizes.update(1500);  // Response 2
-            responseSizes.update(200);   // Response 3
-    
-            // Output: Displays the min, max, and mean response sizes
-            System.out.println("Min response size: " + responseSizes.getSnapshot().getMin());
-            System.out.println("Max response size: " + responseSizes.getSnapshot().getMax());
-            System.out.println("Mean response size: " + responseSizes.getSnapshot().getMean());
-        }
-    }
-    ```
-    
-    This histogram records the distribution of response sizes. After updating it with three response sizes, we can retrieve statistics like the minimum, maximum, and mean sizes. Histograms help visualize the spread and frequency of values, making them useful for performance analysis.
-    
-    Output:
-    
-    ```java
-    Min response size: 200
-    Max response size: 1500
-    Mean response size: 733.33
-    ```
-    
+
+   Example of a Histogram:
+
+   ```java
+   package org.example;
+
+   import com.codahale.metrics.*;
+
+   public class Main {
+       public static void main(String[] args) {
+
+           MetricRegistry metrics = new MetricRegistry();
+
+           // Create a histogram metric to track response sizes
+           Histogram responseSizes = metrics.histogram("response-sizes");
+
+           // Update the histogram with various response sizes (in bytes)
+           responseSizes.update(500);   // Response 1
+           responseSizes.update(1500);  // Response 2
+           responseSizes.update(200);   // Response 3
+
+           // Output: Displays the min, max, and mean response sizes
+           System.out.println("Min response size: " + responseSizes.getSnapshot().getMin());
+           System.out.println("Max response size: " + responseSizes.getSnapshot().getMax());
+           System.out.println("Mean response size: " + responseSizes.getSnapshot().getMean());
+       }
+   }
+   ```
+
+   This histogram records the distribution of response sizes. After updating it with three response sizes, we can retrieve statistics like the minimum, maximum, and mean sizes. Histograms help visualize the spread and frequency of values, making them useful for performance analysis.
+
+   Output:
+
+   ```java
+   Min response size: 200
+   Max response size: 1500
+   Mean response size: 733.33
+   ```
+
 4. Meters: A meter measures the rate of events over time, such as the number of requests per second. It’s similar to a speedometer in a car, showing the rate at which events are occurring over time. It is ideal for tracking the rate of requests, error rates, or database transactions.
-    
-    Example of a Meter:
-    
-    ```java
-    package org.example;
-    
-    import com.codahale.metrics.*;
-    
-    public class Main {
-        public static void main(String[] args) {
-    
-            MetricRegistry metrics = new MetricRegistry();
-            
-            // Create a meter metric to track the rate of requests per second
-            Meter requestsPerSecond = metrics.meter("requests-per-second");
-    
-            // Mark the meter each time a request is received
-            requestsPerSecond.mark();  // Request 1
-            requestsPerSecond.mark(5); // Simulate 5 more requests
-    
-            // Output: Displays the count and rate of events per second
-            System.out.println("Total requests: " + requestsPerSecond.getCount());
-            System.out.println("Requests per second: " + requestsPerSecond.getOneMinuteRate());
-        }
-    }
-    ```
-    
-    The meter `requests-per-second` tracks the rate of incoming requests. By calling `mark()` each time a request is received, it calculates rates (e.g., events per second). This can help track traffic patterns in real-time, showing if a service is experiencing a surge or slowdown.
-    
-    Output: 
-    
-    ```java
-    Total requests: 6
-    Requests per second: [calculated value, depending on runtime duration]
-    ```
-    
+
+   Example of a Meter:
+
+   ```java
+   package org.example;
+
+   import com.codahale.metrics.*;
+
+   public class Main {
+       public static void main(String[] args) {
+
+           MetricRegistry metrics = new MetricRegistry();
+
+           // Create a meter metric to track the rate of requests per second
+           Meter requestsPerSecond = metrics.meter("requests-per-second");
+
+           // Mark the meter each time a request is received
+           requestsPerSecond.mark();  // Request 1
+           requestsPerSecond.mark(5); // Simulate 5 more requests
+
+           // Output: Displays the count and rate of events per second
+           System.out.println("Total requests: " + requestsPerSecond.getCount());
+           System.out.println("Requests per second: " + requestsPerSecond.getOneMinuteRate());
+       }
+   }
+   ```
+
+   The meter `requests-per-second` tracks the rate of incoming requests. By calling `mark()` each time a request is received, it calculates rates (e.g., events per second). This can help track traffic patterns in real-time, showing if a service is experiencing a surge or slowdown.
+
+   Output:
+
+   ```java
+   Total requests: 6
+   Requests per second: [calculated value, depending on runtime duration]
+   ```
+
 5. Timers: A timer is basically a combination of a histogram and a meter. It measures both the rate and duration of events. Used to track how long a particular process takes and how often it happens. It is ideal for measuring response times of API calls, database queries, or critical code sections.
-    
-    Example of a Timer:
-    
-    ```java
-    package org.example;
-    
-    import com.codahale.metrics.*;
-    
-    public class Test {
-        public static void main(String[] args) {
-    
-            MetricRegistry metrics = new MetricRegistry();
-            // Create a timer metric to measure request durations
-            Timer responses = metrics.timer("responses");
-    
-            // Start timing a block of code
-            Timer.Context context = responses.time();
-            try {
-                // Simulate some work being done (e.g., a request is being processed)
-                Thread.sleep(100);  // Simulates request processing delay of 100ms
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            } finally {
-                // Stop the timer and record the duration
-                context.stop();
-            }
-    
-            // Output: Displays the total number of timed events and mean duration
-            System.out.println("Total events: " + responses.getCount());
-            System.out.println("Mean response time: " + responses.getSnapshot().getMean() / 1_000_000 + " ms");}
-    }
-    ```
-    
-    The timer `responses` measures both the number of events and their duration. By timing specific blocks of code (in this case, simulating a 100ms delay), it collects data on how long each event takes, providing insights into process efficiency and potential bottlenecks.
-    
-    Output:
-    
-    ```java
-    Total events: 1
-    Mean response time: 100.0 ms
-    ```
-    
+
+   Example of a Timer:
+
+   ```java
+   package org.example;
+
+   import com.codahale.metrics.*;
+
+   public class Test {
+       public static void main(String[] args) {
+
+           MetricRegistry metrics = new MetricRegistry();
+           // Create a timer metric to measure request durations
+           Timer responses = metrics.timer("responses");
+
+           // Start timing a block of code
+           Timer.Context context = responses.time();
+           try {
+               // Simulate some work being done (e.g., a request is being processed)
+               Thread.sleep(100);  // Simulates request processing delay of 100ms
+           } catch (InterruptedException e) {
+               e.printStackTrace();
+           } finally {
+               // Stop the timer and record the duration
+               context.stop();
+           }
+
+           // Output: Displays the total number of timed events and mean duration
+           System.out.println("Total events: " + responses.getCount());
+           System.out.println("Mean response time: " + responses.getSnapshot().getMean() / 1_000_000 + " ms");}
+   }
+   ```
+
+   The timer `responses` measures both the number of events and their duration. By timing specific blocks of code (in this case, simulating a 100ms delay), it collects data on how long each event takes, providing insights into process efficiency and potential bottlenecks.
+
+   Output:
+
+   ```java
+   Total events: 1
+   Mean response time: 100.0 ms
+   ```
 
 Note: To use the examples in this article, ensure you have the following setup:
 
@@ -293,7 +298,11 @@ DropWizard Meters use an exponentially weighted moving average (EWMA) to calcula
 
 The decaying effect of each interval helps give more weight to recent events, ensuring that the metric adjusts to changing traffic or error patterns quickly.
 
-<Figure src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image.webp" alt="Demonstration of requests per second" caption="Demonstration of requests per second" />
+<Figure
+  src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image.webp"
+  alt="Demonstration of requests per second"
+  caption="Demonstration of requests per second"
+/>
 
 ### Implementing Meters in DropWizard
 
@@ -346,7 +355,7 @@ The methods used in the above example serve different purposes:
 - `getFiveMinuteRate()`: Returns the average rate of events over the last five minutes.
 - `getFifteenMinuteRate()`: Returns the average rate of events over the last fifteen minutes.
 
-### Best  Practices for Naming and Organizing Meters
+### Best Practices for Naming and Organizing Meters
 
 1. Use Descriptive Names: Choose names that clearly describe the action or event being tracked. For example, `api.requests.rate` for tracking API request rates or `orders.processed.rate` for processed orders.
 2. Consistent Naming Convention: Stick to a consistent naming pattern across your application to keep metrics organized and easily identifiable. For example, prefix with the system component like `db.` for database-related metrics or `service.` for service-level metrics.
@@ -357,13 +366,13 @@ The methods used in the above example serve different purposes:
 ### Common Pitfalls and How to Avoid Them with Meters
 
 1. Overuse of Meters: Tracking too many events with meters can lead to metric bloat and performance issues.
-    - Solution: Focus on high-value events, like critical business operations or high-volume events. Avoid tracking infrequent or low-priority actions with meters.
+   - Solution: Focus on high-value events, like critical business operations or high-volume events. Avoid tracking infrequent or low-priority actions with meters.
 2. Unclear Metric Naming: Vague or unclear names make it hard to identify the purpose of a meter.
-    - Solution: Use meaningful names with specific terms related to the business logic. Avoid generic terms like `rate1` or `requestRate`, which can cause confusion.
+   - Solution: Use meaningful names with specific terms related to the business logic. Avoid generic terms like `rate1` or `requestRate`, which can cause confusion.
 3. Not Removing Stale or Deprecated Meters: Meters associated with outdated logic or removed components can lead to misleading data or unnecessary overhead.
-    - *Solution:* Periodically review and clean up unused or deprecated meters from your `MetricRegistry`.
+   - _Solution:_ Periodically review and clean up unused or deprecated meters from your `MetricRegistry`.
 4. Ignoring Memory and Resource Costs: Meters add overhead, and unoptimized usage can increase memory consumption.
-    - *Solution*: Use meters judiciously, especially in high-throughput areas. Regularly monitor their resource impact, especially if you have many meters in use.
+   - _Solution_: Use meters judiciously, especially in high-throughput areas. Regularly monitor their resource impact, especially if you have many meters in use.
 
 ### Meter implementation in a Real-World Scenario
 
@@ -462,20 +471,28 @@ Utilizing Timers can significantly improve observability in various scenarios, i
 Timers calculate:
 
 1. Rate of Events: Using a meter internally, timers track how frequently a specific event (e.g., method execution) happens.
-    
-    <Figure src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image%201.webp" alt="Demonstration of the rate of events" caption="Demonstration of the rate of events" />
-    
-    - X-axis: Rate of events (requests per second)
-    - Y-axis: Time (e.g., minutes or seconds)
+
+   <Figure
+     src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image%201.webp"
+     alt="Demonstration of the rate of events"
+     caption="Demonstration of the rate of events"
+   />
+
+   - X-axis: Rate of events (requests per second)
+   - Y-axis: Time (e.g., minutes or seconds)
+
 2. Distribution of Durations: Using a histogram internally, timers capture statistical data like mean, min, max, and percentiles for the recorded durations.
-    
-    <Figure src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image%202.webp" alt="Distribution of event durations" caption="Distribution of event durations" />
-    
-    - X-axis: Duration (in milliseconds or seconds)
-    - Y-axis: Event types or intervals (e.g., database queries, API response times)
-    
-    The red dashed lines indicate key percentile values (e.g., 50th, 75th, 90th). These values show how spread out the event durations are, helping to detect anomalies.
-    
+
+   <Figure
+     src="/img/guides/2024/11/dropwizard-metrics-meters-vs-timers-image%202.webp"
+     alt="Distribution of event durations"
+     caption="Distribution of event durations"
+   />
+
+   - X-axis: Duration (in milliseconds or seconds)
+   - Y-axis: Event types or intervals (e.g., database queries, API response times)
+
+   The red dashed lines indicate key percentile values (e.g., 50th, 75th, 90th). These values show how spread out the event durations are, helping to detect anomalies.
 
 ### Implementing Timers in DropWizard
 
@@ -490,10 +507,10 @@ import com.codahale.metrics.Timer;
 public class TimerExample {
     public static void main(String[] args) {
         MetricRegistry metrics = new MetricRegistry();
-        
+
         // Create a timer to track database query durations
         Timer dbQueryTimer = metrics.timer("db-query-duration");
-        
+
         // Start timing the database query
         Timer.Context context = dbQueryTimer.time();
 
@@ -516,7 +533,7 @@ public class TimerExample {
         try {
             // Simulate a database query by adding a delay
             // 100 ms delay to simulate a query
-            Thread.sleep(100); 
+            Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
@@ -551,17 +568,17 @@ To maximize the effectiveness of your timers, adhere to these best practices for
 Being aware of common pitfalls can help you use timers more effectively and prevent potential issues:
 
 1. Creating Timers in Loops
-    - Description: Avoid creating new `Timer` instances inside a loop or in methods that are called frequently.
-    - Consequence: This leads to excessive memory usage and potential memory leaks since each `Timer` creates its own internal data structure.
-    - Solution: Define the timer once at the class or method level and reuse it.
+   - Description: Avoid creating new `Timer` instances inside a loop or in methods that are called frequently.
+   - Consequence: This leads to excessive memory usage and potential memory leaks since each `Timer` creates its own internal data structure.
+   - Solution: Define the timer once at the class or method level and reuse it.
 2. Misusing `time()` Method
-    - Description: If the `Timer.Context` returned by `time()` is not properly stopped, it can lead to incomplete or inconsistent metrics.
-    - Consequence: Metrics will be skewed (inaccurate, biased, or misleading due to improper collection, incomplete data points, or irregular patterns), with some timers running indefinitely, making it difficult to diagnose real performance issues.
-    - Solution: Always use a `try-finally` block to ensure `context.stop()` is called even if exceptions occur.
+   - Description: If the `Timer.Context` returned by `time()` is not properly stopped, it can lead to incomplete or inconsistent metrics.
+   - Consequence: Metrics will be skewed (inaccurate, biased, or misleading due to improper collection, incomplete data points, or irregular patterns), with some timers running indefinitely, making it difficult to diagnose real performance issues.
+   - Solution: Always use a `try-finally` block to ensure `context.stop()` is called even if exceptions occur.
 3. Excessive Timers
-    - Description: Creating too many timers to track every small operation can overwhelm the system.
-    - Consequence: This leads to high memory consumption, CPU overhead, and cluttered metrics dashboards, making it hard to identify critical data points.
-    - Solution: Only create timers for key processes and operations that significantly impact performance. Use hierarchical naming to avoid redundancy.
+   - Description: Creating too many timers to track every small operation can overwhelm the system.
+   - Consequence: This leads to high memory consumption, CPU overhead, and cluttered metrics dashboards, making it hard to identify critical data points.
+   - Solution: Only create timers for key processes and operations that significantly impact performance. Use hierarchical naming to avoid redundancy.
 
 ## Meters vs Timers: Key Differences and When to Use Each
 
@@ -570,44 +587,44 @@ The main differences between Meters and Timers lie in their focus and the granul
 ### 1. Comparison of Measurement Focus
 
 - Meters:
-    - Focus on event rate measurement only.
-    - Ideal for tracking how frequently events are happening, like request rate or error rate.
-    - E.g., Meters are perfect for monitoring requests per second or the number of successful logins per minute.
+  - Focus on event rate measurement only.
+  - Ideal for tracking how frequently events are happening, like request rate or error rate.
+  - E.g., Meters are perfect for monitoring requests per second or the number of successful logins per minute.
 - Timers:
-    - Measure both rate and duration of events.
-    - Useful for scenarios where the execution time is also crucial, such as response time or database query latency.
-    - E.g., Timers are best for tracking API response times and method execution durations.
+  - Measure both rate and duration of events.
+  - Useful for scenarios where the execution time is also crucial, such as response time or database query latency.
+  - E.g., Timers are best for tracking API response times and method execution durations.
 
 ### 2. Granularity of Data
 
 - Meters:
-    - Provide simple counts and rates, like the number of events per second or minute.
-    - No information on how long each event took.
-    - Output includes rates over 1, 5, and 15-minute moving averages.
+  - Provide simple counts and rates, like the number of events per second or minute.
+  - No information on how long each event took.
+  - Output includes rates over 1, 5, and 15-minute moving averages.
 - Timers:
-    - Offer detailed insights through statistical distribution of durations.
-    - Record metrics like min, max, mean, and percentiles (e.g., 50th, 75th, 90th).
-    - Timers can pinpoint performance bottlenecks by showing outliers or skewed durations.
+  - Offer detailed insights through statistical distribution of durations.
+  - Record metrics like min, max, mean, and percentiles (e.g., 50th, 75th, 90th).
+  - Timers can pinpoint performance bottlenecks by showing outliers or skewed durations.
 
 ### 3. Performance Overhead Considerations
 
 - Meters:
-    - Lightweight; low overhead.
-    - Can be safely used in high-throughput applications without significant performance impact.
+  - Lightweight; low overhead.
+  - Can be safely used in high-throughput applications without significant performance impact.
 - Timers:
-    - Slightly heavier due to maintaining both rate and duration data.
-    - Avoid excessive use in high-frequency scenarios as it could lead to performance degradation.
+  - Slightly heavier due to maintaining both rate and duration data.
+  - Avoid excessive use in high-frequency scenarios as it could lead to performance degradation.
 
 ### 4. Decision-Making: When to Use Meters vs. Timers
 
 - Use Meters When:
-    - You only care about how often something happens (e.g., tracking user logins or error counts).
-    - Low overhead is crucial.
-    - Rate measurement over time is sufficient (no need for duration data).
+  - You only care about how often something happens (e.g., tracking user logins or error counts).
+  - Low overhead is crucial.
+  - Rate measurement over time is sufficient (no need for duration data).
 - Use Timers When:
-    - You want to track how long something takes in addition to how often it happens.
-    - Detailed analysis of event durations is required, such as profiling method performance.
-    - Identifying slow operations is necessary (e.g., pinpointing slow database queries).
+  - You want to track how long something takes in addition to how often it happens.
+  - Detailed analysis of event durations is required, such as profiling method performance.
+  - Identifying slow operations is necessary (e.g., pinpointing slow database queries).
 
 ## Advanced Usage: Combining Meters and Timers
 
@@ -669,7 +686,7 @@ public class DropwizardMetricsExample {
         Timer.Context context = responseTimer.time();
         try {
             // Simulate some processing logic (e.g., database access, computation)
-            Thread.sleep(200); 
+            Thread.sleep(200);
 
             // Return some dummy data
             return "Data processed successfully!";
@@ -874,4 +891,4 @@ A Histogram measures the statistical distribution of values over a stream of dat
 
 ### How can I reset a Timer or Meter in DropWizard Metrics?
 
-DropWizard Metrics doesn't provide a built-in method to reset Timers or Meters. If you need to reset metrics, consider creating a new instance or using a different metric type like Counters that can be manually reset. Alternatively, you can track the start time of your measurements and calculate delta values in your reporting logic.
\ No newline at end of file
+DropWizard Metrics doesn't provide a built-in method to reset Timers or Meters. If you need to reset metrics, consider creating a new instance or using a different metric type like Counters that can be manually reset. Alternatively, you can track the start time of your measurements and calculate delta values in your reporting logic.
diff --git a/data/guides/dynatrace-pricing.mdx b/data/guides/dynatrace-pricing.mdx
index 3807567a0..db5b8aa01 100644
--- a/data/guides/dynatrace-pricing.mdx
+++ b/data/guides/dynatrace-pricing.mdx
@@ -1,17 +1,16 @@
 ---
-title: "Understanding Dynatrace Pricing: How Much Does It Really Cost?"
-slug: "dynatrace-pricing"
-date: "2025-09-11"
+title: 'Understanding Dynatrace Pricing: How Much Does It Really Cost?'
+date: '2025-09-11'
 tags: [observability, dynatrace]
-authors: ["yuvraj"]
-image: "/img/guides/2025/09/dynatrace-pricing-dynatrace-dashboard.webp"
+authors: ['yuvraj']
+image: '/img/guides/2025/09/dynatrace-pricing-dynatrace-dashboard.webp'
 description: "A clear guide to understanding Dynatrace's pricing model — DPS today vs Classic (DDU) licensing — with real calculations and cost scenarios"
-keywords: [dynatrace pricing, dynatrace cost, DPS, DDU, application monitoring pricing, observability costs]
+keywords:
+  [dynatrace pricing, dynatrace cost, DPS, DDU, application monitoring pricing, observability costs]
 ---
 
 Dynatrace pricing can feel like trying to solve a puzzle without all the pieces. You see the advertised rates on their website, but when you actually talk to sales, suddenly there's an annual minimum commitment that wasn't mentioned anywhere. The confusion is real, and it's something many teams discover only after investing significant time in evaluation.
 
-
 Let's break down how Dynatrace pricing actually works, what you'll really pay, and what factors can affect your bill.
 
 ## How Dynatrace Pricing Works
@@ -25,12 +24,12 @@ Think of it like a prepaid phone plan. You commit to spending a certain amount a
 **Dynatrace Platform Subscription (DPS)** is your annual commitment. This is the minimum amount you agree to spend with Dynatrace each year. Dynatrace confirms there is a minimum annual commitment under DPS (amount not published on their pricing pages). Some users report ~\$2,000/month minimums in practice; your terms will vary by contract and discounts ([pricing](https://www.dynatrace.com/pricing/), [Reddit anecdote](https://www.reddit.com/r/devops/comments/16umdhn/most_affordable_monitoring_platform_dynatrace_is/)).
 
 **Rate Cards** determine how much each service costs. These are the per-unit prices for different capabilities. For example:
+
 - Full-Stack Monitoring: \$0.01 per GiB-hour
 - [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/): \$0.04 per host-hour
 - Real User Monitoring: \$0.00225 per session
 - Log Management: \$0.20 per GiB ingested
 
-
 ### What's a GiB-Hour?
 
 This is where things get interesting. A GiB-hour represents monitoring 1 GiB of memory for one hour. If you have a server with 16 GiB of RAM running for 24 hours, that's:
@@ -46,6 +45,7 @@ Let's look at what different scenarios actually cost, based on the rate card fro
 ### Small Environment Example
 
 Say you have:
+
 - 2 servers (8 GiB RAM each) running Kubernetes
 - 1 Kubernetes cluster with 10 pods
 - Basic log ingestion (50 GiB/month)
@@ -53,35 +53,36 @@ Say you have:
 
 Here's the monthly breakdown:
 
-| Component | Calculation | Monthly Cost |
-|-----------|------------|--------------|
-| Full-Stack Monitoring | 2 servers × 8 GiB × 730 hours × \$0.01 | \$116.80 |
-| Kubernetes Monitoring | Included in Full-Stack | \$0.00 |
-| Log Ingestion | 50 GiB × \$0.20 | \$10.00 |
-| Log Retention (30 days) | 50 GiB × 30 days × \$0.02 | \$30.00 |
-| Real User Monitoring | 10,000 sessions × \$0.00225 | \$22.50 |
-| **Total** | | **\$179.30** |
+| Component               | Calculation                            | Monthly Cost |
+| ----------------------- | -------------------------------------- | ------------ |
+| Full-Stack Monitoring   | 2 servers × 8 GiB × 730 hours × \$0.01 | \$116.80     |
+| Kubernetes Monitoring   | Included in Full-Stack                 | \$0.00       |
+| Log Ingestion           | 50 GiB × \$0.20                        | \$10.00      |
+| Log Retention (30 days) | 50 GiB × 30 days × \$0.02              | \$30.00      |
+| Real User Monitoring    | 10,000 sessions × \$0.00225            | \$22.50      |
+| **Total**               |                                        | **\$179.30** |
 
 That's about \$2,152 annually. However, based on user reports, Dynatrace often requires minimum annual commitments that can be significantly higher than actual usage for small deployments.
 
 ### Medium Environment Example
 
 For a more typical setup:
+
 - 10 servers (16 GiB RAM average) running Kubernetes
 - 3 Kubernetes clusters with 50 pods total
 - Log ingestion (500 GiB/month)
 - 100,000 user sessions per month
 - Synthetic monitoring (50,000 checks/month)
 
-| Component | Calculation | Monthly Cost |
-|-----------|------------|--------------|
-| Full-Stack Monitoring | 10 servers × 16 GiB × 730 hours × \$0.01 | \$1,168.00 |
-| Kubernetes Monitoring | Included in Full-Stack |  \$0.00 |
-| Log Ingestion | 500 GiB × \$0.20 | \$100.00 |
-| Log Retention (30 days) | 500 GiB × 30 days × \$0.02 | \$300.00 |
-| Real User Monitoring | 100,000 sessions × \$0.00225 | \$225.00 |
-| Synthetic Monitoring (HTTP monitors or third-party API ingestion at \$0.001 per request) | 50,000 requests × \$0.001 | \$50.00 |
-| **Total** | | **$1,843.00** |
+| Component                                                                                | Calculation                              | Monthly Cost  |
+| ---------------------------------------------------------------------------------------- | ---------------------------------------- | ------------- |
+| Full-Stack Monitoring                                                                    | 10 servers × 16 GiB × 730 hours × \$0.01 | \$1,168.00    |
+| Kubernetes Monitoring                                                                    | Included in Full-Stack                   | \$0.00        |
+| Log Ingestion                                                                            | 500 GiB × \$0.20                         | \$100.00      |
+| Log Retention (30 days)                                                                  | 500 GiB × 30 days × \$0.02               | \$300.00      |
+| Real User Monitoring                                                                     | 100,000 sessions × \$0.00225             | \$225.00      |
+| Synthetic Monitoring (HTTP monitors or third-party API ingestion at \$0.001 per request) | 50,000 requests × \$0.001                | \$50.00       |
+| **Total**                                                                                |                                          | **$1,843.00** |
 
 Note: Browser clickpaths are priced at \$0.0045 per synthetic action, which would cost more for multi-step flows.
 
@@ -94,6 +95,7 @@ That's about \$22,116 annually.
 One Reddit user shared their frustration: "We have a single host (PHP application), a SQL server instance, and an Android and iOS app." For this minimal setup, they were quoted \$20,000 annually ([source](https://www.reddit.com/r/devops/comments/16umdhn/most_affordable_monitoring_platform_dynatrace_is/)).
 
 Using the rate card, their actual consumption would be:
+
 - 1 server (8 GiB assumed): \$58.40/month (8 GiB × 730 h × \$0.01/GiB-h)
 - Mobile app monitoring: Variable based on sessions
 
@@ -104,9 +106,11 @@ The gap between actual usage and minimum commitment is substantial for small dep
 Dynatrace's hourly pricing model works well for dynamic cloud environments. If you spin up a container for 15 minutes, you're billed for 15 minutes (rounded up from any usage). This is different from some competitors who charge for the full hour or day.
 
 For auto-scaling environments, costs can vary significantly:
+
 - Baseline: 5 hosts, always on
 - Peak: add 15 hosts for 4 hours/day
 - Price used: Full-Stack Monitoring = \$0.01 per GiB-hour; each host is 16 GiB → \$0.16 per host-hour
+
 ```
 Baseline: 5 hosts × 730 h/month × $0.16 ≈ $584/month
 Peak add-on: 15 hosts × 4 h/day × 30 days × $0.16 ≈ $288/month
@@ -122,6 +126,7 @@ Log costs include both ingestion and retention. A moderately active application
 **Total:** \$2,400/month for logs alone
 
 You can choose between two retention models:
+
 - **Retain with Included Queries:** \$0.02 per GiB-day (queries included) - simpler but more expensive
 - **Usage-based:** \$0.0007 per GiB-day retention + \$0.0035 per GiB scanned - cheaper if you query selectively
 
@@ -164,6 +169,7 @@ For teams not needing full APM capabilities, Infrastructure Monitoring at \$0.04
 ## Making Sense of It All
 
 Dynatrace's pricing model makes sense for organizations that:
+
 - Have substantial monitoring needs across multiple capabilities
 - Want flexibility to shift between different monitoring types
 - Operate in dynamic cloud environments with variable workloads
@@ -173,17 +179,22 @@ For smaller teams or simpler monitoring needs, the minimum commitment can be a s
 
 The platform provides comprehensive monitoring capabilities, and the hourly billing model offers genuine flexibility for cloud-native workloads. However, understanding the true cost requires looking beyond the rate card to factor in minimum commitments and your actual usage patterns.
 
-
 ## SigNoz - An Alternative to Dynatrace with Transparent Pricing
+
 If the complexity of Dynatrace's pricing model and minimum commitments have you looking for alternatives, [SigNoz](https://signoz.io/docs/introduction/) offers a different approach to observability pricing that many teams find refreshing.
 
 SigNoz is built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) from the ground up, not retrofitted to support it. This means you're working with industry-standard instrumentation that won't lock you into a proprietary agent. Your telemetry data remains portable, and you can switch vendors or run multiple backends without changing your instrumentation.
 
-<Figure src="/img/guides/2025/09/dynatrace-pricing-signoz-logging-dashboard.webp" alt="SigNoz logging dashboard" caption="SigNoz logging dashboard"/>
+<Figure
+  src="/img/guides/2025/09/dynatrace-pricing-signoz-logging-dashboard.webp"
+  alt="SigNoz logging dashboard"
+  caption="SigNoz logging dashboard"
+/>
 
 ### A Simpler Pricing Model
 
 SigNoz uses straightforward usage-based pricing without hidden minimums. You start at \$49/month (which includes \$49 worth of usage), then pay only for what you consume:
+
 - Logs and traces: \$0.30 per GB ingested
 - Metrics: \$0.10 per million samples
 
diff --git a/data/guides/ec2-monitoring.mdx b/data/guides/ec2-monitoring.mdx
index 400e036e1..042e76fc7 100644
--- a/data/guides/ec2-monitoring.mdx
+++ b/data/guides/ec2-monitoring.mdx
@@ -1,16 +1,21 @@
 ---
-
 title: EC2 Monitoring - Essential Guide for AWS Users
-slug: ec2-monitoring
 date: 2024-10-03
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Master EC2 monitoring with our comprehensive guide. Learn key metrics, tools, and best practices to optimize your AWS infrastructure performance.
-keywords: [ec2 monitoring, aws monitoring, cloudwatch, performance optimization, devops, cloud infrastructure]
-
+keywords:
+  [
+    ec2 monitoring,
+    aws monitoring,
+    cloudwatch,
+    performance optimization,
+    devops,
+    cloud infrastructure,
+  ]
 ---
 
-Amazon EC2 (Elastic Compute Cloud) is the foundation of many AWS-powered services, offering scalable virtual servers in the cloud. For cloud engineers and DevOps specialists, ensuring these EC2 instances run smoothly is important. EC2 monitoring is critical for ensuring a dependable, high-performance AWS infrastructure. 
+Amazon EC2 (Elastic Compute Cloud) is the foundation of many AWS-powered services, offering scalable virtual servers in the cloud. For cloud engineers and DevOps specialists, ensuring these EC2 instances run smoothly is important. EC2 monitoring is critical for ensuring a dependable, high-performance AWS infrastructure.
 
 This article covers the fundamentals of EC2 monitoring, from basic concepts to advanced strategies.
 
@@ -127,24 +132,24 @@ You can enable EC2 Auto Recovery by setting up an Amazon CloudWatch alarm that t
 AWS provides a variety of useful tools for monitoring your EC2 instances, allowing you to measure performance, detect anomalies, and automate replies.
 
 - Amazon CloudWatch: CloudWatch is AWS' offers monitoring EC2 and other resources. It collects measurements, monitors log data, generates alerts, and provides real-time performance information. CloudWatch enables you to monitor the health of your instance and respond quickly to concerns. An example can be monitoring CPU use, disk I/O, and network traffic.
-    - An example use case:
-        - Setting up alarms to send notifications or perform scheduled tasks.
+  - An example use case:
+    - Setting up alarms to send notifications or perform scheduled tasks.
 - AWS CloudTrail: CloudTrail captures and tracks all API requests performed through your AWS account, including those involving EC2 instances. This logging helps trace changes to EC2 setups, which improves your security posture and assists with compliance and auditing requirements.
-    - Some example use cases:
-        - Detecting unauthorized changes to instance settings.
-        - Auditing activities performed by various AWS users or services.
+  - Some example use cases:
+    - Detecting unauthorized changes to instance settings.
+    - Auditing activities performed by various AWS users or services.
 - Amazon GuardDuty: GuardDuty is a threat detection service that detects suspicious activities throughout your AWS environment, including EC2 instances. It analyzes data from CloudTrail, VPC Flow Logs, and DNS logs to identify possible security concerns such as hacked instances or strange API requests.
-    - Some example use cases:
-        - Including detecting anomalous or illegal network activity.
-        - Detection of Bitcoin mining on EC2 instances.
+  - Some example use cases:
+    - Including detecting anomalous or illegal network activity.
+    - Detection of Bitcoin mining on EC2 instances.
 - AWS Systems Manager: Systems Manager provides a common interface for operational data from all AWS services, allowing you to manage and monitor EC2 fleets at scale. You can automate typical operations like patch management and get precise performance data.
-    - Some example use cases:
-        - Perform automatic patching and configuration upgrades.
-        - Monitor many EC2 instances from a single dashboard.
+  - Some example use cases:
+    - Perform automatic patching and configuration upgrades.
+    - Monitor many EC2 instances from a single dashboard.
 
 ## Best Practices for Effective EC2 Monitoring
 
-To achieve effective EC2 monitoring, follow a few best practices. These will assist you in proactively managing your resources, reducing expenditures, and detecting problems before they worsen. 
+To achieve effective EC2 monitoring, follow a few best practices. These will assist you in proactively managing your resources, reducing expenditures, and detecting problems before they worsen.
 
 - Set up custom CloudWatch dashboards: Organize all key EC2 metrics into CloudWatch dashboards to provide consolidated monitoring. These dashboards give a visual overview of your instances' performance, allowing you to identify patterns and abnormalities immediately. For example, create a real-time dashboard to monitor CPU, RAM, disk I/O, and network traffic.
 - Implement correct tagging: Tag EC2 instances by environment (e.g., dev, test, prod), application, or business unit. This makes it easy to organize resources, implement procedures, and evaluate metrics. For example, tagging instances with `Environment=Production` enables restricted monitoring of only production systems.
@@ -180,7 +185,7 @@ To enable detailed monitoring, follow these steps:
 CloudWatch collects essential EC2 instance metrics, such as:
 
 - CPU Utilization: Tracks the percentage of allocated EC2 compute units in use.
-- Disk Read/Write Operations: Measures the rate  data is being read/written from/to the disk.
+- Disk Read/Write Operations: Measures the rate data is being read/written from/to the disk.
 - Network In/Out: Monitors the volume of data transferred via network interfaces.
 
 To view [CloudWatch metric](https://signoz.io/blog/cloudwatch-metrics/), follow these steps:
@@ -194,41 +199,35 @@ To view [CloudWatch metric](https://signoz.io/blog/cloudwatch-metrics/), follow
 CloudWatch alarms notify you when an EC2 instance metric crosses a specific threshold. This is essential for real-time monitoring and automation.
 
 - Example: Set an alarm to trigger if CPU utilization exceeds 80% for 5 minutes.
-    
-    ```bash
-    aws cloudwatch put-metric-alarm \\
-      --alarm-name "HighCPUUtilization" \\
-      --metric-name "CPUUtilization" \\
-      --namespace "AWS/EC2" \\
-      --statistic "Average" \\
-      --period 300 \\
-      --threshold 80 \\
-      --comparison-operator "GreaterThanThreshold" \\
-      --evaluation-periods 1 \\
-      --alarm-actions arn:aws:sns:your-topic-arn \\
-      --dimensions Name=InstanceId,Value=i-0123456789abcdef0
-    ```
-    
+  ```bash
+  aws cloudwatch put-metric-alarm \\
+    --alarm-name "HighCPUUtilization" \\
+    --metric-name "CPUUtilization" \\
+    --namespace "AWS/EC2" \\
+    --statistic "Average" \\
+    --period 300 \\
+    --threshold 80 \\
+    --comparison-operator "GreaterThanThreshold" \\
+    --evaluation-periods 1 \\
+    --alarm-actions arn:aws:sns:your-topic-arn \\
+    --dimensions Name=InstanceId,Value=i-0123456789abcdef0
+  ```
 
 ### 4. Install the CloudWatch Agent for Additional Metrics
 
 To collect more detailed information like memory usage, you need to install and configure the CloudWatch Agent.
 
 - Steps:
-    - SSH into your EC2 instance and install the CloudWatch Agent:
-        
-        ```bash
-        sudo yum install amazon-cloudwatch-agent
-        ```
-        
-    - Create a configuration file for the metrics you want to collect, including memory and disk utilization.
-    - Start the CloudWatch Agent:
-        
-        ```bash
-        sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \\
-          -a start
-        ```
-        
+  - SSH into your EC2 instance and install the CloudWatch Agent:
+    ```bash
+    sudo yum install amazon-cloudwatch-agent
+    ```
+  - Create a configuration file for the metrics you want to collect, including memory and disk utilization.
+  - Start the CloudWatch Agent:
+    ```bash
+    sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \\
+      -a start
+    ```
 
 For more detailed steps, refer to the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html" rel="noopener noreferrer nofollow" target="_blank">AWS CloudWatch User Guide</a>.
 
@@ -245,61 +244,57 @@ While CloudWatch provides robust native monitoring capabilities, tools like [Sig
 
 ### Getting Started with SigNoz:
 
-1. Sign Up for a SigNoz account or deploy the open-source version.
-<GetStartedSigNoz />
-2. Install the SigNoz Agent on your EC2 instance to start collecting metrics.
-3. Configure EC2 to Send Metrics: 
-For EC2 instances (without Kubernetes): You need to install the OpenTelemetry agent directly on your EC2 instance. This will collect and send telemetry data (metrics, logs, and traces) to SigNoz. Here's how you can configure it:
-    - Install OpenTelemetry Collector (or agent) on your EC2 instance. This can be done by downloading the OpenTelemetry Collector binaries or using package managers, such as Yum or APT.
-    - Once installed, you can configure the agent to collect system metrics like CPU, memory, disk I/O, and network performance.
-    
-    An example to configure the OpenTelemetry agent (no Kubernetes involved) using a configuration file stored locally on the EC2 instance:
-    
-    ```yaml
-    receivers:
-      hostmetrics:
-        collection_interval: 60s
-        scrapers:
-          cpu:
-          memory:
-          disk:
-          network:
-    
-    processors:
-      batch:
-        timeout: 10s
-    
-    exporters:
-      otlp:
-        endpoint: <SigNoz-endpoint>
-        insecure: true
-    
-    service:
-      pipelines:
-        metrics:
-          receivers: [hostmetrics]
-          processors: [batch]
-          exporters: [otlp]
-    
-    ```
-    
-    - Save this YAML configuration file on your EC2 instance.
-    - Start the OpenTelemetry agent using the configuration file. The agent will send metrics to the SigNoz server over the OTLP (OpenTelemetry Protocol).
-    
-    For Kubernetes-based EC2 Instances:
-    If you're using EC2 instances as part of a Kubernetes cluster, you can apply the YAML configuration to your cluster. The provided YAML file is used to configure the OpenTelemetry Collector in Kubernetes environments to send data to SigNoz.
-    
-    An example uses the YAML file in Kubernetes:
-    
-    - Apply the YAML configuration to your Kubernetes cluster:
-    
-    ```bash
-    kubectl apply -f opentelemetry-config.yaml
-    ```
-    
-    This will set up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) in the cluster to forward metrics from your EC2 instances (via Kubernetes) to SigNoz.
-    
-4. Set Up Dashboards: In the SigNoz UI, configure custom dashboards for EC2 metrics such as CPU usage, disk I/O, and network traffic. Create alerts for any critical thresholds, ensuring you stay ahead of potential issues.
+1.  Sign Up for a SigNoz account or deploy the open-source version.
+    <GetStartedSigNoz />
+2.  Install the SigNoz Agent on your EC2 instance to start collecting metrics.
+3.  Configure EC2 to Send Metrics:
+    For EC2 instances (without Kubernetes): You need to install the OpenTelemetry agent directly on your EC2 instance. This will collect and send telemetry data (metrics, logs, and traces) to SigNoz. Here's how you can configure it: - Install OpenTelemetry Collector (or agent) on your EC2 instance. This can be done by downloading the OpenTelemetry Collector binaries or using package managers, such as Yum or APT. - Once installed, you can configure the agent to collect system metrics like CPU, memory, disk I/O, and network performance.
+        An example to configure the OpenTelemetry agent (no Kubernetes involved) using a configuration file stored locally on the EC2 instance:
+
+        ```yaml
+        receivers:
+          hostmetrics:
+            collection_interval: 60s
+            scrapers:
+              cpu:
+              memory:
+              disk:
+              network:
+
+        processors:
+          batch:
+            timeout: 10s
+
+        exporters:
+          otlp:
+            endpoint: <SigNoz-endpoint>
+            insecure: true
+
+        service:
+          pipelines:
+            metrics:
+              receivers: [hostmetrics]
+              processors: [batch]
+              exporters: [otlp]
+
+        ```
+
+        - Save this YAML configuration file on your EC2 instance.
+        - Start the OpenTelemetry agent using the configuration file. The agent will send metrics to the SigNoz server over the OTLP (OpenTelemetry Protocol).
+
+        For Kubernetes-based EC2 Instances:
+        If you're using EC2 instances as part of a Kubernetes cluster, you can apply the YAML configuration to your cluster. The provided YAML file is used to configure the OpenTelemetry Collector in Kubernetes environments to send data to SigNoz.
+
+        An example uses the YAML file in Kubernetes:
+
+        - Apply the YAML configuration to your Kubernetes cluster:
+
+        ```bash
+        kubectl apply -f opentelemetry-config.yaml
+        ```
+
+        This will set up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) in the cluster to forward metrics from your EC2 instances (via Kubernetes) to SigNoz.
+4.  Set Up Dashboards: In the SigNoz UI, configure custom dashboards for EC2 metrics such as CPU usage, disk I/O, and network traffic. Create alerts for any critical thresholds, ensuring you stay ahead of potential issues.
 
 To learn more, visit the [SigNoz Documentation](https://signoz.io/docs).
 
@@ -354,4 +349,4 @@ Troubleshooting EC2 performance starts by examining metrics like CPU utilization
 
 ### What’s the role of EC2 monitoring in hybrid cloud setups?
 
-In hybrid cloud environments, where part of the infrastructure is on-premises and part is in the cloud, EC2 monitoring helps maintain consistency and performance between the two. [Monitoring EC2 instances](https://signoz.io/guides/ec2-monitoring/#tools-for-ec2-monitoring-in-aws) alongside on-premises resources (using tools like AWS Systems Manager or CloudWatch hybrid monitoring) ensures that applications running across both environments have optimal performance, security, and resource utilization. Monitoring also aids in load balancing and the efficient allocation of resources between on-premises and cloud environments.
\ No newline at end of file
+In hybrid cloud environments, where part of the infrastructure is on-premises and part is in the cloud, EC2 monitoring helps maintain consistency and performance between the two. [Monitoring EC2 instances](https://signoz.io/guides/ec2-monitoring/#tools-for-ec2-monitoring-in-aws) alongside on-premises resources (using tools like AWS Systems Manager or CloudWatch hybrid monitoring) ensures that applications running across both environments have optimal performance, security, and resource utilization. Monitoring also aids in load balancing and the efficient allocation of resources between on-premises and cloud environments.
diff --git a/data/guides/edge-observability.mdx b/data/guides/edge-observability.mdx
index 8eb19021d..82ad87141 100644
--- a/data/guides/edge-observability.mdx
+++ b/data/guides/edge-observability.mdx
@@ -1,6 +1,5 @@
 ---
 title: What is Edge Observability - A Guide to Modern System Monitoring
-slug: edge-observability
 date: 2024-11-20
 tags: [observability, faq]
 authors: [soumya_gupta]
diff --git a/data/guides/embedding-a-website-in-a-grafana-dashboard.mdx b/data/guides/embedding-a-website-in-a-grafana-dashboard.mdx
index e60473fe1..dc7c520db 100644
--- a/data/guides/embedding-a-website-in-a-grafana-dashboard.mdx
+++ b/data/guides/embedding-a-website-in-a-grafana-dashboard.mdx
@@ -1,22 +1,31 @@
 ---
-
 title: How to embed Grafana dashboards into web applications
-slug: embedding-a-website-in-a-grafana-dashboard
 date: 2024-10-22
 tags: [grafana, faq]
 authors: [simran_kumari]
 description: Learn how to seamlessly integrate Grafana dashboards into your web applications. Explore embedding methods, security considerations, and best practices.
-keywords: [Grafana, dashboard embedding, web applications, data visualization, SigNoz, application monitoring]
-
+keywords:
+  [
+    Grafana,
+    dashboard embedding,
+    web applications,
+    data visualization,
+    SigNoz,
+    application monitoring,
+  ]
 ---
 
 Embedding Grafana dashboards into web applications is a powerful way to deliver real-time data visualization to users without requiring them to log into Grafana itself. Whether you are looking to share key metrics with your team or provide external stakeholders with crucial insights, embedding a dashboard ensures seamless integration with your existing web application. This guide will walk you through the process of embedding Grafana dashboards, covering various methods, security considerations, and best practices.
 
 ## Understanding Grafana Dashboard Embedding
 
-Grafana dashboards are web-based interfaces that display data from various sources in a visually appealing and interactive format. They're essential for monitoring system performance, analyzing trends, and making data-driven decisions. 
+Grafana dashboards are web-based interfaces that display data from various sources in a visually appealing and interactive format. They're essential for monitoring system performance, analyzing trends, and making data-driven decisions.
 
-<Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image.webp" alt="Grafana dashboard" caption="Grafana dashboard" />
+<Figure
+  src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image.webp"
+  alt="Grafana dashboard"
+  caption="Grafana dashboard"
+/>
 
 Embedding these dashboards into your web applications allows you to:
 
@@ -46,77 +55,94 @@ Grafana allows users to create public snapshots of dashboards, which can then be
 - Advantages: Quick and easy method to share a dashboard.
 - Disadvantages: The data in the snapshot is static, and the dashboard is publicly accessible.
 
-Follow the given steps to embed the static version of your Grafana dashboard: 
-
-1. Open the dashboard you want to share.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%201.webp" alt="Open the dashboard" caption="Open the dashboard" />
-    
-2. Click on the share icon in the top navigation bar.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%202.webp" alt="Find share icon in the top navigation bar" caption="Find share icon in the top navigation bar" />
-    
-3. Select the "Snapshot" tab.
-4. Click "Publish to [snapshot.raintank.io](http://snapshot.raintank.io/)" to create a public snapshot.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%203.webp" alt="Create a public snapshot" caption="Create a public snapshot" />
-    
+Follow the given steps to embed the static version of your Grafana dashboard:
+
+1.  Open the dashboard you want to share.
+
+    <Figure
+      src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%201.webp"
+      alt="Open the dashboard"
+      caption="Open the dashboard"
+    />
+
+2.  Click on the share icon in the top navigation bar.
+
+    <Figure
+      src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%202.webp"
+      alt="Find share icon in the top navigation bar"
+      caption="Find share icon in the top navigation bar"
+    />
+
+3.  Select the "Snapshot" tab.
+4.  Click "Publish to [snapshot.raintank.io](http://snapshot.raintank.io/)" to create a public snapshot.
+
+    <Figure
+      src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%203.webp"
+      alt="Create a public snapshot"
+      caption="Create a public snapshot"
+    />
+
     You will get the Snapshot URL.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%204.webp" alt="Fetch the Snapshot URL" caption="Fetch the Snapshot URL" />
-    
-5. After creating a snapshot of your Grafana dashboard, you can easily embed it into any web application or website using an iframe. 
-    
+
+    <Figure
+      src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%204.webp"
+      alt="Fetch the Snapshot URL"
+      caption="Fetch the Snapshot URL"
+    />
+
+5.  After creating a snapshot of your Grafana dashboard, you can easily embed it into any web application or website using an iframe.
+
     ### Embedding using Iframe
-    
+
     An `iframe` (short for "inline frame") allows you to display content from one webpage inside another, such as embedding your Grafana dashboard into a separate web page or application.
-    
+
     Here’s how you can do it:
-    
-    1. Copy the Embed Code:
-    Use the following code snippet, and replace `your-snapshot-id` with the actual snapshot ID from your Grafana instance:
-        
-        ```html
-        <iframe src="https://snapshot.raintank.io/dashboard/snapshot/your-snapshot-id" width="800" height="600" frameborder="0"></iframe>
-        ```
-        
-        In this example:
-        
-        - The `src` attribute contains the link to your Grafana snapshot.
-        - The `width` and `height` attributes control the size of the embedded dashboard. You can modify these values based on how large or small you want the dashboard to appear.
-        - `frameborder="0"` removes the border around the iframe for a cleaner look.
-    2. Where to Paste It:
-    You can paste this code directly into the HTML of any web page or application that supports HTML, such as a web app, content management system, or even a simple HTML file. When the page loads, the Grafana snapshot will display within the specified area.
-        
-        Example HTML File
-        
-        ```sql
-        <!DOCTYPE html>
-        <html lang="en">
-        <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>Embedded Grafana Dashboard</title>
-        </head>
-        <body>
-            <h1>My Grafana Dashboard</h1>
-            <p>Here is a live snapshot of my Grafana dashboard:</p>
-        
-            <!-- Embed Grafana Snapshot -->
-            <iframe src="https://snapshot.raintank.io/dashboard/snapshot/your-snapshot-id" 
-                    width="800" height="600" frameborder="0"></iframe>
-        
-            <p>Dashboard embedded using an iframe.</p>
-        </body>
-        </html>
-        ```
-        
-    3. Adjust the Settings:
+
+    1.  Copy the Embed Code:
+        Use the following code snippet, and replace `your-snapshot-id` with the actual snapshot ID from your Grafana instance:
+            ```html
+            <iframe src="https://snapshot.raintank.io/dashboard/snapshot/your-snapshot-id" width="800" height="600" frameborder="0"></iframe>
+            ```
+
+            In this example:
+
+            - The `src` attribute contains the link to your Grafana snapshot.
+            - The `width` and `height` attributes control the size of the embedded dashboard. You can modify these values based on how large or small you want the dashboard to appear.
+            - `frameborder="0"` removes the border around the iframe for a cleaner look.
+    2.  Where to Paste It:
+        You can paste this code directly into the HTML of any web page or application that supports HTML, such as a web app, content management system, or even a simple HTML file. When the page loads, the Grafana snapshot will display within the specified area.
+            Example HTML File
+
+            ```sql
+            <!DOCTYPE html>
+            <html lang="en">
+            <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>Embedded Grafana Dashboard</title>
+            </head>
+            <body>
+                <h1>My Grafana Dashboard</h1>
+                <p>Here is a live snapshot of my Grafana dashboard:</p>
+
+                <!-- Embed Grafana Snapshot -->
+                <iframe src="https://snapshot.raintank.io/dashboard/snapshot/your-snapshot-id"
+                        width="800" height="600" frameborder="0"></iframe>
+
+                <p>Dashboard embedded using an iframe.</p>
+            </body>
+            </html>
+            ```
+    3.  Adjust the Settings:
+
         - Width and Height: You can adjust the width and height parameters to fit the size of your page or app. For example, `width="100%"` will make it span the full width of the page.
         - Scrolling: By default, if the embedded dashboard is too large, users may need to scroll within the iframe. If needed, you can enable or disable scrolling using the `scrolling="yes"` or `scrolling="no"` attributes.
-        
-        <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%205.webp" alt="Embedded Grafana Dashboard" caption="Embedded Grafana Dashboard" />
-        
+
+        <Figure
+          src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%205.webp"
+          alt="Embedded Grafana Dashboard"
+          caption="Embedded Grafana Dashboard"
+        />
 
 ### 2. Public Dashboards Feature
 
@@ -130,13 +156,21 @@ Grafana's public dashboard feature allows you to share entire dashboards without
 1. Navigate to the dashboard you want to make public.
 2. Click the "Share" button and select "Public dashboard".
 3. Toggle the "Public dashboard" switch to enable it.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%206.webp" alt="Public Dashboards Feature" caption="Public Dashboards Feature" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%206.webp"
+     alt="Public Dashboards Feature"
+     caption="Public Dashboards Feature"
+   />
+
 4. Copy the provided URL and iframe code to embed the dashboard.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%207.webp" alt="Dashboard URL using Public Dashboards Feature" caption="Dashboard URL using Public Dashboards Feature" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%207.webp"
+     alt="Dashboard URL using Public Dashboards Feature"
+     caption="Dashboard URL using Public Dashboards Feature"
+   />
+
 5. Once you have the dashboard URL you can use an `iframe` as described before to embed it in the web page.
 
 ### 3. Grafana API Embedding
@@ -148,86 +182,111 @@ For more advanced use cases, you can use the Grafana API to embed dashboards dyn
 
 Steps for Embedding Grafana Dashboards Using the API
 
-1. Login to Grafana as an admin. 
+1. Login to Grafana as an admin.
 2. Go to Administration → Users and access → Service accounts, and click on `Add service account` button.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%208.webp" alt="Adding service account in Grafana" caption="Adding service account in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%208.webp"
+     alt="Adding service account in Grafana"
+     caption="Adding service account in Grafana"
+   />
+
 3. Add the display name for the service account, choose the corresponding role, and click on the `Create` button.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%209.webp" alt="Creating service account in Grafana" caption="Creating service account in Grafana" />
-    
-4. Next, click on the `Add Service account token` 
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2010.webp" alt="Add service account token" caption="Add service account token" />
-    
-    Generate a token, you can also set an expiration date if you want. The token will be used for access.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2011.webp" alt="Generate token for service account" caption="Generate token for service account" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%209.webp"
+     alt="Creating service account in Grafana"
+     caption="Creating service account in Grafana"
+   />
+
+4. Next, click on the `Add Service account token`
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2010.webp"
+     alt="Add service account token"
+     caption="Add service account token"
+   />
+
+   Generate a token, you can also set an expiration date if you want. The token will be used for access.
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2011.webp"
+     alt="Generate token for service account"
+     caption="Generate token for service account"
+   />
+
 5. Fetch the Dashboard UUID: Once you are in the dashboard you want to embed check the URL to get the dashboard UUID.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2012.webp" alt="Fetch the Dashboard UUID" caption="Fetch the Dashboard UUID" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2012.webp"
+     alt="Fetch the Dashboard UUID"
+     caption="Fetch the Dashboard UUID"
+   />
+
 6. Fetch Dashboard Data
-    
-    Use Grafana's API to retrieve the dashboard JSON using the dashboard link:
-    
-    ```bash
-    curl -H "Authorization: Bearer <Service_account_token>" \
-         -H "Content-Type: application/json" \
-         https://your-grafana-instance/api/dashboards/uid/<UID>
-    ```
-    
-    Replace `<UID>` with the dashboard's UID from the URL.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2013.webp" alt="Test the URL" caption="Test the URL" />
-    
+
+   Use Grafana's API to retrieve the dashboard JSON using the dashboard link:
+
+   ```bash
+   curl -H "Authorization: Bearer <Service_account_token>" \
+        -H "Content-Type: application/json" \
+        https://your-grafana-instance/api/dashboards/uid/<UID>
+   ```
+
+   Replace `<UID>` with the dashboard's UID from the URL.
+
+   <Figure
+     src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2013.webp"
+     alt="Test the URL"
+     caption="Test the URL"
+   />
+
 7. Embed in Your Web Application
-    
-    To dynamically fetch and render the Grafana dashboard in your web application, you can use JavaScript. Instead of simply embedding the iframe, you can programmatically retrieve the dashboard data from Grafana's API and render it within your application.
-    
-    Here’s how to fetch the dashboard data using JavaScript:
-    
-    ```jsx
-    const dashboardUrl = 'https://your-grafana-instance/api/dashboards/uid/your-dashboard-uid';
-    const serviceAccountToken = 'your-service-account-token';
-    
-    fetch(dashboardUrl, {
-      headers: { 'Authorization': `Bearer ${serviceAccountToken}` }
-    })
-      .then(response => response.json())
-      .then(data => renderDashboard(data.dashboard.panels))
-      .catch(error => console.error('Error fetching the dashboard:', error));
-    ```
-    
-    Explanation: 
-    
-    - `dashboardUrl`: This is the API endpoint for fetching your Grafana dashboard. Replace `'your-dashboard-uid'` with the actual UID of your dashboard.
-    - `serviceAccountToken`: Grafana requires an API token (usually from a service account) to access the dashboard data. Ensure you replace `'your-service-account-token'` with a valid API token.
-    - `renderDashboard(data.dashboard.panels)`: This function would contain logic to render the dashboard data (e.g., charts, graphs, panels) into your web application.
-    
-    Example of rendering function (a basic idea to start):
-    
-    ```jsx
-    function renderDashboard(panels) {
-      const dashboardContainer = document.getElementById('dashboard');
-      panels.forEach(panel => {
-        const panelElement = document.createElement('div');
-        panelElement.className = 'panel';
-        panelElement.innerHTML = `
-          <h2>${panel.title}</h2>
-          <img src="${panel.url}" alt="${panel.title}" />
-        `;
-        dashboardContainer.appendChild(panelElement);
-      });
-    }
-    ```
-    
-    In this example:
-    
-    - Each panel's title and image (or content) are dynamically rendered within the HTML element with the ID `dashboard`.
-    - You can modify `renderDashboard` based on your requirements, whether to display charts, panels, or other components.
+
+   To dynamically fetch and render the Grafana dashboard in your web application, you can use JavaScript. Instead of simply embedding the iframe, you can programmatically retrieve the dashboard data from Grafana's API and render it within your application.
+
+   Here’s how to fetch the dashboard data using JavaScript:
+
+   ```jsx
+   const dashboardUrl = 'https://your-grafana-instance/api/dashboards/uid/your-dashboard-uid'
+   const serviceAccountToken = 'your-service-account-token'
+
+   fetch(dashboardUrl, {
+     headers: { Authorization: `Bearer ${serviceAccountToken}` },
+   })
+     .then((response) => response.json())
+     .then((data) => renderDashboard(data.dashboard.panels))
+     .catch((error) => console.error('Error fetching the dashboard:', error))
+   ```
+
+   Explanation:
+
+   - `dashboardUrl`: This is the API endpoint for fetching your Grafana dashboard. Replace `'your-dashboard-uid'` with the actual UID of your dashboard.
+   - `serviceAccountToken`: Grafana requires an API token (usually from a service account) to access the dashboard data. Ensure you replace `'your-service-account-token'` with a valid API token.
+   - `renderDashboard(data.dashboard.panels)`: This function would contain logic to render the dashboard data (e.g., charts, graphs, panels) into your web application.
+
+   Example of rendering function (a basic idea to start):
+
+   ```jsx
+   function renderDashboard(panels) {
+     const dashboardContainer = document.getElementById('dashboard')
+     panels.forEach((panel) => {
+       const panelElement = document.createElement('div')
+       panelElement.className = 'panel'
+       panelElement.innerHTML = `
+         <h2>${panel.title}</h2>
+         <img src="${panel.url}" alt="${panel.title}" />
+       `
+       dashboardContainer.appendChild(panelElement)
+     })
+   }
+   ```
+
+   In this example:
+
+   - Each panel's title and image (or content) are dynamically rendered within the HTML element with the ID `dashboard`.
+   - You can modify `renderDashboard` based on your requirements, whether to display charts, panels, or other components.
+
 8. Handle CORS: Enable embedding by setting `allow_embedding = true` in Grafana's `grafana.ini` under `[security]`.
 
 ## Security Considerations for Embedding
@@ -269,45 +328,47 @@ If you’re using the Grafana API for embedding, ensure your API access is prope
 When embedding Grafana dashboards, you might encounter some challenges:
 
 1. Cross-Origin Resource Sharing (CORS) Issues:
-    - Enable CORS in your Grafana configuration:
-        
-        ```
-        allow_embedding = true
-        cookie_samesite = none
-        ```
-        
-    - Set appropriate CORS headers on your web server
+   - Enable CORS in your Grafana configuration:
+     ```
+     allow_embedding = true
+     cookie_samesite = none
+     ```
+   - Set appropriate CORS headers on your web server
 2. Authentication Challenges:
-    - Use API tokens for server-side requests to Grafana
-    - Implement OAuth or SAML for seamless user authentication
+   - Use API tokens for server-side requests to Grafana
+   - Implement OAuth or SAML for seamless user authentication
 3. Performance Optimization:
-    - Limit the number of panels in embedded dashboards
-    - Use efficient queries and appropriate time ranges
-    - Consider using Grafana's caching features
+   - Limit the number of panels in embedded dashboards
+   - Use efficient queries and appropriate time ranges
+   - Consider using Grafana's caching features
 4. Responsive Design:
-    - Make sure that your embedded dashboard is responsive to various screen sizes by adjusting the iframe size or using CSS media queries.
-        
-        ```html
-        <div style="position: relative; padding-bottom: 56.25%; height: 0;">
-          <iframe src="..." style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe>
-        </div>
-        ```
-        
+   - Make sure that your embedded dashboard is responsive to various screen sizes by adjusting the iframe size or using CSS media queries.
+     ```html
+     <div style="position: relative; padding-bottom: 56.25%; height: 0;">
+       <iframe
+         src="..."
+         style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
+       ></iframe>
+     </div>
+     ```
 
 ## Alternatives to Grafana for Dashboard Embedding
 
 While Grafana is a popular choice for dashboard embedding, alternatives like [SigNoz](https://signoz.io) offer modern solutions for application monitoring and dashboard creation. SigNoz provides:
 
 - Easy-to-Embed Dashboards:
-    - Through its [simple API](https://signoz.io/api-reference/#/operations/getDashboards), developers can seamlessly integrate real-time dashboards into any application with minimal configuration.
-    - Whether it's embedding live metrics or visualizing performance data, SigNoz makes it easy to customize and tailor dashboards to specific needs.
+  - Through its [simple API](https://signoz.io/api-reference/#/operations/getDashboards), developers can seamlessly integrate real-time dashboards into any application with minimal configuration.
+  - Whether it's embedding live metrics or visualizing performance data, SigNoz makes it easy to customize and tailor dashboards to specific needs.
 - Built-in Application Performance Monitoring (APM):
-    - Unlike Grafana, which often requires external APM solutions, SigNoz offers native APM capabilities. This provides deep visibility into application performance, including [distributed tracing](https://signoz.io/distributed-tracing/), error tracking, and resource utilization—all without needing additional tools.
-    - The integration of monitoring and dashboards in one platform eliminates the complexity of managing multiple systems.
+  - Unlike Grafana, which often requires external APM solutions, SigNoz offers native APM capabilities. This provides deep visibility into application performance, including [distributed tracing](https://signoz.io/distributed-tracing/), error tracking, and resource utilization—all without needing additional tools.
+  - The integration of monitoring and dashboards in one platform eliminates the complexity of managing multiple systems.
 - Open-Source Flexibility: Enjoy a user-friendly interface while leveraging the benefits of open-source software.
-    
-    <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2014.webp" alt="User-friendly SigNoz Interface" caption="User-friendly SigNoz Interface" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2014.webp"
+    alt="User-friendly SigNoz Interface"
+    caption="User-friendly SigNoz Interface"
+  />
 
 SigNoz can be particularly beneficial for teams looking for an all-in-one solution that combines monitoring, tracing, and dashboard embedding.
 
@@ -348,4 +409,4 @@ Embedded dashboards can impact page load times. Optimize by limiting data points
 
 ### Is it possible to customize the appearance of an embedded Grafana dashboard?
 
-Yes, you can customize themes, sizes, and even create custom panels using Grafana's API and plugin system.
\ No newline at end of file
+Yes, you can customize themes, sizes, and even create custom panels using Grafana's API and plugin system.
diff --git a/data/guides/end-to-end-monitoring-solution.mdx b/data/guides/end-to-end-monitoring-solution.mdx
index 7e536213c..6f6d268bb 100644
--- a/data/guides/end-to-end-monitoring-solution.mdx
+++ b/data/guides/end-to-end-monitoring-solution.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: End-to-End Monitoring - A Complete Guide for Businesses
-slug: end-to-end-monitoring-solution
 date: 2024-11-29
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover how end-to-end monitoring solutions can revolutionize your business operations, improve performance, and enhance user experience. Learn implementation strategies and best practices.
-keywords: [end-to-end monitoring, IT performance, system monitoring, business efficiency, DevOps, application performance, network monitoring, SigNoz]
-
+keywords:
+  [
+    end-to-end monitoring,
+    IT performance,
+    system monitoring,
+    business efficiency,
+    DevOps,
+    application performance,
+    network monitoring,
+    SigNoz,
+  ]
 ---
 
 Today businesses are facing the challenge of maintaining optimal performance across interconnected systems and applications. Now to soolve this issue, one can rely on end-to-end monitoring which provides a comprehensive solution by offering a whole view of your entire technology stack. This article helps you learn and deepen your understanding of implementing and optimizing end-to-end monitoring solutions, focusing their importance for modern businesses.
@@ -26,148 +33,178 @@ Modern IT systems are complex. A single user request generally passes across sev
 
 ### Differences from Traditional Monitoring
 
-| Aspect | Traditional Monitoring | End-to-End Monitoring |
-| --- | --- | --- |
-| Scope | Focuses on specific components | Covers the entire technology stack |
-| Data Correlation | Limited or absent | Cross-layer correlation |
-| Use Case | CPU or server-specific monitoring | Full-stack visibility |
+| Aspect           | Traditional Monitoring            | End-to-End Monitoring              |
+| ---------------- | --------------------------------- | ---------------------------------- |
+| Scope            | Focuses on specific components    | Covers the entire technology stack |
+| Data Correlation | Limited or absent                 | Cross-layer correlation            |
+| Use Case         | CPU or server-specific monitoring | Full-stack visibility              |
 
 ### Visual Representation of an End-to-End Monitoring Workflow
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.152x.webp" alt="" caption="" />Here you can see how user actions propagate across layers and how end-to-end monitoring connects the dots to provide a complete picture.
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.152x.webp"
+  alt=""
+  caption=""
+/>
+Here you can see how user actions propagate across layers and how end-to-end monitoring connects the
+dots to provide a complete picture.
 
 ### Key Components of End-to-End Monitoring
 
 1. User Experience Monitoring: It tracks user interactions, with an emphasis on data like page load times, transaction success rates, and error frequencies.
-    - *Example*: If consumers see significant latency on your e-commerce checkout page, user experience monitoring may help identify the root reason, which could be frontend rendering or API performance.
+   - _Example_: If consumers see significant latency on your e-commerce checkout page, user experience monitoring may help identify the root reason, which could be frontend rendering or API performance.
 2. Application Performance Monitoring (APM): It monitors application-level performance metrics, including response times, errors, and database queries.
-    - *Example*: An online streaming service may employ APM to ensure continuous video playback during busy hours.
+   - _Example_: An online streaming service may employ APM to ensure continuous video playback during busy hours.
 3. [Infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/): It monitors the backend, including servers, databases, and storage systems, to ensure uptime and scalability.
-    - *Example*: Setting up CPU spike alerts on a web server during a flash sale can assist prevent crashes.
+   - _Example_: Setting up CPU spike alerts on a web server during a flash sale can assist prevent crashes.
 4. Network Monitoring: It ensures smooth interaction and excellent data transmission speeds across networks.
-    - *Example*: Identifying packet losses in a corporate VPN setup ensures uninterrupted remote work.
+   - _Example_: Identifying packet losses in a corporate VPN setup ensures uninterrupted remote work.
 
 ### Diagram of Key Components
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.302x.webp" alt="" caption="" />## Why Implement an End-to-End Monitoring Solution?
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.302x.webp"
+  alt=""
+  caption=""
+/>
+## Why Implement an End-to-End Monitoring Solution?
 
 Implementing an end-to-end monitoring solution isn’t just a technical necessity; it’s a business imperative.
 
 ### Benefits
 
 1. Improved Visibility: A full 360-degree perspective enables IT professionals to spot hidden bottlenecks and performance concerns across interconnected systems.
-    - *Example*: A retail firm monitors the whole customer experience to identify delays in payment processing caused by a backend database query.
+   - _Example_: A retail firm monitors the whole customer experience to identify delays in payment processing caused by a backend database query.
 2. Quicker Problem Resolution: Correlating data across all levels allows teams to pinpoint fundamental causes in minutes, decreasing MTTR.
-    - *Example*: Monitoring dashboards may indicate that slowness is due to a poorly optimized query in a certain microservice.
+   - _Example_: Monitoring dashboards may indicate that slowness is due to a poorly optimized query in a certain microservice.
 3. Improved User Experience: Preventing issues before they occur leads to smoother encounters and increased retention rates.
-    - *Example*: Automated notifications for sluggish load times on a trip booking website enable the technical team to address the issue proactively.
+   - _Example_: Automated notifications for sluggish load times on a trip booking website enable the technical team to address the issue proactively.
 4. Improved alignment with business objectives: Ensures IT performance meets SLAs and business requirements.
-    - *Example*: Tracking checkout times aligns with revenue goals for e-commerce platforms.
+   - _Example_: Tracking checkout times aligns with revenue goals for e-commerce platforms.
 5. Increased Operational Efficiency: Automation reduces manual workload which lets the IT teams focus on innovation.
 
 ### Diagram: ROI of End-to-End Monitoring
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.412x.webp" alt="" caption="" />## How to Implement End-to-End Monitoring
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.412x.webp"
+  alt=""
+  caption=""
+/>
+## How to Implement End-to-End Monitoring
 
 Implementing an efficient end-to-end monitoring solution requires a methodical approach to provide broad coverage and useful insights. Follow these steps to establish a strong monitoring framework:
 
 ### Step-by-Step Guide
 
 1. Define Monitoring Goals and KPIs: Start by identifying the critical aspects of your business processes and applications:
-    - *Examples of KPIs*:
-        - Response Time: Ensure all API calls are complete within 300ms.
-        - Transaction Success Rate: Aim for a 99.9% success rate for checkout processes.
-    - Align these KPIs with business objectives and customer expectations.
+   - _Examples of KPIs_:
+     - Response Time: Ensure all API calls are complete within 300ms.
+     - Transaction Success Rate: Aim for a 99.9% success rate for checkout processes.
+   - Align these KPIs with business objectives and customer expectations.
 2. Select Appropriate Tools and Technologies: Choose tools that address your specific needs:
-    - *Examples*:
-        - For distributed systems: [SigNoz](https://signoz.io/) (an open-source observability platform) and OpenTelemetry (a standardized framework for generating, collecting, and exporting telemetry data). SigNoz provides an integrated approach to monitoring with seamless support for metrics, traces, and logs, enabling better insights into application performance. It also offers an intuitive user interface and self-hosted deployment for complete data control.
-    - Evaluate factors like scalability, integration capabilities, and user-friendliness.
+   - _Examples_:
+     - For distributed systems: [SigNoz](https://signoz.io/) (an open-source observability platform) and OpenTelemetry (a standardized framework for generating, collecting, and exporting telemetry data). SigNoz provides an integrated approach to monitoring with seamless support for metrics, traces, and logs, enabling better insights into application performance. It also offers an intuitive user interface and self-hosted deployment for complete data control.
+   - Evaluate factors like scalability, integration capabilities, and user-friendliness.
 3. Integrate Monitoring Across Systems: Ensure seamless data flow between components:
-    - Use monitoring agents to collect data from servers, networks, and applications.
-    - Correlate data across systems for actionable insights.
+   - Use monitoring agents to collect data from servers, networks, and applications.
+   - Correlate data across systems for actionable insights.
 4. Establish Baselines and Thresholds:
-    - Collect data over time to identify normal behaviour patterns.
-    - Set thresholds for alerts, such as triggering a notification if server CPU usage exceeds 85%.
-    - Regularly adjust baselines to accommodate growth or changing usage patterns.
+   - Collect data over time to identify normal behaviour patterns.
+   - Set thresholds for alerts, such as triggering a notification if server CPU usage exceeds 85%.
+   - Regularly adjust baselines to accommodate growth or changing usage patterns.
 
 ### Diagram: Steps to Implement End-to-End Monitoring
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.572x.webp" alt="" caption="" />### Overcoming Implementation Challenges
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.10.572x.webp"
+  alt=""
+  caption=""
+/>
+### Overcoming Implementation Challenges
 
 Implementing an end-to-end monitoring solution is not without hurdles. Here's how to tackle common challenges:
 
 1. Dealing with Complex, Distributed Systems
-    - Problem: Tracking requests across multiple microservices can be daunting.
-    - Solution:
-        - Use distributed [tracing tools](https://signoz.io/blog/distributed-tracing-tools/) like OpenTelemetry to follow user requests end-to-end.
-        - Implement [centralized logging](https://signoz.io/blog/centralized-logging/) using solutions like Elasticsearch and Kibana.
-    
-    Example: A retail platform using microservices for payment processing and inventory can trace failed requests to an overloaded database shard.
-    
+
+   - Problem: Tracking requests across multiple microservices can be daunting.
+   - Solution:
+     - Use distributed [tracing tools](https://signoz.io/blog/distributed-tracing-tools/) like OpenTelemetry to follow user requests end-to-end.
+     - Implement [centralized logging](https://signoz.io/blog/centralized-logging/) using solutions like Elasticsearch and Kibana.
+
+   Example: A retail platform using microservices for payment processing and inventory can trace failed requests to an overloaded database shard.
+
 2. Managing Data Overload and [Alert Fatigue](https://signoz.io/blog/alert-fatigue/)
-    - Problem: Overwhelming alerts make it hard to identify real issues.
-    - Solution:
-        - Set intelligent alert thresholds and suppress low-priority notifications.
-        - Use AI-driven anomaly detection to focus on critical events.
+   - Problem: Overwhelming alerts make it hard to identify real issues.
+   - Solution:
+     - Set intelligent alert thresholds and suppress low-priority notifications.
+     - Use AI-driven anomaly detection to focus on critical events.
 3. Ensuring Proper Integration Between Tools
-    - Problem: Lack of interoperability between different monitoring tools.
-    - Solution:
-        - Opt for tools with robust APIs and integration capabilities.
-        - Use a unified monitoring dashboard like Grafana for consolidated views.
+   - Problem: Lack of interoperability between different monitoring tools.
+   - Solution:
+     - Opt for tools with robust APIs and integration capabilities.
+     - Use a unified monitoring dashboard like Grafana for consolidated views.
 4. Addressing Skill Gaps in the Team
-    - Problem: Limited expertise in modern monitoring tools and strategies.
-    - Solution:
-        - Provide training in tools like Prometheus, OpenTelemetry, or Datadog.
-        - Use [managed monitoring](https://signoz.io/guides/managed-prometheus/) services for specialized expertise.
+   - Problem: Limited expertise in modern monitoring tools and strategies.
+   - Solution:
+     - Provide training in tools like Prometheus, OpenTelemetry, or Datadog.
+     - Use [managed monitoring](https://signoz.io/guides/managed-prometheus/) services for specialized expertise.
 
 ## Best Practices for Effective End-to-End Monitoring
 
 To maximise the capabilities of your monitoring setup, you can adopt these proven strategies:
 
 1. Adopt a [Proactive Monitoring](https://signoz.io/guides/proactive-monitoring/) Approach
-    - Use predictive analytics to predict potential failures based on historical data.
-    - Regularly analyze the performance trends to optimize systems beforehand.
-    
-    Example: A banking app proactively scales up its servers during high-traffic periods like payday.
-    
+
+   - Use predictive analytics to predict potential failures based on historical data.
+   - Regularly analyze the performance trends to optimize systems beforehand.
+
+   Example: A banking app proactively scales up its servers during high-traffic periods like payday.
+
 2. Implement Automated Alerting and Escalation
-    - Define clear escalation policies to prioritize critical issues.
-    - Integrate chatbots or automated ticketing systems with tools like Slack or Jira for faster resolution.
-    
-    Example: A server crash automatically creates a high-priority ticket in Jira and sends an alert to the on-call engineer.
-    
+
+   - Define clear escalation policies to prioritize critical issues.
+   - Integrate chatbots or automated ticketing systems with tools like Slack or Jira for faster resolution.
+
+   Example: A server crash automatically creates a high-priority ticket in Jira and sends an alert to the on-call engineer.
+
 3. Utilize AI and Machine Learning for Anomaly Detection
-    - Use machine learning algorithms to detect unusual patterns, such as sudden spikes in latency.
-    - Use AI-driven root cause analysis to minimize time spent diagnosing issues.
-    
-    Example: An AI-powered monitoring system detects a 50% increase in API errors during deployment, flagging the new code release as the probable cause.
-    
+
+   - Use machine learning algorithms to detect unusual patterns, such as sudden spikes in latency.
+   - Use AI-driven root cause analysis to minimize time spent diagnosing issues.
+
+   Example: An AI-powered monitoring system detects a 50% increase in API errors during deployment, flagging the new code release as the probable cause.
+
 4. Regularly Review and Optimize Monitoring Strategies
-    - Conduct periodic audits to ensure monitoring tools remain aligned with your business needs.
-    - Adapt to evolving environments by incorporating new tools or revising thresholds.
+   - Conduct periodic audits to ensure monitoring tools remain aligned with your business needs.
+   - Adapt to evolving environments by incorporating new tools or revising thresholds.
 
 ### Diagram: End-to-End Monitoring Best Practices
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.082x.webp" alt="" caption="" />## End-to-End Monitoring Tools and Technologies
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.082x.webp"
+  alt=""
+  caption=""
+/>
+## End-to-End Monitoring Tools and Technologies
 
 Choosing the right tool for end-to-end monitoring can make all the difference in achieving seamless observability across your systems. Here’s an overview of some widely used options:
 
 1. [SigNoz](https://signoz.io/)
-    - Type: Open-source Application Performance Monitoring (APM)
-    - Features: Distributed tracing, customizable dashboards, OpenTelemetry support, and cost-effectiveness.
-    - Best For: Businesses seeking a cost-efficient yet robust monitoring solution.
+   - Type: Open-source Application Performance Monitoring (APM)
+   - Features: Distributed tracing, customizable dashboards, OpenTelemetry support, and cost-effectiveness.
+   - Best For: Businesses seeking a cost-efficient yet robust monitoring solution.
 2. Datadog
-    - Type: Comprehensive monitoring platform
-    - Features: Supports wide integration with cloud providers, infrastructure, and applications.
-    - Best For: Enterprises with diverse tech stacks requiring centralized monitoring.
+   - Type: Comprehensive monitoring platform
+   - Features: Supports wide integration with cloud providers, infrastructure, and applications.
+   - Best For: Enterprises with diverse tech stacks requiring centralized monitoring.
 3. New Relic
-    - Type: Full-stack observability platform
-    - Features: Concentrated focus on cloud-native applications and real-time insights.
-    - Best For: Teams prioritizing scalability and modern architectures.
+   - Type: Full-stack observability platform
+   - Features: Concentrated focus on cloud-native applications and real-time insights.
+   - Best For: Teams prioritizing scalability and modern architectures.
 4. Dynatrace
-    - Type: AI-powered monitoring solution
-    - Features: Automated root cause analysis and full-stack monitoring.
-    - Best For: Big enterprises utilising AI to minimize manual interventions.
+   - Type: AI-powered monitoring solution
+   - Features: Automated root cause analysis and full-stack monitoring.
+   - Best For: Big enterprises utilising AI to minimize manual interventions.
 
 ### Key Factors to Consider
 
@@ -199,7 +236,7 @@ SigNoz offers an integrated approach to observability, helping businesses mainta
 Follow these steps to begin monitoring with SigNoz:
 
 1. Visit the official [SigNoz website](https://signoz.io/).
-<GetStartedSigNoz />
+   <GetStartedSigNoz />
 2. Choose between a cloud-hosted or self-hosted version, depending on your needs.
 3. To get started with SigNoz, follow the installation guide.
 4. Set up your applications to send telemetry data using the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) SDKs.
@@ -209,49 +246,60 @@ Example: A logistics company uses SigNoz to monitor API latencies and trace deli
 
 ### Diagram: SigNoz Workflow
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.262x.webp" alt="" caption="" />## Measuring the ROI of End-to-End Monitoring
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.262x.webp"
+  alt=""
+  caption=""
+/>
+## Measuring the ROI of End-to-End Monitoring
 
 Investing in an end-to-end monitoring solution will bring solid business benefits. Here's how to calculate the return on investment (ROI):
 
 ### Key Metrics
 
 1. Improved System Performance
-    - Assess reductions in response times, error rates, and downtime frequency.
-    - For example, a retail website reduces page load times from 3 to 1.2 seconds, increasing conversion rates by 20%.
+   - Assess reductions in response times, error rates, and downtime frequency.
+   - For example, a retail website reduces page load times from 3 to 1.2 seconds, increasing conversion rates by 20%.
 2. Cost Savings from Reduced Downtime
-    - Determine the financial impact of fewer unplanned outages.
-    - Monitor improvements in Mean Time to Detection (MTTD) and Mean Time to Resolution (MTTR).
-    - For example, an e-commerce platform saves outage costs by $50,000 per event by lowering MTTR by 40%.
+   - Determine the financial impact of fewer unplanned outages.
+   - Monitor improvements in Mean Time to Detection (MTTD) and Mean Time to Resolution (MTTR).
+   - For example, an e-commerce platform saves outage costs by $50,000 per event by lowering MTTR by 40%.
 3. Impact on Customer Satisfaction and Retention:
-    - Monitor indicators such as Net Promoter Score (NPS) and Customer Satisfaction (CSAT).
-    - Example: Improved API performance decreases customer complaints by 30%.
+   - Monitor indicators such as Net Promoter Score (NPS) and Customer Satisfaction (CSAT).
+   - Example: Improved API performance decreases customer complaints by 30%.
 4. Operational Efficiency Gains
-    - Quantify the time saved up on manual tasks like log analysis and incident resolution.
-    - Example: Automated alerting cuts troubleshooting time by 50%.
+   - Quantify the time saved up on manual tasks like log analysis and incident resolution.
+   - Example: Automated alerting cuts troubleshooting time by 50%.
 
 ### Diagram: ROI of End-to-End Monitoring
 
-<Figure src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.412x.webp" alt="" caption="" />Pro Tip: Combine qualitative insights (such as satisfied customers) with quantitative metrics to present a convincing case to stakeholders for continued investment.
+<Figure
+  src="/img/guides/2024/11/end-to-end-monitoring-solution-CleanShot_2024-11-29_at_15.11.412x.webp"
+  alt=""
+  caption=""
+/>
+Pro Tip: Combine qualitative insights (such as satisfied customers) with quantitative metrics to
+present a convincing case to stakeholders for continued investment.
 
 ## Future Trends in End-to-End Monitoring
 
 The advancement of technology is continually transforming how firms handle monitoring. Here are some forward-looking tendencies that shape the future:
 
 1. AI-Driven Predictive Analytics
-    - What to Expect: Machine learning (ML) algorithms examine past data to predict system failures or performance issues.
-    - Example: Predicting database overloads during high traffic using prior trends and dynamically allocating resources to avoid downtime.
+   - What to Expect: Machine learning (ML) algorithms examine past data to predict system failures or performance issues.
+   - Example: Predicting database overloads during high traffic using prior trends and dynamically allocating resources to avoid downtime.
 2. Increased Focus on Security Monitoring
-    - What to Expect: Real-time identification of security abnormalities, such as strange login patterns or data exfiltration attempts, will be essential.
-    - Example: Integrating monitoring tools with security incident and event management (SIEM) systems to speed up threat detection and resolution.
+   - What to Expect: Real-time identification of security abnormalities, such as strange login patterns or data exfiltration attempts, will be essential.
+   - Example: Integrating monitoring tools with security incident and event management (SIEM) systems to speed up threat detection and resolution.
 3. Integration with DevOps and CI/CD Pipelines
-    - What to Expect: Monitoring will integrate smoothly with development workflows, providing immediate feedback on code deployments and allowing for rapid iterations.
-    - Example: Monitor API response times straight from CI/CD processes to detect regressions before they reach production.
+   - What to Expect: Monitoring will integrate smoothly with development workflows, providing immediate feedback on code deployments and allowing for rapid iterations.
+   - Example: Monitor API response times straight from CI/CD processes to detect regressions before they reach production.
 4. Edge Computing and IoT Monitoring
-    - What to Expect: Monitoring systems will adapt to handle scattered devices and low-latency data.
-    - Example: Monitoring sensor networks in real-time to detect defective IoT devices in smart cities.
+   - What to Expect: Monitoring systems will adapt to handle scattered devices and low-latency data.
+   - Example: Monitoring sensor networks in real-time to detect defective IoT devices in smart cities.
 5. [Observability as Code](https://signoz.io/guides/observability-as-code/)
-    - What to Expect: Monitoring setups are defined programmatically (similar to infrastructure-as-code) to ensure consistency and scalability.
-    - Example: Using YAML files to specify metrics, logs, and tracing setups, which allows for version-controlled observability.
+   - What to Expect: Monitoring setups are defined programmatically (similar to infrastructure-as-code) to ensure consistency and scalability.
+   - Example: Using YAML files to specify metrics, logs, and tracing setups, which allows for version-controlled observability.
 
 ### Staying Future-Ready
 
@@ -295,4 +343,4 @@ Key skills include system administration, which involves understanding servers,
 - Cloud and Containerization: Experience with AWS, Kubernetes, or Docker.
 - AI Basics: Using machine learning for sophisticated analytics.
 
-Tip: To bridge skill gaps, promote continual learning through workshops, certifications, and relationships with monitoring specialists.
\ No newline at end of file
+Tip: To bridge skill gaps, promote continual learning through workshops, certifications, and relationships with monitoring specialists.
diff --git a/data/guides/endpoint-monitoring.mdx b/data/guides/endpoint-monitoring.mdx
index 3a0349f70..6076fe9e9 100644
--- a/data/guides/endpoint-monitoring.mdx
+++ b/data/guides/endpoint-monitoring.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Essential Guide to Endpoint Monitoring - Secure Your Network
-slug: endpoint-monitoring
 date: 2024-10-03
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover how endpoint monitoring secures your network, learn implementation strategies, and overcome common challenges in this comprehensive guide.
-keywords: [endpoint monitoring, network security, cybersecurity, threat detection, endpoint protection]
-
+keywords:
+  [endpoint monitoring, network security, cybersecurity, threat detection, endpoint protection]
 ---
 
 In today's hyperlinked digital environment, protecting your network from cyber attacks is necessary. Endpoint monitoring is essential to current cybersecurity methods, providing real-time visibility and control over the devices that connect to your network. But what exactly is endpoint monitoring, and how can it help you improve your network security? In this article, we will look into endpoint monitoring, its importance, and how to implement it efficiently.
@@ -61,17 +59,17 @@ Keeping a successful endpoint monitoring strategy demands ongoing attention and
 While endpoint monitoring is important for network security, enterprises frequently encounter difficulties that limit its efficacy. Here's a look at some frequent issues and how to solve them:
 
 1. Increasing quantity and variety of endpoints:
-    - Challenge: With the growing expansion of devices, such as smartphones, tablets, IoT devices, and remote work arrangements, thorough monitoring becomes increasingly challenging.
-    - Solution: Use scalable endpoint monitoring solutions to manage an increasing number of devices. Maintain a dynamic, up-to-date inventory system to guarantee that any additional endpoints are tracked and monitored.
+   - Challenge: With the growing expansion of devices, such as smartphones, tablets, IoT devices, and remote work arrangements, thorough monitoring becomes increasingly challenging.
+   - Solution: Use scalable endpoint monitoring solutions to manage an increasing number of devices. Maintain a dynamic, up-to-date inventory system to guarantee that any additional endpoints are tracked and monitored.
 2. Managing Data Volume:
-    - Challenge: Endpoint monitoring produces massive volumes of data that might be difficult to handle, analyze, and act on in real-time.
-    - Solution: Use methods based on machine learning and AI to automate data analysis, prioritize key warnings, and minimize false positives. These algorithms may detect trends in massive datasets faster than manual analysis, allowing your security staff to focus on true risks.
+   - Challenge: Endpoint monitoring produces massive volumes of data that might be difficult to handle, analyze, and act on in real-time.
+   - Solution: Use methods based on machine learning and AI to automate data analysis, prioritize key warnings, and minimize false positives. These algorithms may detect trends in massive datasets faster than manual analysis, allowing your security staff to focus on true risks.
 3. Balancing security and productivity:
-    - Challenge. Overly tight monitoring and security measures might reduce user productivity by preventing lawful activity or slowing down devices.
-    - Solution: Implement context-aware security policies that change dynamically in response to user behaviour and risk levels. Employees who operate in secure facilities, for example, may be subject to fewer limitations than those who access critical data remotely.
+   - Challenge. Overly tight monitoring and security measures might reduce user productivity by preventing lawful activity or slowing down devices.
+   - Solution: Implement context-aware security policies that change dynamically in response to user behaviour and risk levels. Employees who operate in secure facilities, for example, may be subject to fewer limitations than those who access critical data remotely.
 4. The complexity of modern threats:
-    - Challenge: Cybercriminals are constantly evolving their strategies and employing complex methods such as advanced persistent threats (APTs) and zero-day vulnerabilities, which are difficult to detect using traditional approaches.
-    - Solution: Keep ahead of attackers by incorporating sophisticated threat information feeds into your monitoring system. To boost detection capabilities against new threats, update your endpoint monitoring tools regularly and add machine learning models into them.
+   - Challenge: Cybercriminals are constantly evolving their strategies and employing complex methods such as advanced persistent threats (APTs) and zero-day vulnerabilities, which are difficult to detect using traditional approaches.
+   - Solution: Keep ahead of attackers by incorporating sophisticated threat information feeds into your monitoring system. To boost detection capabilities against new threats, update your endpoint monitoring tools regularly and add machine learning models into them.
 
 ## Enhancing Endpoint Monitoring with SigNoz
 
@@ -129,4 +127,4 @@ While endpoint monitoring dramatically improves network security, it does not pr
 ### What is the distinction between endpoint monitoring and endpoint protection?
 
 - Endpoint monitoring: Observes and analyzes device activity to detect abnormalities that may signal a threat.
-- Endpoint Protection: Actively protects the endpoint by detecting, blocking, and eliminating threats like malware or unauthorized access attempts.
\ No newline at end of file
+- Endpoint Protection: Actively protects the endpoint by detecting, blocking, and eliminating threats like malware or unauthorized access attempts.
diff --git a/data/guides/enterprise-observability.mdx b/data/guides/enterprise-observability.mdx
index f9910d811..029b53990 100644
--- a/data/guides/enterprise-observability.mdx
+++ b/data/guides/enterprise-observability.mdx
@@ -1,24 +1,28 @@
 ---
-
 title: Enterprise Observability - Complete Guide
-slug: enterprise-observability
 date: 2025-02-28
 tags: [observability]
 authors: [nitin_gouda]
 description: Discover the key benefits and best practices of enterprise observability. Learn how to optimize complex IT environments and improve decision-making.
-keywords: [enterprise observability, monitoring, microservices, distributed systems, DevOps, incident response, SigNoz]
-
+keywords:
+  [
+    enterprise observability,
+    monitoring,
+    microservices,
+    distributed systems,
+    DevOps,
+    incident response,
+    SigNoz,
+  ]
 ---
 
-As you build and maintain distributed, cloud-native applications, you need clear, actionable insights into your systems’ behavior. 
+As you build and maintain distributed, cloud-native applications, you need clear, actionable insights into your systems’ behavior.
 
 We'll cover what observability is (and how it differs from traditional monitoring), explore its key pillars, and outline a roadmap for implementing observability in a large organization. By the end, you’ll see how observability improves reliability, security, and performance, and you’ll have actionable steps to start or enhance an observability strategy in your enterprise.
 
-
-
 ## What is Enterprise Observability?
 
-Enterprise observability is a modern approach to understanding and managing the performance, reliability, and behavior of complex IT systems. It involves collecting, correlating, and analyzing signals—such as logs, metrics, and traces—at scale to view the system's internal states comprehensively. 
+Enterprise observability is a modern approach to understanding and managing the performance, reliability, and behavior of complex IT systems. It involves collecting, correlating, and analyzing signals—such as logs, metrics, and traces—at scale to view the system's internal states comprehensively.
 
 Unlike traditional monitoring, which focuses on predefined metrics and thresholds, observability enables teams to investigate unknown issues and confidently perform root-cause analysis.
 
@@ -26,7 +30,7 @@ This practice has become essential for organizations operating in **distributed
 
 ### Key Pillars of Observability (MELT)
 
-Modern observability centers on four main types of telemetry data often summarized as **MELT: Metrics, Events, Logs, and Traces.** Each pillar provides unique insight, and together they offer a 360° view of system behavior. 
+Modern observability centers on four main types of telemetry data often summarized as **MELT: Metrics, Events, Logs, and Traces.** Each pillar provides unique insight, and together they offer a 360° view of system behavior.
 
 Here's why each is important:
 
@@ -38,9 +42,11 @@ Here's why each is important:
 
 - **Traces**: Traces follow the journey of a single request or transaction through a distributed system, recording how it passes through various services and components. A trace is like a hierarchical log for one operation, showing each step (with timings) across microservices or processes. Tracing is vital for understanding dependencies and performance in modern architectures – for example, if a user action is slow, traces help pinpoint which service or database call caused the slowdown. They give a end-to-end view that is essential for debugging in microservices or serverless environments. By visualizing request flows (often as flame graphs or timelines), tracing lets teams find bottlenecks and optimize complex transactions.
 
-
 <KeyPointCallout title="Why these pillars matter">
-While each pillar provides unique insights, their true value emerges when combined. Together, metrics, events, logs, and traces create a comprehensive framework that enables rapid detection and resolution of issues. An effective observability strategy leverages all four data types to ensure complete system visibility.
+  While each pillar provides unique insights, their true value emerges when combined. Together,
+  metrics, events, logs, and traces create a comprehensive framework that enables rapid detection
+  and resolution of issues. An effective observability strategy leverages all four data types to
+  ensure complete system visibility.
 </KeyPointCallout>
 
 ## Why Traditional Monitoring Falls Short
@@ -57,43 +63,49 @@ Here's why traditional monitoring approaches are insufficient for modern enterpr
 
 - **Dynamic Systems Challenges**: Modern enterprises with microservices, containers, and ephemeral infrastructure overwhelm traditional monitoring. The volume and volatility of data from constantly changing services exceed what static monitoring can effectively track.
 
-
 While traditional monitoring is necessary, it's not sufficient for modern enterprises. It tells you that something is wrong, but observability tells you what's wrong and why. Enterprises adopting observability move from firefighting known issues to a more resilient posture where even unexpected problems can be dissected and resolved quickly.
 
-
 ### Difference Between Monitoring and Observability
 
-| **Aspect** | **Monitoring** | **Observability** |
-| --- | --- | --- |
-| **Definition** | Tracks predefined metrics and thresholds. | Explores system behavior by exposing internal states. |
-| **Focus** | Known issues and static thresholds. | Unknown issues and dynamic, ad-hoc analysis. |
-| **Key Components** | Metrics and alerts. | Logs, metrics, and traces (correlated insights). |
-| **Approach** | Reactive: Alerts on threshold breaches. | Proactive: Enables root-cause analysis and system insights. |
-| **Scope** | Limited to detecting and alerting on predefined problems. | Provides a holistic view of the entire system. |
-| **Use Case** | Answering "What is wrong?" | Answering "Why is it wrong?" and "How do I fix it?" |
-| **Tools** | Typically single-purpose tools (e.g., metrics collectors). | Unified platforms combining logs, metrics, and traces. |
-| **Scalability** | Struggles with complex, dynamic, and distributed systems. | Designed for modern, distributed architectures. |
-| **Example** | Monitoring CPU usage exceeds 80%. | Identifying the root cause of high CPU usage in a microservice. |
+| **Aspect**         | **Monitoring**                                             | **Observability**                                               |
+| ------------------ | ---------------------------------------------------------- | --------------------------------------------------------------- |
+| **Definition**     | Tracks predefined metrics and thresholds.                  | Explores system behavior by exposing internal states.           |
+| **Focus**          | Known issues and static thresholds.                        | Unknown issues and dynamic, ad-hoc analysis.                    |
+| **Key Components** | Metrics and alerts.                                        | Logs, metrics, and traces (correlated insights).                |
+| **Approach**       | Reactive: Alerts on threshold breaches.                    | Proactive: Enables root-cause analysis and system insights.     |
+| **Scope**          | Limited to detecting and alerting on predefined problems.  | Provides a holistic view of the entire system.                  |
+| **Use Case**       | Answering "What is wrong?"                                 | Answering "Why is it wrong?" and "How do I fix it?"             |
+| **Tools**          | Typically single-purpose tools (e.g., metrics collectors). | Unified platforms combining logs, metrics, and traces.          |
+| **Scalability**    | Struggles with complex, dynamic, and distributed systems.  | Designed for modern, distributed architectures.                 |
+| **Example**        | Monitoring CPU usage exceeds 80%.                          | Identifying the root cause of high CPU usage in a microservice. |
 
 ## Why Enterprise Observability Matters
 
 For large organizations, observability isn’t a luxury – it’s quickly becoming a necessity. Here are key reasons enterprises are investing in observability:
 
 ### Managing Growing System Complexity
+
 Enterprises run distributed systems at scale with hundreds of microservices, hybrid environments, and globally distributed users. Observability provides a holistic view of these complex ecosystems, preventing small issues from snowballing into major incidents.
 
 **Example**: When a container spins up temporarily to handle a surge in requests, observability tools capture its performance metrics and logs before it disappears.
-    
-<Figure src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp" alt="SigNoz dashboard displaying container metrics in a unified view" caption="SigNoz dashboard displaying container metrics in a unified view" />
-    
-### Faster Issue Resolution & Reduced Downtime
-Observability helps reduce MTTR (Mean Time to Repair) by providing rich context when failures occur. Instead of spending days reproducing issues, engineers can examine traces and logs to pinpoint root causes in minutes.
-**Example**: If an application experiences slow response times, traces can reveal whether the bottleneck is in the database query, network latency, or application code.
+
+<Figure
+  src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp"
+  alt="SigNoz dashboard displaying container metrics in a unified view"
+  caption="SigNoz dashboard displaying container metrics in a unified view"
+/>
+### Faster Issue Resolution & Reduced Downtime Observability helps reduce MTTR (Mean Time to Repair)
+by providing rich context when failures occur. Instead of spending days reproducing issues,
+engineers can examine traces and logs to pinpoint root causes in minutes. **Example**: If an
+application experiences slow response times, traces can reveal whether the bottleneck is in the
+database query, network latency, or application code.
 
 ### Cross-Team Collaboration
+
 Observability breaks down silos by offering a single source of truth that all stakeholders can use. When an incident strikes, developers, SREs, and business analysts can look at the same dashboards to understand the impact.
 
 ### Customer Experience & Business Impact
+
 Beyond uptime, observability connects technical performance to business outcomes. Teams can prioritize issues based on business impact and demonstrate how improvements like reducing latency directly correlate with metrics such as conversion rates.
 
 **Example**: Reducing latency by 100ms might directly correlate with a 5% increase in e-commerce conversions, demonstrating the tangible value of observability initiatives.
@@ -104,167 +116,156 @@ Bottom line: Enterprises need observability to maintain control and confidence i
 
 ### Improved Reliability and System Resilience
 
-- **Proactive Issue Detection & Resolution:** 
-Enterprise observability employs advanced anomaly detection techniques, such as machine learning (ML) algorithms or predefined thresholds, to detect irregular patterns before they [escalate into system failures](https://signoz.io/guides/proactive-monitoring/), reducing downtime and improving user experience.
+- **Proactive Issue Detection & Resolution:**
+  Enterprise observability employs advanced anomaly detection techniques, such as machine learning (ML) algorithms or predefined thresholds, to detect irregular patterns before they [escalate into system failures](https://signoz.io/guides/proactive-monitoring/), reducing downtime and improving user experience.
 
-- **Reduced Downtime:** 
-By correlating signals across metrics, logs, and traces, engineers can quickly identify the root cause of incidents and address them, dramatically cutting Mean Time to Repair. Instead of hours spent combing through logs, a team can use distributed tracing to pinpoint a failing service in minutes.
+- **Reduced Downtime:**
+  By correlating signals across metrics, logs, and traces, engineers can quickly identify the root cause of incidents and address them, dramatically cutting Mean Time to Repair. Instead of hours spent combing through logs, a team can use distributed tracing to pinpoint a failing service in minutes.
 
-- **Higher Uptime and Consistency:** 
-With comprehensive instrumentation and monitoring, nothing goes unnoticed. This ensures systems meet or exceed their uptime targets because the observability platform is watching every critical component.
+- **Higher Uptime and Consistency:**
+  With comprehensive instrumentation and monitoring, nothing goes unnoticed. This ensures systems meet or exceed their uptime targets because the observability platform is watching every critical component.
 
 ### Enhanced Security and Compliance
 
-- **Anomaly Detection for Security:** 
-Observability tools can spot unusual patterns that might signal security issues, such as surges in database queries (possible SQL injection) or failed login attempts followed by error spikes. This integration with security monitoring enables real-time threat detection.
+- **Anomaly Detection for Security:**
+  Observability tools can spot unusual patterns that might signal security issues, such as surges in database queries (possible SQL injection) or failed login attempts followed by error spikes. This integration with security monitoring enables real-time threat detection.
 
-- **Audit Trails:** 
-Comprehensive logging provides detailed audit trails crucial for compliance requirements like HIPAA, PCI, or GDPR. If an incident occurs, security teams can trace exactly what happened – which user account, what data was accessed, and which services were involved.
+- **Audit Trails:**
+  Comprehensive logging provides detailed audit trails crucial for compliance requirements like HIPAA, PCI, or GDPR. If an incident occurs, security teams can trace exactly what happened – which user account, what data was accessed, and which services were involved.
 
 ### Better Performance and User Experience
 
 - **Optimized Resource Allocation & Cost Management:**
-Fine-grained observability metrics allow organizations to analyze resource utilization and identify inefficiencies. 
-**Example**: Detecting overprovisioned Kubernetes clusters or underutilized virtual machines(VMs) can directly reduce cloud costs. By monitoring usage trends, teams can make data-driven decisions about scaling up or down, avoiding unnecessary expenditures on infrastructure.
-To learn more about Optimized Resource Allocation and Cost Management, check out [Optimize Cloud Costs](https://signoz.io/guides/optimize-cloud-costs/).
+  Fine-grained observability metrics allow organizations to analyze resource utilization and identify inefficiencies.
+  **Example**: Detecting overprovisioned Kubernetes clusters or underutilized virtual machines(VMs) can directly reduce cloud costs. By monitoring usage trends, teams can make data-driven decisions about scaling up or down, avoiding unnecessary expenditures on infrastructure.
+  To learn more about Optimized Resource Allocation and Cost Management, check out [Optimize Cloud Costs](https://signoz.io/guides/optimize-cloud-costs/).
 
-- **Performance Optimization:** 
-With detailed traces and metrics, teams can identify slow spots in the system, such as inefficient microservice calls or database queries. These insights allow developers to optimize code, adjust infrastructure, or refine configurations for better performance.
+- **Performance Optimization:**
+  With detailed traces and metrics, teams can identify slow spots in the system, such as inefficient microservice calls or database queries. These insights allow developers to optimize code, adjust infrastructure, or refine configurations for better performance.
 
 - **Improved Customer Experience:**
-Reliable systems and stable performance are the cornerstones of user satisfaction. Real-time monitoring of Service Level Agreements (SLAs) and Service Level Objectives (SLOs) ensures that performance guarantees are met. 
-**Example**: A retailer using observability tools to maintain consistent page load times during peak shopping seasons like Black Friday or Diwali ensures positive customer experiences.
+  Reliable systems and stable performance are the cornerstones of user satisfaction. Real-time monitoring of Service Level Agreements (SLAs) and Service Level Objectives (SLOs) ensures that performance guarantees are met.
+  **Example**: A retailer using observability tools to maintain consistent page load times during peak shopping seasons like Black Friday or Diwali ensures positive customer experiences.
 
-- **Capacity Planning and Scaling:** 
-By analyzing metrics trends, organizations can predict when they'll need more resources and ensure systems can handle peak loads without degradation in user experience.
+- **Capacity Planning and Scaling:**
+  By analyzing metrics trends, organizations can predict when they'll need more resources and ensure systems can handle peak loads without degradation in user experience.
 
 ### Business Agility and Innovation
 
 - **Accelerated Innovation & Time-to-Market:**
-Observability reduces the time teams spend diagnosing and resolving incidents, freeing up resources for innovation. Faster root-cause analysis shortens development cycles, allowing new features to be released quickly.
-**Example**: Developers identifying a database query bottleneck within minutes can implement optimizations and refocus on shipping updates.
+  Observability reduces the time teams spend diagnosing and resolving incidents, freeing up resources for innovation. Faster root-cause analysis shortens development cycles, allowing new features to be released quickly.
+  **Example**: Developers identifying a database query bottleneck within minutes can implement optimizations and refocus on shipping updates.
 
-- **Continuous Improvement:** 
-When developers can watch the performance of new features in production via observability dashboards, it creates a feedback loop that encourages building more efficient, user-friendly systems. This drives a culture of performance tuning where real-world behavior informs ongoing improvements.
+- **Continuous Improvement:**
+  When developers can watch the performance of new features in production via observability dashboards, it creates a feedback loop that encourages building more efficient, user-friendly systems. This drives a culture of performance tuning where real-world behavior informs ongoing improvements.
 
 ### ROI of Enterprise Observability
 
 The financial and operational benefits of enterprise observability are tangible, making it a strategic investment for any organization:
 
 - **Reduced MTTD/MTTR:**
-By correlating logs, metrics, and traces, observability tools help teams detect and resolve issues faster.
-To learn [how to implement Incident Management using SigNoz](https://signoz.io/guides/incident-management-metrics/#how-to-implement-effective-incident-management-metrics), visit our guide.
+  By correlating logs, metrics, and traces, observability tools help teams detect and resolve issues faster.
+  To learn [how to implement Incident Management using SigNoz](https://signoz.io/guides/incident-management-metrics/#how-to-implement-effective-incident-management-metrics), visit our guide.
 - **Improved Operational Efficiency:**
-Consolidated dashboards eliminate the need for teams to juggle multiple tools, streamlining workflows and reducing context-switching. Unified platforms provide a centralized view for monitoring infrastructure, applications, and network performance.
+  Consolidated dashboards eliminate the need for teams to juggle multiple tools, streamlining workflows and reducing context-switching. Unified platforms provide a centralized view for monitoring infrastructure, applications, and network performance.
 - **Lower TCO:**
-Replacing multiple niche monitoring tools with a [unified observability](https://signoz.io/unified-observability/) platform reduces licensing costs and administrative overhead.
+  Replacing multiple niche monitoring tools with a [unified observability](https://signoz.io/unified-observability/) platform reduces licensing costs and administrative overhead.
 - **Customer Satisfaction & Retention:**
-Stable and high-performing systems build trust with end-users.
+  Stable and high-performing systems build trust with end-users.
 
 ## Best Practices for Implementing Enterprise Observability
 
 To maximize the benefits of enterprise observability, follow these best practices:
 
-1. **Establish Clear Goals & Success Metrics**:
-Before diving into tools and implementations, it’s crucial to define what you aim to achieve with observability. Goals provide direction, and metrics help track progress.
-Without clear objectives, observability efforts may focus on collecting irrelevant data or setting alerts that don’t align with business priorities.
-    
-    **What to Do**: 
-    
-    - Define **SLOs** to set measurable benchmarks for your system’s reliability. This can ensure 99.9% uptime, maintain response times below 500ms, or limit error rates to less than 1%.
-    - Use these metrics to configure alerts and drive decisions, focusing on what impacts users the most.
-    - Set **error budgets**, allowing teams to measure how much downtime or latency is acceptable before taking action.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-22e88cdd-3bc6-4621-a90b-6b51af8e505d.webp" alt="MindMap to establish and check goals" caption="MindMap to establish and check goals" />
-    
-2. **Adopt a Holistic Approach**:
-Observability should provide a complete picture of your system’s health by collecting data from all layers of the stack. Monitoring only parts of your system leaves gaps that can hide root causes during incidents.
-    
-    **What to Do**:
-    Instrument all layers of your system, including:
-    
-    - **Application code**: Collect metrics like request counts, error rates, and processing times.
-    - **Containers and orchestration**: Monitor CPU, memory, and pod statuses in Kubernetes.
-    - **Networks**: Track latency, bandwidth, and packet loss.
-    - **Databases and storage**: Observe query performance and storage utilization.
-    - **Standardize data:** Ensure uniformity across all components with frameworks like **OpenTelemetry.**
-    - Implement **traces**, **metrics**, and **logs:** Get complete visibility into user interactions and system behavior.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-image%202.webp" alt="OpenTelemetry-instrumented applications in a VM can send data to otel-binary which then sends data to SigNoz cloud." caption="OpenTelemetry-instrumented applications in a VM can send data to otel-binary which then sends data to SigNoz cloud." />
-    
-3. **Implement Data Quality Processes**:
-High-quality data is the cornerstone of effective observability. Poorly managed telemetry can overwhelm teams with irrelevant information. Excessive, low-value data creates noise, leading to missed alerts and wasted resources.
-    
-    **What to Do**:
-    
-    - Use **sampling techniques** to retain only the most critical or representative data points, especially for high-traffic systems.
-    - Apply **rate-limiting** to control how often metrics or logs are ingested, preventing resource overuse.
-    - Implement **indexing strategies** for logs and traces to enable faster querying without overloading storage.
-    - Continuously refine data collection rules to maintain a high signal-to-noise ratio.
-    
-    **Example**: For a web application with millions of requests per second, sampling might focus on error traces and performance outliers rather than logging every request.
-    
-4. **Foster a Culture of Observability**:
-Observability is not just a technical practice; it’s a mindset that must be embraced across teams. Observability only succeeds when all stakeholders—developers, operations, and management—collaborate and share responsibility for system reliability.
-    
-    **What to Do**:
-    
-    - Encourage **cross-team collaboration**, where dashboards and alert definitions are shared openly across Dev, Ops, and QA teams.
-    - Promote a **“you build it, you run it”** mentality from DevOps, ensuring developers are responsible for monitoring and resolving issues in their own code.
-    - Offer **training sessions** on observability tools and workflows, helping teams become proficient with query languages, instrumentation, and dashboard design.
-    - Foster a culture of learning with **post-mortems** for outages, focusing on understanding and improving rather than assigning blame.
-    
+1.  **Establish Clear Goals & Success Metrics**:
+    Before diving into tools and implementations, it’s crucial to define what you aim to achieve with observability. Goals provide direction, and metrics help track progress.
+    Without clear objectives, observability efforts may focus on collecting irrelevant data or setting alerts that don’t align with business priorities.
+        **What to Do**:
+
+        - Define **SLOs** to set measurable benchmarks for your system’s reliability. This can ensure 99.9% uptime, maintain response times below 500ms, or limit error rates to less than 1%.
+        - Use these metrics to configure alerts and drive decisions, focusing on what impacts users the most.
+        - Set **error budgets**, allowing teams to measure how much downtime or latency is acceptable before taking action.
+
+        <Figure src="/img/guides/2025/03/enterprise-observability-22e88cdd-3bc6-4621-a90b-6b51af8e505d.webp" alt="MindMap to establish and check goals" caption="MindMap to establish and check goals" />
+2.  **Adopt a Holistic Approach**:
+    Observability should provide a complete picture of your system’s health by collecting data from all layers of the stack. Monitoring only parts of your system leaves gaps that can hide root causes during incidents.
+        **What to Do**:
+        Instrument all layers of your system, including:
+
+        - **Application code**: Collect metrics like request counts, error rates, and processing times.
+        - **Containers and orchestration**: Monitor CPU, memory, and pod statuses in Kubernetes.
+        - **Networks**: Track latency, bandwidth, and packet loss.
+        - **Databases and storage**: Observe query performance and storage utilization.
+        - **Standardize data:** Ensure uniformity across all components with frameworks like **OpenTelemetry.**
+        - Implement **traces**, **metrics**, and **logs:** Get complete visibility into user interactions and system behavior.
+
+        <Figure src="/img/guides/2025/03/enterprise-observability-image%202.webp" alt="OpenTelemetry-instrumented applications in a VM can send data to otel-binary which then sends data to SigNoz cloud." caption="OpenTelemetry-instrumented applications in a VM can send data to otel-binary which then sends data to SigNoz cloud." />
+3.  **Implement Data Quality Processes**:
+    High-quality data is the cornerstone of effective observability. Poorly managed telemetry can overwhelm teams with irrelevant information. Excessive, low-value data creates noise, leading to missed alerts and wasted resources.
+        **What to Do**:
+
+        - Use **sampling techniques** to retain only the most critical or representative data points, especially for high-traffic systems.
+        - Apply **rate-limiting** to control how often metrics or logs are ingested, preventing resource overuse.
+        - Implement **indexing strategies** for logs and traces to enable faster querying without overloading storage.
+        - Continuously refine data collection rules to maintain a high signal-to-noise ratio.
+
+        **Example**: For a web application with millions of requests per second, sampling might focus on error traces and performance outliers rather than logging every request.
+4.  **Foster a Culture of Observability**:
+    Observability is not just a technical practice; it’s a mindset that must be embraced across teams. Observability only succeeds when all stakeholders—developers, operations, and management—collaborate and share responsibility for system reliability.
+        **What to Do**:
+
+        - Encourage **cross-team collaboration**, where dashboards and alert definitions are shared openly across Dev, Ops, and QA teams.
+        - Promote a **“you build it, you run it”** mentality from DevOps, ensuring developers are responsible for monitoring and resolving issues in their own code.
+        - Offer **training sessions** on observability tools and workflows, helping teams become proficient with query languages, instrumentation, and dashboard design.
+        - Foster a culture of learning with **post-mortems** for outages, focusing on understanding and improving rather than assigning blame.
+
 ### Choosing the Right Observability Tools for Enterprise Needs
-    
+
 The tools you choose play a significant role in your observability strategy’s success. Keep these factors in mind to ensure your tools meet your current and future needs:
 
-1. **Scalability & Flexibility**:
-Modern enterprises operate in dynamic environments where traffic patterns can shift dramatically—during sales promotions, product launches, or holiday seasons. Your observability tools must be designed to scale in tandem with your infrastructure. 
-    
-    Without scalability, observability tools may fail to capture or process telemetry data during high traffic surges, leading to blind spots in monitoring. Similarly, tools that lack flexibility may struggle to adapt to a multi-cloud, hybrid, or containerized ecosystem.
-    
-    **What to Look For**:
-    
-    - Tools capable of processing **high-throughput data** without dropping critical metrics or traces.
-    - Support for distributed architectures, ensuring global teams can monitor systems across multiple regions without latency.
-    - Real-time ingestion and querying capabilities that remain performant under heavy loads.
-    **Example**: A streaming platform experiencing a spike during a live event must ensure that latency metrics, user request traces, and [error logs](https://signoz.io/guides/error-log/) are captured without delays, allowing teams to troubleshoot issues on the fly.
-2. **Integration Capabilities**
-Observability is most effective when seamlessly integrated across all aspects of your tech stack. A siloed observability toolset creates gaps and inefficiencies in data collection and analysis. Enterprises typically rely on a mix of cloud providers, container orchestrators, CI/CD pipelines, and third-party services. Observability tools must work across these systems to create a unified view.
-    
-    **What to Look For**:
-    
-    - Out-of-the-box support for AWS, Azure, and Google Cloud to monitor infrastructure resources such as EC2 instances, storage buckets, and managed databases.
-    - Native integration with Kubernetes for monitoring pods, nodes, and cluster health. Ability to track build times, deployment frequencies, and failure rates, ensuring smooth releases.
-    - Pre-built connectors for tools like Jenkins, GitHub Actions, PagerDuty, or Slack to streamline incident response and notifications.
-    **Example**: A company deploying microservices on Kubernetes and using AWS for its cloud infrastructure should prioritize tools that can monitor Kubernetes clusters, EC2 instances, and S3 buckets, all within a single interface.
-        
-        <Figure src="/img/guides/2025/03/enterprise-observability-image%203.webp" alt="Different pre-built community integrations" caption="Different pre-built community integrations" /> 
-        
-3. **User Adoption & Ease of Use**
-Even the most powerful observability tools can fail if they are not user-friendly. For successful adoption, observability platforms must cater to both technical and non-technical users. Observability is not just for engineers; product managers, customer support teams, and executives can also benefit from insights. Tools that are overly complex risk alienating users and limiting adoption across teams.
-    
-    **What to Look For**:
-    
-    - Pre-configured and customizable dashboards allow users to visualize data without steep learning curves. Tools like PromQL or SQL-like interfaces allow advanced users to create specific, meaningful queries.
-    - Shared dashboards, annotations, and incident timelines that promote cross-functional collaboration.
-    - For non-technical users, features like drag-and-drop visualization builders are essential.
-    A DevOps engineer may use PromQL to create a detailed latency graph, while a product manager might rely on high-level dashboards showing error rates and uptime trends over the past quarter.
-4. **Data Retention & Storage Optimization**
-Efficiently managing telemetry data is a critical challenge for enterprises, especially when dealing with long-term storage or sensitive data. Observability tools must strike a balance between cost, performance, and compliance. Storing all observability data indefinitely is neither practical nor cost-effective. Enterprises also need to ensure compliance with regulations like GDPR, HIPAA, or CCPA when handling user data.
-    
-    **What to Look For**:
-    
-    - Support for cost-efficient tiers such as cold storage (e.g., S3 Glacier) for older logs and traces, while retaining high-performance storage for real-time data.
-    - Granular control over how long different types of data (e.g., logs, metrics, traces) are retained allows organizations to prioritize critical insights.
-    - Built-in tools for masking sensitive fields (e.g., personally identifiable information or PII), encryption, and audit logging to meet regulatory requirements.
-    - Efficient data compression techniques to reduce storage costs and indexing strategies for faster querying.
-    **Example**: A healthcare provider monitoring patient-facing applications must comply with HIPAA by ensuring all telemetry data is encrypted, securely stored, and retained only for the legally mandated duration.
-        
-        <Figure src="/img/guides/2025/03/enterprise-observability-image%204.webp" alt="SigNoz metrics, logs and traces retention settings" caption="SigNoz metrics, logs and traces retention settings" />
-        
-        To learn more about the retention period in SigNoz, check out the [retention period documentation](https://signoz.io/docs/userguide/retention-period/).
-            
+1.  **Scalability & Flexibility**:
+    Modern enterprises operate in dynamic environments where traffic patterns can shift dramatically—during sales promotions, product launches, or holiday seasons. Your observability tools must be designed to scale in tandem with your infrastructure.
+        Without scalability, observability tools may fail to capture or process telemetry data during high traffic surges, leading to blind spots in monitoring. Similarly, tools that lack flexibility may struggle to adapt to a multi-cloud, hybrid, or containerized ecosystem.
+
+        **What to Look For**:
+
+        - Tools capable of processing **high-throughput data** without dropping critical metrics or traces.
+        - Support for distributed architectures, ensuring global teams can monitor systems across multiple regions without latency.
+        - Real-time ingestion and querying capabilities that remain performant under heavy loads.
+        **Example**: A streaming platform experiencing a spike during a live event must ensure that latency metrics, user request traces, and [error logs](https://signoz.io/guides/error-log/) are captured without delays, allowing teams to troubleshoot issues on the fly.
+2.  **Integration Capabilities**
+    Observability is most effective when seamlessly integrated across all aspects of your tech stack. A siloed observability toolset creates gaps and inefficiencies in data collection and analysis. Enterprises typically rely on a mix of cloud providers, container orchestrators, CI/CD pipelines, and third-party services. Observability tools must work across these systems to create a unified view.
+        **What to Look For**:
+
+        - Out-of-the-box support for AWS, Azure, and Google Cloud to monitor infrastructure resources such as EC2 instances, storage buckets, and managed databases.
+        - Native integration with Kubernetes for monitoring pods, nodes, and cluster health. Ability to track build times, deployment frequencies, and failure rates, ensuring smooth releases.
+        - Pre-built connectors for tools like Jenkins, GitHub Actions, PagerDuty, or Slack to streamline incident response and notifications.
+        **Example**: A company deploying microservices on Kubernetes and using AWS for its cloud infrastructure should prioritize tools that can monitor Kubernetes clusters, EC2 instances, and S3 buckets, all within a single interface.
+
+            <Figure src="/img/guides/2025/03/enterprise-observability-image%203.webp" alt="Different pre-built community integrations" caption="Different pre-built community integrations" />
+
+3.  **User Adoption & Ease of Use**
+    Even the most powerful observability tools can fail if they are not user-friendly. For successful adoption, observability platforms must cater to both technical and non-technical users. Observability is not just for engineers; product managers, customer support teams, and executives can also benefit from insights. Tools that are overly complex risk alienating users and limiting adoption across teams.
+        **What to Look For**:
+
+        - Pre-configured and customizable dashboards allow users to visualize data without steep learning curves. Tools like PromQL or SQL-like interfaces allow advanced users to create specific, meaningful queries.
+        - Shared dashboards, annotations, and incident timelines that promote cross-functional collaboration.
+        - For non-technical users, features like drag-and-drop visualization builders are essential.
+        A DevOps engineer may use PromQL to create a detailed latency graph, while a product manager might rely on high-level dashboards showing error rates and uptime trends over the past quarter.
+4.  **Data Retention & Storage Optimization**
+    Efficiently managing telemetry data is a critical challenge for enterprises, especially when dealing with long-term storage or sensitive data. Observability tools must strike a balance between cost, performance, and compliance. Storing all observability data indefinitely is neither practical nor cost-effective. Enterprises also need to ensure compliance with regulations like GDPR, HIPAA, or CCPA when handling user data.
+        **What to Look For**:
+
+        - Support for cost-efficient tiers such as cold storage (e.g., S3 Glacier) for older logs and traces, while retaining high-performance storage for real-time data.
+        - Granular control over how long different types of data (e.g., logs, metrics, traces) are retained allows organizations to prioritize critical insights.
+        - Built-in tools for masking sensitive fields (e.g., personally identifiable information or PII), encryption, and audit logging to meet regulatory requirements.
+        - Efficient data compression techniques to reduce storage costs and indexing strategies for faster querying.
+        **Example**: A healthcare provider monitoring patient-facing applications must comply with HIPAA by ensuring all telemetry data is encrypted, securely stored, and retained only for the legally mandated duration.
+
+            <Figure src="/img/guides/2025/03/enterprise-observability-image%204.webp" alt="SigNoz metrics, logs and traces retention settings" caption="SigNoz metrics, logs and traces retention settings" />
+
+            To learn more about the retention period in SigNoz, check out the [retention period documentation](https://signoz.io/docs/userguide/retention-period/).
+
 
 ## Implementing Enterprise Observability with SigNoz
 
@@ -275,24 +276,36 @@ Built on OpenTelemetry—the emerging industry standard for telemetry data—Sig
 Key features of SigNoz include:
 
 - **[Distributed Tracing](https://signoz.io/distributed-tracing/)**: SigNoz enables seamless tracing of requests across microservices, helping you pinpoint bottlenecks and optimize service interactions. By visualizing request flows, you can identify exactly where delays or failures occur in your architecture.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-image%205.webp" alt="Distributed Tracing in SigNoz" caption="Distributed Tracing in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/enterprise-observability-image%205.webp"
+    alt="Distributed Tracing in SigNoz"
+    caption="Distributed Tracing in SigNoz"
+  />
 - **Log and Trace Correlation**: SigNoz provides a unified view by linking specific log entries to trace spans, offering deeper insights for faster troubleshooting. This correlation allows you to drill down into trace events and analyze related logs efficiently.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-image%206.webp" alt="Log and Trace Correlation in SigNoz" caption="Log and Trace Correlation in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/enterprise-observability-image%206.webp"
+    alt="Log and Trace Correlation in SigNoz"
+    caption="Log and Trace Correlation in SigNoz"
+  />
 - **Metrics Monitoring**: Visualize critical performance indicators such as request rates, latencies, and system health. SigNoz's customizable dashboards make it easier to track key metrics in real-time and spot anomalies.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-image%207.webp" alt="Real-time Metrics Monitoring Dashboard in SigNoz" caption="Real-time Metrics Monitoring Dashboard in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/enterprise-observability-image%207.webp"
+    alt="Real-time Metrics Monitoring Dashboard in SigNoz"
+    caption="Real-time Metrics Monitoring Dashboard in SigNoz"
+  />
 - **Custom Dashboards & Alerts**: Build flexible dashboards to visualize application and system metrics. Set up alerts based on predefined thresholds or anomaly detection to proactively address potential issues.
-    
-    <Figure src="/img/guides/2025/03/enterprise-observability-6f59e135-17f5-40e6-ae34-8946d48bb4ee.webp" alt="HostMetrics Dashboard" caption="HostMetrics Dashboard" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2025/03/enterprise-observability-6f59e135-17f5-40e6-ae34-8946d48bb4ee.webp"
+    alt="HostMetrics Dashboard"
+    caption="HostMetrics Dashboard"
+  />
 - **Scalable Architecture**: SigNoz supports both self-hosted and managed (SigNoz Cloud) deployments, making it suitable for large enterprise systems. It can scale to ingest and process large volumes of telemetry data reliably when configured appropriately.
 
-<GetStartedSigNoz/>
+<GetStartedSigNoz />
 
 To unlock the full potential of SigNoz and explore its comprehensive observability capabilities, check out these articles:
 
@@ -304,60 +317,34 @@ To unlock the full potential of SigNoz and explore its comprehensive observabili
 SigNoz offers both a **cloud-hosted** and a **self-hosted open-source** version, catering to different operational needs.
 
 - **SigNoz Cloud**:
-    - SigNoz Cloud offers a fully managed service, removing the complexity of infrastructure management.
-    - The cloud version is perfect for enterprises that want to focus on application performance and observability without worrying about server maintenance, scaling, or updates.
-    - It also comes with a simplified setup and minimal configuration, making it ideal for teams looking to quickly deploy and scale their [observability infrastructure](https://signoz.io/blog/observability-tools/) with minimal overhead.
+  - SigNoz Cloud offers a fully managed service, removing the complexity of infrastructure management.
+  - The cloud version is perfect for enterprises that want to focus on application performance and observability without worrying about server maintenance, scaling, or updates.
+  - It also comes with a simplified setup and minimal configuration, making it ideal for teams looking to quickly deploy and scale their [observability infrastructure](https://signoz.io/blog/observability-tools/) with minimal overhead.
 - **Open-Source Deployment**:
-    - SigNoz’s open-source deployment offers complete autonomy over your observability stack. You maintain full control over data storage, compliance, and security, which is particularly important for organizations with stringent regulatory requirements.
-    - This option is highly customizable, allowing you to fine-tune configurations according to your specific needs, such as scaling with Kubernetes or integrating with your existing systems.
-    - Open-source deployment also provides cost-effective flexibility, particularly for organizations that already have an internal DevOps team capable of handling infrastructure setup and maintenance.
+  - SigNoz’s open-source deployment offers complete autonomy over your observability stack. You maintain full control over data storage, compliance, and security, which is particularly important for organizations with stringent regulatory requirements.
+  - This option is highly customizable, allowing you to fine-tune configurations according to your specific needs, such as scaling with Kubernetes or integrating with your existing systems.
+  - Open-source deployment also provides cost-effective flexibility, particularly for organizations that already have an internal DevOps team capable of handling infrastructure setup and maintenance.
 
 ## Overcoming Common Enterprise Observability Challenges
 
 Enterprise observability is vital for modern organizations, but implementing it effectively can be fraught with challenges. By understanding these obstacles and employing strategic solutions, organizations can ensure their observability practices deliver maximum value.
 
-1. **Data Overload & [Alert Fatigue](https://signoz.io/blog/alert-fatigue/):** 
-In enterprise environments, telemetry data is generated in vast quantities. Without proper management, teams can become overwhelmed by an avalanche of alerts, many of which may be irrelevant or low-priority. This phenomenon, known as alert fatigue, can lead to critical issues being missed and response times increasing.
-    - **The Challenge**: Differentiating critical alerts from noise while maintaining team focus.
-    - **Solutions**:
-        - Implement **smart sampling** to capture only the most relevant data points, ensuring storage and analysis focus on actionable information.
-        - Leverage **AI-driven anomaly detection** systems that can identify unusual patterns or deviations without human intervention.
-        - Regularly **revisit and refine alert thresholds** to ensure they are aligned with SLOs and business priorities.
-        
-        For example, instead of flagging every minor spike in CPU usage, configure alerts to trigger only when sustained spikes risk impacting end-user experiences.
-        
-2. **Data Privacy & Compliance**:
-As organizations collect and analyze telemetry data, safeguarding sensitive information and ensuring compliance with regulations like GDPR, CCPA, or HIPAA becomes paramount.
-    - **The Challenge**: Preventing the exposure of sensitive data while adhering to diverse regional and industry-specific compliance requirements.
-    - **Solutions**:
-        - **Mask or redact sensitive fields** during data ingestion, ensuring that Personally Identifiable Information (PII) or confidential details are not stored or processed unnecessarily.
-        - Establish **region-specific data storage policies** to comply with local regulations regarding data residency and sovereignty.
-        - Conduct regular **compliance audits** to identify and mitigate potential vulnerabilities in your [observability pipeline](https://signoz.io/guides/observability-pipeline/).
-        
-        For instance, an organization with a global presence might store European customer data exclusively in EU-based servers to comply with GDPR, while U.S. customer data is stored in American facilities.
-        
-3. **Balancing Costs & Coverage**:
-Observability can become a financial burden if organizations attempt to collect and store all possible telemetry data without considering its relevance or utility. Striking a balance between comprehensive coverage and cost efficiency is essential.
-    - **The Challenge**: Managing the high costs of storing and analyzing vast amounts of data while ensuring critical systems are monitored in detail.
-    - **Solutions**:
-        - Use **tiered storage strategies**, such as retaining real-time metrics in high-performance databases while archiving older data in cost-efficient cold storage options like Amazon S3 Glacier.
-        - Adjust **data resolution and collection frequencies** based on the system’s criticality. For example:
-            - High-resolution metrics for production systems that directly impact users.
-            - Lower-resolution metrics for non-critical staging or development environments.
-        - Regularly **audit data retention policies** to remove obsolete or redundant data, optimizing storage costs.
-        
-        For example, an e-commerce platform might prioritize storing detailed transaction logs for real-time fraud detection while archiving less critical server logs for long-term trend analysis.
-        
-4. **Skills Gaps & Training**:
-Effective observability requires technical expertise in areas such as instrumentation, query languages, and dashboard design. Teams lacking these skills may struggle to unlock the full potential of their observability tools.
-    - **The Challenge**: Bridging the skills gap for teams unfamiliar with modern observability platforms and practices.
-    - **Solutions**:
-        - Offer **onboarding and training programs** tailored to new tools, covering everything from querying languages (e.g., PromQL) to visualization design.
-        - Create a **self-service knowledge base** with detailed documentation, tutorials, and FAQs to enable continuous learning.
-        - Foster a culture of collaboration through **internal workshops and knowledge-sharing sessions**, encouraging cross-team expertise.
-        
-        For example, developers can benefit from workshops on integrating [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) into their applications, while operations teams might focus on learning advanced query techniques for troubleshooting.
-        
+1.  **Data Overload & [Alert Fatigue](https://signoz.io/blog/alert-fatigue/):**
+    In enterprise environments, telemetry data is generated in vast quantities. Without proper management, teams can become overwhelmed by an avalanche of alerts, many of which may be irrelevant or low-priority. This phenomenon, known as alert fatigue, can lead to critical issues being missed and response times increasing. - **The Challenge**: Differentiating critical alerts from noise while maintaining team focus. - **Solutions**: - Implement **smart sampling** to capture only the most relevant data points, ensuring storage and analysis focus on actionable information. - Leverage **AI-driven anomaly detection** systems that can identify unusual patterns or deviations without human intervention. - Regularly **revisit and refine alert thresholds** to ensure they are aligned with SLOs and business priorities.
+            For example, instead of flagging every minor spike in CPU usage, configure alerts to trigger only when sustained spikes risk impacting end-user experiences.
+
+2.  **Data Privacy & Compliance**:
+    As organizations collect and analyze telemetry data, safeguarding sensitive information and ensuring compliance with regulations like GDPR, CCPA, or HIPAA becomes paramount. - **The Challenge**: Preventing the exposure of sensitive data while adhering to diverse regional and industry-specific compliance requirements. - **Solutions**: - **Mask or redact sensitive fields** during data ingestion, ensuring that Personally Identifiable Information (PII) or confidential details are not stored or processed unnecessarily. - Establish **region-specific data storage policies** to comply with local regulations regarding data residency and sovereignty. - Conduct regular **compliance audits** to identify and mitigate potential vulnerabilities in your [observability pipeline](https://signoz.io/guides/observability-pipeline/).
+            For instance, an organization with a global presence might store European customer data exclusively in EU-based servers to comply with GDPR, while U.S. customer data is stored in American facilities.
+
+3.  **Balancing Costs & Coverage**:
+    Observability can become a financial burden if organizations attempt to collect and store all possible telemetry data without considering its relevance or utility. Striking a balance between comprehensive coverage and cost efficiency is essential. - **The Challenge**: Managing the high costs of storing and analyzing vast amounts of data while ensuring critical systems are monitored in detail. - **Solutions**: - Use **tiered storage strategies**, such as retaining real-time metrics in high-performance databases while archiving older data in cost-efficient cold storage options like Amazon S3 Glacier. - Adjust **data resolution and collection frequencies** based on the system’s criticality. For example: - High-resolution metrics for production systems that directly impact users. - Lower-resolution metrics for non-critical staging or development environments. - Regularly **audit data retention policies** to remove obsolete or redundant data, optimizing storage costs.
+            For example, an e-commerce platform might prioritize storing detailed transaction logs for real-time fraud detection while archiving less critical server logs for long-term trend analysis.
+
+4.  **Skills Gaps & Training**:
+    Effective observability requires technical expertise in areas such as instrumentation, query languages, and dashboard design. Teams lacking these skills may struggle to unlock the full potential of their observability tools. - **The Challenge**: Bridging the skills gap for teams unfamiliar with modern observability platforms and practices. - **Solutions**: - Offer **onboarding and training programs** tailored to new tools, covering everything from querying languages (e.g., PromQL) to visualization design. - Create a **self-service knowledge base** with detailed documentation, tutorials, and FAQs to enable continuous learning. - Foster a culture of collaboration through **internal workshops and knowledge-sharing sessions**, encouraging cross-team expertise.
+            For example, developers can benefit from workshops on integrating [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) into their applications, while operations teams might focus on learning advanced query techniques for troubleshooting.
+
 
 ## Key Takeaways
 
@@ -385,4 +372,4 @@ A: Look for a platform that is scalable to handle growing data volumes, integrat
 
 **Q: How can organizations measure the ROI of their observability initiatives?**
 
-A: Measure ROI by tracking operational improvements such as reduced MTTD and MTTR. Calculate infrastructure cost savings through optimized resource usage. Assess team productivity gains by evaluating the time saved in diagnosing issues. Finally, link observability outcomes to business metrics, such as increased customer satisfaction, improved retention rates, and higher revenue due to reduced downtime and enhanced user experiences.
\ No newline at end of file
+A: Measure ROI by tracking operational improvements such as reduced MTTD and MTTR. Calculate infrastructure cost savings through optimized resource usage. Assess team productivity gains by evaluating the time saved in diagnosing issues. Finally, link observability outcomes to business metrics, such as increased customer satisfaction, improved retention rates, and higher revenue due to reduced downtime and enhanced user experiences.
diff --git a/data/guides/error-log.mdx b/data/guides/error-log.mdx
index ac37d1040..ccbb06075 100644
--- a/data/guides/error-log.mdx
+++ b/data/guides/error-log.mdx
@@ -1,120 +1,147 @@
 ---
-
 title: Best Practices for Maintaining Clean and Useful Error Logs
-slug: error-log
 date: 2024-07-18
 tags: [logging]
 authors: [niyati_thakkar]
 description: Learn best practices for maintaining clean and useful error logs in software development. Explore the importance of error logging, key components, common tools, and troubleshooting techniques to enhance application performance and security.
-keywords: [error logging, log management, troubleshooting, debugging, software development, application performance, security management, log analysis, error monitoring, logging best practices, log retention, root cause analysis, log formats, logging tools, system logs, application logs, log levels, error codes, stack traces, log monitoring]
-
+keywords:
+  [
+    error logging,
+    log management,
+    troubleshooting,
+    debugging,
+    software development,
+    application performance,
+    security management,
+    log analysis,
+    error monitoring,
+    logging best practices,
+    log retention,
+    root cause analysis,
+    log formats,
+    logging tools,
+    system logs,
+    application logs,
+    log levels,
+    error codes,
+    stack traces,
+    log monitoring,
+  ]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Best Practices for Maintaining Clean and Useful Error Logs",
-  "alternativeHeadline": "Learn best practices for maintaining clean and useful error logs in software development. Explore the importance of error logging, key components, common tools, and troubleshooting techniques to enhance application performance and security.",
-  "author": {
-    "@type": "Person",
-    "name": "Niyati Thakkar"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-18T00:00:00Z",
-  "dateModified": "2024-07-18T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/error-log/"
-  },
-  "description": "Learn best practices for maintaining clean and useful error logs in software development. Explore the importance of error logging, key components, common tools, and troubleshooting techniques to enhance application performance and security.",
-  "keywords": "error logging, log management, troubleshooting, debugging, software development, application performance, security management, log analysis, error monitoring, logging best practices, log retention, root cause analysis, log formats, logging tools, system logs, application logs, log levels, error codes, stack traces, log monitoring",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Error Logging",
-      "description": "A mechanism that helps capture and record the errors or issues occurring in the application."
-    },
-    {
-      "@type": "Thing",
-      "name": "Log Management",
-      "description": "Techniques and tools for managing log data generated by software applications and systems."
-    },
-    {
-      "@type": "Thing",
-      "name": "Troubleshooting",
-      "description": "The process of diagnosing the source of a problem in software development and finding a solution."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What is the error code log?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "An error code log can be a file or a record representing the error within a software application, system, or service. It contains information about the error such as error code, error message, date and time, etc."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the log error function?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Error Log function is a function used to log an error. It helps developers add a log of the level error, provide a message, the method from which the error is generated, etc."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How to find error from log file?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "There are several methods to filter error logs from a log file, we can manually search using the file search option, and there are CLI or UI tools that can help filter and analyze the logs, we can also set the log level to error to get the logs which are error or higher priority."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is HTTP error log?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "HTTP error log reports HTTP-related errors such as 404 (Not found), 500 (Internal Server Error), etc. A web server encounters these and indicates problems with serving web requests."
-        }
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Best Practices for Maintaining Clean and Useful Error Logs',
+        alternativeHeadline:
+          'Learn best practices for maintaining clean and useful error logs in software development. Explore the importance of error logging, key components, common tools, and troubleshooting techniques to enhance application performance and security.',
+        author: {
+          '@type': 'Person',
+          name: 'Niyati Thakkar',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-18T00:00:00Z',
+        dateModified: '2024-07-18T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/error-log/',
+        },
+        description:
+          'Learn best practices for maintaining clean and useful error logs in software development. Explore the importance of error logging, key components, common tools, and troubleshooting techniques to enhance application performance and security.',
+        keywords:
+          'error logging, log management, troubleshooting, debugging, software development, application performance, security management, log analysis, error monitoring, logging best practices, log retention, root cause analysis, log formats, logging tools, system logs, application logs, log levels, error codes, stack traces, log monitoring',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Error Logging',
+            description:
+              'A mechanism that helps capture and record the errors or issues occurring in the application.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log Management',
+            description:
+              'Techniques and tools for managing log data generated by software applications and systems.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Troubleshooting',
+            description:
+              'The process of diagnosing the source of a problem in software development and finding a solution.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is the error code log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'An error code log can be a file or a record representing the error within a software application, system, or service. It contains information about the error such as error code, error message, date and time, etc.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the log error function?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Error Log function is a function used to log an error. It helps developers add a log of the level error, provide a message, the method from which the error is generated, etc.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How to find error from log file?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'There are several methods to filter error logs from a log file, we can manually search using the file search option, and there are CLI or UI tools that can help filter and analyze the logs, we can also set the log level to error to get the logs which are error or higher priority.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is HTTP error log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'HTTP error log reports HTTP-related errors such as 404 (Not found), 500 (Internal Server Error), etc. A web server encounters these and indicates problems with serving web requests.',
+              },
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
-Error Logging is a mechanism that helps capture and record the errors or issues occurring in the application. Errors refer to issues that disrupt the normal operation of the application, such as missing files, server failures, or network problems. It is very helpful to grab attention at the earliest and debug the cause of the problem. Error logs are crucial for monitoring and security management. 
+Error Logging is a mechanism that helps capture and record the errors or issues occurring in the application. Errors refer to issues that disrupt the normal operation of the application, such as missing files, server failures, or network problems. It is very helpful to grab attention at the earliest and debug the cause of the problem. Error logs are crucial for monitoring and security management.
 
 <Figure src="/img/guides/2024/07/error-log-SigNoz.webp" alt="SigNoz.webp" caption="SigNoz.webp" />
 
-Error logs are specifically meant to record errors, which can be related to server or network operating systems or third-party applications. A well-written error log provides enough information to locate and resolve the problem. Additionally, it may indicate the seriousness of the issue along with details of the module or trace ID to dig deeper. 
+Error logs are specifically meant to record errors, which can be related to server or network operating systems or third-party applications. A well-written error log provides enough information to locate and resolve the problem. Additionally, it may indicate the seriousness of the issue along with details of the module or trace ID to dig deeper.
 
 ### Example: Reading a File in Java
 
@@ -142,7 +169,7 @@ public class MyProgram {
                 String line = scanner.nextLine();
                 System.out.println(line);
             }
-            
+
 		        scanner.close();
         } catch (FileNotFoundException e) {
             String timestamp = sdf.format(new java.util.Date());
@@ -160,36 +187,36 @@ Output:
 ```
 
 The above output log provides a timestamp, severity level `SEVERE`, class name, and the error message along with the file path, helping developers quickly identify and address the issue.
-In output we get the complete path of the file because when we create a file object with the relative path, the file is created in the current directory and its  relative path. The  `getAbsolutePath()` method on the `File` object gets the absolute path of the file using the path of the current directory and returns a string containing absolute path.
+In output we get the complete path of the file because when we create a file object with the relative path, the file is created in the current directory and its relative path. The `getAbsolutePath()` method on the `File` object gets the absolute path of the file using the path of the current directory and returns a string containing absolute path.
 
 ## Importance of Error Logs
 
-- Faster Troubleshooting - When non-desired behavior is detected, error logs are the first thing  checked to figure out root cause, identify the type of the error, and get additional contextual detail along with stack traces. This lookup saves hours of debugging code and speeds up the troubleshooting process.
+- Faster Troubleshooting - When non-desired behavior is detected, error logs are the first thing checked to figure out root cause, identify the type of the error, and get additional contextual detail along with stack traces. This lookup saves hours of debugging code and speeds up the troubleshooting process.
 - Quick Decision Making - Error logs assist in identifying areas of concern and the parts of the application affected by the issue. In large programs, it can be challenging to locate these areas manually. Error logs enable rapid identification and addressing of critical issues, facilitating swift decision-making.
 - Better Performance - Error logs can reveal patterns that cause the system to run slowly or impact performance. By analyzing past logs, trends, and recurring errors, developers can identify and rectify issues that degrade system performance, preventing major breakdowns.
 - Better Security - Error logs play a crucial role in security management by reporting suspicious activities such as unauthorized access or security breaches. They provide information on the specific areas where the malfunction occurred, helping to improve overall security measures.
 
 ## Key Components of Error Logs
 
-Irrespective of the programming language or the platform error logs must contain these pieces of information. to make the most out of it. 
+Irrespective of the programming language or the platform error logs must contain these pieces of information. to make the most out of it.
 
 ### Timestamp
 
-The first element is a timestamp. A properly formatted timestamp, including the date and the exact time of the event's occurrence, must be included. The format should be consistent for the entire application or the company’s standard format. 
+The first element is a timestamp. A properly formatted timestamp, including the date and the exact time of the event's occurrence, must be included. The format should be consistent for the entire application or the company’s standard format.
 
 A precise timestamp can help developers track the occurrence of events across different systems and understand what led to an error in the first place. It usually appears at the beginning of the log.
 
 ### Severity Level
 
-A Severity Level indicates the seriousness of the log record. Higher severity indicates quick attention. Error Log Level is a severe level and needs immediate attention. Other log levels include DEBUG, WARN, INFO, FATAL, etc. FATA or SEVERE is even more severe than ERROR, rest are less serious and are used either just for info or debugging. 
+A Severity Level indicates the seriousness of the log record. Higher severity indicates quick attention. Error Log Level is a severe level and needs immediate attention. Other log levels include DEBUG, WARN, INFO, FATAL, etc. FATA or SEVERE is even more severe than ERROR, rest are less serious and are used either just for info or debugging.
 
 ### Error Code
 
-Common errors are usually given a unique code to identify them and resolve them easily. This quick reference helps on understand the error and what potential places could be causing it. Error code is of much help in large systems. 
+Common errors are usually given a unique code to identify them and resolve them easily. This quick reference helps on understand the error and what potential places could be causing it. Error code is of much help in large systems.
 
 ### Error Message (stack traces)
 
-The error message for exceptions or critical errors can contain a stack trace of the call sequence that led to the error.  Giving context about errors helps in diagnosing the issue faster. Many times the error is thrown at a certain method and is caught much later. 
+The error message for exceptions or critical errors can contain a stack trace of the call sequence that led to the error. Giving context about errors helps in diagnosing the issue faster. Many times the error is thrown at a certain method and is caught much later.
 
 ### Source
 
@@ -197,58 +224,42 @@ The source refers to the class, method, module, etc. from where the error is log
 
 ## Types of Error Logs
 
-Error logs can be categorized based on their origin like application, server, hardware, etc. to resolve the error. 
+Error logs can be categorized based on their origin like application, server, hardware, etc. to resolve the error.
 
 - Application Logs - Application logs capture software-specific logs for example application crash exception or unexpected behavior.
-    
-    Example:
-    
-    ```
-    2024-07-18 14:30:15 ERROR [UserService] - NullPointerException: User object is null
-    java.lang.NullPointerException: Cannot invoke "User.getUsername()" because "user" is null
-        at com.example.UserService.processUser(UserService.java:45)
-        at com.example.UserController.getUserDetails(UserController.java:30)
-    
-    ```
-    
-    This log shows a NullPointerException in the UserService, providing the exact line and method where the error occurred.
-    
+  Example:
+  ```
+  2024-07-18 14:30:15 ERROR [UserService] - NullPointerException: User object is null
+  java.lang.NullPointerException: Cannot invoke "User.getUsername()" because "user" is null
+      at com.example.UserService.processUser(UserService.java:45)
+      at com.example.UserController.getUserDetails(UserController.java:30)
+
+  ```
+  This log shows a NullPointerException in the UserService, providing the exact line and method where the error occurred.
 - System Logs - System logs are more focused on operating systems, hardware failures, performance metrics, etc. These help monitor the efficiency and troubleshoot system-wide issues specific to single or multiple systems.
-    
-    Example:
-    
-    ```
-    Jul 18 15:45:23 server kernel: [62456.302490] Out of memory: Kill process 1234 (java) score 236 or sacrifice child
-    Jul 18 15:45:23 server kernel: [62456.302495] Killed process 1234 (java) total-vm:8052516kB, anon-rss:7836428kB, file-rss:0kB, shmem-rss:0kB
-    
-    ```
-    
-    This system log shows an out-of-memory error that resulted in the termination of a Java process.
-    
+  Example:
+  ```
+  Jul 18 15:45:23 server kernel: [62456.302490] Out of memory: Kill process 1234 (java) score 236 or sacrifice child
+  Jul 18 15:45:23 server kernel: [62456.302495] Killed process 1234 (java) total-vm:8052516kB, anon-rss:7836428kB, file-rss:0kB, shmem-rss:0kB
+
+  ```
+  This system log shows an out-of-memory error that resulted in the termination of a Java process.
 - Security Logs - These capture security issues and detect suspicious actions and security breaches. It is useful to separate them from the application logs as these can be separately forwarded to security developers.
-    
-    Example:
-    
-    ```
-    2024-07-18 16:20:45 WARN  [SecurityFilter] - Failed login attempt for user 'admin' from IP 192.168.1.100
-    2024-07-18 16:20:50 ERROR [SecurityFilter] - Multiple failed login attempts detected. Possible brute force attack from IP 192.168.1.100
-    
-    ```
-    
-    This security log shows failed login attempts and a potential security threat.
-    
+  Example:
+  ```
+  2024-07-18 16:20:45 WARN  [SecurityFilter] - Failed login attempt for user 'admin' from IP 192.168.1.100
+  2024-07-18 16:20:50 ERROR [SecurityFilter] - Multiple failed login attempts detected. Possible brute force attack from IP 192.168.1.100
+
+  ```
+  This security log shows failed login attempts and a potential security threat.
 - Network Logs (Grouped under System Logs) - Network-related issues like high traffic, multiple attempts to connect, problems with data transformation, server downtime, etc. are covered under this. It lets network engineers solve the issue faster by providing device ID, timestamp, error message, etc.
-    
-    Example:
-    
-    ```
-    2024-07-18 17:05:30 ERROR [NetworkMonitor] - Connection timeout: Unable to reach database server at 10.0.0.5:5432
-    2024-07-18 17:05:35 WARN  [NetworkMonitor] - High network latency detected: 500ms response time from API server
-    
-    ```
-    
-    This network log shows a database connection timeout and a warning about high network latency.
-    
+  Example:
+  ```
+  2024-07-18 17:05:30 ERROR [NetworkMonitor] - Connection timeout: Unable to reach database server at 10.0.0.5:5432
+  2024-07-18 17:05:35 WARN  [NetworkMonitor] - High network latency detected: 500ms response time from API server
+
+  ```
+  This network log shows a database connection timeout and a warning about high network latency.
 
 By categorizing logs in this manner, teams can quickly identify the source of an error and route it to the appropriate team for resolution. For instance, application logs would typically be handled by software developers, system logs by system administrators, security logs by the security team, and network logs by network engineers.
 
@@ -266,7 +277,7 @@ Log4J was a popular logging framework for Java applications. However, it has sev
 
 ### LogBack
 
-It is a successor of Log4J and it addresses security concerns and offers enhanced features. It offers flexibility in configuration and allows customizations in logging behavior, output formats, and filtering options. 
+It is a successor of Log4J and it addresses security concerns and offers enhanced features. It offers flexibility in configuration and allows customizations in logging behavior, output formats, and filtering options.
 
 ### LOG4J 2
 
@@ -274,15 +285,13 @@ It is rewritten and designed from beginning, it offers better performance, scala
 
 ### SLF4J
 
-It is not a logging framework it is a logging facade. It acts as a bridge between frameworks and standard logging API. It simplifies switching between various frameworks without having to change code. 
+It is not a logging framework it is a logging facade. It acts as a bridge between frameworks and standard logging API. It simplifies switching between various frameworks without having to change code.
 
 ## Best Practices for Effective Error Logging
 
 - Consistent Formatting - Use the same structure throughout or make a standard for consistent logging. For example,
-`[Timestamp] [Severity Level] [Source] [Message] [Context]`
-    
-    This will help the developer understand the log at first glance and can only refer to sections of their interest. 
-    
+  `[Timestamp] [Severity Level] [Source] [Message] [Context]`
+      This will help the developer understand the log at first glance and can only refer to sections of their interest.
 - Comprehensive Logging - While logging errors are crucial, logging every relevant event is necessary. Log all the informational messages, warnings, user actions, etc. to get an entire picture of the system and its flow.
 - Regular Monitoring - Make use of these logs by monitoring and analyzing them regularly to make the system robust. Consider leveraging automated tools available for monitoring, analysis, and alerts.
 - Alerting and Notification - To minimize downtime and address critical issues faster, developers can set up appropriate notification channels to notify relevant teams of critical errors. Remember when some e-commerce websites sold iPhones at an 80-90% discount due to some technical errors and faced a huge loss, it can be helpful in such situations to detect unusual activity.
@@ -292,7 +301,11 @@ It is not a logging framework it is a logging facade. It acts as a bridge betwee
 
 ## Troubleshooting with Error Logs
 
-<Figure src="/img/guides/2024/07/error-log-napkin-selection.webp" alt="napkin-selection.webp" caption="napkin-selection.webp" />
+<Figure
+  src="/img/guides/2024/07/error-log-napkin-selection.webp"
+  alt="napkin-selection.webp"
+  caption="napkin-selection.webp"
+/>
 
 - Identifying Common Issues - The very first step in troubleshooting is to identify errors that occur frequently. This can be done by aggregating logs from various sources, filtering and searching using tools to identify frequent log messages, and recognizing patterns to resolve issues.
 - Root Cause Analysis - Once the error is logged, the next step is to find the origin of the issue. Root Cause Analysis (RCA) is crucial for pinpointing the exact origin of issues, preventing recurrence, enhancing system performance, and improving decision-making. This can be done using log context, looking for recurring patterns in the errors, using stack traces, and using monitoring tools.
@@ -302,7 +315,7 @@ SigNoz provides functionalities for [capturing and analyzing exceptions and erro
 
 ### Real-World Scenario
 
-Let us take an example of the issue where users are not able to log in to a web application. The first step will be gathering all the logs and finding logs where the user is logging in. If the issue is with all the users common errors can be useful. If only some users are facing this issue, then the root cause of the issue must be analyzed. 
+Let us take an example of the issue where users are not able to log in to a web application. The first step will be gathering all the logs and finding logs where the user is logging in. If the issue is with all the users common errors can be useful. If only some users are facing this issue, then the root cause of the issue must be analyzed.
 
 Next, look for errors or exceptions reporting that the user login failed. It can be due to several issues, there can be a problem with the authentication, database connection, or issue with the input method.
 
@@ -455,7 +468,7 @@ How to avoid:
 - Regularly review and update logging practices.
 - Seek feedback from developers and operations teams on the usefulness of current logs.
 
-By being aware of these common pitfalls and taking steps to avoid them, you can significantly improve the effectiveness of your error logging practices. Remember, the goal of error logging is to provide clear, actionable information that helps quickly identify and resolve issues in your application. 
+By being aware of these common pitfalls and taking steps to avoid them, you can significantly improve the effectiveness of your error logging practices. Remember, the goal of error logging is to provide clear, actionable information that helps quickly identify and resolve issues in your application.
 
 ## Send Error Logs to SigNoz
 
@@ -465,21 +478,33 @@ SigNoz is a full-stack open-source APM tool that simplifies the process of [moni
 
 The logs tab in SigNoz is packed with advanced features that streamline the process of analyzing logs. Features such as a log [query builder](https://signoz.io/blog/query-builder-v5/), search across multiple fields, structured table view, and JSON view make the process of analyzing logs easier and more efficient.
 
-<Figure src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled.webp" alt="Logs management in SigNoz" caption="Logs management in SigNoz" />
+<Figure
+  src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled.webp"
+  alt="Logs management in SigNoz"
+  caption="Logs management in SigNoz"
+/>
 
-*Logs management in SigNoz*
+_Logs management in SigNoz_
 
 SigNoz offers real-time analysis of logs, enabling you to search, filter, and visualize them as they are generated. This can assist in identifying patterns, trends, and problems in the logs and resolving issues efficiently.
 
-<Figure src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled%201.webp" alt="Live tail logging in SigNoz" caption="Live tail logging in SigNoz" />
+<Figure
+  src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled%201.webp"
+  alt="Live tail logging in SigNoz"
+  caption="Live tail logging in SigNoz"
+/>
 
-*Live tail logging in SigNoz*
+_Live tail logging in SigNoz_
 
 With the advanced Log Query Builder, you can filter out logs quickly with a mix and match of fields.
 
-<Figure src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled%202.webp" alt="Advanced query builder to search and filter logs quickly in SigNoz dashboard" caption="Advanced query builder to search and filter logs quickly in SigNoz dashboard" />
+<Figure
+  src="https://signoz.io/img/guides/2024/07/docker-logs-location-Untitled%202.webp"
+  alt="Advanced query builder to search and filter logs quickly in SigNoz dashboard"
+  caption="Advanced query builder to search and filter logs quickly in SigNoz dashboard"
+/>
 
-*Advanced query builder to search and filter logs quickly in [SigNoz](https://signoz.io/docs/introduction/) dashboard*
+_Advanced query builder to search and filter logs quickly in [SigNoz](https://signoz.io/docs/introduction/) dashboard_
 
 Refer to [this](https://signoz.io/docs/userguide/collect_logs_from_file/) article for complete details on using SigNoz for analyzing error logs.
 
diff --git a/data/guides/filter-prometheus-results-by-metric-value-not-by-label-value.mdx b/data/guides/filter-prometheus-results-by-metric-value-not-by-label-value.mdx
index edba05684..e7fb016ad 100644
--- a/data/guides/filter-prometheus-results-by-metric-value-not-by-label-value.mdx
+++ b/data/guides/filter-prometheus-results-by-metric-value-not-by-label-value.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Filter Prometheus Metrics by Value - A Guide
-slug: filter-prometheus-results-by-metric-value-not-by-label-value
 date: 2024-10-30
 tags: [grafana]
 authors: [nitin_gouda]
 description: Learn how to filter Prometheus metrics by value for precise monitoring. This guide covers advanced techniques, practical examples, and optimization strategies.
-keywords: [Prometheus metrics, value-based filtering, PromQL, metric analysis, monitoring, observability, SigNoz]
-
+keywords:
+  [
+    Prometheus metrics,
+    value-based filtering,
+    PromQL,
+    metric analysis,
+    monitoring,
+    observability,
+    SigNoz,
+  ]
 ---
 
 Prometheus, a powerful open-source monitoring system, collects and stores time series data as metrics. While label-based filtering is common, there are scenarios where filtering by metric value becomes crucial for precise analysis. This guide explores the ins and outs of filtering Prometheus results by metric value, providing you with the knowledge to enhance your monitoring capabilities.
@@ -18,14 +24,13 @@ Prometheus is a powerful monitoring and alerting toolkit used to collect metrics
 
 1. Metric Name: This identifies what is being measured. For example, `http_requests_total` tracks the total number of HTTP requests made to your application.
 2. Labels: Labels are key-value pairs that provide additional context about the metric. They help categorize and filter metrics based on specific attributes. For example:
-    - `method="GET"`: Indicates the HTTP method used.
-    - `status="200"`: Represents the HTTP response status code.
+   - `method="GET"`: Indicates the HTTP method used.
+   - `status="200"`: Represents the HTTP response status code.
 3. Metric Value: This is the actual numerical value associated with the metric. For instance, in the example below, `1234` is the metric value. It indicates that 1,234 HTTP GET requests resulted in a 200 (OK) status code.
-    
-    ```
-    http_requests_total{method="GET", status="200"} 1234
-    ```
-    
+
+   ```
+   http_requests_total{method="GET", status="200"} 1234
+   ```
 
 ### Common Filtering Techniques in Prometheus
 
@@ -104,284 +109,301 @@ While label-based filtering is effective for segmenting metrics, it has some lim
 Filtering Prometheus results by metric value is a powerful feature that enhances your ability to analyze and monitor system performance. Unlike traditional label-based filtering, which primarily focuses on metadata, value-based filtering allows for a deeper and more dynamic approach to querying metrics. Here’s why this capability is essential for effective monitoring:
 
 1. Precise Thresholds
-    
-    Value-based filtering enables you to set precise thresholds for your metrics. This is crucial for performance monitoring, as it allows you to quickly identify metrics that exceed specific limits. For instance, if you're monitoring JVM memory usage and want to be alerted when it exceeds 10 MB, you can use a query like this:
-    
-    ```
-    jvm_memory_used_bytes > 10000000
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.08.06_PM.webp" alt="" caption="" />2. Dynamic Analysis
-    
-    Adapt your queries to reflect changing system behaviors without modifying label structures. For example, if you want to monitor the JVM memory usage and focus on instances where the committed memory exceeds 50 MB, you can use:
-    
-    ```
-    jvm_memory_committed_bytes > 50 * 1024 * 1024
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-09-30_at_7.10.29_PM.webp" alt="" caption="" />3. Complex Conditions
-    
-    Value-based filtering allows you to create sophisticated queries that combine multiple conditions. This capability is particularly useful for analyzing several metrics simultaneously. For example, you might want to identify instances where both the live threads and CPU usage are above certain thresholds:
-    
-    ```
-    jvm_threads_live_threads > 20 and system_cpu_usage > 0.04
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.54.21_PM.webp" alt="" caption="" />This query provides a comprehensive view of resource utilization, allowing you to pinpoint potential issues that could affect system performance. However, if the values do not meet the conditions during the time of the query, it may return an `Empty Query result`.
-    
-4. Efficient Alerting
-    
-    Setting up alerts based on actual metric values rather than predefined label categories leads to more effective monitoring. By using value-based conditions, you can ensure that alerts are triggered only when specific performance thresholds are breached. For example, to alert when the number of HTTP 500 errors exceeds a certain count within a defined time frame, you could use:
-    
-    ```
-    increase(jvm_gc_pause_seconds_count[5m]) >= 0
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.57.53_PM.webp" alt="" caption="" />This alert will only activate if there are more than 10 HTTP 500 errors in the last 5 minutes, allowing for a focused response to real issues.
-    
-5. Monitoring CPU Usage
-    
-    Consider a scenario where you need to identify all servers with CPU usage above 13%. Label-based filtering can't achieve this directly, but value-based filtering makes it straightforward:
-    
-    ```lua
-    system_cpu_usage > 0.13
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-09-30_at_7.39.50_PM.webp" alt="" caption="" />This query directly retrieves all instances where CPU utilization exceeds 80%, providing immediate insights into servers that may require scaling or optimization.
-    
+
+   Value-based filtering enables you to set precise thresholds for your metrics. This is crucial for performance monitoring, as it allows you to quickly identify metrics that exceed specific limits. For instance, if you're monitoring JVM memory usage and want to be alerted when it exceeds 10 MB, you can use a query like this:
+
+   ```
+   jvm_memory_used_bytes > 10000000
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.08.06_PM.webp"
+     alt=""
+     caption=""
+   />
+   2. Dynamic Analysis
+
+   Adapt your queries to reflect changing system behaviors without modifying label structures. For example, if you want to monitor the JVM memory usage and focus on instances where the committed memory exceeds 50 MB, you can use:
+
+   ```
+   jvm_memory_committed_bytes > 50 * 1024 * 1024
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-09-30_at_7.10.29_PM.webp"
+     alt=""
+     caption=""
+   />
+   3. Complex Conditions
+
+   Value-based filtering allows you to create sophisticated queries that combine multiple conditions. This capability is particularly useful for analyzing several metrics simultaneously. For example, you might want to identify instances where both the live threads and CPU usage are above certain thresholds:
+
+   ```
+   jvm_threads_live_threads > 20 and system_cpu_usage > 0.04
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.54.21_PM.webp"
+     alt=""
+     caption=""
+   />
+   This query provides a comprehensive view of resource utilization, allowing you to pinpoint
+   potential issues that could affect system performance. However, if the values do not meet the
+   conditions during the time of the query, it may return an `Empty Query result`.
+
+2. Efficient Alerting
+
+   Setting up alerts based on actual metric values rather than predefined label categories leads to more effective monitoring. By using value-based conditions, you can ensure that alerts are triggered only when specific performance thresholds are breached. For example, to alert when the number of HTTP 500 errors exceeds a certain count within a defined time frame, you could use:
+
+   ```
+   increase(jvm_gc_pause_seconds_count[5m]) >= 0
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_10.57.53_PM.webp"
+     alt=""
+     caption=""
+   />
+   This alert will only activate if there are more than 10 HTTP 500 errors in the last 5 minutes,
+   allowing for a focused response to real issues.
+
+3. Monitoring CPU Usage
+
+   Consider a scenario where you need to identify all servers with CPU usage above 13%. Label-based filtering can't achieve this directly, but value-based filtering makes it straightforward:
+
+   ```lua
+   system_cpu_usage > 0.13
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-09-30_at_7.39.50_PM.webp"
+     alt=""
+     caption=""
+   />
+   This query directly retrieves all instances where CPU utilization exceeds 80%, providing
+   immediate insights into servers that may require scaling or optimization.
 
 ### Comparison Between Label-Based and Value-Based Filtering
 
 Understanding the differences between label-based and value-based filtering can help you choose the right approach for your monitoring needs:
 
 1. Focus:
-    - Label-Based Filtering: Primarily focuses on metadata (labels) associated with metrics. It's useful for grouping and segmenting data based on predefined categories.
-    - Value-Based Filtering: Concentrates on the actual numerical values of metrics, allowing for more nuanced analysis and dynamic querying based on real-time data.
+   - Label-Based Filtering: Primarily focuses on metadata (labels) associated with metrics. It's useful for grouping and segmenting data based on predefined categories.
+   - Value-Based Filtering: Concentrates on the actual numerical values of metrics, allowing for more nuanced analysis and dynamic querying based on real-time data.
 2. Query Complexity:
-    - Label-Based Filtering: Often limited to straightforward queries that rely on labels, which may not capture complex performance scenarios.
-    - Value-Based Filtering: Enables complex queries that combine multiple conditions, providing a deeper understanding of system performance.
+   - Label-Based Filtering: Often limited to straightforward queries that rely on labels, which may not capture complex performance scenarios.
+   - Value-Based Filtering: Enables complex queries that combine multiple conditions, providing a deeper understanding of system performance.
 3. Alerting Efficiency:
-    - Label-Based Filtering: Alerts may be based on label categories, which can lead to false positives if not carefully defined.
-    - Value-Based Filtering: Triggers alerts based on specific metric values, reducing false positives and enhancing the effectiveness of monitoring.
+   - Label-Based Filtering: Alerts may be based on label categories, which can lead to false positives if not carefully defined.
+   - Value-Based Filtering: Triggers alerts based on specific metric values, reducing false positives and enhancing the effectiveness of monitoring.
 
 ## Step-by-Step Guide: Filtering Prometheus Results by Metric Value
 
 To filter Prometheus results by metric value, use PromQL (Prometheus Query Language) with comparison operators. Here's how:
 
 1. Start with a Basic Metric Query
-    
-    To begin, you’ll need to identify the metric you want to query. For example, if you want to monitor CPU utilization, you can use the following basic metric query:
-    
-    ```
-    node_cpu_utilization
-    ```
-    
+
+   To begin, you’ll need to identify the metric you want to query. For example, if you want to monitor CPU utilization, you can use the following basic metric query:
+
+   ```
+   node_cpu_utilization
+   ```
+
 2. Add a Comparison Operator to Filter by Value
-    
-    To filter the results by a specific value, use comparison operators like `>`, `<`, `=`, etc. For instance, if you're interested in CPU utilization that exceeds 80%, you can modify the query as follows:
-    
-    ```
-    node_cpu_utilization > 0.8
-    ```
-    
-    This query returns only the instances where the CPU utilization is greater than 80%, helping you focus on high-utilization scenarios.
-    
+
+   To filter the results by a specific value, use comparison operators like `>`, `<`, `=`, etc. For instance, if you're interested in CPU utilization that exceeds 80%, you can modify the query as follows:
+
+   ```
+   node_cpu_utilization > 0.8
+   ```
+
+   This query returns only the instances where the CPU utilization is greater than 80%, helping you focus on high-utilization scenarios.
+
 3. Combine with Label Filters for More Precise Results
-    
-    Prometheus metrics come with labels, which provide additional context (e.g., job names, instance details). You can use these labels to further refine your query. For example, if you want to filter the CPU utilization of only your `webserver` job, you can add a label filter like this:
-    
-    ```
-    node_cpu_utilization{job="webserver"} > 0.8
-    ```
-    
-    This query will return CPU utilization exceeding 80%, but only for instances running in the `webserver` job.
-    
+
+   Prometheus metrics come with labels, which provide additional context (e.g., job names, instance details). You can use these labels to further refine your query. For example, if you want to filter the CPU utilization of only your `webserver` job, you can add a label filter like this:
+
+   ```
+   node_cpu_utilization{job="webserver"} > 0.8
+   ```
+
+   This query will return CPU utilization exceeding 80%, but only for instances running in the `webserver` job.
+
 4. Use Logical Operators for Complex Conditions
-    
-    To build more complex queries, you can combine multiple conditions using logical operators like `and`, `or`, and `unless`. For example, if you want to monitor both high CPU and memory utilization, you can combine the two conditions as follows:
-    
-    ```
-    node_cpu_utilization > 0.8 and node_memory_utilization > 0.7
-    ```
-    
-    This query finds instances where both the CPU utilization is greater than 80% and the memory utilization is greater than 70%, helping you pinpoint systems under high load.
-    
-    ### Best Practices for Writing Efficient Value-Based Queries
-    
-    Writing efficient value-based queries in Prometheus is crucial for maximizing performance analysis and ensuring your monitoring system provides accurate and actionable insights. Here are some best practices to consider:
-    
-    1. Use Appropriate Operators
-        
-        Choose the right comparison operators to accurately reflect the conditions you want to monitor. Prometheus supports various operators, including:
-        
-        - Greater than (`>`): To find instances where a metric exceeds a certain value.
-        - Less than (`<`): To identify when a metric falls below a defined threshold.
-        - Equality (`==`): To filter metrics that match a specific value.
-        - Inequality (`!=`): To exclude metrics that match certain values.
+
+   To build more complex queries, you can combine multiple conditions using logical operators like `and`, `or`, and `unless`. For example, if you want to monitor both high CPU and memory utilization, you can combine the two conditions as follows:
+
+   ```
+   node_cpu_utilization > 0.8 and node_memory_utilization > 0.7
+   ```
+
+   This query finds instances where both the CPU utilization is greater than 80% and the memory utilization is greater than 70%, helping you pinpoint systems under high load.
+
+   ### Best Practices for Writing Efficient Value-Based Queries
+
+   Writing efficient value-based queries in Prometheus is crucial for maximizing performance analysis and ensuring your monitoring system provides accurate and actionable insights. Here are some best practices to consider:
+
+   1. Use Appropriate Operators
+
+      Choose the right comparison operators to accurately reflect the conditions you want to monitor. Prometheus supports various operators, including:
+
+      - Greater than (`>`): To find instances where a metric exceeds a certain value.
+      - Less than (`<`): To identify when a metric falls below a defined threshold.
+      - Equality (`==`): To filter metrics that match a specific value.
+      - Inequality (`!=`): To exclude metrics that match certain values.
         Using the correct operator ensures your queries return relevant results while minimizing unnecessary data retrieval.
-    2. Leverage Time Ranges
-        
-        Use time ranges effectively in your queries to focus on relevant periods. Prometheus allows you to specify time intervals, such as using functions like `rate()` or `increase()` to analyze changes over time. For example, if you want to monitor HTTP request rates, you can use:
-        
+
+   2. Leverage Time Ranges
+
+      Use time ranges effectively in your queries to focus on relevant periods. Prometheus allows you to specify time intervals, such as using functions like `rate()` or `increase()` to analyze changes over time. For example, if you want to monitor HTTP request rates, you can use:
+
+      ```
+      rate(http_requests_total[5m])
+      ```
+
+      This approach provides insights into trends and anomalies in metric values over the specified time range, helping you make informed decisions.
+
+   3. Filter with Labels
+
+      Combine value-based filtering with label selectors to refine your queries. While value-based filtering focuses on metric values, incorporating labels can help narrow down the results to specific instances or categories. For example:
+
+      ```
+      http_requests_total{status="500"} > 10
+      ```
+
+      This query retrieves only those HTTP requests with a 500 status code that exceed a count of 10, making it easier to identify problematic areas in your application.
+
+   4. Minimize Result Cardinality
+
+      Be mindful of result cardinality when writing queries. [High cardinality](https://signoz.io/blog/high-cardinality-data/) can lead to performance issues, as Prometheus needs to process a larger number of series. To minimize cardinality:
+
+      - Avoid using too many label dimensions in queries.
+      - Use value-based filtering to limit the number of time series returned. For instance:
+
+      ```
+      cpu_usage > 0.8
+      ```
+
+      This approach retrieves only the instances where CPU usage exceeds 80%, reducing the number of series processed.
+
+   5. Utilize Functions Wisely
+
+      Take advantage of Prometheus functions to enhance your queries. Functions like `avg()`, `sum()`, or `count()` can help aggregate metrics effectively, providing a clearer picture of system performance. For example:
+
+      ```
+      avg(jvm_memory_used_bytes{area="heap"}) > 50 * 1024 * 1024
+      ```
+
+      This query calculates the average heap memory used across all instances, allowing you to monitor memory utilization trends without querying each instance individually.
+
+   6. Test Queries for Performance
+
+      Before deploying your queries in a production environment, test them to assess their performance. Use Prometheus's built-in tools to analyze query execution times and optimize as necessary. Pay attention to the time complexity and ensure that your queries return results efficiently, especially during peak usage.
+
+   By following these best practices, you can write efficient value-based queries that enhance your performance analysis capabilities in Prometheus, leading to improved monitoring, quicker issue resolution, and ultimately, a more reliable system.
+
+### Advanced Techniques for Value-Based Filtering
+
+To effectively monitor your systems and applications in Prometheus, applying advanced techniques for value-based filtering can significantly enhance your query capabilities. Below are some of the key techniques you can utilize:
+
+1.  Using Functions like `avg()`, `sum()`, and `rate()` with Value Filters
+    Leveraging Prometheus' built-in functions allows for more sophisticated analysis of your metrics. You can apply aggregate functions to summarize and assess performance over time. - Average Request Duration:
         ```
-        rate(http_requests_total[5m])
+        avg(rate(http_request_duration_seconds[5m])) > 0.1
         ```
-        
-        This approach provides insights into trends and anomalies in metric values over the specified time range, helping you make informed decisions.
-        
-    3. Filter with Labels
-        
-        Combine value-based filtering with label selectors to refine your queries. While value-based filtering focuses on metric values, incorporating labels can help narrow down the results to specific instances or categories. For example:
-        
+
+        This query identifies services where the average request duration exceeds 100 milliseconds over the last 5 minutes. It helps to pinpoint slow services that may affect user experience.
+
+        - Sum of CPU Utilization:
+
         ```
-        http_requests_total{status="500"} > 10
+        sum by (instance) (node_cpu_utilization) > 0.8
         ```
-        
-        This query retrieves only those HTTP requests with a 500 status code that exceed a count of 10, making it easier to identify problematic areas in your application.
-        
-    4. Minimize Result Cardinality
-        
-        Be mindful of result cardinality when writing queries. [High cardinality](https://signoz.io/blog/high-cardinality-data/) can lead to performance issues, as Prometheus needs to process a larger number of series. To minimize cardinality:
-        
-        - Avoid using too many label dimensions in queries.
-        - Use value-based filtering to limit the number of time series returned. For instance:
-        
+
+        This query calculates the total CPU utilization across all cores for each instance, filtering for instances where the total exceeds 80%. This helps in identifying heavily loaded systems.
+2.  Combining Label and Value Filters for Precise Results:
+    Combining label filters with value filters allows you to refine your queries and target specific instances or jobs more effectively.
         ```
-        cpu_usage > 0.8
+        node_cpu_utilization{instance="server1"} > 0.8
         ```
-        
-        This approach retrieves only the instances where CPU usage exceeds 80%, reducing the number of series processed.
-        
-    5. Utilize Functions Wisely
-        
-        Take advantage of Prometheus functions to enhance your queries. Functions like `avg()`, `sum()`, or `count()` can help aggregate metrics effectively, providing a clearer picture of system performance. For example:
-        
+
+        In this example, the query returns CPU utilization metrics for `server1` that exceed 80%. This approach ensures that your monitoring efforts focus on the right targets without unnecessary noise from other instances.
+3.  Handling Time Series with Multiple Samples in Value Filtering:
+    [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) often contain multiple samples over time, making it essential to use functions that consider historical data when filtering.
         ```
-        avg(jvm_memory_used_bytes{area="heap"}) > 50 * 1024 * 1024
+        avg_over_time(node_cpu_utilization[5m]) > 0.75
         ```
-        
-        This query calculates the average heap memory used across all instances, allowing you to monitor memory utilization trends without querying each instance individually.
-        
-    6. Test Queries for Performance
-        
-        Before deploying your queries in a production environment, test them to assess their performance. Use Prometheus's built-in tools to analyze query execution times and optimize as necessary. Pay attention to the time complexity and ensure that your queries return results efficiently, especially during peak usage.
-        
-    
-    By following these best practices, you can write efficient value-based queries that enhance your performance analysis capabilities in Prometheus, leading to improved monitoring, quicker issue resolution, and ultimately, a more reliable system.
-    
 
-### Advanced Techniques for Value-Based Filtering
-
-To effectively monitor your systems and applications in Prometheus, applying advanced techniques for value-based filtering can significantly enhance your query capabilities. Below are some of the key techniques you can utilize:
-
-1. Using Functions like `avg()`, `sum()`, and `rate()` with Value Filters
-Leveraging Prometheus' built-in functions allows for more sophisticated analysis of your metrics. You can apply aggregate functions to summarize and assess performance over time.
-    - Average Request Duration:
-    
-    ```
-    avg(rate(http_request_duration_seconds[5m])) > 0.1
-    ```
-    
-    This query identifies services where the average request duration exceeds 100 milliseconds over the last 5 minutes. It helps to pinpoint slow services that may affect user experience.
-    
-    - Sum of CPU Utilization:
-    
-    ```
-    sum by (instance) (node_cpu_utilization) > 0.8
-    ```
-    
-    This query calculates the total CPU utilization across all cores for each instance, filtering for instances where the total exceeds 80%. This helps in identifying heavily loaded systems.
-    
-2. Combining Label and Value Filters for Precise Results:
-Combining label filters with value filters allows you to refine your queries and target specific instances or jobs more effectively.
-    
-    ```
-    node_cpu_utilization{instance="server1"} > 0.8
-    ```
-    
-    In this example, the query returns CPU utilization metrics for `server1` that exceed 80%. This approach ensures that your monitoring efforts focus on the right targets without unnecessary noise from other instances.
-    
-3. Handling Time Series with Multiple Samples in Value Filtering:
-[Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) often contain multiple samples over time, making it essential to use functions that consider historical data when filtering.
-    
-    ```
-    avg_over_time(node_cpu_utilization[5m]) > 0.75
-    ```
-    
-    This query calculates the average CPU utilization over the past 5 minutes, returning instances where the average exceeds 75%. This helps smooth out fluctuations and provides a clearer picture of resource usage.
-    
-4. Troubleshooting Common Issues in Value-Based Filtering
-When using value-based filtering, you may encounter common challenges that can affect the accuracy of your queries.
-    - No Results: If your query returns no results, double-check that the metric name and labels match correctly. Also, ensure your value conditions aren't too restrictive.
-    - Unexpected Results: If the results seem off, verify that you're using the correct aggregation functions. For example, if summing values, confirm that you’re summing the right labels.
+        This query calculates the average CPU utilization over the past 5 minutes, returning instances where the average exceeds 75%. This helps smooth out fluctuations and provides a clearer picture of resource usage.
+4.  Troubleshooting Common Issues in Value-Based Filtering
+    When using value-based filtering, you may encounter common challenges that can affect the accuracy of your queries. - No Results: If your query returns no results, double-check that the metric name and labels match correctly. Also, ensure your value conditions aren't too restrictive. - Unexpected Results: If the results seem off, verify that you're using the correct aggregation functions. For example, if summing values, confirm that you’re summing the right labels.
 
 ## Practical Examples of Value-Based Filtering in Prometheus
 
 Let's explore some real-world scenarios where value-based filtering shines:
 
 1. Filtering High CPU Usage Metrics:
-    
-    To identify instances where CPU utilization exceeds 80%, use the following query:
-    
-    ```
-    node_cpu_utilization > 80
-    ```
-    
-    This helps in monitoring and addressing performance bottlenecks in your applications.
-    
+
+   To identify instances where CPU utilization exceeds 80%, use the following query:
+
+   ```
+   node_cpu_utilization > 80
+   ```
+
+   This helps in monitoring and addressing performance bottlenecks in your applications.
+
 2. Identifying Slow HTTP Requests:
-    
-    To track HTTP requests that take longer than 5 seconds, you can use:
-    
-    ```
-    http_request_duration_seconds > 5
-    ```
-    
-    This query helps in pinpointing slow requests that may affect user experience.
-    
-3. High Memory Usage Detection: 
-    
-    To monitor Java applications, you can filter by memory usage to catch potential memory leaks or performance degradation. The following query identifies instances where non-heap memory usage in the Metaspace area exceeds 1 byte:
-    
-    ```
-    jvm_memory_used_bytes{area="nonheap", id="Metaspace", instance="host.docker.internal:8090", job="spring-petclinic-job"} > 1
-    ```
-    
-    This query finds services where the 95th percentile of request durations exceeds 1 second.
-    
+
+   To track HTTP requests that take longer than 5 seconds, you can use:
+
+   ```
+   http_request_duration_seconds > 5
+   ```
+
+   This query helps in pinpointing slow requests that may affect user experience.
+
+3. High Memory Usage Detection:
+
+   To monitor Java applications, you can filter by memory usage to catch potential memory leaks or performance degradation. The following query identifies instances where non-heap memory usage in the Metaspace area exceeds 1 byte:
+
+   ```
+   jvm_memory_used_bytes{area="nonheap", id="Metaspace", instance="host.docker.internal:8090", job="spring-petclinic-job"} > 1
+   ```
+
+   This query finds services where the 95th percentile of request durations exceeds 1 second.
+
 4. Disk Space Alerts:
-    
-    To monitor disk space usage, use this query to alert when any filesystem is more than 90% full:
-    
-    ```
-    (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 10
-    ```
-    
-    This alerts you when any filesystem is more than 90% full.
-    
+
+   To monitor disk space usage, use this query to alert when any filesystem is more than 90% full:
+
+   ```
+   (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 10
+   ```
+
+   This alerts you when any filesystem is more than 90% full.
+
 5. Unusual Network Traffic:
-    
-    To detect instances receiving more than 1 MB/s of network traffic, use:
-    
-    ```
-    rate(node_network_receive_bytes_total[5m]) > 1e6
-    ```
-    
-    This detects instances receiving more than 1 MB/s of network traffic.
-    
+
+   To detect instances receiving more than 1 MB/s of network traffic, use:
+
+   ```
+   rate(node_network_receive_bytes_total[5m]) > 1e6
+   ```
+
+   This detects instances receiving more than 1 MB/s of network traffic.
 
 ## Optimizing Prometheus Queries with Value-Based Filters
 
 While value-based filters in Prometheus offer significant analytical capabilities, they can also impact query performance if not managed properly. Here are some optimization tips to ensure your queries run efficiently:
 
-- Use Time Ranges Judiciously: 
-When formulating your queries, limit the time range to only what is necessary. Narrowing the time frame helps reduce the amount of data Prometheus needs to process, leading to faster query execution. For instance, instead of querying for data over an entire month, consider specifying a range of a few hours or days if that suffices for your analysis.
-- Leverage Label Pre-Filtering: 
-Combine label filters with value-based filters to narrow down the dataset before applying more complex queries. By first filtering with labels, you can significantly reduce the volume of data that the subsequent value-based filtering needs to process. This method enhances performance by minimizing the data set size upfront.
-- Avoid Unnecessary Precision: 
-In some cases, the exact precision of values may not be essential for your analysis. When it is acceptable, consider rounding values or simplifying comparisons. This approach can help to streamline your queries and reduce the computational load on Prometheus.
-- Use Subqueries sparingly: 
-Subqueries enable complex inquiries by nesting questions within others, but they may be resource-intensive, particularly when working with huge datasets. Use subqueries only when absolutely necessary, and examine alternatives that may get identical results without adding complexity or costs.
+- Use Time Ranges Judiciously:
+  When formulating your queries, limit the time range to only what is necessary. Narrowing the time frame helps reduce the amount of data Prometheus needs to process, leading to faster query execution. For instance, instead of querying for data over an entire month, consider specifying a range of a few hours or days if that suffices for your analysis.
+- Leverage Label Pre-Filtering:
+  Combine label filters with value-based filters to narrow down the dataset before applying more complex queries. By first filtering with labels, you can significantly reduce the volume of data that the subsequent value-based filtering needs to process. This method enhances performance by minimizing the data set size upfront.
+- Avoid Unnecessary Precision:
+  In some cases, the exact precision of values may not be essential for your analysis. When it is acceptable, consider rounding values or simplifying comparisons. This approach can help to streamline your queries and reduce the computational load on Prometheus.
+- Use Subqueries sparingly:
+  Subqueries enable complex inquiries by nesting questions within others, but they may be resource-intensive, particularly when working with huge datasets. Use subqueries only when absolutely necessary, and examine alternatives that may get identical results without adding complexity or costs.
 
 By following these optimization strategies, you can enhance the performance of your Prometheus queries with value-based filters. This not only improves response times but also ensures that you derive actionable insights without placing undue strain on your monitoring system.
 
@@ -390,37 +412,56 @@ By following these optimization strategies, you can enhance the performance of y
 Grafana, a popular visualization tool for Prometheus, supports value-based filtering in dashboards:
 
 1. Design Your Dashboard Layout: Start by outlining the layout of your dashboard. Identify the key metrics you want to visualize, such as CPU usage, memory consumption, or request latency. A well-organized layout enhances readability and makes it easier to spot trends.
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-bf9f3868-dab0-4127-b9e2-eedec9c9662e.webp" alt="" caption="" />2. Add Panels for Key Metrics: Use Grafana panels to display different metrics. Each panel can represent a specific value-based query. For instance, a panel showing high CPU usage might use the query:
-    
-    ```
-    process_cpu_usage > 0.002
-    ```
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-2b99dc90-14c7-48a6-9bfe-c83b2d2e2c68.webp" alt="" caption="" />By displaying these metrics side-by-side, you can quickly assess the overall system health.
-    
-3. Utilize Graphs and Alerts: Choose appropriate visualization types for your metrics. Use time-series graphs for metrics that change over time, such as CPU and memory utilization. Set up alerts for any value-based filters you define. For example, configure alerts for CPU utilization exceeding a certain threshold, ensuring your team can respond proactively.
-    
-    <Figure src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_11.39.18_PM.webp" alt="" caption="" />4. Interactive Controls: Grafana allows for interactive controls, such as sliders or dropdown menus, to adjust filter values dynamically. This interactivity enables users to tweak thresholds on the fly, facilitating real-time analysis without needing to modify queries manually.
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-bf9f3868-dab0-4127-b9e2-eedec9c9662e.webp"
+     alt=""
+     caption=""
+   />
+   2. Add Panels for Key Metrics: Use Grafana panels to display different metrics. Each panel can
+   represent a specific value-based query. For instance, a panel showing high CPU usage might use
+   the query:
+
+   ```
+   process_cpu_usage > 0.002
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-2b99dc90-14c7-48a6-9bfe-c83b2d2e2c68.webp"
+     alt=""
+     caption=""
+   />
+   By displaying these metrics side-by-side, you can quickly assess the overall system health.
+
+2. Utilize Graphs and Alerts: Choose appropriate visualization types for your metrics. Use time-series graphs for metrics that change over time, such as CPU and memory utilization. Set up alerts for any value-based filters you define. For example, configure alerts for CPU utilization exceeding a certain threshold, ensuring your team can respond proactively.
+
+   <Figure
+     src="/img/guides/2024/10/filter-prometheus-results-by-metric-value-not-by-label-value-Screenshot_2024-10-25_at_11.39.18_PM.webp"
+     alt=""
+     caption=""
+   />
+   4. Interactive Controls: Grafana allows for interactive controls, such as sliders or dropdown
+   menus, to adjust filter values dynamically. This interactivity enables users to tweak thresholds
+   on the fly, facilitating real-time analysis without needing to modify queries manually.
 
 ### Using Template Variables for Flexible Value Thresholds
 
 1. Defining Template Variables: Create template variables in Grafana to make your dashboards more dynamic. For instance, you can define a variable for CPU thresholds:
-    
-    ```
-    $cpu_threshold
-    ```
-    
-    This variable allows users to input a custom threshold for CPU utilization directly from the dashboard.
-    
+
+   ```
+   $cpu_threshold
+   ```
+
+   This variable allows users to input a custom threshold for CPU utilization directly from the dashboard.
+
 2. Integrating Variables into Queries: Modify your queries to incorporate these template variables. For example:
-    
-    ```
-    node_cpu_utilization > $cpu_threshold
-    ```
-    
-    This integration provides flexibility, allowing users to experiment with different threshold values without editing the query itself.
-    
+
+   ```
+   node_cpu_utilization > $cpu_threshold
+   ```
+
+   This integration provides flexibility, allowing users to experiment with different threshold values without editing the query itself.
+
 3. Dynamic Dropdowns: You can also create dropdown menus for users to select from predefined values. For instance, you might allow users to choose between different services or regions, making it easier to tailor the dashboard to their specific needs.
 
 ### Best Practices for Visualizing Value-Filtered Metrics
@@ -441,7 +482,7 @@ Grafana, a popular visualization tool for Prometheus, supports value-based filte
 
 To effectively monitor your applications and systems, leveraging an advanced observability platform like [SigNoz](https://signoz.io/) can elevate your monitoring strategy. [SigNoz](https://signoz.io/) is an open-source observability tool that provides [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/), troubleshooting, and alerting capabilities across your entire application stack.
 
-Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)—the emerging industry standard for telemetry data—SigNoz integrates seamlessly with your existing Prometheus and Grafana setup. This [unified observability](https://signoz.io/unified-observability/) solution enhances your ability to monitor HTTP requests per minute alongside deep traces, giving you a comprehensive view of your application's performance. 
+Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)—the emerging industry standard for telemetry data—SigNoz integrates seamlessly with your existing Prometheus and Grafana setup. This [unified observability](https://signoz.io/unified-observability/) solution enhances your ability to monitor HTTP requests per minute alongside deep traces, giving you a comprehensive view of your application's performance.
 SigNoz complements this setup by offering additional monitoring features:
 
 - User-Friendly Interface: Easily build complex queries without in-depth PromQL knowledge, making insights accessible for all skill levels.
@@ -494,4 +535,4 @@ Absolutely! You can apply value-based filters to the results of [PromQL function
 rate(http_requests_total[5m]) > 100
 ```
 
-This query identifies services that are handling more than 100 requests per second over the last 5 minutes, allowing you to focus on high-traffic services and potential performance issues.
\ No newline at end of file
+This query identifies services that are handling more than 100 requests per second over the last 5 minutes, allowing you to focus on high-traffic services and potential performance issues.
diff --git a/data/guides/flask-logging.mdx b/data/guides/flask-logging.mdx
index a6b1814a5..357c75477 100644
--- a/data/guides/flask-logging.mdx
+++ b/data/guides/flask-logging.mdx
@@ -1,117 +1,130 @@
 ---
-
 title: Complete Guide to Logging in Flask - Python Flask Logging
-slug: flask-logging
 date: 2024-07-18
 tags: [logging]
 authors: [soumya_gupta]
 description: Learn Flask logging from setup to advanced techniques. Covers configuration, best practices, and centralization.
-keywords: [flask logging, logs, logging, flask, flask web applications, flask logging best practices]
-
+keywords:
+  [flask logging, logs, logging, flask, flask web applications, flask logging best practices]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Complete Guide to Logging in Flask - Python Flask Logging",
-  "alternativeHeadline": "Learn Flask logging from setup to advanced techniques. Covers configuration, best practices, and centralization.",
-  "author": {
-    "@type": "Person",
-    "name": "Soumya Gupta"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-18T00:00:00Z",
-  "dateModified": "2024-07-18T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/flask-logging/"
-  },
-  "description": "Learn Flask logging from setup to advanced techniques. Covers configuration, best practices, and centralization.",
-  "keywords": ["flask logging", "logs", "logging", "flask", "flask web applications", "flask logging best practices"],
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Flask Logging",
-      "description": "The process of recording log messages in Flask applications to monitor and debug."
-    },
-    {
-      "@type": "Thing",
-      "name": "Log Management",
-      "description": "Techniques and tools for managing log data generated by software applications and systems."
-    },
-    {
-      "@type": "Thing",
-      "name": "Structured Logging",
-      "description": "Logging data in a structured format like JSON or key-value pairs for easier analysis and monitoring."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "Where are Flask Logs Stored?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Flask logs are typically streamed to the standard output (stdout) of the environment where Flask is running. They can also be directed to files or other logging handlers configured by the developer."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What Logger Does Flask Use?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Flask itself uses the Python logging module, which is a general-purpose logging framework. There isn't a specific logger exclusively for Flask; developers typically configure and use the standard Python logging capabilities to handle logging in Flask applications. This allows for flexibility in configuring loggers, handlers, and formatters according to specific application requirements."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is The Default Level of Logger in Flask?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "The default logging level in Flask is WARNING. This means that only messages of WARNING level and higher (such as ERROR and CRITICAL) will be logged by default."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How Do I Disable Default Logging in Flask?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To disable Flask's default logging completely, you can set the logging level to a higher value than CRITICAL, such as ERROR, in your Flask application's configuration. Another way is to remove or modify the default logging configuration to suit your specific needs."
-        }
-      }
-    ]
-  }
-}) }} />
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to Logging in Flask - Python Flask Logging',
+        alternativeHeadline:
+          'Learn Flask logging from setup to advanced techniques. Covers configuration, best practices, and centralization.',
+        author: {
+          '@type': 'Person',
+          name: 'Soumya Gupta',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-18T00:00:00Z',
+        dateModified: '2024-07-18T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/flask-logging/',
+        },
+        description:
+          'Learn Flask logging from setup to advanced techniques. Covers configuration, best practices, and centralization.',
+        keywords: [
+          'flask logging',
+          'logs',
+          'logging',
+          'flask',
+          'flask web applications',
+          'flask logging best practices',
+        ],
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Flask Logging',
+            description:
+              'The process of recording log messages in Flask applications to monitor and debug.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log Management',
+            description:
+              'Techniques and tools for managing log data generated by software applications and systems.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Structured Logging',
+            description:
+              'Logging data in a structured format like JSON or key-value pairs for easier analysis and monitoring.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Where are Flask Logs Stored?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Flask logs are typically streamed to the standard output (stdout) of the environment where Flask is running. They can also be directed to files or other logging handlers configured by the developer.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What Logger Does Flask Use?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Flask itself uses the Python logging module, which is a general-purpose logging framework. There isn't a specific logger exclusively for Flask; developers typically configure and use the standard Python logging capabilities to handle logging in Flask applications. This allows for flexibility in configuring loggers, handlers, and formatters according to specific application requirements.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is The Default Level of Logger in Flask?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The default logging level in Flask is WARNING. This means that only messages of WARNING level and higher (such as ERROR and CRITICAL) will be logged by default.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How Do I Disable Default Logging in Flask?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "To disable Flask's default logging completely, you can set the logging level to a higher value than CRITICAL, such as ERROR, in your Flask application's configuration. Another way is to remove or modify the default logging configuration to suit your specific needs.",
+              },
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
 Logging is a critical component in Flask applications, providing developers with insights into application behavior, errors, and performance.
 
-As a developer, grasping the fundamentals of logging systems is essential, especially when working with web applications because it helps to identify and solve errors that occur in application by monitoring the code’s execution as if like following a breadcrumb trail. 
+As a developer, grasping the fundamentals of logging systems is essential, especially when working with web applications because it helps to identify and solve errors that occur in application by monitoring the code’s execution as if like following a breadcrumb trail.
 
 It also minimizes Mean time to detection (MTTD) and mean time to resolution (MTTR) through automated alerts, historical data analysis, real-time monitoring, etc.
 
@@ -132,24 +145,23 @@ Before we dive into Flask logging, ensure you have the following set up:
 
 1. A recent version of Python installed on your machine. You can download it from the <a href="https://www.python.org/downloads/" rel="noopener noreferrer nofollow" target="_blank">official Python site</a>.
 2. Flask installed on your system. Install it using pip:
-    
-    ```
-    pip install flask
-    ```
-    
+
+   ```
+   pip install flask
+   ```
+
 3. A new working directory for this project:
-    
-    ```
-    mkdir flasklog
-    cd flasklog
-    ```
-    
+
+   ```
+   mkdir flasklog
+   cd flasklog
+   ```
+
 4. Create a new file `app.py` for your flask application in this directory:
-    
-    ```
-    code app.py
-    ```
-    
+
+   ```
+   code app.py
+   ```
 
 With these prerequisites in place, you're ready to explore Flask logging
 
@@ -163,9 +175,9 @@ Import Flask into the application `app.py` as:
 from flask import Flask
 ```
 
-`Flask` is a class provided by the flask framework and is imported into our application. 
+`Flask` is a class provided by the flask framework and is imported into our application.
 
-It’s a central component used to create an instance of a Flask web application `app.py` as: 
+It’s a central component used to create an instance of a Flask web application `app.py` as:
 
 ```python
 app = Flask(__name__)
@@ -180,23 +192,23 @@ In addition to this three routes (`/`, `/info`, and `/warning`) are defined in o
 app.logger.info("An info message!")
 ```
 
-Let’s break down a logging call, 
+Let’s break down a logging call,
 
 `app`: an instance of our application `app.py`
 
-`logger`: is an attribute of `app` object. This attribute is used for creating log entries by providing various methods to log messages at different severity levels. 
+`logger`: is an attribute of `app` object. This attribute is used for creating log entries by providing various methods to log messages at different severity levels.
 
 `info()`: is a method of the `logger` object that logs a message with a severity level of INFO
 
-We’ll explore the severity of logging levels in detail further in this article. 
+We’ll explore the severity of logging levels in detail further in this article.
 
-So, when you do a logging call the entire process looks like this: 
+So, when you do a logging call the entire process looks like this:
 
 1. “An info message” string is created to be logged
 2. `logger` object associated with the `app` instance is accessed
 3. `info()` method on the `logger` object is called with the message string
-4. A log record includes the message, log levels, and other metadata such as timestamp, module date, etc. 
-5. The log record is dispatched to any handlers configured in the logging setup. 
+4. A log record includes the message, log levels, and other metadata such as timestamp, module date, etc.
+5. The log record is dispatched to any handlers configured in the logging setup.
 
 A Handler defines where and how log messages are output (e.g., console, file, email).
 
@@ -212,45 +224,49 @@ app = Flask(__name__)
 @app.route("/")
 def hello():
 		# A Simple Greeting Message Is Returned
-    return "Greetings!"  
+    return "Greetings!"
 
 # Route to handle requests to "/info"
 @app.route("/info")
 def info():
 		# Log An Information Message
-    app.logger.info("An info message.") 
-    # Return A Message Indicating Info Was Logged 
-    return "Info message"  
+    app.logger.info("An info message.")
+    # Return A Message Indicating Info Was Logged
+    return "Info message"
 
 # Route To Handle Requests To "/warning"
 @app.route("/warning")
 def warning():
 		# Log A Warning Message
-    app.logger.warning("A warning message.")  
+    app.logger.warning("A warning message.")
     # Return A Message Indicating A Warning Was Logged
-    return "Warning message" 
+    return "Warning message"
 ```
 
-`app` instance is used for handling HTTP requests wherein `app.logger` object is then used to make logging calls using methods like `info()` and `warning()`. 
+`app` instance is used for handling HTTP requests wherein `app.logger` object is then used to make logging calls using methods like `info()` and `warning()`.
 
-We’ll learn more about handlers further in this article. 
+We’ll learn more about handlers further in this article.
 
-Type `flask run` command to run the code and see the output in the main server terminal: 
+Type `flask run` command to run the code and see the output in the main server terminal:
 
 ```powershell
 * Debug mode: off
 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
-* 
+*
 Running on http://127.0.0.1:5000
 Press CTRL+C to quit
 127.0.0.1 - - [10/Jul/2024 16:13:08] "GET / HTTP/1.1" 200 -
 ```
 
-Select the provided hyperlink in the console, it’ll direct you to your web browser. 
+Select the provided hyperlink in the console, it’ll direct you to your web browser.
 
-<Figure src="/img/guides/2024/07/flask-logging-Untitled.webp" alt="Web Browser displays the log message" caption="Web Browser displays the log message" />
+<Figure
+  src="/img/guides/2024/07/flask-logging-Untitled.webp"
+  alt="Web Browser displays the log message"
+  caption="Web Browser displays the log message"
+/>
 
-Now we defined three routes in our application `app.py` but it only shows the string message returned by the function `def Hello():`, why is that? 
+Now we defined three routes in our application `app.py` but it only shows the string message returned by the function `def Hello():`, why is that?
 
 What we want the user to see on the web is decided by routes wherein each message is supposed to have its unique route via a decorator. In order to view messages on different routes you can always add a route in the `url` of the website. For example: in order to access the `/warning` route change the URL of your web application to `http://127.0.0.1:5000/warning`.
 
@@ -263,13 +279,13 @@ In the main server terminal, you’ll see
 127.0.0.1 - - [10/Jul/2024 16:22:44] "GET / HTTP/1.1" 200 -
 ```
 
-Similarly view the `info` message on your browser and come back to the main server terminal:  
+Similarly view the `info` message on your browser and come back to the main server terminal:
 
 ```powershell
 127.0.0.1 - - [10/Jul/2024 16:27:42] "GET /info HTTP/1.1" 200 -
 ```
 
-However, if you visit the `/info` route, in the main server terminal you will observe, unlike the warning message, "An info message." message isn't logged as expected. That's because Flask ignores messages with a log level lower than `WARNING` by default, but we can customize this behavior for our web application’s requirements before we get there, we need to have a basic understanding of handlers and formatters.  
+However, if you visit the `/info` route, in the main server terminal you will observe, unlike the warning message, "An info message." message isn't logged as expected. That's because Flask ignores messages with a log level lower than `WARNING` by default, but we can customize this behavior for our web application’s requirements before we get there, we need to have a basic understanding of handlers and formatters.
 
 ## Handlers and Formatters
 
@@ -279,15 +295,15 @@ Two essential components of logging configuration are Handlers and Formatters, w
 
 A Formatter determines the structural layout of log messages before they are emitted by a Handler. It allows customization of how log records are formatted, including adding timestamps, log levels, module names, and the actual message content in a specified order and format. Formatting a log record can help in maintaining and easy parsing of the log records for various purposes.
 
-We can add a custom formatter in our `app.py` using the following code: 
+We can add a custom formatter in our `app.py` using the following code:
 
 ```python
 formatter = logging.Formatter('[%(asctime)s] %(levelname)s - %(message)s')
 ```
 
-Here, 
+Here,
 
-`[%(asctime)s]` : is a placeholder that will be replaced by the current time when the log message is created. The Square brackets `[]` specify literal characters in string format to separate timestamps from different parts of the log message. 
+`[%(asctime)s]` : is a placeholder that will be replaced by the current time when the log message is created. The Square brackets `[]` specify literal characters in string format to separate timestamps from different parts of the log message.
 
 `%(levelame)s`: is also a placeholder that will be replaced by the log level of the message (e.g., `DEBUG`, `INFO`, `WARNING`, etc.).
 
@@ -303,11 +319,11 @@ The expected output would be:
 
 A handler defines where and how log messages should be output. They are also responsible for storing, displaying as well as sending log records (messages) to specified destinations.
 
-In our previous code, you would’ve noticed that we didn’t add any handler to it then how are the log messages recorded and displayed on the console? 
+In our previous code, you would’ve noticed that we didn’t add any handler to it then how are the log messages recorded and displayed on the console?
 
 If no handlers are explicitly added to the `app.logger`, Flask will add a default handler to ensure that log messages are output to the console.
 
-We can configure a handler as:  
+We can configure a handler as:
 
 ```python
 # Configure A Console Handler With A Custom Formatter
@@ -324,40 +340,39 @@ Here, a `StreamHandler` instance is created to send logs to the console, the for
 There are various types of handlers:
 
 1. `StreamHandler`: Sends log messages to the console (`sys.stdout` or `sys.stderr`).
-    
-    ```python
-    handler = logging.StreamHandler()
-    ```
-    
-2. `FileHandler`: Writes log messages to a specified file `app.log` on disk 
-    
-    ```python
-    handler = logging.FileHandler('app.log')
-    ```
-    
-3. `HTTPHandler`:  Sends log messages to an HTTP endpoint. 
-    
-    ```python
-    # Set up the HTTP handler
-    http_handler = HTTPHandler(
-        host='localhost:5001',
-        url='/log',
-        method='POST',
-    )
-    http_handler.setLevel(logging.ERROR)
-    app.logger.addHandler(http_handler)
-    ```
-    
+
+   ```python
+   handler = logging.StreamHandler()
+   ```
+
+2. `FileHandler`: Writes log messages to a specified file `app.log` on disk
+
+   ```python
+   handler = logging.FileHandler('app.log')
+   ```
+
+3. `HTTPHandler`: Sends log messages to an HTTP endpoint.
+
+   ```python
+   # Set up the HTTP handler
+   http_handler = HTTPHandler(
+       host='localhost:5001',
+       url='/log',
+       method='POST',
+   )
+   http_handler.setLevel(logging.ERROR)
+   app.logger.addHandler(http_handler)
+   ```
 
 Note: In the context of logging, python's built-in logging module uses the term handler, while Loguru uses the term sink.
 
-Now, back to our `app.py` wherein we wanted to customize our web application’s behavior by overriding default logger configurations. 
+Now, back to our `app.py` wherein we wanted to customize our web application’s behavior by overriding default logger configurations.
 
 ### Configure a Logger
 
-In the `Set up a simple logger` section we saw how when we accessed the `/info` route we did not see the info because by default [Flask logger](https://signoz.io/guides/flask-logging/#handler) ignores messages with a log level lower than `WARNING` and one way, we can get around it is by overriding default configurations. 
+In the `Set up a simple logger` section we saw how when we accessed the `/info` route we did not see the info because by default [Flask logger](https://signoz.io/guides/flask-logging/#handler) ignores messages with a log level lower than `WARNING` and one way, we can get around it is by overriding default configurations.
 
-To override default configurations, we can use `logging.config.dictConfig()` method to our existing code in `app.py` 
+To override default configurations, we can use `logging.config.dictConfig()` method to our existing code in `app.py`
 
 ```python
 from flask import Flask
@@ -389,19 +404,19 @@ dictConfig(
         "root": {
         # Set root logger level to DEBUG
         "level": "DEBUG",
-        # Attach 'console' handler to the root logger 
+        # Attach 'console' handler to the root logger
         "handlers": ["console"]},
     }
 )
 app = Flask(__name__)
 ```
 
-`dictConfig` is used to configure the logging system in Python with a dictionary that defines the configuration details. The dictionary can specify formatters, handlers, loggers, and other logging settings. This configuration dictionary contains the following key elements: 
+`dictConfig` is used to configure the logging system in Python with a dictionary that defines the configuration details. The dictionary can specify formatters, handlers, loggers, and other logging settings. This configuration dictionary contains the following key elements:
 
 1. Version Key: represents the schema version, which is 1 in this code
 2. Formatter Key: Specifies formatting patterns of log records. Here we are using a default formatter to format log records as `"format": "[%(asctime)s] %(levelname)s in %(module)s: %(message)s"`
-3. Handler Key: Different handlers are created for your logger. Here in this code, `StreamHandler` is used to push log records to the console. 
-4. Root Key: Configurations for the root logger such as level, handlers, etc. are specified.  
+3. Handler Key: Different handlers are created for your logger. Here in this code, `StreamHandler` is used to push log records to the console.
+4. Root Key: Configurations for the root logger such as level, handlers, etc. are specified.
 
 Note that these configurations are to be added before the `app` instance is created otherwise the `app.logger` will create a default handler instead.
 
@@ -417,7 +432,7 @@ Run the file [`app.py`](http://app.py) using `flask run` to see the following ou
 
 ```
 
-Note: Use `CTRL + C` to stop the server. 
+Note: Use `CTRL + C` to stop the server.
 
 ## Beyond the Basics of Flask Logging
 
@@ -448,7 +463,7 @@ def hello():
     return "Hello, World!"
 ```
 
-Now, run the file again and observe the following output: 
+Now, run the file again and observe the following output:
 
 ```powershell
 [2024-07-10 16:34:49,121] WARNING in app: A warning message
@@ -458,7 +473,7 @@ Now, run the file again and observe the following output:
 
 However, when you run this code, only messages with a log level higher than `INFO` will be logged. That is because you haven't configured this logger yet, which means Flask will use the default configurations leading to the dropping of the `DEBUG` and `INFO` messages.
 
-But what if we want to include info and debug? Then we’ll have to change the default configurations of the said logger just like we did in the previous section. 
+But what if we want to include info and debug? Then we’ll have to change the default configurations of the said logger just like we did in the previous section.
 
 Let’s also take an example to see how we can catch and log errors in our code:
 
@@ -468,7 +483,7 @@ Let’s also take an example to see how we can catch and log errors in our code:
 def error():
     try:
     # ZeroDivisionError
-        1 / 0  
+        1 / 0
     except Exception as e:
 		    # Log the error using the Flask app's logger
         app.logger.error('An error occurred: %s', e)
@@ -476,9 +491,9 @@ def error():
         return "An error occurred!", 500
 ```
 
-In this example, the `/error` route intentionally triggers a `ZeroDivisionError` by trying to divide `1` by `0`. To manage this error, the code uses a `try-except` block. If any error, like the division by zero, occurs during execution, it's caught immediately. 
+In this example, the `/error` route intentionally triggers a `ZeroDivisionError` by trying to divide `1` by `0`. To manage this error, the code uses a `try-except` block. If any error, like the division by zero, occurs during execution, it's caught immediately.
 
-The `app.logger.error('An error occurred: %s', e)` line logs the specific error message for developers to review later. To let users know something went wrong, the route responds with `"An error occurred!"` and sends a status code `500` (Internal Server Error). 
+The `app.logger.error('An error occurred: %s', e)` line logs the specific error message for developers to review later. To let users know something went wrong, the route responds with `"An error occurred!"` and sends a status code `500` (Internal Server Error).
 
 Make sure to include the error level in the configuration.
 
@@ -496,7 +511,7 @@ Visit [`http://127.0.0.1:5000/error`](http://127.0.0.1:5000/error)to see the err
 
 ### Multiple Loggers
 
-Web applications require many loggers in order to handle different message types and route them to the appropriate locations. They assist in classifying log entries according to significance. Additionally, distinct loggers prevent logs from being mixed up in different parts of your app. In online apps, this independence is crucial. It is possible for multiple components to operate simultaneously. To ensure that there is no confusion, each can have its own logging configuration. 
+Web applications require many loggers in order to handle different message types and route them to the appropriate locations. They assist in classifying log entries according to significance. Additionally, distinct loggers prevent logs from being mixed up in different parts of your app. In online apps, this independence is crucial. It is possible for multiple components to operate simultaneously. To ensure that there is no confusion, each can have its own logging configuration.
 
 Consider the following code, for example.
 
@@ -539,7 +554,7 @@ dictConfig(
                 "level": "INFO",
                 # Attach 'console' handler to this logger
                 "handlers": ["console"],
-                # Do not propagate messages to parent loggers 
+                # Do not propagate messages to parent loggers
                 "propagate": False,
             }
         },
@@ -560,7 +575,7 @@ def hello():
     root1.warning("A warning message")
     root1.error("An error message")
     root1.critical("A critical message")
-		
+
 		# Log messages using 'root2' logger
     root2.debug("A debug message")
     root2.info("An info message")
@@ -581,9 +596,9 @@ The `loggers` section is where we define additional named loggers, like `root2`
 
 `root1` isn't included in the `loggers` section because it represents the fundamental logger itself, managed separately within logging configurations. This section is specifically used for setting up extra named loggers beyond the root logger, and tailoring logging behaviors as needed.
 
-These loggers are defined as: 
+These loggers are defined as:
 
-`root1 = logging.getLogger("root")` retrieves or creates a logger named `root`. 
+`root1 = logging.getLogger("root")` retrieves or creates a logger named `root`.
 `root2 = logging.getLogger("root2")` defines another logger named `root2` with its configuration separate from `root`. This separation allows for independent logging settings, such as different log levels or output destinations.
 
 The main difference between these two loggers lies in their configuration and how they are defined, wherein `root2` is explicitly defined in the logging configuration (`dictConfig`) under `"loggers"`, specifying its log level (`INFO`), handlers (in this case, `"console"`), and propagation settings (`False` to prevent messages from propagating to ancestor loggers).
@@ -607,25 +622,25 @@ Output:
 [2024-07-12 00:10:15,474] CRITICAL in app: An extra critical message
 ```
 
-Notice here how the debug message for the `extra` logger isn’t displayed, this is because we set the level in the configuration code as `INFO`. To see debug messages for the `extra` logger you can change it to `DEBUG` like: 
+Notice here how the debug message for the `extra` logger isn’t displayed, this is because we set the level in the configuration code as `INFO`. To see debug messages for the `extra` logger you can change it to `DEBUG` like:
 
 ```powershell
  "root2": {
                 "level": "DEBUG", # This was INFO earlier
-                "handlers": ["console"],  
+                "handlers": ["console"],
                 "propagate": False,
             }
 ```
 
 ### Customizing Log Format with Subclassing `logging.Formatter`
 
-You must be wondering, we just read about formatting log records using `logging.formatter` how is this any different? 
+You must be wondering, we just read about formatting log records using `logging.formatter` how is this any different?
 
 Default logging outputs messages with a `WARNING` severity level to the console, it’s adequate for basic uses such as including timestamp, severity level and message string. Web applications often require logs to contain specific information such as user IDs, request paths, session data, or custom tags. For this purpose, we require a custom formatter that can customize the formatting logic beyond the default capabilities, giving you more control over the log message format.
 
-By subclassing `logging.Formatter` we can define our custom logic for formatting log messages. 
+By subclassing `logging.Formatter` we can define our custom logic for formatting log messages.
 
-Subclassing `logging.Formatter` implies that we create a new class that inherits `logging.formatter` and overrides its methods (mostly it’s `format()` method) in order to customize it. This way we have complete control over the formatting process in a way that suits our web application’s needs and style. 
+Subclassing `logging.Formatter` implies that we create a new class that inherits `logging.formatter` and overrides its methods (mostly it’s `format()` method) in order to customize it. This way we have complete control over the formatting process in a way that suits our web application’s needs and style.
 
 Let’s see an example,
 
@@ -651,7 +666,7 @@ logger.info('This is an info message.')
 
 ```
 
-A new class `CustomFormatter` is defined and inherits from `logging.formatter` to override its methods for creating a custom format via subclassing. 
+A new class `CustomFormatter` is defined and inherits from `logging.formatter` to override its methods for creating a custom format via subclassing.
 
 Here, `format(self, record)` method is overridden to define a custom log format which includes:
 
@@ -660,9 +675,9 @@ Here, `format(self, record)` method is overridden to define a custom log format
 - `record.lineno` for including the exact line in the code at which the logging call was made.
 - `record.getMessage()` for displaying the log message.
 
-Then a logger with the current module is configured using `logger.getLogger(__name__)`, where `__name__` is the name of the current module. 
+Then a logger with the current module is configured using `logger.getLogger(__name__)`, where `__name__` is the name of the current module.
 
-Using the `setLevel()` method we have set the level as `INFO` for recording messages with `INFO` level severity. After the handler is configured properly, we log the required message. 
+Using the `setLevel()` method we have set the level as `INFO` for recording messages with `INFO` level severity. After the handler is configured properly, we log the required message.
 
 ```powershell
 INFO - <module> at line 15: This is an info message.
@@ -685,118 +700,102 @@ We get the following output:
 ### Ensuring Sensitive Information is Not Logged
 
 - Logging Filters
-    
-    Logging filters allow us to selectively discard log messages based on predefined criteria, ensuring that sensitive data remains protected and compliant with security standards. This is useful in web applications for preventing the exposure of confidential information, maintaining user privacy, and reducing the risk of data breaches.
-    
-    Let’s see how we can employ this functionality in our code:
-    
-    ```python
-    class RedactingFilter(logging.Filter):
-        # Override the filter method to check and redact sensitive information
-        def filter(self, record):
-            sensitive_info = ["password", "token", "secret"]
-            for word in sensitive_info:
-                if word in record.getMessage():
-                    return False
-            return True
-    
-    # Configure logger with redacting filter
-    logger = logging.getLogger(__name__)
-    logger.setLevel(logging.DEBUG)
-    
-    handler = logging.StreamHandler()
-    handler.setLevel(logging.DEBUG)
-    handler.addFilter(RedactingFilter())
-    
-    formatter = logging.Formatter("[%(asctime)s] %(levelname)s in %(module)s: %(message)s")
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    
-    # Example usage
-    logger.info("Processing request with sensitive information: password=123456")
-    logger.info("Authentication successful. token: abcdef1234567890")
-    logger.info("Received secret document from user.")
-    logger.info("This message will be logged")
-    
-    ```
-    
-    We create a custom filter class named `RedactingFilter` that inherits from the `logging.filter` in order to override the `filter(self, record)` method to define the filtering logic. 
-    
-    A list `sensitive_info` is defined such that it includes all the words that if contained in any statements should not appear in log records. 
-    
-    If the current sensitive word matches from the list, the function returns false, and the log message will not be displayed. On the contrary, if it doesn’t match the log message will be displayed.
-    
-    Output: 
-    
-    ```python
-    [2024-07-12 11:23:33,839] INFO in app: This message will be logged
-    ```
-    
-    Notice how only the log record with none of the words in the `sensitive_info` is displayed.
-    
+  Logging filters allow us to selectively discard log messages based on predefined criteria, ensuring that sensitive data remains protected and compliant with security standards. This is useful in web applications for preventing the exposure of confidential information, maintaining user privacy, and reducing the risk of data breaches.
+  Let’s see how we can employ this functionality in our code:
+  ```python
+  class RedactingFilter(logging.Filter):
+      # Override the filter method to check and redact sensitive information
+      def filter(self, record):
+          sensitive_info = ["password", "token", "secret"]
+          for word in sensitive_info:
+              if word in record.getMessage():
+                  return False
+          return True
+
+  # Configure logger with redacting filter
+  logger = logging.getLogger(__name__)
+  logger.setLevel(logging.DEBUG)
+
+  handler = logging.StreamHandler()
+  handler.setLevel(logging.DEBUG)
+  handler.addFilter(RedactingFilter())
+
+  formatter = logging.Formatter("[%(asctime)s] %(levelname)s in %(module)s: %(message)s")
+  handler.setFormatter(formatter)
+  logger.addHandler(handler)
+
+  # Example usage
+  logger.info("Processing request with sensitive information: password=123456")
+  logger.info("Authentication successful. token: abcdef1234567890")
+  logger.info("Received secret document from user.")
+  logger.info("This message will be logged")
+
+  ```
+  We create a custom filter class named `RedactingFilter` that inherits from the `logging.filter` in order to override the `filter(self, record)` method to define the filtering logic.
+  A list `sensitive_info` is defined such that it includes all the words that if contained in any statements should not appear in log records.
+  If the current sensitive word matches from the list, the function returns false, and the log message will not be displayed. On the contrary, if it doesn’t match the log message will be displayed.
+  Output:
+  ```python
+  [2024-07-12 11:23:33,839] INFO in app: This message will be logged
+  ```
+  Notice how only the log record with none of the words in the `sensitive_info` is displayed.
 - Replace Method
-    
-    What if the statement contains a word from the list of sensitive words but we still want it to be displayed in our log records all the while maintaining user privacy and security? For this purpose, we can use the replace method to simply replace the actual password with some symbol.
-    
-    ```python
-    app = Flask(__name__)
-    
-    # Define a custom logging filter
-    class SensitiveDataFilter(logging.Filter):
-        def filter(self, record):
-            # Example of sensitive information patterns to replace
-            sensitive_info_ = ['password', 'credit_card', 'ssn']
-            
-            # Replace sensitive patterns in log message
-            for pattern in sensitive_info:
-                record.msg = record.msg.replace(pattern, '*FILTERED*')
-            
-            return True
-    
-    # Configure Flask logger
-    logger = logging.getLogger(__name__)
-    logger.setLevel(logging.INFO)
-    
-    # Add a stream handler to log to console
-    handler = logging.StreamHandler()
-    handler.setLevel(logging.INFO)
-    
-    # Apply the sensitive data filter to the handler
-    handler.addFilter(SensitiveDataFilter())
-    
-    # Create a formatter and add it to the handler
-    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
-    
-    # Add the handler to the logger
-    logger.addHandler(handler)
-    
-    # Example route that logs sensitive information
-    @app.route('/')
-    def index():
-        # Simulating sensitive information being logged
-        logger.info("Sensitive info: password=%s, credit_card=%s", request.args.get('password'), request.args.get('credit_card'))
-        return "Logged sensitive information."
-    
-    if __name__ == '__main__':
-        app.run(debug=True)
-    
-    ```
-    
-    Here, we’ve used `record.msg.replace(pattern, '*FILTERED*')` method to replace sensitive information with `*FILTERED*`.
-    
-    Output in main server terminal: 
-    
-    ```python
-    2024-07-12 11:51:41,373 - INFO - Sensitive info: *FILTERED*=None, *FILTERED*=None
-    ```
-    
+  What if the statement contains a word from the list of sensitive words but we still want it to be displayed in our log records all the while maintaining user privacy and security? For this purpose, we can use the replace method to simply replace the actual password with some symbol.
+  ```python
+  app = Flask(__name__)
+
+  # Define a custom logging filter
+  class SensitiveDataFilter(logging.Filter):
+      def filter(self, record):
+          # Example of sensitive information patterns to replace
+          sensitive_info_ = ['password', 'credit_card', 'ssn']
+
+          # Replace sensitive patterns in log message
+          for pattern in sensitive_info:
+              record.msg = record.msg.replace(pattern, '*FILTERED*')
+
+          return True
+
+  # Configure Flask logger
+  logger = logging.getLogger(__name__)
+  logger.setLevel(logging.INFO)
+
+  # Add a stream handler to log to console
+  handler = logging.StreamHandler()
+  handler.setLevel(logging.INFO)
+
+  # Apply the sensitive data filter to the handler
+  handler.addFilter(SensitiveDataFilter())
+
+  # Create a formatter and add it to the handler
+  formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+  handler.setFormatter(formatter)
+
+  # Add the handler to the logger
+  logger.addHandler(handler)
+
+  # Example route that logs sensitive information
+  @app.route('/')
+  def index():
+      # Simulating sensitive information being logged
+      logger.info("Sensitive info: password=%s, credit_card=%s", request.args.get('password'), request.args.get('credit_card'))
+      return "Logged sensitive information."
+
+  if __name__ == '__main__':
+      app.run(debug=True)
+
+  ```
+  Here, we’ve used `record.msg.replace(pattern, '*FILTERED*')` method to replace sensitive information with `*FILTERED*`.
+  Output in main server terminal:
+  ```python
+  2024-07-12 11:51:41,373 - INFO - Sensitive info: *FILTERED*=None, *FILTERED*=None
+  ```
 
 ### Regularly Reviewing and Pruning Log Files
 
-Regularly reviewing and pruning log files is indispensable in web-based applications, especially in Flask, for practical and security-focused reasons. Web applications handle a constant flow of user interactions and transactions, generating extensive logs that may inadvertently capture sensitive data such as user credentials or payment information. By regularly reviewing logs, developers can promptly identify and remove such sensitive information, reducing the risk of data breaches and ensuring compliance with data protection regulations. 
+Regularly reviewing and pruning log files is indispensable in web-based applications, especially in Flask, for practical and security-focused reasons. Web applications handle a constant flow of user interactions and transactions, generating extensive logs that may inadvertently capture sensitive data such as user credentials or payment information. By regularly reviewing logs, developers can promptly identify and remove such sensitive information, reducing the risk of data breaches and ensuring compliance with data protection regulations.
 
-This purpose can be fulfilled using the concept of rotation and retention. Let’s take an example: 
+This purpose can be fulfilled using the concept of rotation and retention. Let’s take an example:
 
 ```python
 from flask import Flask, request
@@ -834,9 +833,9 @@ if __name__ == '__main__':
 
 We use the `TimedRotatingFileHandler` from Python's `logging.handlers` module which allows us to rotate log files based on specified intervals and retain a certain number of backup log files or in this case `app.log`. Each day, a new log file is created, and older files are rotated and retained based on the specified configuration (`backupCount=7`).
 
-`TimedRotatingFileHandler()` has the following elements: 
+`TimedRotatingFileHandler()` has the following elements:
 
-- `LOG_FILE` :  the specified file that will store all the log records.
+- `LOG_FILE` : the specified file that will store all the log records.
 - `when='midnight'` : Specifies when log rotation should occur based on time intervals. Setting `when='midnight'` means log files will rotate at midnight each day. You can also change this to `'S' (second)`, `'M' (minute)`, `'H' (hour)`, `'D' (day)`, `'W0'` through `'W6' (weekday)`, `'midnight'`, and `'mon'` through `'sun'` for Monday through Sunday rotations.
 - `interval=1`: Defines the time interval for log rotation. For example, `interval=1` combined with `when='midnight'` rotates logs daily.
 - `backupCount=7`: Specifies the number of backup log files to retain after rotation. In this case, `backupCount=7` ensures that up to 7 previous days' log files are kept before being overwritten.
@@ -853,7 +852,7 @@ Before we can start logging with `structlog`, you must download the package with
 python -m pip install structlog
 ```
 
-`structlog` provides a pre-configured logger by default, which you access by invoking the `structlog.get_logger()` method. 
+`structlog` provides a pre-configured logger by default, which you access by invoking the `structlog.get_logger()` method.
 
 ```python
 # import structlog library for structured logging
@@ -869,48 +868,48 @@ logger.info("Logging with structlog")
 Let’s see how we can log data in a structured format such as `JSON`:
 
 ```python
-import structlog  
-import logging  
-from flask import Flask  
+import structlog
+import logging
+from flask import Flask
 
 # Configure structlog to format log entries as JSON
 structlog.configure(
     processors=[
 		    # Add log level information
-        structlog.stdlib.add_log_level,  
+        structlog.stdlib.add_log_level,
         # Add timestamp in ISO format
-        structlog.processors.TimeStamper(fmt="iso"),  
+        structlog.processors.TimeStamper(fmt="iso"),
         # Render log entries as JSON
-        structlog.processors.JSONRenderer()  
+        structlog.processors.JSONRenderer()
     ],
     # Use a dictionary as the context class
-    context_class=dict,  
+    context_class=dict,
     # Use structlog's logger factory
-    logger_factory=structlog.stdlib.LoggerFactory(),  
+    logger_factory=structlog.stdlib.LoggerFactory(),
     # Use structlog's BoundLogger for logger wrapping
-    wrapper_class=structlog.stdlib.BoundLogger,  
+    wrapper_class=structlog.stdlib.BoundLogger,
     # Cache the logger on first use for efficiency
-    cache_logger_on_first_use=True,  
+    cache_logger_on_first_use=True,
 )
 
 # Configure the root logger to use structlog
 logging.basicConfig(level=logging.INFO)
 
 # Create a Flask application instance
-app = Flask(__name__)  
+app = Flask(__name__)
 
 @app.route('/')
 def index():
 		# Get a logger instance from structlog
-    logger = structlog.get_logger()  
+    logger = structlog.get_logger()
     # Log an info message in JSON format
-    logger.info("Log entry in JSON format", process_id=12345)  
+    logger.info("Log entry in JSON format", process_id=12345)
     # Return a simple HTTP response
-    return "Hello, World!"  
+    return "Hello, World!"
 
 if __name__ == '__main__':
     # Run the Flask application in debug mode if executed directly
-    app.run(debug=True)  
+    app.run(debug=True)
 
 ```
 
@@ -948,7 +947,7 @@ Sometimes, logs may not appear in the expected output, which can hinder debuggin
 
 ## Centralizing Your Logs in the SigNoz Cloud
 
-Create a python virtual environment `venv` using the following command: 
+Create a python virtual environment `venv` using the following command:
 
 ```python
 python -m venv venv
@@ -981,10 +980,10 @@ Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
 Once you’ve successfully activated the virtual environment you should see the following as your directory path in the PowerShell terminal:
 
 ```powershell
-(venv) PS C:\Users\Desktop\SigNoz\flasklog> 
+(venv) PS C:\Users\Desktop\SigNoz\flasklog>
 ```
 
-Set the environment variables correctly in your PowerShell terminal, and insert your access token on line 3 as shown: 
+Set the environment variables correctly in your PowerShell terminal, and insert your access token on line 3 as shown:
 
 ```powershell
 $env:OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED="true"
@@ -1015,11 +1014,15 @@ Starting Flask app
 127.0.0.1 - - [14/Jul/2024 21:48:00] "GET / HTTP/1.1" 200 -
 ```
 
-On the SigNoz Dashboard navigate to Logs and verify if the logs have been successfully sent to SigNoz. 
+On the SigNoz Dashboard navigate to Logs and verify if the logs have been successfully sent to SigNoz.
 
-<Figure src="/img/guides/2024/07/flask-logging-Untitled%201.webp" alt="SigNoz Logs Dashboard shows successfully receiving logs in the Table View." caption="SigNoz Logs Dashboard shows successfully receiving logs in the Table View." />   
+<Figure
+  src="/img/guides/2024/07/flask-logging-Untitled%201.webp"
+  alt="SigNoz Logs Dashboard shows successfully receiving logs in the Table View."
+  caption="SigNoz Logs Dashboard shows successfully receiving logs in the Table View."
+/>{' '}
 
-Learn more about different ways you can use to send logs to SigNoz [here](https://signoz.io/opentelemetry/logging-in-python/). 
+Learn more about different ways you can use to send logs to SigNoz [here](https://signoz.io/opentelemetry/logging-in-python/).
 
 ## Conclusion
 
@@ -1046,4 +1049,4 @@ The default logging level in Flask is `WARNING`. This means that only messages o
 
 ### How Do I Disable Default Logging in Flask?
 
-To disable Flask's default logging completely, you can set the logging level to a higher value than `CRITICAL`, such as `ERROR`, in your Flask application's configuration. Another way is to remove or modify the default logging configuration to suit your specific needs.
\ No newline at end of file
+To disable Flask's default logging completely, you can set the logging level to a higher value than `CRITICAL`, such as `ERROR`, in your Flask application's configuration. Another way is to remove or modify the default logging configuration to suit your specific needs.
diff --git a/data/guides/full-stack-observability-essentials.mdx b/data/guides/full-stack-observability-essentials.mdx
index cb80a7bfa..1e22809d4 100644
--- a/data/guides/full-stack-observability-essentials.mdx
+++ b/data/guides/full-stack-observability-essentials.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Full-Stack Observability Essentials - A Comprehensive Guide
-slug: full-stack-observability-essentials
 date: 2024-08-14
 tags: [observability]
 authors: [soumya_gupta]
 description: Discover the essentials of full-stack observability, its importance in modern IT, and how to implement it effectively for improved system reliability and performance.
-keywords: [full-stack observability, monitoring, logs, metrics, traces, OpenTelemetry, distributed systems, observability tools]
-
+keywords:
+  [
+    full-stack observability,
+    monitoring,
+    logs,
+    metrics,
+    traces,
+    OpenTelemetry,
+    distributed systems,
+    observability tools,
+  ]
 ---
 
 Full-stack observability is a crucial aspect of modern IT environments. It provides a holistic view of your entire technology stack, enabling you to identify and resolve issues quickly. This comprehensive guide will walk you through the essentials of full-stack observability, its key components, and how to implement it effectively in your organization.
@@ -22,7 +29,11 @@ Once configured with your application, you can simply open its dashboard. The FS
 
 FSO helps us to reduce mean time to resolution (MTTR) and minimize downtime, which leads to money savings.
 
-<Figure src="/img/guides/2024/08/full-stack-observability-essentials-a4633214-86f1-48a1-9e41-a901969966b0.webp" alt="SigNoz Dashboard for visualizing Full Stack Observability" caption="SigNoz Dashboard for visualizing Full Stack Observability" />
+<Figure
+  src="/img/guides/2024/08/full-stack-observability-essentials-a4633214-86f1-48a1-9e41-a901969966b0.webp"
+  alt="SigNoz Dashboard for visualizing Full Stack Observability"
+  caption="SigNoz Dashboard for visualizing Full Stack Observability"
+/>
 
 The three pillars of full-stack observability are:
 
@@ -36,99 +47,105 @@ Installing the FSO on your organization's infrastructure and configuring your fi
 
 Let's dive deeper into the three key components of full-stack observability:
 
-<Figure src="/img/guides/2024/08/full-stack-observability-essentials-Untitled.webp" alt="Three Pillars of Observability" caption="Three Pillars of Observability" />
+<Figure
+  src="/img/guides/2024/08/full-stack-observability-essentials-Untitled.webp"
+  alt="Three Pillars of Observability"
+  caption="Three Pillars of Observability"
+/>
 
 1. Logs: These are time-stamped records of events in your system. Logs provide context for what's happening in your application. They include details such as:
-    - Error messages
-    - User actions
-    - System events
-    
-    Example log entry:
-    
-    ```
-    2023-05-12 14:30:15 [INFO] User 'john_doe' logged in successfully
-    
-    ```
-    
-       
-    
-    Logs frequently contain intricate details about how an application processes requests therefore parsing logs can also reveal valuable insights into the application's performance.
-    An effective observability solution should enable log analysis and facilitate the capture of log data and its correlation with metric and trace data, especially for security-related incidents.
-    Good logging practice is also vital to power an observability platform across your system; thus, we have some log management practices, which include log generation, collection, storage, and retention. Often, it’s recommended to use a machine learning optimization tool to ensure that you aren’t paying more for your logs than you need to. One of the best practices that enhances the role of logs in observability is log aggregation.
-    
-    Imagine facing an outage where you’re trying to SSH into multiple servers to manually pinpoint the root cause and piece together the issue. On the other hand, imagine having a system where all your logs are systematically collated and centralized in a [log management service](https://signoz.io/blog/logging-as-a-service/), allowing for a swift, comprehensive overview and efficient troubleshooting.
-    
-    Log aggregation is a powerful way to remove the “noise” from a complex system as a result of a distributed system. Log aggregation can bring the scattered logs into a centralized repository for easier access, monitoring, and analysis.
-    
-    A prerequisite of log aggregation is ensuring functional and structured log generation from the system. The following list depicts the requirements of log aggregation:
-    
-    1. Log sources: Identify the log sources you need to aggregate (Application logs, Database logs, Security logs, etc.) to ensure complete and desired visibility
-    2. Log management solution: Determine the destinations and methods for sending logs collected from different sources.
-    3. Log Collection: Devise an aggregation strategy for your desired needs for automatic collection and transportation of data. Construct an automated logging pipeline for collecting, parsing, and shipping the logs, or configure your application's logging framework for transmitting logs.
-    4. Parsing, filtering, and transmitting the logs: Often, logs are sent to different systems via Pipeline wherein distinct systems might have different logging standards, which is why it is necessary to change them into a format that is common enough to make log analysis and correlation once the data is centralized. Parsing rules for log collection, filtering out irrelevant or sensitive data, standardizing key attributes, sampling logs to remove duplicates, normalizing field names and attributes, and structuring data in a format can help fulfill that goal.
-    5. Logs Centralization: Once logs are collected and processed, it is time for them to be monitored, analyzed, and alerted. To reduce data loss and maintain data integrity during aggregations due to any possible interruptions, consider employing a queuing mechanism.
+
+   - Error messages
+   - User actions
+   - System events
+
+   Example log entry:
+
+   ```
+   2023-05-12 14:30:15 [INFO] User 'john_doe' logged in successfully
+
+   ```
+
+   Logs frequently contain intricate details about how an application processes requests therefore parsing logs can also reveal valuable insights into the application's performance.
+   An effective observability solution should enable log analysis and facilitate the capture of log data and its correlation with metric and trace data, especially for security-related incidents.
+   Good logging practice is also vital to power an observability platform across your system; thus, we have some log management practices, which include log generation, collection, storage, and retention. Often, it’s recommended to use a machine learning optimization tool to ensure that you aren’t paying more for your logs than you need to. One of the best practices that enhances the role of logs in observability is log aggregation.
+
+   Imagine facing an outage where you’re trying to SSH into multiple servers to manually pinpoint the root cause and piece together the issue. On the other hand, imagine having a system where all your logs are systematically collated and centralized in a [log management service](https://signoz.io/blog/logging-as-a-service/), allowing for a swift, comprehensive overview and efficient troubleshooting.
+
+   Log aggregation is a powerful way to remove the “noise” from a complex system as a result of a distributed system. Log aggregation can bring the scattered logs into a centralized repository for easier access, monitoring, and analysis.
+
+   A prerequisite of log aggregation is ensuring functional and structured log generation from the system. The following list depicts the requirements of log aggregation:
+
+   1. Log sources: Identify the log sources you need to aggregate (Application logs, Database logs, Security logs, etc.) to ensure complete and desired visibility
+   2. Log management solution: Determine the destinations and methods for sending logs collected from different sources.
+   3. Log Collection: Devise an aggregation strategy for your desired needs for automatic collection and transportation of data. Construct an automated logging pipeline for collecting, parsing, and shipping the logs, or configure your application's logging framework for transmitting logs.
+   4. Parsing, filtering, and transmitting the logs: Often, logs are sent to different systems via Pipeline wherein distinct systems might have different logging standards, which is why it is necessary to change them into a format that is common enough to make log analysis and correlation once the data is centralized. Parsing rules for log collection, filtering out irrelevant or sensitive data, standardizing key attributes, sampling logs to remove duplicates, normalizing field names and attributes, and structuring data in a format can help fulfill that goal.
+   5. Logs Centralization: Once logs are collected and processed, it is time for them to be monitored, analyzed, and alerted. To reduce data loss and maintain data integrity during aggregations due to any possible interruptions, consider employing a queuing mechanism.
+
 2. Metrics: These are numerical measurements of your system's performance over time. Metrics help you understand trends and patterns in your system's behavior. Common metrics include:
-    - CPU usage
-    - Memory consumption
-    - Request latency
-    - Response time
-    - Error Rates
-    
-    The collected metrics depend upon your systems, configurations as well as needs. However, there are four most common metrics that are considered essential for observability:
-    
-    - Latency: Total time it takes for a request to be processed.
-    - Saturation: The way resources are used. (CPU or memory usage)
-    - Traffic: The volume and flow of requests in the system.
-    - Errors: Rate of errors and exceptions that occurred in the system.
-    
-    Example metric:
-    
-    ```
-    http_requests_total{method="GET", endpoint="/api/users"} 1234
-    
-    ```
-    
-    Metrics can help in quickly identifying the scope and impact during an incident. After the issue is resolved, the root cause can be revealed through a detailed analysis which is why they are useful in the case of performance monitoring for Full Stack Observability. 
-    
-    - Firstly, for being instrumental in performance optimization and tuning, as they pinpoint performance bottlenecks within an application's subsystems by tracking latency and throughput helping the user make informed decisions about where to allocate resources for maximum impact.
-    - Secondly since querying a time-series database is relatively faster than querying log data it proves to be a more efficient means of generating alerts
-    - Metrics can also prove useful in the case of business intelligence as we can get valuable insights into customer preferences via metrics related to user engagement, feature usage, etc.
+
+   - CPU usage
+   - Memory consumption
+   - Request latency
+   - Response time
+   - Error Rates
+
+   The collected metrics depend upon your systems, configurations as well as needs. However, there are four most common metrics that are considered essential for observability:
+
+   - Latency: Total time it takes for a request to be processed.
+   - Saturation: The way resources are used. (CPU or memory usage)
+   - Traffic: The volume and flow of requests in the system.
+   - Errors: Rate of errors and exceptions that occurred in the system.
+
+   Example metric:
+
+   ```
+   http_requests_total{method="GET", endpoint="/api/users"} 1234
+
+   ```
+
+   Metrics can help in quickly identifying the scope and impact during an incident. After the issue is resolved, the root cause can be revealed through a detailed analysis which is why they are useful in the case of performance monitoring for Full Stack Observability.
+
+   - Firstly, for being instrumental in performance optimization and tuning, as they pinpoint performance bottlenecks within an application's subsystems by tracking latency and throughput helping the user make informed decisions about where to allocate resources for maximum impact.
+   - Secondly since querying a time-series database is relatively faster than querying log data it proves to be a more efficient means of generating alerts
+   - Metrics can also prove useful in the case of business intelligence as we can get valuable insights into customer preferences via metrics related to user engagement, feature usage, etc.
+
 3. Traces: These track the journey of a request through your system, especially in distributed architectures. Traces help you understand:
-    - The path of a request
-    - Time spent in each component
-    - Bottlenecks in your system
-    - Sequences of Services
-    
-    In environments characterized by distributed architectures, tracing is critical in understanding and optimizing complex software systems
-    
-    Let’s consider a scenario wherein you’d like to see the impact of cache hits and misses. You can perform sampling a fraction of user HTTP requests and analyze the time allocations for interactions with underlying systems like databases and caches by tracing.
-    
-    It provides insights into the operational dynamics of an application without overwhelming the system with data since it considers specific functions or requests of interest tracks their execution time and allows you to understand the intricate paths requests take, including interactions with databases and caches, and how these interactions influence overall response times. While metrics analysis focuses on overall system health and efficiency, [distributed tracing](https://signoz.io/blog/distributed-tracing/) dives deeper into interactions between services within a distributed architecture. It uses unique IDs for requests across remote procedure calls (RPCs), gathering trace data from various processes and servers. This allows for tracking how requests move through different parts of the system, providing a comprehensive view of their journey across service boundaries. This approach enhances visibility and simplifies monitoring and troubleshooting in complex, distributed environments, and microservice architectures, where requests travel through multiple loosely coupled services.
-    
-    Note: A distributed trace consists of several spans, each representing a fundamental unit that captures a specific operation within a distributed system. These operations can range from an HTTP request to a database call or the processing of a message from a queue.
-    
-    Example trace visualization:
-    
-    ```
-    [Frontend] --> [API Gateway] --> [User Service] --> [Database]
-       10ms          20ms             50ms              30ms
-    
-    ```
-    
+
+   - The path of a request
+   - Time spent in each component
+   - Bottlenecks in your system
+   - Sequences of Services
+
+   In environments characterized by distributed architectures, tracing is critical in understanding and optimizing complex software systems
+
+   Let’s consider a scenario wherein you’d like to see the impact of cache hits and misses. You can perform sampling a fraction of user HTTP requests and analyze the time allocations for interactions with underlying systems like databases and caches by tracing.
+
+   It provides insights into the operational dynamics of an application without overwhelming the system with data since it considers specific functions or requests of interest tracks their execution time and allows you to understand the intricate paths requests take, including interactions with databases and caches, and how these interactions influence overall response times. While metrics analysis focuses on overall system health and efficiency, [distributed tracing](https://signoz.io/blog/distributed-tracing/) dives deeper into interactions between services within a distributed architecture. It uses unique IDs for requests across remote procedure calls (RPCs), gathering trace data from various processes and servers. This allows for tracking how requests move through different parts of the system, providing a comprehensive view of their journey across service boundaries. This approach enhances visibility and simplifies monitoring and troubleshooting in complex, distributed environments, and microservice architectures, where requests travel through multiple loosely coupled services.
+
+   Note: A distributed trace consists of several spans, each representing a fundamental unit that captures a specific operation within a distributed system. These operations can range from an HTTP request to a database call or the processing of a message from a queue.
+
+   Example trace visualization:
+
+   ```
+   [Frontend] --> [API Gateway] --> [User Service] --> [Database]
+      10ms          20ms             50ms              30ms
+
+   ```
 
 By correlating these components, you gain comprehensive insights into your system's behavior and performance.
 
-These components have complementary roles with each other, for instance, you can detect a problem through metrics, diagnose it with logs, and use tracing to understand the flow of requests that led to the issue. while metrics are ideal for recording event occurrences and reporting the status of resources (CPU and memory, logs are ideal for capturing detailed narratives of events and traces are useful in visualizing the journey of a request as it moves through various services in a microservices setup, requiring a unique identifier for each trace to ensure traceability. 
+These components have complementary roles with each other, for instance, you can detect a problem through metrics, diagnose it with logs, and use tracing to understand the flow of requests that led to the issue. while metrics are ideal for recording event occurrences and reporting the status of resources (CPU and memory, logs are ideal for capturing detailed narratives of events and traces are useful in visualizing the journey of a request as it moves through various services in a microservices setup, requiring a unique identifier for each trace to ensure traceability.
 
 ## Why Full-Stack Observability is Essential
 
 Modern software architectures are increasingly complex. Microservices, serverless functions, and distributed systems have made traditional monitoring approaches insufficient.
 
-Nowadays it is essential to possess detailed structured data about your applications for the sake of making sure they operate at optimal performance. More companies are taking a shift to microservice architecture for granular scaling of individual components and distributed systems for the sake of spreading workloads and reducing the impact of single points of failure along with elastic scaling. Each microservice produces its own set of logs which increases data volume. Not only this, usage of multiple containers on top of every Virtual machine (VM) also contributes to an increasing data volume since they have multiple labels and are changing oftentimes as it leads to new metrics adding onto the data. This increasing volume of data makes the system complex and filled with “noise”. 
+Nowadays it is essential to possess detailed structured data about your applications for the sake of making sure they operate at optimal performance. More companies are taking a shift to microservice architecture for granular scaling of individual components and distributed systems for the sake of spreading workloads and reducing the impact of single points of failure along with elastic scaling. Each microservice produces its own set of logs which increases data volume. Not only this, usage of multiple containers on top of every Virtual machine (VM) also contributes to an increasing data volume since they have multiple labels and are changing oftentimes as it leads to new metrics adding onto the data. This increasing volume of data makes the system complex and filled with “noise”.
 
 A Full Stack Observability platform solves this issue to provide a comprehensive view into all the systems and get the most value out of the humongous amount of collected and stored data.
 
- Full-stack observability addresses these challenges by:
+Full-stack observability addresses these challenges by:
 
 1. Improving system reliability: You can quickly identify and resolve issues before they impact users.
 2. Enhancing performance: Detailed insights allow you to optimize your system for better performance.
@@ -141,9 +158,9 @@ For example, imagine an e-commerce platform experiencing slow response times. Wi
 - Analyze traces to find slow database queries: As we read earlier, traces provide a detailed view of the execution path of requests through the system which can help in identifying bottlenecks by showing the time spent in each component, such as API calls, database queries, and external service interactions.
 - Review logs to spot any error messages or unusual patterns: We can first aggregate logs from various sources while making sure they're indexed for efficient filtering and searching and then review these logs on a regular basis either by setting up alerts for critical level errors or using ML algorithms to detect anomalies in log patterns.
 
-Full Stack Observability enables you to quickly diagnose and resolve the issue, minimizing downtime as well as improving user experience. 
+Full Stack Observability enables you to quickly diagnose and resolve the issue, minimizing downtime as well as improving user experience.
 
-Imagine you’re operating a web application, and you encounter an error message that causes the site to go down. The time between the issue occurring and its resolution is called Mean Time to Resolution (MTTR). 
+Imagine you’re operating a web application, and you encounter an error message that causes the site to go down. The time between the issue occurring and its resolution is called Mean Time to Resolution (MTTR).
 
 The purpose of every organization is to minimize MTTR as it determines the overall quality as well as stability of your application. Because of the complex and distributed applications used these days troubleshooting such an error while minimizing MTTR can prove to be quite a challenge especially if the applications are run on multiple hosting environments and are distributed around the world with each request routed to different instances. Tracking down certain requests without knowing what exactly is happening within the architecture or knowing where the issue exists can prove to be quite meaningless with the use of FSO tools.
 
@@ -151,46 +168,48 @@ The purpose of every organization is to minimize MTTR as it determines the overa
 
 Implementing full-stack observability requires a strategic approach. Here's a step-by-step guide to get you started:
 
-1. Assess your current monitoring capabilities: 
-    - Identify gaps in your existing monitoring setup: Depending on your organization's needs, one monitoring system may address all of your use cases, or you may want to use a combination of systems such as:
-        - Speed: for an organization, the speed and freshness of data, as well as the speed of data retrieval, are crucial factors. Freshness impacts your Mean Time to Resolution (MTTR), as outdated data might lead to incorrect decisions. If there is a long delay between an action (the cause) and seeing its impact in your monitoring (the effect), you might mistakenly think a change had no effect or draw false correlations between cause and effect. When dealing with large amounts of data, faster retrieval speeds can enhance performance.
-            
-            <Figure src="/img/guides/2024/08/full-stack-observability-essentials-Untitled%201.webp" alt="SigNoz insertion speed(count/sec)" caption="SigNoz insertion speed(count/sec)" />
-            
-            *SigNoz insertion speed(count/sec)*
-            
-            For example, speeding up slower graphs is easier if the monitoring system can create   and store new time series based on incoming data, allowing it to precompute answers to common queries.
-            
-        - Alerts: Classifying alerts according to their severity allows for proportional responses and helps avoid unnecessary noise that can distract on-call engineers. For example, if all nodes are experiencing the same high error rate, you can send a single alert for the global error rate instead of individual alerts for each node.
-        - Interfaces: A robust monitoring system should display time-series data in graphs and structure data in tables or various chart styles. Different audiences, such as management and SREs, require different views of the same data. You may need to graph metrics across different aggregations—like machine type, server version, or request type—in real-time. Your team should be comfortable performing ad hoc drilldowns to identify correlations and patterns in the data.
-    - Determine which components of your stack lack visibility: Using dependency analysis tools like OpenTelemetry, we can analyze dependencies and visualize trace data, highlighting areas with missing traces or incomplete monitoring. Application Performance Monitoring (APM) tools provide a holistic view of your stack's performance and identify areas lacking visibility. Additionally, collaborating with SREs, developers, and operations teams helps gather insights on known visibility issues.
+1. Assess your current monitoring capabilities:
+   - Identify gaps in your existing monitoring setup: Depending on your organization's needs, one monitoring system may address all of your use cases, or you may want to use a combination of systems such as:
+     - Speed: for an organization, the speed and freshness of data, as well as the speed of data retrieval, are crucial factors. Freshness impacts your Mean Time to Resolution (MTTR), as outdated data might lead to incorrect decisions. If there is a long delay between an action (the cause) and seeing its impact in your monitoring (the effect), you might mistakenly think a change had no effect or draw false correlations between cause and effect. When dealing with large amounts of data, faster retrieval speeds can enhance performance.
+       {' '}
+       <Figure
+         src="/img/guides/2024/08/full-stack-observability-essentials-Untitled%201.webp"
+         alt="SigNoz insertion speed(count/sec)"
+         caption="SigNoz insertion speed(count/sec)"
+       />
+       *SigNoz insertion speed(count/sec)* For example, speeding up slower graphs is easier if the
+       monitoring system can create and store new time series based on incoming data, allowing it to
+       precompute answers to common queries.
+     - Alerts: Classifying alerts according to their severity allows for proportional responses and helps avoid unnecessary noise that can distract on-call engineers. For example, if all nodes are experiencing the same high error rate, you can send a single alert for the global error rate instead of individual alerts for each node.
+     - Interfaces: A robust monitoring system should display time-series data in graphs and structure data in tables or various chart styles. Different audiences, such as management and SREs, require different views of the same data. You may need to graph metrics across different aggregations—like machine type, server version, or request type—in real-time. Your team should be comfortable performing ad hoc drilldowns to identify correlations and patterns in the data.
+   - Determine which components of your stack lack visibility: Using dependency analysis tools like OpenTelemetry, we can analyze dependencies and visualize trace data, highlighting areas with missing traces or incomplete monitoring. Application Performance Monitoring (APM) tools provide a holistic view of your stack's performance and identify areas lacking visibility. Additionally, collaborating with SREs, developers, and operations teams helps gather insights on known visibility issues.
 2. Select appropriate observability tools:
-    - Consider open-source options like [SigNoz](https://signoz.io/docs/introduction/) for metrics, as it provides quantifiable data points commonly used to monitor cloud infrastructure, signaling when and where problems occur and, Jaeger for tracing to visualize the chain of events in microservice interactions and isolate issues when something goes wrong. Jaeger, also known as Jaeger Tracing, follows the path of a request through a series of microservice interactions.
-    - Evaluate commercial platforms that offer integrated solutions, such as O11y, SigNoz, DataDog, etc., based on various factors such as if it can help you troubleshoot quickly without a detailed knowledge of the codebase for the person using it or if it helps you identify the error before the customer does.
+   - Consider open-source options like [SigNoz](https://signoz.io/docs/introduction/) for metrics, as it provides quantifiable data points commonly used to monitor cloud infrastructure, signaling when and where problems occur and, Jaeger for tracing to visualize the chain of events in microservice interactions and isolate issues when something goes wrong. Jaeger, also known as Jaeger Tracing, follows the path of a request through a series of microservice interactions.
+   - Evaluate commercial platforms that offer integrated solutions, such as O11y, SigNoz, DataDog, etc., based on various factors such as if it can help you troubleshoot quickly without a detailed knowledge of the codebase for the person using it or if it helps you identify the error before the customer does.
 3. Instrument your applications and infrastructure:
-    - Use logging libraries to generate structured logs which can help in maintaining and easy parsing of the log records for diagnosing issues. You can structure your logs using handlers, formatters, or by using the `structlog` library
-    - Implement metrics collection in your code and infrastructure since they help understand trends, identify anomalies, and make informed decisions to optimize performance.
-    - Add tracing to track requests across your distributed system improves visibility and makes it easier to monitor and troubleshoot in complex, distributed setups as well as within microservice architectures, where requests traverse multiple loosely coupled service
+   - Use logging libraries to generate structured logs which can help in maintaining and easy parsing of the log records for diagnosing issues. You can structure your logs using handlers, formatters, or by using the `structlog` library
+   - Implement metrics collection in your code and infrastructure since they help understand trends, identify anomalies, and make informed decisions to optimize performance.
+   - Add tracing to track requests across your distributed system improves visibility and makes it easier to monitor and troubleshoot in complex, distributed setups as well as within microservice architectures, where requests traverse multiple loosely coupled service
 4. Create a culture of observability:
-    - Train your team on the importance of observability. The journey to full-stack observability begins with building internal support for IT teams. Communicating the value of full-stack observability and the benefits for cybersecurity, compliance, and cloud cost optimization to business and technical stakeholders is encouraged. Use informative content and informal meetings to help them understand the benefits and secure budget support for these initiatives.
-    - Encourage developers to add meaningful logs and metrics. A data-centric approach that relies on contextual information can help organizations to "connect the dots" and make informed decisions. Poor data quality leads to incorrect conclusions and decision-making, affecting business outcomes and network performance. Therefore, it is essential to prioritize data quality and maintain it by using proper tools and processes to validate and verify data accuracy, consistency, and completeness.
-    - Integrate observability throughout the development lifecycle to ensure end-to-end visibility by incorporating instrumentation in the design, planning, testing, deployment, and maintenance phases. By embedding observability into the development process, organizations can identify and address issues before they escalate. It also enhances system performance by pinpointing bottlenecks and optimization opportunities, improves security by detecting anomalous behavior and vulnerabilities, and enables teams to make informed decisions based on real-time data and analytics, leading to more efficient and effective development practices.
+   - Train your team on the importance of observability. The journey to full-stack observability begins with building internal support for IT teams. Communicating the value of full-stack observability and the benefits for cybersecurity, compliance, and cloud cost optimization to business and technical stakeholders is encouraged. Use informative content and informal meetings to help them understand the benefits and secure budget support for these initiatives.
+   - Encourage developers to add meaningful logs and metrics. A data-centric approach that relies on contextual information can help organizations to "connect the dots" and make informed decisions. Poor data quality leads to incorrect conclusions and decision-making, affecting business outcomes and network performance. Therefore, it is essential to prioritize data quality and maintain it by using proper tools and processes to validate and verify data accuracy, consistency, and completeness.
+   - Integrate observability throughout the development lifecycle to ensure end-to-end visibility by incorporating instrumentation in the design, planning, testing, deployment, and maintenance phases. By embedding observability into the development process, organizations can identify and address issues before they escalate. It also enhances system performance by pinpointing bottlenecks and optimization opportunities, improves security by detecting anomalous behavior and vulnerabilities, and enables teams to make informed decisions based on real-time data and analytics, leading to more efficient and effective development practices.
 
 ### Overcoming Common Challenges
 
 As you implement full-stack observability, you may encounter some challenges:
 
 1. Data silos: Logs, metrics, and traces frequently originate from different sources and systems, resulting in data silos. Aggregating and correlating this disparate data to achieve a unified view can be challenging. This fragmentation can lead to reduced visibility and collaboration across organizations, delay incident response times, and diminish the overall effectiveness of observability practices.
-    
-    To address this, opt for cross-functional collaboration between teams responsible for network infrastructure, application development, and operations to enhance understanding of network performance and expedite problem resolution. Additionally, integrate observability tools to provide a cohesive view of your system.
-    
-2. Data volume: As we discussed earlier distributed cloud-based systems as each microservice might produce its own set of logs, which can lead to a higher volume of data and delayed response. We can resolve this by implementing sampling, filtering, aggregation and, retention of data as well as advanced querying to manage large volumes of data without losing important information. 
+
+   To address this, opt for cross-functional collaboration between teams responsible for network infrastructure, application development, and operations to enhance understanding of network performance and expedite problem resolution. Additionally, integrate observability tools to provide a cohesive view of your system.
+
+2. Data volume: As we discussed earlier distributed cloud-based systems as each microservice might produce its own set of logs, which can lead to a higher volume of data and delayed response. We can resolve this by implementing sampling, filtering, aggregation and, retention of data as well as advanced querying to manage large volumes of data without losing important information.
 3. Effective visualization: Design dashboards to deliver clear, actionable insights at a glance. Effective data visualization and interpretation require integrating anomaly detection. Start by identifying anomalies through log observability, and once your logs are aggregated, use machine learning tools like Flow Anomaly or Error Volume Anomaly to detect deviations from the norm. To manage micro-releases on customer-facing platforms, incorporate Benchmark Reports and Version Tags to trace each system change, assess its impact, and visualize the outcomes.
 4. Privacy and security: Ensure that your observability practices comply with data protection regulations and security best practices. Implement strong data governance practices, including data anonymization, compliance audits, secure data storage, and transport mechanisms, to reduce the risk of sensitive data being exposed to unauthorized parties during observability processes. Establish clear data usage policies and access rights to ensure adherence to international standards and compliance regulations, such as GDPR and HIPAA.
 
 ## Leveraging OpenTelemetry for Full-Stack Observability
 
-OpenTelemetry is an open-source project that provides a standardized approach to observability.  It aims to address the fragmentation and complexity of how telemetry data is collected and processed in distributed systems. It seeks to replace the myriads of proprietary agents and formats with a unified, vendor-neutral, and open-source standard for instrumenting applications, collecting signals (traces, metrics, and logs), and exporting them to various analysis backends and enables seamless integration with multiple monitoring and observability platforms. 
+OpenTelemetry is an open-source project that provides a standardized approach to observability. It aims to address the fragmentation and complexity of how telemetry data is collected and processed in distributed systems. It seeks to replace the myriads of proprietary agents and formats with a unified, vendor-neutral, and open-source standard for instrumenting applications, collecting signals (traces, metrics, and logs), and exporting them to various analysis backends and enables seamless integration with multiple monitoring and observability platforms.
 
 Note: OpenTelemetry focuses solely on collecting and delivering telemetry data, leaving the generation of actionable insights to dedicate analysis tools and platforms.
 
@@ -204,31 +223,36 @@ The most common types of telemetry data include:
 - Events: are structured records that contains contextual information about what it took to complete a unit of work in an application (commonly a single HTTP transaction).
 - Profiles: provides insights into resource usage (CPU, memory, etc.) within the context of code execution.
 
- The framework is centered around several key components: the OpenTelemetry API, SDK, and Collector. These elements work together to generate, collect, and export telemetry data to various backends.
+The framework is centered around several key components: the OpenTelemetry API, SDK, and Collector. These elements work together to generate, collect, and export telemetry data to various backends.
 
 It offers:
 
 - A unified SDK, API, and data specification are used for instrumenting your code. The API outlines the data types and programming interfaces for creating and manipulating telemetry data across various languages to ensure consistency in data generation and handling. The SDK implements the OpenTelemetry API in various languages, handling tasks like sampling, [context propagation](https://signoz.io/blog/opentelemetry-context-propagation/), processing, and exporting telemetry data. It also supports automatic instrumentation via integrations and agents which helps in minimizing manual coding to capture metrics and traces. The data specification includes a vendor-agnostic protocol (OTLP) for transmitting telemetry data within the OpenTelemetry ecosystem. It defines data formats, semantic conventions, and communication mechanisms for telemetry signals, ensuring consistency and simplifying data analysis and correlation.
 - A collector is used for processing and exporting telemetry data, serving as an intermediary between your instrumented applications and the backend systems where you analyze and visualize your data. It operates as a standalone binary process (which can function as a proxy or sidecar) that receives telemetry data in various formats, processes and filters it, and then sends it to one or more configured observability backends.
-    
-    <Figure src="/img/guides/2024/08/full-stack-observability-essentials-Untitled%202.webp" alt="OTel Collector visual depiction" caption="OTel Collector visual depiction" />
-    
-    The OpenTelemetry Collector’s receiver is used to get data into the OTel Collector. If you’re sending out instrumentation data from your application code, you would use the native OpenTelemetry Protocol (OTLP) format, which means that you’ll be using the OTLP receiver.
-    
-    If you’re receiving metrics data from your infrastructure in some different data format (e.g. satsd, Jaeger, Prometheus), you’ll need to use a receiver that ingests that format to convert it to OTLP. The OTel Collector sends data to multiple back-ends by way of exporters. These translate OTLP to a vendor-specific back-end format.
-    
-    - Receivers: ingests telemetry data in different formats from various sources.
-    - Processors: to process the ingested telemetry data by filtering, aggregating, enriching or, transforming it.
-    - Exporters: to deliver the processed data to one or more observability backends in a desired format.
-    - Connectors: for bridging different pipelines within the Collector, facilitating seamless data flow and transformation between them. They function as both exporters for one pipeline and receivers for another.
-    - Extensions: provide additional functionality such as health checks, profiling, and configuration management. They do not require direct access to telemetry data.
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/full-stack-observability-essentials-Untitled%202.webp"
+    alt="OTel Collector visual depiction"
+    caption="OTel Collector visual depiction"
+  />
+  The OpenTelemetry Collector’s receiver is used to get data into the OTel Collector. If you’re
+  sending out instrumentation data from your application code, you would use the native
+  OpenTelemetry Protocol (OTLP) format, which means that you’ll be using the OTLP receiver. If
+  you’re receiving metrics data from your infrastructure in some different data format (e.g. satsd,
+  Jaeger, Prometheus), you’ll need to use a receiver that ingests that format to convert it to OTLP.
+  The OTel Collector sends data to multiple back-ends by way of exporters. These translate OTLP to a
+  vendor-specific back-end format. - Receivers: ingests telemetry data in different formats from
+  various sources. - Processors: to process the ingested telemetry data by filtering, aggregating,
+  enriching or, transforming it. - Exporters: to deliver the processed data to one or more
+  observability backends in a desired format. - Connectors: for bridging different pipelines within
+  the Collector, facilitating seamless data flow and transformation between them. They function as
+  both exporters for one pipeline and receivers for another. - Extensions: provide additional
+  functionality such as health checks, profiling, and configuration management. They do not require
+  direct access to telemetry data.
 - Vendor-agnostic instrumentation, allows you to switch between different observability backends, in other words, the code you write using [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) and API is vendor-agnostic, meaning it is compatible with any backend supported by OpenTelemetry like Jaeger, Prometheus, Datadog, etc.
 - The OpenTelemetry Protocol (OTLP) is a vendor-neutral, open-source specification for encoding, transporting, and delivering telemetry data between different components within the OpenTelemetry ecosystem.
-    
-    It facilitates seamless communication across various parts of your [observability stack](https://signoz.io/guides/observability-stack/), regardless of the specific tools or platforms you use. This flexibility helps avoid vendor lock-in and allows you to select the tools that best meet your needs.
-    
-    Note: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) supports ingesting data in other protocols through appropriate receivers, and it can convert data from one format to another to simplify integration with different backends
-    
+  It facilitates seamless communication across various parts of your [observability stack](https://signoz.io/guides/observability-stack/), regardless of the specific tools or platforms you use. This flexibility helps avoid vendor lock-in and allows you to select the tools that best meet your needs.
+  Note: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) supports ingesting data in other protocols through appropriate receivers, and it can convert data from one format to another to simplify integration with different backends
 
 To implement OpenTelemetry:
 
@@ -245,8 +269,8 @@ Refer to our previous articles for a detailed step-by-step instruction on how to
 - Java - [https://signoz.io/opentelemetry/java-agent/](https://signoz.io/opentelemetry/java-agent/)
 
   By standardizing data formats and transmission, OpenTelemetry facilitates seamless integration with various monitoring and observability platforms. This ensures that organizations are not tied to a specific vendor or proprietary solution, allowing them to choose the best tools for their needs.
-OpenTelemetry allows the collection of telemetry data from diverse sources and export to multiple platforms with minimal configuration changes, enabling you to switch to the desired backend and providing insights using desired tools/formats, thereby avoiding vendor lock-in
-OpenTelemetry’s flexibility in handling data such as aggregating, enriching, filtering, and processing telemetry data before export, optimizes data flow and minimizes the resource impact on instrumented applications.
+  OpenTelemetry allows the collection of telemetry data from diverse sources and export to multiple platforms with minimal configuration changes, enabling you to switch to the desired backend and providing insights using desired tools/formats, thereby avoiding vendor lock-in
+  OpenTelemetry’s flexibility in handling data such as aggregating, enriching, filtering, and processing telemetry data before export, optimizes data flow and minimizes the resource impact on instrumented applications.
 
 ## A Better Way to Think About Observability
 
@@ -292,4 +316,4 @@ Yes, full-stack observability can help identify underutilized resources, perform
 
 Consider factors such as ease of integration, scalability, data retention capabilities, visualization features, and support for your technology stack when selecting observability tools.
 
-##
\ No newline at end of file
+##
diff --git a/data/guides/game-server-monitoring.mdx b/data/guides/game-server-monitoring.mdx
index 240665e93..0f113e534 100644
--- a/data/guides/game-server-monitoring.mdx
+++ b/data/guides/game-server-monitoring.mdx
@@ -1,6 +1,5 @@
 ---
 title: Essential Guide to Game Server Monitoring - Boost Performance
-slug: game-server-monitoring
 date: 2025-01-09
 tags: [monitoring]
 authors: [niyati_thakkar]
diff --git a/data/guides/generating-range-vectors-from-return-values-in-prometheus-queries.mdx b/data/guides/generating-range-vectors-from-return-values-in-prometheus-queries.mdx
index 4d3264836..ef97356e2 100644
--- a/data/guides/generating-range-vectors-from-return-values-in-prometheus-queries.mdx
+++ b/data/guides/generating-range-vectors-from-return-values-in-prometheus-queries.mdx
@@ -1,13 +1,18 @@
 ---
-
-title: How to Create Range Vectors in Prometheus Queries 
-slug: generating-range-vectors-from-return-values-in-prometheus-queries
+title: How to Create Range Vectors in Prometheus Queries
 date: 2024-11-20
 tags: [prometheus, faq]
 authors: [nitin_gouda]
 description: Learn how to create and use range vectors in Prometheus queries for effective time-series analysis. Includes practical examples and best practices.
-keywords: [range vectors prometheus, prometheus queries, time series analysis, prometheus monitoring, prometheus metrics, prometheus query optimization]
-
+keywords:
+  [
+    range vectors prometheus,
+    prometheus queries,
+    time series analysis,
+    prometheus monitoring,
+    prometheus metrics,
+    prometheus query optimization,
+  ]
 ---
 
 Range vectors in Prometheus allow you to analyze metric data over specific time periods. You create range vectors by adding a time duration selector `[d]` to your instant vector selectors. This fundamental concept enables you to perform time-series analysis, calculate rates of change, and identify trends in your metrics data.
@@ -29,9 +34,9 @@ Range vectors empower Prometheus to evaluate metrics in a more dynamic way, whic
 In Prometheus, instant vectors and range vectors are two distinct ways to query and analyze time-series data. Understanding their differences helps in selecting the right approach for specific monitoring or analytical needs.
 
 - Instant Vectors: An instant vector captures a snapshot of data at a single moment. They are ideal for real-time monitoring, where current metric values (e.g., CPU usage or memory utilization at a specific instant) are more relevant. For example:
-    - `http_requests_total`: Returns the current value of HTTP requests at the time of the query.
+  - `http_requests_total`: Returns the current value of HTTP requests at the time of the query.
 - Range Vectors: A range vector captures a series of data points over a specified time range. These values are then used to calculate trends, averages, or rates over time, making range vectors suitable for more in-depth analyses that require historical context. For example:
-    - `http_requests_total[5m]`: Returns the values of HTTP requests collected over the past 5 minutes.
+  - `http_requests_total[5m]`: Returns the values of HTTP requests collected over the past 5 minutes.
 
 These differences can help in determining whether you need single-point data (instant) or need to evaluate a trend over time (range).
 
@@ -55,7 +60,11 @@ node_cpu_seconds_total
 node_cpu_seconds_total[5m]
 ```
 
-<Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_11.52.45.webp" alt="Checking range vectors for `node_cpu_seconds_total` over 5 min" caption="Checking range vectors for `node_cpu_seconds_total` over 5 min" />
+<Figure
+  src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_11.52.45.webp"
+  alt="Checking range vectors for `node_cpu_seconds_total` over 5 min"
+  caption="Checking range vectors for `node_cpu_seconds_total` over 5 min"
+/>
 
 ### Common Use Cases for Range Vectors in Monitoring
 
@@ -98,29 +107,27 @@ metric_name[1y]   # Last year
 
 Selecting the right time range in Prometheus queries is essential for accurate monitoring and analysis. Here are some best practices to help you make the right choice:
 
-1. Align with Metric Frequency: 
-The time range should generally match the frequency of data collection for your metric.
-    - High-frequency metrics (e.g., per-second data) benefit from shorter time ranges (like 30s to 5m) for recent data aggregation.
-    - Low-frequency metrics (e.g., daily data) are better suited to longer time ranges, such as several hours or days.
-2. Consider Performance Impact: 
-Shorter time ranges generally return smaller data sets and are faster to query. As the time range grows, so does the amount of data Prometheus needs to process, which can increase query time and resource usage.
-3. Use Specific Time Durations for Alerting: 
-For alerts, choose time ranges that capture relevant patterns. For instance, if you’re monitoring a metric that typically fluctuates every few minutes, a 5-minute range may be ideal to avoid false positives.
-4. Experiment and Adapt: 
-Adjust the time range based on the specific behavior of the metrics you're tracking. Monitoring patterns often vary across systems, and a trial-and-error approach can help in finding the most effective time range for accurate insights.
+1. Align with Metric Frequency:
+   The time range should generally match the frequency of data collection for your metric. - High-frequency metrics (e.g., per-second data) benefit from shorter time ranges (like 30s to 5m) for recent data aggregation. - Low-frequency metrics (e.g., daily data) are better suited to longer time ranges, such as several hours or days.
+2. Consider Performance Impact:
+   Shorter time ranges generally return smaller data sets and are faster to query. As the time range grows, so does the amount of data Prometheus needs to process, which can increase query time and resource usage.
+3. Use Specific Time Durations for Alerting:
+   For alerts, choose time ranges that capture relevant patterns. For instance, if you’re monitoring a metric that typically fluctuates every few minutes, a 5-minute range may be ideal to avoid false positives.
+4. Experiment and Adapt:
+   Adjust the time range based on the specific behavior of the metrics you're tracking. Monitoring patterns often vary across systems, and a trial-and-error approach can help in finding the most effective time range for accurate insights.
 
 ### Impact of Time Range Selection on Query Performance
 
 Selecting an appropriate time range has a direct impact on query performance in Prometheus. Since Prometheus pulls multiple data points from the specified range, broader ranges increase the volume of data that needs to be processed. Here’s how time range selection can impact performance:
 
-1. Data Volume and Processing Time: 
-A larger time range means that Prometheus needs to retrieve and process a more extensive dataset. This can slow down the query and, depending on your server’s capacity, may affect the performance of other queries or tasks running concurrently. For example, querying a metric over `[1y]` pulls a year’s worth of data, which can take much longer than a query over `[5m]` or `[1h]`.
+1. Data Volume and Processing Time:
+   A larger time range means that Prometheus needs to retrieve and process a more extensive dataset. This can slow down the query and, depending on your server’s capacity, may affect the performance of other queries or tasks running concurrently. For example, querying a metric over `[1y]` pulls a year’s worth of data, which can take much longer than a query over `[5m]` or `[1h]`.
 2. Resource Utilization:
-Prometheus queries that process large time ranges consume more CPU and memory, especially for high-frequency metrics. If your Prometheus server has limited resources, you may experience lag or even timeouts when querying long periods for metrics collected at high rates. Optimizing time ranges ensures that Prometheus remains responsive and can continue collecting and storing data reliably.
+   Prometheus queries that process large time ranges consume more CPU and memory, especially for high-frequency metrics. If your Prometheus server has limited resources, you may experience lag or even timeouts when querying long periods for metrics collected at high rates. Optimizing time ranges ensures that Prometheus remains responsive and can continue collecting and storing data reliably.
 3. Balancing Detail and Query Speed:
-Narrower time ranges often produce faster query results, but they also limit the scope of the data being analyzed. It’s important to strike a balance between retrieving enough data for meaningful analysis and keeping queries fast and efficient. If you need insights on trends across both short and long periods, consider running separate queries with different time ranges or using roll-up metrics that aggregate data over longer intervals.
+   Narrower time ranges often produce faster query results, but they also limit the scope of the data being analyzed. It’s important to strike a balance between retrieving enough data for meaningful analysis and keeping queries fast and efficient. If you need insights on trends across both short and long periods, consider running separate queries with different time ranges or using roll-up metrics that aggregate data over longer intervals.
 4. Impact on Graph Readability:
-In tools like Grafana, using larger time ranges for fast-changing metrics can result in cluttered graphs with too much data to interpret easily. Selecting an appropriate time range helps create clearer visualizations that highlight trends without overwhelming the display.
+   In tools like Grafana, using larger time ranges for fast-changing metrics can result in cluttered graphs with too much data to interpret easily. Selecting an appropriate time range helps create clearer visualizations that highlight trends without overwhelming the display.
 
 ## Creating Basic Range Vector Queries
 
@@ -130,43 +137,37 @@ Range vectors are an essential part of Prometheus querying, enabling you to anal
 
 Follow these steps to construct and optimize range vector queries in Prometheus effectively:
 
-1. Identify the Metric: 
-The first step in constructing a range vector query is identifying the metric you want to analyze. Prometheus collects data as different metrics—like `http_requests_total` or `node_cpu_seconds_total`. Each metric represents a specific aspect of your system or application.
-2. Specify the Range Duration: 
-After identifying the metric, you need to decide how far back you want to look in time. This is defined as the range duration, which is added in square brackets (`[]`) after the metric name.
-    
-    For example:
-    
-    ```
-    rate(prometheus_http_requests_total[15m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-41d3241e-2ef0-4cf0-8b22-6d799eda4dfe.webp" alt="Checking range durations for 15mins for `prometheus_http_requests_tota`" caption="Checking range durations for 15mins for `prometheus_http_requests_tota`" />
-    
-    This range vector query retrieves `http_requests_total` data from the last 5 minutes.
-    
-3. Apply Aggregation Functions (If Needed):
-Functions like `rate`, `irate`, and `increase` are commonly used with range vectors to provide meaningful calculations based on the data over time. For instance, to calculate the rate of HTTP requests over a 5-minute window, you can use:
-    
-    ```
-    irate(prometheus_http_requests_total[15m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-1ff9062f-e309-42a1-950a-40d91010ec0b.webp" alt="Checking `prometheus_http_requests_total` with adding a function `irate`" caption="Checking `prometheus_http_requests_total` with adding a function `irate`" />
-    
-    This calculates the instantaneous rate of HTTP requests per second over the last 15 minutes based on the most recent counter increments.
-    
-4. Use Filters or Labels (Optional):
-[Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) often come with labels that provide additional context, such as `method="POST"` or `status="200"`. You can use these labels to filter data within a range vector query to target specific data.
-    
-    ```
-    rate(prometheus_http_requests_total{code="200"}[5m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-a4728e4f-53a2-4c6e-9b3b-308576b54c40.webp" alt="" caption="" />
-    
-    This query calculates the `code=200` requests only, helping you focus on specific metrics.
-    
+1.  Identify the Metric:
+    The first step in constructing a range vector query is identifying the metric you want to analyze. Prometheus collects data as different metrics—like `http_requests_total` or `node_cpu_seconds_total`. Each metric represents a specific aspect of your system or application.
+2.  Specify the Range Duration:
+    After identifying the metric, you need to decide how far back you want to look in time. This is defined as the range duration, which is added in square brackets (`[]`) after the metric name.
+        For example:
+
+        ```
+        rate(prometheus_http_requests_total[15m])
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-41d3241e-2ef0-4cf0-8b22-6d799eda4dfe.webp" alt="Checking range durations for 15mins for `prometheus_http_requests_tota`" caption="Checking range durations for 15mins for `prometheus_http_requests_tota`" />
+
+        This range vector query retrieves `http_requests_total` data from the last 5 minutes.
+3.  Apply Aggregation Functions (If Needed):
+    Functions like `rate`, `irate`, and `increase` are commonly used with range vectors to provide meaningful calculations based on the data over time. For instance, to calculate the rate of HTTP requests over a 5-minute window, you can use:
+        ```
+        irate(prometheus_http_requests_total[15m])
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-1ff9062f-e309-42a1-950a-40d91010ec0b.webp" alt="Checking `prometheus_http_requests_total` with adding a function `irate`" caption="Checking `prometheus_http_requests_total` with adding a function `irate`" />
+
+        This calculates the instantaneous rate of HTTP requests per second over the last 15 minutes based on the most recent counter increments.
+4.  Use Filters or Labels (Optional):
+    [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) often come with labels that provide additional context, such as `method="POST"` or `status="200"`. You can use these labels to filter data within a range vector query to target specific data.
+        ```
+        rate(prometheus_http_requests_total{code="200"}[5m])
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-a4728e4f-53a2-4c6e-9b3b-308576b54c40.webp" alt="" caption="" />
+
+        This query calculates the `code=200` requests only, helping you focus on specific metrics.
 
 Example of a Basic Range Vector Query
 
@@ -176,7 +177,11 @@ Let’s put it all together. Suppose you want to calculate the rate of CPU usage
 rate(node_cpu_seconds_total{instance="node-exporter:9100", mode="user"}[10m])
 ```
 
-<Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_19.23.50.webp" alt="Calculating a basic Range Vector Query over 10min" caption="Calculating a basic Range Vector Query over 10min" />
+<Figure
+  src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_19.23.50.webp"
+  alt="Calculating a basic Range Vector Query over 10min"
+  caption="Calculating a basic Range Vector Query over 10min"
+/>
 
 This query provides the rate of CPU usage in "user" mode over the past 10 minutes for the `node-exporter:9100` instance.
 
@@ -185,17 +190,17 @@ This query provides the rate of CPU usage in "user" mode over the past 10 minute
 Range vector queries are powerful when combined with operators that allow you to analyze trends and monitor changes effectively. Here are the most commonly used operators:
 
 1. `rate`
-    - Definition: Calculates the average per-second rate of increase for a given metric within a specified time range.
-    - Usage: `rate(http_requests_total[5m])`
-    - When to Use: Use `rate` when you need an averaged rate over a period, such as the average requests per second over the past 5 minutes.
+   - Definition: Calculates the average per-second rate of increase for a given metric within a specified time range.
+   - Usage: `rate(http_requests_total[5m])`
+   - When to Use: Use `rate` when you need an averaged rate over a period, such as the average requests per second over the past 5 minutes.
 2. `irate`
-    - Definition: Computes the "instantaneous" per-second rate, based on the most recent two data points within the specified range.
-    - Usage: `irate(node_cpu_seconds_total[1m])`
-    - When to Use: `irate` is useful for detecting sudden spikes or drops, as it’s more responsive to recent changes compared to `rate`. However, it can be noisy since it relies only on the latest two samples.
+   - Definition: Computes the "instantaneous" per-second rate, based on the most recent two data points within the specified range.
+   - Usage: `irate(node_cpu_seconds_total[1m])`
+   - When to Use: `irate` is useful for detecting sudden spikes or drops, as it’s more responsive to recent changes compared to `rate`. However, it can be noisy since it relies only on the latest two samples.
 3. `increase`
-    - Definition: Calculates the total increase in a metric over the specified time range.
-    - Usage: `increase(http_requests_total[1h])`
-    - When to Use: Use `increase` when you need to know the cumulative growth over a period, such as the total number of requests in the last hour.
+   - Definition: Calculates the total increase in a metric over the specified time range.
+   - Usage: `increase(http_requests_total[1h])`
+   - When to Use: Use `increase` when you need to know the cumulative growth over a period, such as the total number of requests in the last hour.
 
 These operators are the foundation of effective range vector queries, enabling you to derive meaningful insights from raw metrics.
 
@@ -205,50 +210,44 @@ In some cases, you may need to look at data from a specific time in the past, in
 
 Example Use Cases for Offset Modifiers
 
-1. Comparing Past and Current Performance:
-Suppose you want to compare the current CPU usage with the usage from an hour ago. You can use `offset` to achieve this:
-    
-    ```
-    # Current rate over the last 5 minutes
-    rate(node_cpu_seconds_total[5m])   
-    
-    # Rate over 5 minutes, but one hour ago
-    rate(node_cpu_seconds_total[5m] offset 1h)   
-    ```
-    
-    This comparison allows you to monitor changes and identify if the CPU usage has increased or decreased over time.
-    
-2. Handling Delayed Data:
-Sometimes, data may have delayed ingestion due to network issues or other factors. If you know your data arrives with a delay, you can use `offset` to account for it, ensuring your query aligns with the latest available data.
+1.  Comparing Past and Current Performance:
+    Suppose you want to compare the current CPU usage with the usage from an hour ago. You can use `offset` to achieve this:
+        ```
+        # Current rate over the last 5 minutes
+        rate(node_cpu_seconds_total[5m])
+
+        # Rate over 5 minutes, but one hour ago
+        rate(node_cpu_seconds_total[5m] offset 1h)
+        ```
+
+        This comparison allows you to monitor changes and identify if the CPU usage has increased or decreased over time.
+2.  Handling Delayed Data:
+    Sometimes, data may have delayed ingestion due to network issues or other factors. If you know your data arrives with a delay, you can use `offset` to account for it, ensuring your query aligns with the latest available data.
 
 ### Handling Missing or Incomplete Data Points
 
 [Prometheus data](https://signoz.io/guides/how-does-grafana-get-data-from-prometheus/) may sometimes be incomplete due to collection delays, system issues, or network interruptions. Handling missing data points gracefully in range vector queries is important to ensure reliable results. Here are ways to handle these situations:
 
-1. Using Functions to Handle Missing Data:
-Prometheus functions such as `rate`, `irate`, and `increase` are generally resilient to missing data points because they calculate rates and totals based on available data. However, if you have a specific need to handle missing data, the `present_over_time` function can be useful:
-    
-    ```
-    present_over_time(prometheus_http_requests_total[5m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.19.53.webp" alt="Using `present_over_time` to handle missing data" caption="Using `present_over_time` to handle missing data" />
-    
-    This function will return `1` if any data points are recorded for `prometheus_http_requests_total` with `code="200"` on `localhost:9090` within the last 5 minutes, and `0` if there are no data points. This can be especially useful for detecting whether data was recorded in a specific period.
-    
-2. Adjusting the Range Duration:
-If you encounter frequent gaps in data, it may be helpful to adjust your range duration to be longer, allowing Prometheus to pull in more data points. For example, changing a 1-minute window to 5 minutes may yield more consistent results.
-3. Using Aggregation Operators for Stability:
-Aggregation operators like `avg_over_time` can also help in smoothing out missing data points. For example:
-    
-    ```
-    avg_over_time(node_cpu_seconds_total[10m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.21.04.webp" alt="Using `avg_over_time` to average out missing data" caption="Using `avg_over_time` to average out missing data" />
-    
-    This takes the average value over the last 10 minutes, which can reduce the effect of missing data by averaging over a broader time span.
-    
+1.  Using Functions to Handle Missing Data:
+    Prometheus functions such as `rate`, `irate`, and `increase` are generally resilient to missing data points because they calculate rates and totals based on available data. However, if you have a specific need to handle missing data, the `present_over_time` function can be useful:
+        ```
+        present_over_time(prometheus_http_requests_total[5m])
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.19.53.webp" alt="Using `present_over_time` to handle missing data" caption="Using `present_over_time` to handle missing data" />
+
+        This function will return `1` if any data points are recorded for `prometheus_http_requests_total` with `code="200"` on `localhost:9090` within the last 5 minutes, and `0` if there are no data points. This can be especially useful for detecting whether data was recorded in a specific period.
+2.  Adjusting the Range Duration:
+    If you encounter frequent gaps in data, it may be helpful to adjust your range duration to be longer, allowing Prometheus to pull in more data points. For example, changing a 1-minute window to 5 minutes may yield more consistent results.
+3.  Using Aggregation Operators for Stability:
+    Aggregation operators like `avg_over_time` can also help in smoothing out missing data points. For example:
+        ```
+        avg_over_time(node_cpu_seconds_total[10m])
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.21.04.webp" alt="Using `avg_over_time` to average out missing data" caption="Using `avg_over_time` to average out missing data" />
+
+        This takes the average value over the last 10 minutes, which can reduce the effect of missing data by averaging over a broader time span.
 
 ## Advanced Range Vector Operations
 
@@ -259,46 +258,61 @@ After learning the basics of range vectors, you may find that more complex scena
 Aggregation functions are vital in Prometheus for summarizing data over time, making it easier to extract meaningful insights from large datasets. By applying these functions to range vectors, you can calculate averages, maximums, minimums, sums, and more across your data.
 
 1. `avg_over_time`: Calculates the average value over the specified range duration.
-    
-    ```
-    avg_over_time(node_cpu_seconds_total[10m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.28.14.webp" alt="Using `avg_over_time` function for 10min" caption="Using `avg_over_time` function for 10min" />
-    
-    This example gives the average CPU usage over the last 10 minutes. It’s particularly useful for smoothing out fluctuations and understanding general trends.
-    
+
+   ```
+   avg_over_time(node_cpu_seconds_total[10m])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.28.14.webp"
+     alt="Using `avg_over_time` function for 10min"
+     caption="Using `avg_over_time` function for 10min"
+   />
+
+   This example gives the average CPU usage over the last 10 minutes. It’s particularly useful for smoothing out fluctuations and understanding general trends.
+
 2. `min_over_time` and `max_over_time`: These functions return the minimum and maximum values within the specified time range.
-    
-    ```
-    min_over_time(node_memory_MemAvailable_bytes[5m])
-    max_over_time(node_memory_MemAvailable_bytes[5m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.29.15.webp" alt="Using `max_over_time` function to identify highest memory availability" caption="Using `max_over_time` function to identify highest memory availability" />
-    
-    These queries can help identify the lowest and highest memory availability within the past 5 minutes, providing insight into memory spikes or dips.
-    
+
+   ```
+   min_over_time(node_memory_MemAvailable_bytes[5m])
+   max_over_time(node_memory_MemAvailable_bytes[5m])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.29.15.webp"
+     alt="Using `max_over_time` function to identify highest memory availability"
+     caption="Using `max_over_time` function to identify highest memory availability"
+   />
+
+   These queries can help identify the lowest and highest memory availability within the past 5 minutes, providing insight into memory spikes or dips.
+
 3. `sum_over_time`: Calculates the total sum of values within the range.
-    
-    ```
-    sum_over_time(prometheus_http_requests_total[1h])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.30.25.webp" alt="Using `sum_over_time` to add all prometheus HTTP requests over the last hour" caption="Using `sum_over_time` to add all prometheus HTTP requests over the last hour" />
-    
-    This example sums all prometheus HTTP requests over the last hour, giving a cumulative count of requests over time.
-    
+
+   ```
+   sum_over_time(prometheus_http_requests_total[1h])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_20.30.25.webp"
+     alt="Using `sum_over_time` to add all prometheus HTTP requests over the last hour"
+     caption="Using `sum_over_time` to add all prometheus HTTP requests over the last hour"
+   />
+
+   This example sums all prometheus HTTP requests over the last hour, giving a cumulative count of requests over time.
+
 4. `count_over_time`: Counts the number of data points available in the time range.
-    
-    ```
-    count_over_time(prometheus_http_requests_total[1h])
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-038bd15a-b3b3-45b8-88be-5d1b2757798e.webp" alt="Using `count_over_time`to check data availability" caption="Using `count_over_time`to check data availability" />
-    
-    This can be useful to check data availability and ensure consistent collection, as it shows the number of samples recorded in the past hour.
-    
+
+   ```
+   count_over_time(prometheus_http_requests_total[1h])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-038bd15a-b3b3-45b8-88be-5d1b2757798e.webp"
+     alt="Using `count_over_time`to check data availability"
+     caption="Using `count_over_time`to check data availability"
+   />
+
+   This can be useful to check data availability and ensure consistent collection, as it shows the number of samples recorded in the past hour.
 
 When to Use Aggregation Functions
 Aggregation functions are especially useful when analyzing high-frequency metrics. They help reduce the volume of data by summarizing it, making it easier to visualize and analyze trends without being overwhelmed by individual data points. For example, using `avg_over_time` to calculate average CPU load over 5 minutes provides a smoothed-out view of CPU performance.
@@ -307,39 +321,31 @@ Aggregation functions are especially useful when analyzing high-frequency metric
 
 In real-world scenarios, you might need to analyze multiple metrics together. Combining range vectors in a single query allows you to relate different metrics and gain a holistic view of your system’s performance.
 
-1. Using Mathematical Operators:
-You can combine range vectors using arithmetic operations such as addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`). Here’s an example:
-    
-    ```
-    (rate(http_requests_total[5m]) / rate(node_cpu_seconds_total[5m])) * 100
-    ```
-    
-    This query calculates the HTTP request rate as a percentage of CPU usage, which might be useful in understanding how request load affects CPU performance.
-    
-2. Using Conditional Operators:
-Prometheus also supports conditional operators (`and`, `or`, `unless`) that help you filter and compare range vectors:
-    - `and`: Returns values that match in both range vectors.
-    - `or`: Returns values that match in either range vector.
-    - `unless`: Excludes values present in the second vector from the first vector.
-    
-    For example:
-    
-    ```
-    rate(http_requests_total[5m]) and rate(node_cpu_seconds_total[5m])
-    ```
-    
-    This query returns only data points where both `http_requests_total` and `node_cpu_seconds_total` are present within the last 5 minutes, ensuring you compare data only when both metrics have recorded values.
-    
-3. Using Grouping and Aggregation Together
-    
+1.  Using Mathematical Operators:
+    You can combine range vectors using arithmetic operations such as addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`). Here’s an example:
+        ```
+        (rate(http_requests_total[5m]) / rate(node_cpu_seconds_total[5m])) * 100
+        ```
+
+        This query calculates the HTTP request rate as a percentage of CPU usage, which might be useful in understanding how request load affects CPU performance.
+2.  Using Conditional Operators:
+    Prometheus also supports conditional operators (`and`, `or`, `unless`) that help you filter and compare range vectors: - `and`: Returns values that match in both range vectors. - `or`: Returns values that match in either range vector. - `unless`: Excludes values present in the second vector from the first vector.
+        For example:
+
+        ```
+        rate(http_requests_total[5m]) and rate(node_cpu_seconds_total[5m])
+        ```
+
+        This query returns only data points where both `http_requests_total` and `node_cpu_seconds_total` are present within the last 5 minutes, ensuring you compare data only when both metrics have recorded values.
+3.  Using Grouping and Aggregation Together
+
     Prometheus supports grouping by specific labels, allowing you to calculate values within each group separately:
-    
+
     ```
     sum(rate(http_requests_total[5m])) by (job)
     ```
-    
+
     This query calculates the sum of HTTP requests in the past 5 minutes, grouped by the `job` label, so you can see the request rate for each service separately.
-    
 
 ### Using Subqueries for Nested Range Vector Operations
 
@@ -368,7 +374,7 @@ This structure allows you to calculate a moving average over time, which is usef
 
 Applications of Subqueries
 
-Subqueries in Prometheus enable more complex and powerful query constructions by allowing you to use the results of one query as the input for another. Here are some key applications: 
+Subqueries in Prometheus enable more complex and powerful query constructions by allowing you to use the results of one query as the input for another. Here are some key applications:
 
 - Rolling Averages: Calculate the average rate or value over time to smooth data.
 - Multi-Level Aggregations: Use multiple aggregation functions to obtain more complex summaries.
@@ -378,30 +384,26 @@ Subqueries in Prometheus enable more complex and powerful query constructions by
 
 As range vector queries grow more complex, optimizing them becomes crucial to ensure fast query performance and avoid straining Prometheus resources. Here are some tips:
 
-1. Use Appropriate Time Durations:
-Avoid overly large time ranges in high-frequency metrics. For instance, querying `[1w]` (one week) for metrics recorded every second can result in massive data retrieval. Instead, try limiting range durations to what’s necessary for the analysis.
-2. Apply Aggregation Early:
-Whenever possible, aggregate data early in the query. For instance, summing up data first before combining multiple vectors reduces the amount of data Prometheus has to handle:
-    
-    ```
-    sum(rate(http_requests_total[5m])) by (job)
-    ```
-    
-    This approach aggregates the data by `job`, reducing the volume of data before further processing.
-    
-3. Avoid Redundant Subqueries:
-Subqueries can quickly become resource-intensive if not used carefully. If a query doesn’t require a nested calculation, avoid using subqueries.
-4. Filter by Labels:
-Adding label filters (e.g., `{job="web_server"}`) helps narrow down data selection to only relevant time series, which can significantly speed up query execution. For example:
-    
-    ```
-    rate(node_cpu_seconds_total{instance="server1"}[5m])
-    ```
-    
-    This filter limits the data to a specific server instance, reducing the data Prometheus needs to analyze.
-    
-5. Leverage Caching and Timeouts:
-Prometheus caching settings and timeout configurations can help manage performance when working with complex queries. Check your Prometheus settings to optimize these based on your server resources.
+1.  Use Appropriate Time Durations:
+    Avoid overly large time ranges in high-frequency metrics. For instance, querying `[1w]` (one week) for metrics recorded every second can result in massive data retrieval. Instead, try limiting range durations to what’s necessary for the analysis.
+2.  Apply Aggregation Early:
+    Whenever possible, aggregate data early in the query. For instance, summing up data first before combining multiple vectors reduces the amount of data Prometheus has to handle:
+        ```
+        sum(rate(http_requests_total[5m])) by (job)
+        ```
+
+        This approach aggregates the data by `job`, reducing the volume of data before further processing.
+3.  Avoid Redundant Subqueries:
+    Subqueries can quickly become resource-intensive if not used carefully. If a query doesn’t require a nested calculation, avoid using subqueries.
+4.  Filter by Labels:
+    Adding label filters (e.g., `{job="web_server"}`) helps narrow down data selection to only relevant time series, which can significantly speed up query execution. For example:
+        ```
+        rate(node_cpu_seconds_total{instance="server1"}[5m])
+        ```
+
+        This filter limits the data to a specific server instance, reducing the data Prometheus needs to analyze.
+5.  Leverage Caching and Timeouts:
+    Prometheus caching settings and timeout configurations can help manage performance when working with complex queries. Check your Prometheus settings to optimize these based on your server resources.
 
 ## Implementing Range Vectors with SigNoz
 
@@ -409,88 +411,73 @@ Leveraging range vectors in SigNoz can enhance your ability to monitor and analy
 
 Here's how you can leverage SigNoz to implement range vectors:
 
-1. Create a SigNoz Cloud Account
-[SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
-2. Clone Sample Go App Repository
-From your terminal use the following command to clone sample Go app from the GitHub repository.
-    
-    ```bash
-    git clone https://github.com/SigNoz/sample-golang-app
-    ```
-    
-3. Add .env File to the Root Project Folder
-In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
-    
-    ```yaml
-    OTEL_COLLECTOR_ENDPOINT=ingest.{region}.signoz.cloud:443
-    SIGNOZ_INGESTION_KEY=***
-    ```
-    
+1.  Create a SigNoz Cloud Account
+    [SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
+2.  Clone Sample Go App Repository
+    From your terminal use the following command to clone sample Go app from the GitHub repository.
+        ```bash
+        git clone https://github.com/SigNoz/sample-golang-app
+        ```
+3.  Add .env File to the Root Project Folder
+    In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
+        ```yaml
+        OTEL_COLLECTOR_ENDPOINT=ingest.{region}.signoz.cloud:443
+        SIGNOZ_INGESTION_KEY=***
+        ```
+
 - `OTEL_COLLECTOR_ENDPOINT`: Specifies the address of the SigNoz collector where your application will send its telemetry data.
 - `SIGNOZ_INGESTION_KEY`: Authenticates your application with the SigNoz collector.
-    
-    Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your actual ingestion key.
-    
-    To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Untitled.webp" alt="SigNoz Ingestion Settings Page" caption="SigNoz Ingestion Settings Page" />
-    
-1. Using SigNoz Application Monitoring
-In the top left corner, click on getting started. 
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
-    
-    You will be redirected to “Get Started Page”. Choose `Application Monitoring` to check latency and how your application is performing.
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-05_at_11.35.06_AM.webp" alt="SigNoz Getting Started" caption="SigNoz Getting Started" />
-    
-2. Select the Language and Framework of the Application 
-We are using a Go Application which we want to monitor. Select `Go` You can write service name as you want, we are using go.
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-08_at_23.23.11.webp" alt="SigNoz Application Monitoring (Select Data Source)" caption="SigNoz Application Monitoring (Select Data Source)" />
-    
-3. Choose Environment your App is Running On
-Choose from the environment options that match your setup. Since I'm running this on my Mac, I'm choosing the ARM option.  
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-08_at_23.23.47.webp" alt="SigNoz Env Details" caption="SigNoz Env Details" />
-    
-4. Using OpenTelemtry SDK or Collector to send data to SigNoz :
-To send data to SigNoz, we will use the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector. The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations. 
-For more details, visit [OpenTelemetry Collector Guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/).
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-05_at_11.43.33_AM.webp" alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." />
-    
-5. Start Your Application with SigNoz
-To begin sending telemetry data from your application to SigNoz, use the following command to start your app. This command specifies key configuration details like the service name, access token, and the endpoint for the [OpenTelemetry collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/).
-    
-    ```bash
-    SERVICE_NAME=goApp 
-    INSECURE_MODE=false 
-    OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=<SIGNOZ-INGESTION_KEY-HERE> 
-    OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{region}.signoz.cloud:443 go run main.go
-    ```
-    
-6. Verify Your Application in the SigNoz Dashboard: 
-Once your application is running, navigate to the Services tab in the SigNoz dashboard. If everything is set up correctly, you should see your app listed here. 
-From this tab, you can monitor your app's performance metrics, including latency, error rates, and throughput, gaining valuable insights into how your application is performing in real time
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_00.29.59.webp" alt="SigNoz Services tab" caption="SigNoz Services tab" />
-    
-7. Use Range Vector Queries to [Analyze Metrics](https://signoz.io/blog/metrics-explorer/):
-Navigate to the Traces section via the sidebar menu in the SigNoz dashboard. In the Search Filter section, input the necessary query expressions. This allows you to filter and analyze specific metrics.
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-735d3ae6-eb7a-472b-aea6-cd5776bc6277.webp" alt="Navigate to Traces to use the Search Filter" caption="Navigate to Traces to use the Search Filter" />
-    
-    For instance, to analyze the room temperature over the last 10 minutes, you can use the following range vector query in the SigNoz Metrics Explorer:
-    
-    ```
-    room_temperature[10m]
-    ```
-    
-    <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_00.50.16.webp" alt="SigNoz Explorers tab" caption="SigNoz Explorers tab" />
-    
-    This query retrieves the room temperature data for the last 10 minutes, allowing you to monitor any fluctuations or patterns in the temperature during that time period. You can modify the duration (e.g., `5m`, `30m`) based on the time window you wish to analyze.
-    
+  Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your actual ingestion key.
+  To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Untitled.webp"
+    alt="SigNoz Ingestion Settings Page"
+    caption="SigNoz Ingestion Settings Page"
+  />
+
+1.  Using SigNoz Application Monitoring
+    In the top left corner, click on getting started.
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+
+        You will be redirected to “Get Started Page”. Choose `Application Monitoring` to check latency and how your application is performing.
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-05_at_11.35.06_AM.webp" alt="SigNoz Getting Started" caption="SigNoz Getting Started" />
+2.  Select the Language and Framework of the Application
+    We are using a Go Application which we want to monitor. Select `Go` You can write service name as you want, we are using go.
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-08_at_23.23.11.webp" alt="SigNoz Application Monitoring (Select Data Source)" caption="SigNoz Application Monitoring (Select Data Source)" />
+3.  Choose Environment your App is Running On
+    Choose from the environment options that match your setup. Since I'm running this on my Mac, I'm choosing the ARM option.
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-08_at_23.23.47.webp" alt="SigNoz Env Details" caption="SigNoz Env Details" />
+4.  Using OpenTelemtry SDK or Collector to send data to SigNoz :
+    To send data to SigNoz, we will use the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector. The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations.
+    For more details, visit [OpenTelemetry Collector Guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/).
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-08-05_at_11.43.33_AM.webp" alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." />
+5.  Start Your Application with SigNoz
+    To begin sending telemetry data from your application to SigNoz, use the following command to start your app. This command specifies key configuration details like the service name, access token, and the endpoint for the [OpenTelemetry collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/).
+        ```bash
+        SERVICE_NAME=goApp
+        INSECURE_MODE=false
+        OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=<SIGNOZ-INGESTION_KEY-HERE>
+        OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{region}.signoz.cloud:443 go run main.go
+        ```
+6.  Verify Your Application in the SigNoz Dashboard:
+    Once your application is running, navigate to the Services tab in the SigNoz dashboard. If everything is set up correctly, you should see your app listed here.
+    From this tab, you can monitor your app's performance metrics, including latency, error rates, and throughput, gaining valuable insights into how your application is performing in real time
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_00.29.59.webp" alt="SigNoz Services tab" caption="SigNoz Services tab" />
+7.  Use Range Vector Queries to [Analyze Metrics](https://signoz.io/blog/metrics-explorer/):
+    Navigate to the Traces section via the sidebar menu in the SigNoz dashboard. In the Search Filter section, input the necessary query expressions. This allows you to filter and analyze specific metrics.
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-735d3ae6-eb7a-472b-aea6-cd5776bc6277.webp" alt="Navigate to Traces to use the Search Filter" caption="Navigate to Traces to use the Search Filter" />
+
+        For instance, to analyze the room temperature over the last 10 minutes, you can use the following range vector query in the SigNoz Metrics Explorer:
+
+        ```
+        room_temperature[10m]
+        ```
+
+        <Figure src="/img/guides/2024/11/generating-range-vectors-from-return-values-in-prometheus-queries-Screenshot_2024-11-09_at_00.50.16.webp" alt="SigNoz Explorers tab" caption="SigNoz Explorers tab" />
+
+        This query retrieves the room temperature data for the last 10 minutes, allowing you to monitor any fluctuations or patterns in the temperature during that time period. You can modify the duration (e.g., `5m`, `30m`) based on the time window you wish to analyze.
 
 By using such queries, you can effectively analyze time-based metrics and gain deeper insights into how your application's performance or environmental factors (like room temperature) evolve over time.
 
@@ -503,27 +490,24 @@ Working with range vector queries in Prometheus can sometimes lead to unexpected
 ### Common Pitfalls and How to Avoid Them
 
 1. No Data Points Returned
-    - Problem: Sometimes, a query returns no data points, which could be due to mismatched time ranges or gaps in data.
-    - Solution:
-        - Ensure the time range in your query matches your data retention settings. Prometheus retains data for a specified duration, so if you query outside that range, you’ll get no results.
-        - Verify that the metric exists during the specified period. Use a simple `up` query to confirm that Prometheus was scraping data from the relevant target at that time.
+   - Problem: Sometimes, a query returns no data points, which could be due to mismatched time ranges or gaps in data.
+   - Solution:
+     - Ensure the time range in your query matches your data retention settings. Prometheus retains data for a specified duration, so if you query outside that range, you’ll get no results.
+     - Verify that the metric exists during the specified period. Use a simple `up` query to confirm that Prometheus was scraping data from the relevant target at that time.
 2. [High Cardinality](https://signoz.io/blog/high-cardinality-data/)
-    - Problem: High cardinality in queries, especially when grouping by labels with many unique values (like `user_id`), can slow down queries and increase memory usage.
-    - Solution:
-        - Group by labels with fewer unique values. For example, instead of grouping by `user_id`, consider using `user_category` or another higher-level grouping.
-        
-        ```
-        plaintext
-        Copy code
-        # High cardinality query (slower)
-        sum(rate(http_requests_total[5m])) by (user_id)
-        
-        # Reduced cardinality query (faster)
-        sum(rate(http_requests_total[5m])) by (user_category)
-        ```
-        
-        Reducing cardinality not only improves query performance but also ensures your query remains within Prometheus’s memory limits.
-        
+   - Problem: High cardinality in queries, especially when grouping by labels with many unique values (like `user_id`), can slow down queries and increase memory usage.
+   - Solution:
+     - Group by labels with fewer unique values. For example, instead of grouping by `user_id`, consider using `user_category` or another higher-level grouping.
+     ```
+     plaintext
+     Copy code
+     # High cardinality query (slower)
+     sum(rate(http_requests_total[5m])) by (user_id)
+
+     # Reduced cardinality query (faster)
+     sum(rate(http_requests_total[5m])) by (user_category)
+     ```
+     Reducing cardinality not only improves query performance but also ensures your query remains within Prometheus’s memory limits.
 
 ### Debugging Query Performance Issues
 
@@ -572,4 +556,4 @@ Yes, you can use range vectors in alerting rules. However, it's advisable to use
 
 ### How do range vectors handle missing data points?
 
-Range vectors require at least two samples within the specified time range to function correctly. If there are gaps larger than five times the scrape interval, Prometheus will mark the data as stale, impacting the accuracy of your queries.
\ No newline at end of file
+Range vectors require at least two samples within the specified time range to function correctly. If there are gaps larger than five times the scrape interval, Prometheus will mark the data as stale, impacting the accuracy of your queries.
diff --git a/data/guides/golang-log.mdx b/data/guides/golang-log.mdx
index 34ab45a37..97e8d22d2 100644
--- a/data/guides/golang-log.mdx
+++ b/data/guides/golang-log.mdx
@@ -1,6 +1,5 @@
 ---
 title: Complete Guide to Logging in Go - Golang Log
-slug: golang-log
 date: 2024-07-02
 tags: [logging]
 authors: [eromosele]
@@ -9,100 +8,104 @@ keywords: [log, logging, golang, zap, zerolog, logrus, logxi, klog, seelog, log1
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Complete Guide to Logging in Go - Golang Log",
-  "alternativeHeadline": "A comprehensive guide to effective logging practices in Go",
-  "author": {
-    "@type": "Person",
-    "name": "Eromosele"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-02T00:00:00Z",
-  "dateModified": "2024-07-02T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/golang-log/"
-  },
-  "description": "This guide explores the critical role of logging in GoLang application development. It introduces the basics of effective logging practices and dives into the 'log' package from the standard library, covering usage and customization. Popular third-party logging libraries like Logrus, Zap, and Zerolog are detailed for their features and setup. Additionally, it provides instructions on integrating SigNoz for log management.",
-  "keywords": "log, logging, golang, zap, zerolog, logrus, logxi, klog, seelog, log15, glog",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Go (Programming Language)",
-      "description": "An open-source programming language developed by Google"
-    },
-    {
-      "@type": "Thing",
-      "name": "Logging",
-      "description": "The process of recording events, messages, and data during software execution"
-    },
-    {
-      "@type": "Thing",
-      "name": "SigNoz",
-      "description": "An open-source observability platform for monitoring applications"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Logrus",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Zap",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Zerolog",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Glog",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Log15",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Seelog",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Klog",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Logxi",
-      "applicationCategory": "Logging Library"
-    }
-  ]
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to Logging in Go - Golang Log',
+        alternativeHeadline: 'A comprehensive guide to effective logging practices in Go',
+        author: {
+          '@type': 'Person',
+          name: 'Eromosele',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-02T00:00:00Z',
+        dateModified: '2024-07-02T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/golang-log/',
+        },
+        description:
+          "This guide explores the critical role of logging in GoLang application development. It introduces the basics of effective logging practices and dives into the 'log' package from the standard library, covering usage and customization. Popular third-party logging libraries like Logrus, Zap, and Zerolog are detailed for their features and setup. Additionally, it provides instructions on integrating SigNoz for log management.",
+        keywords: 'log, logging, golang, zap, zerolog, logrus, logxi, klog, seelog, log15, glog',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Go (Programming Language)',
+            description: 'An open-source programming language developed by Google',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logging',
+            description:
+              'The process of recording events, messages, and data during software execution',
+          },
+          {
+            '@type': 'Thing',
+            name: 'SigNoz',
+            description: 'An open-source observability platform for monitoring applications',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Logrus',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Zap',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Zerolog',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Glog',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Log15',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Seelog',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Klog',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Logxi',
+            applicationCategory: 'Logging Library',
+          },
+        ],
+      }),
+    }}
   />
 </head>
 
diff --git a/data/guides/golang-logrus.mdx b/data/guides/golang-logrus.mdx
index 8483b14da..71c5fb72e 100644
--- a/data/guides/golang-logrus.mdx
+++ b/data/guides/golang-logrus.mdx
@@ -1,6 +1,5 @@
 ---
 title: Golang Logrus - Complete Guide to logging in Golang with Logrus
-slug: golang-logrus
 date: 2024-07-11
 tags: [logging]
 authors: [aayush_sharma]
diff --git a/data/guides/golang-slog.mdx b/data/guides/golang-slog.mdx
index 6c5eeb4fe..2b7dcfcea 100644
--- a/data/guides/golang-slog.mdx
+++ b/data/guides/golang-slog.mdx
@@ -1,121 +1,124 @@
 ---
-
 title: Complete Guide to Logging in Golang with slog
-slug: golang-slog
 date: 2024-09-26
 tags: [logging]
 authors: [aayush_sharma]
 description: Learn how to use Go's slog package for structured logging in your projects. This comprehensive guide covers setup, implementation, and best practices.
-keywords: [slog, logging, logging slog, golang, opentelemetry, opentelemetry golang, opentelemetry slog]
-
+keywords:
+  [slog, logging, logging slog, golang, opentelemetry, opentelemetry golang, opentelemetry slog]
 ---
 
 <head>
-<script
-type="application/ld+json"
-dangerouslySetInnerHTML={{ __html: JSON.stringify({
-"@context": "[https://schema.org](https://schema.org/)",
-"@type": "TechArticle",
-"headline": "Complete Guide to Logging in Golang with slog",
-"alternativeHeadline": "A comprehensive guide to implementing structured logging in Golang using slog",
-"author": {
-"@type": "Person",
-"name": "Aayush Sharma"
-},
-"publisher": {
-"@type": "Organization",
-"name": "SigNoz",
-"logo": {
-"@type": "ImageObject",
-"url": "https://signoz.io/img/SigNozLogo-orange.svg"
-}
-},
-"datePublished": "2024-07-01T00:00:00Z",
-"dateModified": "2024-07-01T00:00:00Z",
-"mainEntityOfPage": {
-"@type": "WebPage",
-"@id": "https://signoz.io/guides/golang-slog/"
-},
-"description": "In this tutorial, we will discover Golang slog and some of the best practices provided by slog for implementing structured logging in Golang applications. We will set up the Golang application and practice different logging formats slog provides.",
-"keywords": "slog, logging, logging slog, golang, opentelemetry, opentelemetry golang, opentelemetry slog",
-"articleSection": "Technology",
-"inLanguage": "en",
-"isPartOf": {
-"@type": "Blog",
-"name": "SigNoz Blog",
-"url": "https://signoz.io/blog/"
-},
-"about": [
-{
-"@type": "Thing",
-"name": "Go (Programming Language)",
-"description": "An open-source programming language developed by Google"
-},
-{
-"@type": "Thing",
-"name": "slog",
-"description": "A structured logging package for Go"
-},
-{
-"@type": "Thing",
-"name": "OpenTelemetry",
-"description": "An observability framework for cloud-native software"
-}
-],
-"mentions": [
-{
-"@type": "SoftwareApplication",
-"name": "SigNoz",
-"applicationCategory": "Observability Platform"
-}
-],
-"mainEntity": {
-"@type": "FAQPage",
-"mainEntity": [
-{
-"@type": "Question",
-"name": "What are the features of slog?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "The slog package in Go offers enhanced logging capabilities with features like multiple output destinations, allowing logs to be sent to various handlers simultaneously. It provides robust filtering control, enabling developers to filter logs by level, and message content. Additionally, slog-envlogger acts as a port of env_logger, facilitating environment-based log filtering."
-}
-},
-{
-"@type": "Question",
-"name": "What are the levels of slog logging?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "The log/slog package provides four log levels by default, with each one associated with an integer value: DEBUG (-4), INFO (0), WARN (4), and ERROR (8)."
-}
-},
-{
-"@type": "Question",
-"name": "Where to place the logger when logging with slog?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "In Go, using the slog library, you can handle logger placement based on your application's complexity. For simple setups, a global logger initialized in the main or an init function is effective. For more complex applications, dependency injection is recommended, where the logger is passed as a dependency to maintain clean architecture and ease testing."
-}
-},
-{
-"@type": "Question",
-"name": "What are the benefits of using slog over log?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "slog provides structured logging, which is beneficial for querying and analyzing logs, especially in microservices architectures or distributed systems where logs are critical for debugging."
-}
-},
-{
-"@type": "Question",
-"name": "Can slog integrate with external logging systems?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "Yes, slog can integrate with systems like SigNoz, ELK, Splunk, or any other logging infrastructure that supports structured log data. This is often done through custom handlers that format and transmit log data."
-}
-}
-]
-}
-}) }}
-/>
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': '[https://schema.org](https://schema.org/)',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to Logging in Golang with slog',
+        alternativeHeadline:
+          'A comprehensive guide to implementing structured logging in Golang using slog',
+        author: {
+          '@type': 'Person',
+          name: 'Aayush Sharma',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-01T00:00:00Z',
+        dateModified: '2024-07-01T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/golang-slog/',
+        },
+        description:
+          'In this tutorial, we will discover Golang slog and some of the best practices provided by slog for implementing structured logging in Golang applications. We will set up the Golang application and practice different logging formats slog provides.',
+        keywords:
+          'slog, logging, logging slog, golang, opentelemetry, opentelemetry golang, opentelemetry slog',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Go (Programming Language)',
+            description: 'An open-source programming language developed by Google',
+          },
+          {
+            '@type': 'Thing',
+            name: 'slog',
+            description: 'A structured logging package for Go',
+          },
+          {
+            '@type': 'Thing',
+            name: 'OpenTelemetry',
+            description: 'An observability framework for cloud-native software',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are the features of slog?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The slog package in Go offers enhanced logging capabilities with features like multiple output destinations, allowing logs to be sent to various handlers simultaneously. It provides robust filtering control, enabling developers to filter logs by level, and message content. Additionally, slog-envlogger acts as a port of env_logger, facilitating environment-based log filtering.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the levels of slog logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The log/slog package provides four log levels by default, with each one associated with an integer value: DEBUG (-4), INFO (0), WARN (4), and ERROR (8).',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where to place the logger when logging with slog?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "In Go, using the slog library, you can handle logger placement based on your application's complexity. For simple setups, a global logger initialized in the main or an init function is effective. For more complex applications, dependency injection is recommended, where the logger is passed as a dependency to maintain clean architecture and ease testing.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the benefits of using slog over log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'slog provides structured logging, which is beneficial for querying and analyzing logs, especially in microservices architectures or distributed systems where logs are critical for debugging.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can slog integrate with external logging systems?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, slog can integrate with systems like SigNoz, ELK, Splunk, or any other logging infrastructure that supports structured log data. This is often done through custom handlers that format and transmit log data.',
+              },
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
 Logging is the record of events that occur in an application, providing critical insights into its behavior, performance, and potential problems. In Golang, the built-in log package helps monitor and debug applications.
@@ -124,7 +127,9 @@ However, for more advanced logging needs, Golang offers slog, a powerful package
 
 ## Prerequisites
 
-- <a href="https://go.dev/doc/install" rel="noopener noreferrer nofollow" target="_blank">Golang Installed in your system</a>
+- <a href="https://go.dev/doc/install" rel="noopener noreferrer nofollow" target="_blank">
+    Golang Installed in your system
+  </a>
 - Familiarity with Logging in Golang
 
 ## Quick Guide: How to use slog in Golang?
@@ -196,7 +201,6 @@ Example of structured logging:
     "Item3": 7914595825068479671
   }
 }
-
 ```
 
 The above structured logging output, when converted into text-based logging, looks like the example below:
@@ -223,13 +227,13 @@ We will discuss more on this in the later part of the article.
 In slog, logging levels are used to describe the severity of logs. These levels help determine which logs are emitted based on their importance, which can be critical in both development and production environments. Here's a breakdown of the typical logging levels provided by slog, which are similar to those in many other logging libraries:
 
 - Debug: This level is used for detailed information, primarily useful for diagnosing problems. Debug logging is usually enabled only in development settings.
-Use Case: Diagnosing a complex issue by logging detailed information about the application's state.
+  Use Case: Diagnosing a complex issue by logging detailed information about the application's state.
 - Info: Provides general information about the application's operations, offering insights into its normal functioning.
-Use Case: Logging the successful completion of an operation or regular status updates.
+  Use Case: Logging the successful completion of an operation or regular status updates.
 - Warn: Indicates that something unexpected happened or there might be a potential issue (e.g., 'disk space low'). The application continues to work as expected.
-Use Case: Alerting about deprecated API usage or low disk space warnings.
+  Use Case: Alerting about deprecated API usage or low disk space warnings.
 - Error: Represents serious issues where the application has encountered a problem and cannot perform some functions.
-Use Case: Logging errors that prevent a function from executing properly, such as database connection failures.
+  Use Case: Logging errors that prevent a function from executing properly, such as database connection failures.
 
 slog is designed to be modular and extensible, allowing users to create custom levels as needed. Logging levels help control log output based on the severity of the information, which is especially useful in production environments to avoid log flooding while maintaining clear and informative logs.
 
@@ -320,7 +324,6 @@ Example Output:
   "msg": "SigNoz",
   "Content": "Golang slog is best for structured logging"
 }
-
 ```
 
 This handler is perfect for logs that must be consumed by log management systems, examined by automated programs, or sent via network protocols that benefit from standardized, structured data formats. It is frequently utilized in production settings where logs are gathered and examined by platforms such as SigNoz, Splunk, the ELK stack, or others.
@@ -596,7 +599,6 @@ Output:
     "Item3": 7503774366427698219
   }
 }
-
 ```
 
 ### Context Integration
@@ -651,7 +653,6 @@ The `ctx` variable receives a `serial_id`, which is then supplied to the `InfoCo
     "Item3": 224524224166418815
   }
 }
-
 ```
 
 ## Monitoring Logs with an Observability Tool
@@ -678,9 +679,9 @@ SigNoz is a full-stack open-source application performance monitoring and obser
 Key architecture features:
 
 - Logs, Metrics, and traces under a single dashboard
-SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
+  SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
 - Native OpenTelemetry support
-SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard to generate and manage telemetry data.
+  SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard to generate and manage telemetry data.
 
 ## Tracking Logs Using Signoz
 
@@ -856,7 +857,6 @@ service:
       receivers: [otlp, filelog/app]
       processors: [batch]
       exporters: [otlp]
-
 ```
 
 ### Step 4: Viewing Logs in SigNoz
@@ -864,16 +864,16 @@ service:
 After running the above application and making the correct configurations, you can navigate to the SigNoz logs dashboard to see all the logs sent to SigNoz.
 
 <Figure
-src="/img/guides/2024/07/golangslog-1.webp"
-alt="SigNoz localhost showcasing the log output of the above application."
-caption="SigNoz localhost showcasing the log output of the above application."
+  src="/img/guides/2024/07/golangslog-1.webp"
+  alt="SigNoz localhost showcasing the log output of the above application."
+  caption="SigNoz localhost showcasing the log output of the above application."
 />
 
 ## Advantages of using slog
 
 - Structured Logging: slog supports structured logging, which is advantageous for producing logs that are simple to interpret and filter. This is especially helpful for contemporary logging systems that compile and examine log information. Key-value pairs represent log data. As a result, logs are more straightforward to search, process, and analyze than unstructured logs that contain free-form text. Because structured logs are machine-readable, integrating them with log analysis tools is made simpler.
 - Contextual Logging: Contextual data, such as requests or user IDs, may be easily appended to your log entries using slog. With this extra information, the logs are enhanced and become much more useful for troubleshooting and comprehending complicated systems. Each log entry may include rich structured data that facilitates more efficient debugging and application flow tracing.
-Integration: slog is easily integrated with the standard library's log package. This implies that you may take advantage of slog's structured logging features in addition to using the existing log mechanisms.
+  Integration: slog is easily integrated with the standard library's log package. This implies that you may take advantage of slog's structured logging features in addition to using the existing log mechanisms.
 - Flexibility: slog enables developers to customize logging to meet the requirements of various contexts (development, staging, and production) by supporting various output formats (such as JSON) and destinations. It provides an excellent level of personalization. Because of its adaptability, you may customize your logging to meet your requirements.
 
 ## Conclusion
@@ -904,4 +904,4 @@ slog provides structured logging, which is beneficial for querying and analyzin
 
 ### Can slog integrate with external logging systems?
 
-Yes, slog can integrate with systems like SigNoz, ELK, Splunk, or any other logging infrastructure that supports structured log data. This is often done through custom handlers that format and transmit log data.
\ No newline at end of file
+Yes, slog can integrate with systems like SigNoz, ELK, Splunk, or any other logging infrastructure that supports structured log data. This is often done through custom handlers that format and transmit log data.
diff --git a/data/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count.mdx b/data/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count.mdx
index 60ef13b0c..aa4e074f3 100644
--- a/data/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count.mdx
+++ b/data/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Grafana Guide - How to Graph HTTP Requests per Minute
-slug: grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count
 date: 2024-10-14
 tags: [Grafana, faq]
 authors: [nitin_gouda]
 description: Learn how to use Grafana to graph HTTP requests per minute using http_server_requests_seconds_count. Step-by-step guide for setup, querying, and analysis.
-keywords: [Grafana, HTTP requests, Prometheus, PromQL, monitoring, visualization, performance analysis]
-
+keywords:
+  [Grafana, HTTP requests, Prometheus, PromQL, monitoring, visualization, performance analysis]
 ---
 
 Monitoring HTTP requests is crucial for understanding your web application's performance and user experience. Grafana, a powerful open-source visualization tool, combined with Prometheus, offers an effective way to track and analyze HTTP request rates. This guide will walk you through graphing HTTP requests per minute in Grafana using the `http_server_requests_seconds_count` metric.
@@ -28,8 +26,12 @@ This section walks you through setting up Grafana and Prometheus to monitor HTTP
 
 ### Prerequisite
 
-- <a href="https://grafana.com/grafana/download" rel="noopener noreferrer nofollow" target="_blank">Grafana Installed</a>
-- <a href="https://prometheus.io/download/" rel="noopener noreferrer nofollow" target="_blank">Prometheus Installed</a>
+- <a href="https://grafana.com/grafana/download" rel="noopener noreferrer nofollow" target="_blank">
+    Grafana Installed
+  </a>
+- <a href="https://prometheus.io/download/" rel="noopener noreferrer nofollow" target="_blank">
+    Prometheus Installed
+  </a>
 
 ### Expose Metrics from Your Application
 
@@ -37,192 +39,233 @@ To monitor your application's performance with Prometheus, the application must
 
 For Java-based applications, libraries like Micrometer and the Prometheus Java Client are commonly used to expose metrics. A sample [Java application](https://signoz.io/guides/monitoring-java-applications/#signoz-a-modern-approach-to-java-application-monitoring) has been provided. Follow the steps below to expose metrics for the application. If you have an existing application already exposing metrics in Prometheus format, skip this step and move on to configuring Prometheus.
 
-1. Add the Micrometer Dependency
-For a Spring Boot application, you’ll need to add the Micrometer dependency to your project. This will allow your app to export its metrics in a format that Prometheus understands.
-    
-    If you're using Maven, add this to your `pom.xml` file:
-    
-    ```xml
-    <dependency>
-        <groupId>io.micrometer</groupId>
-        <artifactId>micrometer-registry-prometheus</artifactId>
-    </dependency>
-    ```
-    
-2. Configure your Application
-Configure the application to expose the Prometheus metrics by enabling the Actuator endpoints in your `application.properties` file located at `src/main/resources`:
-    
-    ```
-    management.endpoints.web.exposure.include=prometheus
-    management.endpoint.prometheus.enabled=true
-    ```
-    
-3. Access the Prometheus Endpoint
-    
+1.  Add the Micrometer Dependency
+    For a Spring Boot application, you’ll need to add the Micrometer dependency to your project. This will allow your app to export its metrics in a format that Prometheus understands.
+        If you're using Maven, add this to your `pom.xml` file:
+
+        ```xml
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-registry-prometheus</artifactId>
+        </dependency>
+        ```
+2.  Configure your Application
+    Configure the application to expose the Prometheus metrics by enabling the Actuator endpoints in your `application.properties` file located at `src/main/resources`:
+        ```
+        management.endpoints.web.exposure.include=prometheus
+        management.endpoint.prometheus.enabled=true
+        ```
+3.  Access the Prometheus Endpoint
+
     Once your application is running, the Prometheus metrics will be available at `http://localhost:8090/actuator/prometheus`
     Open the URL in your browser or use a tool like `curl` to check if the metrics are being exposed properly.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-05_at_11.17.10_AM.webp" alt="Exposed metrics from Java application in Prometheus format" caption="Exposed metrics from Java application in Prometheus format" />
-    
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-05_at_11.17.10_AM.webp"
+      alt="Exposed metrics from Java application in Prometheus format"
+      caption="Exposed metrics from Java application in Prometheus format"
+    />
 
 ### Set up Prometheus to scrape metrics
 
 Now that your application is exposing metrics, you need to configure Prometheus to collect those metrics. Prometheus does this by periodically checking the endpoint where your metrics are exposed (this process is called scraping).
 
 1. Modify the [Prometheus Configuration](https://signoz.io/guides/what-is-prometheus-target/) File
-    
-    Modify the `prometheus.yml` configuration file to specify the targets Prometheus should scrape metrics from. Add the endpoint of your application under the `scrape_configs` section:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'my_application'
-        static_configs:
-          - targets: ['localhost:8080']
-    ```
-    
+
+   Modify the `prometheus.yml` configuration file to specify the targets Prometheus should scrape metrics from. Add the endpoint of your application under the `scrape_configs` section:
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'my_application'
+       static_configs:
+         - targets: ['localhost:8080']
+   ```
+
 2. Start Prometheus
-    
-    To start Prometheus, use the appropriate command based on your installation. For example, If you’ve manually downloaded the Prometheus binary, you can start Prometheus with this command on Linux:
-    
-    ```bash
-    ./prometheus --config.file=prometheus.yml
-    ```
-    
+
+   To start Prometheus, use the appropriate command based on your installation. For example, If you’ve manually downloaded the Prometheus binary, you can start Prometheus with this command on Linux:
+
+   ```bash
+   ./prometheus --config.file=prometheus.yml
+   ```
+
 3. Confirm Prometheus is Scraping Your Application’s Metrics
-    
-    Open Prometheus in the browser by navigating to `http://localhost:9090`. Click on Status > Targets to check if your application’s target is in the UP state.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_8.50.12_AM.webp" alt="Prometheus targets page" caption="Prometheus targets page" />
-    
-    To confirm Prometheus is collecting metrics from your application, click on Graph and run a query like `http_server_requests_seconds_count` :
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_8.53.27_AM.webp" alt="Application metrics being served" caption="Application metrics being served" />
-    
+
+   Open Prometheus in the browser by navigating to `http://localhost:9090`. Click on Status > Targets to check if your application’s target is in the UP state.
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_8.50.12_AM.webp"
+     alt="Prometheus targets page"
+     caption="Prometheus targets page"
+   />
+
+   To confirm Prometheus is collecting metrics from your application, click on Graph and run a query like `http_server_requests_seconds_count` :
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_8.53.27_AM.webp"
+     alt="Application metrics being served"
+     caption="Application metrics being served"
+   />
 
 ### Connect Prometheus to Grafana
 
 After configuring Prometheus to collect metrics from your application, you can visualize those metrics in Grafana. Follow these steps:
 
 1. Log into Grafana
-    
-    Open Grafana in your browser and log in (default credentials: username `admin`, password `admin`).
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-27_at_8.29.28_PM.webp" alt="Grafana landing page" caption="Grafana landing page" />
-    
+
+   Open Grafana in your browser and log in (default credentials: username `admin`, password `admin`).
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-27_at_8.29.28_PM.webp"
+     alt="Grafana landing page"
+     caption="Grafana landing page"
+   />
+
 2. Add Prometheus as a Data Source
-    
-    From the left-hand menu, click Configuration, then select Data Sources.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.13.48_PM.webp" alt="Add data source" caption="Add data source" />
-    
-    Click Add data source, then choose Prometheus from the list.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.15.11_PM.webp" alt="Add Prometheus as data source" caption="Add Prometheus as data source" />
-    
-     Enter the URL where Prometheus is running (e.g., `http://localhost:9090`).
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.16.29_PM.webp" alt="Prometheus data source page" caption="Prometheus data source page" />
-    
+
+   From the left-hand menu, click Configuration, then select Data Sources.
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.13.48_PM.webp"
+     alt="Add data source"
+     caption="Add data source"
+   />
+
+   Click Add data source, then choose Prometheus from the list.
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.15.11_PM.webp"
+     alt="Add Prometheus as data source"
+     caption="Add Prometheus as data source"
+   />
+
+   Enter the URL where Prometheus is running (e.g., `http://localhost:9090`).
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.16.29_PM.webp"
+     alt="Prometheus data source page"
+     caption="Prometheus data source page"
+   />
+
 3. Save the Configuration
-    
-    Click Save & Test to verify that Grafana can successfully connect to Prometheus.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.18.37_PM.webp" alt="Prometheus successfully connected with Grafana" caption="Prometheus successfully connected with Grafana" />
-    
+
+   Click Save & Test to verify that Grafana can successfully connect to Prometheus.
+
+   <Figure
+     src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-28_at_10.18.37_PM.webp"
+     alt="Prometheus successfully connected with Grafana"
+     caption="Prometheus successfully connected with Grafana"
+   />
 
 ### Tips for Ensuring Proper Integration Between Your Application, Prometheus, and Grafana
 
 Integrating Prometheus and Grafana with your application can significantly enhance your monitoring and observability capabilities. To ensure a seamless experience, consider the following best practices:
 
 1. Use Clear Metric Names
-Always give your metrics meaningful names, so it’s easy to understand what they measure. For example, instead of using `request_count`, use `http_requests_total` for clarity.
+   Always give your metrics meaningful names, so it’s easy to understand what they measure. For example, instead of using `request_count`, use `http_requests_total` for clarity.
 2. Make the Most of Labels
-Labels help categorize and filter your data. Use them to add context like status codes (`status_code="200"`) or response times. This makes analysis in Grafana easier.
+   Labels help categorize and filter your data. Use them to add context like status codes (`status_code="200"`) or response times. This makes analysis in Grafana easier.
 3. Set the Right Scraping Interval
-Adjust how often Prometheus collects data based on your app’s traffic. A typical interval is 15 seconds, but don’t set it too low, or it might slow down your system.
+   Adjust how often Prometheus collects data based on your app’s traffic. A typical interval is 15 seconds, but don’t set it too low, or it might slow down your system.
 4. Check Your Metrics Endpoint
-Before launching, use tools like `curl` or Postman to ensure your app’s metrics endpoint works and displays data in Prometheus format. Catching issues early can save you headaches later.
+   Before launching, use tools like `curl` or Postman to ensure your app’s metrics endpoint works and displays data in Prometheus format. Catching issues early can save you headaches later.
 5. Keep an Eye on Prometheus’ Performance
-As your app grows, Prometheus might get bogged down. Monitor its CPU, memory, and disk usage, and adjust settings like retention periods if needed.
+   As your app grows, Prometheus might get bogged down. Monitor its CPU, memory, and disk usage, and adjust settings like retention periods if needed.
 6. Document Everything
-Keep notes on what each metric means, either in your code or a separate file. This helps everyone on your team understand your monitoring setup.
+   Keep notes on what each metric means, either in your code or a separate file. This helps everyone on your team understand your monitoring setup.
 7. Update Dashboards and Alerts
-Regularly check your Grafana dashboards and alerts to make sure they’re still relevant. Remove outdated metrics and add new ones as your app changes.
+   Regularly check your Grafana dashboards and alerts to make sure they’re still relevant. Remove outdated metrics and add new ones as your app changes.
 
 ## Creating a Dashboard for HTTP Requests per Minute
 
 With Prometheus now scraping your application's metrics, follow these steps to create a Grafana dashboard to visualize HTTP requests per minute:
 
-1. Create New Dashboard
-    
+1.  Create New Dashboard
+
     In the left-hand menu, select Dashboards and click the Create dashboard button.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-04_at_11.42.37.webp" alt="Create dashboard" caption="Create dashboard" />
-    
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-04_at_11.42.37.webp"
+      alt="Create dashboard"
+      caption="Create dashboard"
+    />
+
     Click the Add visualization button
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-fec50360-ee07-4569-ab85-8794820adb6d.webp" alt="Adding visualization" caption="Adding visualization" />
-    
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-fec50360-ee07-4569-ab85-8794820adb6d.webp"
+      alt="Adding visualization"
+      caption="Adding visualization"
+    />
+
     Select Prometheus as the data source
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-093fbf6f-d2be-4924-8991-4961ca31fff0.webp" alt="Select datasource" caption="Select datasource" />
-    
-2. Use PromQL to Run Queries
-    
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-093fbf6f-d2be-4924-8991-4961ca31fff0.webp"
+      alt="Select datasource"
+      caption="Select datasource"
+    />
+
+2.  Use PromQL to Run Queries
+
     To query the HTTP request metrics from the application, in the panel's query editor, enter the following PromQL query to calculate the rate of HTTP requests over the last minute:
-    
+
     ```json
     rate(http_server_requests_seconds_count{}[1m])
     ```
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_12.12.25_PM.webp" alt="Querying HTTP request rate over the last minute" caption="Querying HTTP request rate over the last minute" />
-    
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_12.12.25_PM.webp"
+      alt="Querying HTTP request rate over the last minute"
+      caption="Querying HTTP request rate over the last minute"
+    />
+
     This query retrieves the per-second rate of HTTP requests based on the `http_server_requests_seconds_count` metric. It calculates how many requests are happening every second, averaged over a one-minute window. This is useful for monitoring real-time traffic patterns and understanding how request volume changes over time.
-    
-3. Set the Unit to Requests Per Minute
-After running the query, you’ll want to format the result to show requests per minute instead of per second. In the Panel settings on the right, scroll to the Standard options section. Here, you can set the Unit dropdown to display the rate in seconds, which represents the requests per second.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_9.21.33_AM.webp" alt="Unit response set to seconds" caption="Unit response set to seconds" />
-    
-    Since Grafana doesn’t have a built-in option to display requests per minute, you will need to manually convert the per-second rate by multiplying it by 60, which leads us to the next step.
-    
-4. Multiply by 60:
-    
+
+3.  Set the Unit to Requests Per Minute
+    After running the query, you’ll want to format the result to show requests per minute instead of per second. In the Panel settings on the right, scroll to the Standard options section. Here, you can set the Unit dropdown to display the rate in seconds, which represents the requests per second.
+        <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_9.21.33_AM.webp" alt="Unit response set to seconds" caption="Unit response set to seconds" />
+
+        Since Grafana doesn’t have a built-in option to display requests per minute, you will need to manually convert the per-second rate by multiplying it by 60, which leads us to the next step.
+4.  Multiply by 60:
+
     To calculate requests per minute, modify your query to multiply the per-second rate by 60. This will convert the requests-per-second data into requests-per-minute. Update your PromQL query like this:
-    
+
     ```
     rate(http_server_requests_seconds_count[1m]) * 60
     ```
-    
+
     This adjusted query takes the per-second rate over the last minute and multiplies it by 60 to show the total number of requests made each minute.
-    
-    <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.18.04_PM.webp" alt="http_server_requests_seconds_count dashboard" caption="http_server_requests_seconds_count dashboard" />
-    
-5. Customize the Panel
-To improve the readability and relevance of your dashboard, it's helpful to customize the panel:
-    1. Set the panel title: In the General tab, rename the panel to something more descriptive, such as "`HTTP Requests per Minute`." This makes it easier to understand the panel’s purpose at a glance.
-        
-        <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.18.04_PM%201.webp" alt="changing the name of the panel tile" caption="changing the name of the panel tile" />
-        
-    2. Customize as per needs: 
-    You can configure the Y-axis to automatically adjust to the scale of incoming request rates or set a custom range based on your expected traffic volume. In the Display settings, you can also fine-tune the legend to provide more context about the data shown on the dashboard.
-    3. Apply the changes:
-    Once you’ve customized the panel to meet your needs, click Apply to save your settings and add the panel to the dashboard.
-        
-        <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.32.56_PM.webp" alt="Dashboard overview" caption="Dashboard overview" />
-        
-    4. `Optional` - Set Up Alerts
-    To stay informed of significant changes in HTTP request rates, you can configure alerts in Grafana. Alerts will notify you when specific conditions are met, such as sudden spikes or drops in traffic.
-        1. Add alerts:
-        Go to the Alert tab in the panel configuration, where you can define thresholds for high or low request rates that will trigger notifications. This can be useful for early detection of performance issues or traffic anomalies.
-        To know more about Setting up the Alerts you follow the official docs <a href="https://grafana.com/docs/grafana/latest/alerting/" rel="noopener noreferrer nofollow" target="_blank">here</a>. 
-            
-            <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.35.19_PM.webp" alt="Alerts tab" caption="Alerts tab" />
-            
-            Once configured, your dashboard should give you real-time insight into your HTTP request patterns, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) of your application’s performance.
-            
-            <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_9.31.53_AM.webp" alt="Final dashboard" caption="Final dashboard" />
-            
+
+    <Figure
+      src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.18.04_PM.webp"
+      alt="http_server_requests_seconds_count dashboard"
+      caption="http_server_requests_seconds_count dashboard"
+    />
+
+5.  Customize the Panel
+    To improve the readability and relevance of your dashboard, it's helpful to customize the panel: 1. Set the panel title: In the General tab, rename the panel to something more descriptive, such as "`HTTP Requests per Minute`." This makes it easier to understand the panel’s purpose at a glance.
+            <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.18.04_PM%201.webp" alt="changing the name of the panel tile" caption="changing the name of the panel tile" />
+
+        2. Customize as per needs:
+        You can configure the Y-axis to automatically adjust to the scale of incoming request rates or set a custom range based on your expected traffic volume. In the Display settings, you can also fine-tune the legend to provide more context about the data shown on the dashboard.
+        3. Apply the changes:
+        Once you’ve customized the panel to meet your needs, click Apply to save your settings and add the panel to the dashboard.
+
+            <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.32.56_PM.webp" alt="Dashboard overview" caption="Dashboard overview" />
+
+        4. `Optional` - Set Up Alerts
+        To stay informed of significant changes in HTTP request rates, you can configure alerts in Grafana. Alerts will notify you when specific conditions are met, such as sudden spikes or drops in traffic.
+            1. Add alerts:
+            Go to the Alert tab in the panel configuration, where you can define thresholds for high or low request rates that will trigger notifications. This can be useful for early detection of performance issues or traffic anomalies.
+            To know more about Setting up the Alerts you follow the official docs <a href="https://grafana.com/docs/grafana/latest/alerting/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
+
+                <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-09-29_at_1.35.19_PM.webp" alt="Alerts tab" caption="Alerts tab" />
+
+                Once configured, your dashboard should give you real-time insight into your HTTP request patterns, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) of your application’s performance.
+
+                <Figure src="/img/guides/2024/10/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count-Screenshot_2024-10-03_at_9.31.53_AM.webp" alt="Final dashboard" caption="Final dashboard" />
+
 
 ### Crafting the Perfect PromQL Query
 
@@ -231,41 +274,35 @@ PromQL (Prometheus Query Language) is essential for extracting and analyzing met
 Understanding the Query Components
 
 1. Metric Selection:
-`http_server_requests_seconds_count{}`: This part of the query selects all the time series associated with the metric `http_server_requests_seconds_count`, which tracks the number of HTTP requests over time. The empty `{}` allows you to filter further using labels (such as status codes or URIs) if needed.
+   `http_server_requests_seconds_count{}`: This part of the query selects all the time series associated with the metric `http_server_requests_seconds_count`, which tracks the number of HTTP requests over time. The empty `{}` allows you to filter further using labels (such as status codes or URIs) if needed.
 2. Time Range:
-`[1m]`: This specifies the time frame during which the rate is calculated—in this example, a 1-minute window. You may change this depending on your analytical requirements, such as tracking trends over shorter or longer intervals.
+   `[1m]`: This specifies the time frame during which the rate is calculated—in this example, a 1-minute window. You may change this depending on your analytical requirements, such as tracking trends over shorter or longer intervals.
 3. Rate Calculation:
-`rate()`: The `rate()` function computes the average per-second rate of increase for the metric within the specified time range. It helps you understand how fast HTTP requests are being received by the server.
+   `rate()`: The `rate()` function computes the average per-second rate of increase for the metric within the specified time range. It helps you understand how fast HTTP requests are being received by the server.
 
 ### Practical Adjustments for Different Scenarios
 
-1. Hourly Request Rates:
-If you want to calculate the request rate per hour instead of per second, you can adjust the time range and multiply by the number of seconds in an hour:
-    
-    ```lua
-    rate(http_server_requests_seconds_count{}[1h]) * 3600
-    ```
-    
-    This query calculates the per-second rate over the past hour and multiplies it by 3600 (the number of seconds in an hour) to give you requests per hour.
-    
-2. Filtering by Specific Endpoint:
-If you're interested in monitoring requests to a particular endpoint, you can filter the metric by its URI label:
-    
-    ```lua
-    rate(http_server_requests_seconds_count{uri="/api/users"}[1m]) * 60
-    ```
-    
-    This query monitors only the requests to the `/api/users` endpoint over a 1-minute period, multiplied by 60 to get the requests per minute.
-    
-3. Grouping by Status Code:
-To analyze request patterns by status codes (e.g., 200, 404), you can use the `sum by (status)` clause to group requests based on their HTTP status:
-    
-    ```lua
-    sum by (status) (rate(http_server_requests_seconds_count{}[1m])) * 60
-    ```
-    
-    This query calculates the request rate for each status code and aggregates them, showing you the number of requests per minute, broken down by their status (e.g., success, errors).
-    
+1.  Hourly Request Rates:
+    If you want to calculate the request rate per hour instead of per second, you can adjust the time range and multiply by the number of seconds in an hour:
+        ```lua
+        rate(http_server_requests_seconds_count{}[1h]) * 3600
+        ```
+
+        This query calculates the per-second rate over the past hour and multiplies it by 3600 (the number of seconds in an hour) to give you requests per hour.
+2.  Filtering by Specific Endpoint:
+    If you're interested in monitoring requests to a particular endpoint, you can filter the metric by its URI label:
+        ```lua
+        rate(http_server_requests_seconds_count{uri="/api/users"}[1m]) * 60
+        ```
+
+        This query monitors only the requests to the `/api/users` endpoint over a 1-minute period, multiplied by 60 to get the requests per minute.
+3.  Grouping by Status Code:
+    To analyze request patterns by status codes (e.g., 200, 404), you can use the `sum by (status)` clause to group requests based on their HTTP status:
+        ```lua
+        sum by (status) (rate(http_server_requests_seconds_count{}[1m])) * 60
+        ```
+
+        This query calculates the request rate for each status code and aggregates them, showing you the number of requests per minute, broken down by their status (e.g., success, errors).
 
 ## Interpreting and Analyzing HTTP Request Graphs
 
@@ -296,13 +333,13 @@ By analyzing HTTP request graphs in Grafana, you can make informed decisions to
 
 To effectively monitor your applications and systems, leveraging an advanced observability platform like [SigNoz](https://signoz.io/) can elevate your monitoring strategy. [SigNoz](https://signoz.io/) is an open-source observability tool that provides end-to-end monitoring, troubleshooting, and alerting capabilities across your entire application stack.
 
-Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)—the emerging industry standard for telemetry data—SigNoz integrates seamlessly with your existing Prometheus and Grafana setup. This [unified observability](https://signoz.io/unified-observability/) solution enhances your ability to monitor HTTP requests per minute alongside deep traces, giving you a comprehensive view of your application's performance. 
+Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)—the emerging industry standard for telemetry data—SigNoz integrates seamlessly with your existing Prometheus and Grafana setup. This [unified observability](https://signoz.io/unified-observability/) solution enhances your ability to monitor HTTP requests per minute alongside deep traces, giving you a comprehensive view of your application's performance.
 
 SigNoz complements this setup by offering additional monitoring features:
 
 1. Extend [Prometheus Monitoring](https://signoz.io/guides/what-is-prometheus-for-monitoring/): Retain your existing Prometheus setup while enhancing it with tracing and logging capabilities.
 2. Faster Troubleshooting: Correlate metrics with traces and logs to quickly identify and resolve performance issues.
-3. Flexible Data Analysis: Use both PromQL and SigNoz's advanced [query builder](https://signoz.io/blog/query-builder-v5/) for versatile data exploration and analysis. 
+3. Flexible Data Analysis: Use both PromQL and SigNoz's advanced [query builder](https://signoz.io/blog/query-builder-v5/) for versatile data exploration and analysis.
 4. Unified Dashboards: Build custom dashboards that bring together metrics, traces, and logs, helping you monitor key performance indicators and identify trends effectively.
 
 To get started with HTTP request monitoring of your application with SigNoz, follow the steps in this [section](https://signoz.io/guides/monitoring-java-applications/#signoz-a-modern-approach-to-java-application-monitoring).
@@ -357,4 +394,4 @@ Review your dashboards monthly to ensure they still provide relevant insights. U
 
 - Adding new features or endpoints to your application
 - Changing your infrastructure or scaling your application
-- Identifying new metrics or patterns you want to monitor
\ No newline at end of file
+- Identifying new metrics or patterns you want to monitor
diff --git a/data/guides/grafana-loki-total-number-of-a-specific-log-message.mdx b/data/guides/grafana-loki-total-number-of-a-specific-log-message.mdx
index 3f1ff6cf6..d0bcf21fa 100644
--- a/data/guides/grafana-loki-total-number-of-a-specific-log-message.mdx
+++ b/data/guides/grafana-loki-total-number-of-a-specific-log-message.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Count Specific Log Messages in Grafana Loki
-slug: grafana-loki-total-number-of-a-specific-log-message
 date: 2024-09-18
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Learn how to count specific log messages in Grafana Loki. Master LogQL, optimize queries, and create powerful visualizations for effective log analysis.
-keywords: [Grafana Loki, log counting, LogQL, log analysis, Grafana dashboards, log monitoring, SigNoz, observability]
-
+keywords:
+  [
+    Grafana Loki,
+    log counting,
+    LogQL,
+    log analysis,
+    Grafana dashboards,
+    log monitoring,
+    SigNoz,
+    observability,
+  ]
 ---
 
 In today's complex software ecosystems, effective log management is crucial for maintaining system health and troubleshooting issues. Grafana Loki, a powerful log aggregation system, offers robust capabilities for analyzing and quantifying log data. This article provides a comprehensive guide on how to count specific log messages in Grafana Loki, enabling you to gain valuable insights from your log data and enhance your observability practices.
@@ -25,44 +32,56 @@ The challenge in counting specific log messages is efficiently querying and aggr
 Counting specific log messages offers several benefits for system administrators, developers, and DevOps teams:
 
 1. Error quantification: By counting error messages, you can track the frequency of specific issues and prioritize your troubleshooting efforts.
-    - Example: Suppose you're counting error messages related to "OutOfMemory" in your logs. If they spike after a new deployment, you can prioritize fixing memory leaks.
+   - Example: Suppose you're counting error messages related to "OutOfMemory" in your logs. If they spike after a new deployment, you can prioritize fixing memory leaks.
 2. Performance optimization: Identifying recurring patterns in log messages helps pinpoint areas for performance improvements.
-    - Example: By tracking logs for slow database queries, you notice frequent "query timeout" errors, indicating that you need to optimize your database indexes.
+   - Example: By tracking logs for slow database queries, you notice frequent "query timeout" errors, indicating that you need to optimize your database indexes.
 3. Capacity planning: Tracking the volume of certain log messages over time aids in predicting resource needs and scaling decisions.
-    - Example: If you see a steady increase in "disk full" warnings over time, you can proactively add storage capacity before it impacts system performance.
+   - Example: If you see a steady increase in "disk full" warnings over time, you can proactively add storage capacity before it impacts system performance.
 4. Security monitoring: Counting authentication failures or suspicious activity logs enhances your ability to detect and respond to security threats.
-    - Example:  If you count failed login attempts and notice a surge of "invalid password" logs, you can quickly investigate potential brute-force attacks.
+   - Example: If you count failed login attempts and notice a surge of "invalid password" logs, you can quickly investigate potential brute-force attacks.
 5. Compliance reporting: Quantifying specific log events supports compliance requirements by providing concrete data on system activities.
-    - Example: To meet audit requirements, you might count all "user access" logs over a month to show that only authorized users accessed sensitive data.
+   - Example: To meet audit requirements, you might count all "user access" logs over a month to show that only authorized users accessed sensitive data.
 
 ## Setting Up Grafana Loki for Log Counting
 
 Before you can start counting log messages, you need to set up Grafana Loki and configure it to ingest your logs. Here's a brief guide to get you started:
 
 1. Install Grafana Loki using Docker or your preferred deployment method. The quickest way is with Docker:
-    
-    ```bash
-    docker run -d --name=loki -p 3100:3100 grafana/loki:latest
-    ```
-    
+
+   ```bash
+   docker run -d --name=loki -p 3100:3100 grafana/loki:latest
+   ```
+
 2. Configure log sources to send data to Loki using a compatible agent like Promtail.
 3. Add Loki as a data source in Grafana:
-    - Navigate to Configuration > Data Sources in Grafana
-        
-        <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image.webp" alt="Data source in Grafana" caption="Data source in Grafana" />
-        
-    - Click "Add data source" and select Loki
-        
-        <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%201.webp" alt="Adding Loki as data source in Grafana" caption="Adding Loki as data source in Grafana" />
-        
-    - Enter the URL of your Loki instance and save the configuration
-        
-        <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%202.webp" alt="Specifying the Loki instance URL" caption="Specifying the Loki instance URL" />
-        
-    - Save and test the data source
-        
-        <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%203.webp" alt="Testing Grafana Loki data source" caption="Testing Grafana Loki data source" />
-        
+   - Navigate to Configuration > Data Sources in Grafana
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image.webp"
+       alt="Data source in Grafana"
+       caption="Data source in Grafana"
+     />
+   - Click "Add data source" and select Loki
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%201.webp"
+       alt="Adding Loki as data source in Grafana"
+       caption="Adding Loki as data source in Grafana"
+     />
+   - Enter the URL of your Loki instance and save the configuration
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%202.webp"
+       alt="Specifying the Loki instance URL"
+       caption="Specifying the Loki instance URL"
+     />
+   - Save and test the data source
+     {' '}
+     <Figure
+       src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%203.webp"
+       alt="Testing Grafana Loki data source"
+       caption="Testing Grafana Loki data source"
+     />
 
 Best practices for log ingestion and storage:
 
@@ -74,73 +93,99 @@ Best practices for log ingestion and storage:
 
 LogQL, Loki's query language, is the key to effective log counting. Here's an introduction to its basic syntax and structure:
 
-1. Log stream selectors:  Log stream selectors specify which log streams you want to query. They are similar to label selectors in Prometheus. Here’s how they work:
-    
-    ```java
-    {job="varlogs"}
-    ```
-    
-    The query selects logs where the job label equals `varlogs` .
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%204.webp" alt="Log stream selectors" caption="Log stream selectors" />
-    
-2. Filters: Filters allow you to narrow down logs based on their content. 
-    
-    ```java
-    {job="varlogs"} |= "error" 
-    ```
-    
-    The query Filters logs to include only those containing the string error.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%205.webp" alt="Filters in LogQL" caption="Filters in LogQL" />
-    
+1. Log stream selectors: Log stream selectors specify which log streams you want to query. They are similar to label selectors in Prometheus. Here’s how they work:
+
+   ```java
+   {job="varlogs"}
+   ```
+
+   The query selects logs where the job label equals `varlogs` .
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%204.webp"
+     alt="Log stream selectors"
+     caption="Log stream selectors"
+   />
+
+2. Filters: Filters allow you to narrow down logs based on their content.
+
+   ```java
+   {job="varlogs"} |= "error"
+   ```
+
+   The query Filters logs to include only those containing the string error.
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%205.webp"
+     alt="Filters in LogQL"
+     caption="Filters in LogQL"
+   />
+
 3. Aggregation functions: Use functions like `count_over_time` to aggregate log data:
-    
-    ```
-    count_over_time({job="varlogs"}[1h])
-    ```
-    
-    This query counts the entries in the `varlogs` over the last hour.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%206.webp" alt="Aggregate functions in LogQL" caption="Aggregate functions in LogQL" />
-    
+
+   ```
+   count_over_time({job="varlogs"}[1h])
+   ```
+
+   This query counts the entries in the `varlogs` over the last hour.
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%206.webp"
+     alt="Aggregate functions in LogQL"
+     caption="Aggregate functions in LogQL"
+   />
 
 ## Advanced Techniques for Counting Specific Log Messages
 
 To count specific log messages more effectively, you can employ these advanced techniques:
 
 1. Regex patterns: Use regular expressions for flexible message matching:
-    
-    ```
-    count_over_time({app="myapp"} |~ "error.*timeout" [1h])
-    ```
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%207.webp" alt="Regex patterns in LogQL" caption="Regex patterns in LogQL" />
-    
+
+   ```
+   count_over_time({app="myapp"} |~ "error.*timeout" [1h])
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%207.webp"
+     alt="Regex patterns in LogQL"
+     caption="Regex patterns in LogQL"
+   />
+
 2. Time-based aggregations: Group counts by time intervals:
-    
-    ```
-    sum by(minute) (count_over_time({app="myapp"} |= "error" [1m]))
-    ```
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%208.webp" alt="Time-based aggregations using Loki logQL" caption="Time-based aggregations using Loki logQL" />
-    
+
+   ```
+   sum by(minute) (count_over_time({app="myapp"} |= "error" [1m]))
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%208.webp"
+     alt="Time-based aggregations using Loki logQL"
+     caption="Time-based aggregations using Loki logQL"
+   />
+
 3. Label matching: Leverage labels for precise counting:
-    
-    ```
-    sum by(status_code) (count_over_time({app="myapp", job="api"} [1h]))
-    ```
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%209.webp" alt="Label matching in Loki LogQL" caption="Label matching in Loki LogQL" />
-    
+
+   ```
+   sum by(status_code) (count_over_time({app="myapp", job="api"} [1h]))
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%209.webp"
+     alt="Label matching in Loki LogQL"
+     caption="Label matching in Loki LogQL"
+   />
+
 4. Combining queries: Use logical operators to create complex scenarios:
-    
-    ```
-    sum(count_over_time({app="myapp"} |= "error" [1h])) or vector(0)
-    ```
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2010.webp" alt="Combining queries in Loki LogQL" caption="Combining queries in Loki LogQL" />
-    
+
+   ```
+   sum(count_over_time({app="myapp"} |= "error" [1h])) or vector(0)
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2010.webp"
+     alt="Combining queries in Loki LogQL"
+     caption="Combining queries in Loki LogQL"
+   />
 
 ## Creating Visualizations for Log Counts
 
@@ -150,15 +195,23 @@ Visualizing log counts effectively in Grafana allows you to gain insights into l
 
 1. Add a New Panel: Start by creating a Grafana dashboard and specifying `Loki` as the data source.
 2. Query Configuration: Use Loki queries to fetch log counts. Adjust the query according to your log labels and desired time range. Update the query section.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2011.webp" alt="Query Configuration in Grafana Dashboard" caption="Query Configuration in Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2011.webp"
+     alt="Query Configuration in Grafana Dashboard"
+     caption="Query Configuration in Grafana Dashboard"
+   />
+
 3. Choose Visualization Type: Select the appropriate visualization type from the panel options. For log counts, the "Time series" and "Stat" panels are commonly used.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2012.webp" alt="Choosing Visualization Type in Grafana Dashboard" caption="Choosing Visualization Type in Grafana Dashboard" />
-    
-    - For a quick overview of current log counts, use the "Gauge" or "Stat" panels. These are ideal for displaying single, summary metrics.
-    - Choose the "Time series" visualization to visualize log counts over time and detect trends.
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2012.webp"
+     alt="Choosing Visualization Type in Grafana Dashboard"
+     caption="Choosing Visualization Type in Grafana Dashboard"
+   />
+
+   - For a quick overview of current log counts, use the "Gauge" or "Stat" panels. These are ideal for displaying single, summary metrics.
+   - Choose the "Time series" visualization to visualize log counts over time and detect trends.
 
 ## Optimizing Log Counting Queries
 
@@ -174,16 +227,24 @@ To ensure efficient log counting, consider these optimization tips:
 Set up automated alerts based on log counts to proactively monitor your systems:
 
 1. Create an alert rule in Grafana:
-    - Navigate to Alerting > Alert rules
-    - Define a query that counts specific log messages
-    - Set appropriate thresholds and evaluation intervals
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2013.webp" alt="Creating alerts in Grafana Dashboard" caption="Creating alerts in Grafana Dashboard" />
-    
+
+   - Navigate to Alerting > Alert rules
+   - Define a query that counts specific log messages
+   - Set appropriate thresholds and evaluation intervals
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2013.webp"
+     alt="Creating alerts in Grafana Dashboard"
+     caption="Creating alerts in Grafana Dashboard"
+   />
+
 2. Configure notification channels: Set up email, Slack, or other integrations to receive alerts
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-4efd93ec-e24f-468f-81ff-1ff356027d87.webp" alt="Configuring notification channels for alert in Grafana dashboard" caption="Configuring notification channels for alert in Grafana dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-4efd93ec-e24f-468f-81ff-1ff356027d87.webp"
+     alt="Configuring notification channels for alert in Grafana dashboard"
+     caption="Configuring notification channels for alert in Grafana dashboard"
+   />
 
 Best practices for alert management:
 
@@ -205,13 +266,19 @@ While Grafana Loki is an effective tool for log aggregation and querying, it has
 SigNoz solves many of these issues by offering a [unified observability](https://signoz.io/unified-observability/) platform that seamlessly integrates logs, metrics, and traces in a single interface. It eliminates the need for multiple tools and provides a cohesive way to monitor, troubleshoot, and analyze logs alongside other observability data. Here’s how SigNoz helps:
 
 - Unified Platform: SigNoz combines logs, metrics, and traces in one place, offering better context and more holistic analysis. You can view logs, correlate them with traces, and analyze system performance without switching between tools.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2014.webp" alt="SigNoz combines logs, metrics, and traces in one place." caption="SigNoz combines logs, metrics, and traces in one place." /> 
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2014.webp"
+    alt="SigNoz combines logs, metrics, and traces in one place."
+    caption="SigNoz combines logs, metrics, and traces in one place."
+  />
 - Built-In Visualizations: Unlike Loki, SigNoz offers native visualization capabilities for logs, metrics, and traces. This eliminates the need to use external tools like Grafana and simplifies the process of creating dashboards and reports.
-    
-    <Figure src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2015.webp" alt="SigNoz offers native visualization capabilities for logs, metrics, and traces." caption="SigNoz offers native visualization capabilities for logs, metrics, and traces." />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/grafana-loki-total-number-of-a-specific-log-message-image%2015.webp"
+    alt="SigNoz offers native visualization capabilities for logs, metrics, and traces."
+    caption="SigNoz offers native visualization capabilities for logs, metrics, and traces."
+  />
 - Advanced Log Querying: SigNoz leverages [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), providing more powerful and flexible querying capabilities. Its query system allows deeper log analysis, including correlating logs with metrics and traces for root cause analysis.
 - Scalability: SigNoz is designed to handle high log volumes with better resource management, ensuring smoother performance even in large-scale environments. It also supports distributed setups for improved scalability.
 
@@ -246,4 +313,4 @@ While Grafana Loki is powerful, it has some limitations:
 - Aggregations over very large datasets or long time ranges may require significant resources
 - Loki prioritizes recent data, so queries on older logs might be slower
 
-To overcome these limitations, optimize your queries, use efficient labeling strategies, and consider using [SigNoz](https://signoz.io/docs/introduction/) for more advanced log analysis capabilities.
\ No newline at end of file
+To overcome these limitations, optimize your queries, use efficient labeling strategies, and consider using [SigNoz](https://signoz.io/docs/introduction/) for more advanced log analysis capabilities.
diff --git a/data/guides/graphing-a-process-memory-usage.mdx b/data/guides/graphing-a-process-memory-usage.mdx
index e986acc0e..d80ac15e8 100644
--- a/data/guides/graphing-a-process-memory-usage.mdx
+++ b/data/guides/graphing-a-process-memory-usage.mdx
@@ -1,27 +1,34 @@
 ---
-
 title: How to Graph Process Memory Usage - A Step-by-Step Guide
-slug: graphing-a-process-memory-usage
 date: 2024-09-18
 tags: [faq, metrics]
 authors: [nitin_gouda]
 description: Learn how to graph process memory usage with this comprehensive guide. Discover tools, techniques, and best practices for visualizing and optimizing system performance.
-keywords: [process memory usage, memory graphing, performance monitoring, system optimization, memory profiling, Linux tools, Windows tools, SigNoz]
-
+keywords:
+  [
+    process memory usage,
+    memory graphing,
+    performance monitoring,
+    system optimization,
+    memory profiling,
+    Linux tools,
+    Windows tools,
+    SigNoz,
+  ]
 ---
 
 Process memory usage plays a crucial role in system performance and application behavior. Visualizing this data through graphs provides invaluable insights for developers and system administrators. By graphing a process's memory usage, you can identify memory leaks, optimize resource allocation, and enhance overall system efficiency. This guide will walk you through the tools, techniques, and best practices for creating informative memory usage graphs across different operating systems.
 
 ## Understanding Process Memory Usage and Its Importance
 
-Process memory usage refers to the amount of computer memory (RAM) that a running program, or process, consumes. When you run a program or application on your computer, it needs memory (RAM) to operate. 
+Process memory usage refers to the amount of computer memory (RAM) that a running program, or process, consumes. When you run a program or application on your computer, it needs memory (RAM) to operate.
 
 Think of RAM as the workspace where your computer does its thinking—it's like a desk where all the tools and materials you need are spread out. Each project or task you work on is a process, and the space it occupies on your desk represents the process memory usage. If you have a big desk (more RAM), you can spread out more papers and tools without feeling cramped, allowing you to work faster and more efficiently. However, if your desk gets too cluttered with too many projects (high process memory usage), it can become difficult to find space and manage tasks, which can slow you down. Similarly, when your computer’s memory is overused by processes, performance can degrade, making it harder to run additional programs efficiently.
 
 ### Key Terms to Know
 
 - Resident Set Size (RSS): This is the part of memory that a program is using right now—like the tools and papers currently spread out on your desk. It's the memory that's actively in use.
-- Virtual Set Size (VSZ): This is all the memory that a program *could* use, including stuff that's been set aside for later—like a stack of papers you have stored in a drawer but might pull out when you need them. It's the total space the program has claimed, even if it's not using it all right now.
+- Virtual Set Size (VSZ): This is all the memory that a program _could_ use, including stuff that's been set aside for later—like a stack of papers you have stored in a drawer but might pull out when you need them. It's the total space the program has claimed, even if it's not using it all right now.
 - Proportional Set Size (PSS): Sometimes, different programs share the same tools or files, like two people using the same book on their desks. PSS divides the memory based on how much each program is actually using. It gives you a better idea of how much memory a program is using when sharing with others.
 
 ### Significance of Monitoring Memory Usage for System Performance
@@ -49,262 +56,281 @@ Understanding which tools are available for graphing process memory usage is ess
 ### Linux-Specific Tools
 
 1. top and htop: `top` and `htop` are essential tools for real-time monitoring of system performance, including memory usage. These utilities display live updates of how much memory each process is consuming.
-    - Pros: They are built-in to most Linux distributions and are straightforward to use, making them accessible even for those new to Linux. The visual interface of `htop` provides an easier-to-read output compared to `top`.
-    - Cons: The primary limitation of these tools is their lack of advanced graphing features. They display memory usage data in a text format, which is useful for immediate analysis but not ideal for long-term monitoring or trend visualization.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.37.25_AM.webp" alt="htop command output" caption="htop command output" />
-    
+
+   - Pros: They are built-in to most Linux distributions and are straightforward to use, making them accessible even for those new to Linux. The visual interface of `htop` provides an easier-to-read output compared to `top`.
+   - Cons: The primary limitation of these tools is their lack of advanced graphing features. They display memory usage data in a text format, which is useful for immediate analysis but not ideal for long-term monitoring or trend visualization.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.37.25_AM.webp"
+     alt="htop command output"
+     caption="htop command output"
+   />
+
 2. ps command with custom scripts: The `ps` command is a versatile tool that lists running processes along with their memory usage. By combining `ps` with custom scripts, you can automate the collection of memory data and even generate graphs using other tools.
-    - Pros: This method offers significant flexibility, allowing you to tailor the data collection process to meet specific requirements. You can create detailed and customized reports on memory usage.
-    - Cons: This approach requires some knowledge of scripting, which might be challenging for beginners. It involves writing and maintaining scripts, which can be a hurdle if you're not familiar with the command line or programming.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-09_at_8.50.45_PM.webp" alt="ps command custom script output" caption="ps command custom script output" />
-    
+
+   - Pros: This method offers significant flexibility, allowing you to tailor the data collection process to meet specific requirements. You can create detailed and customized reports on memory usage.
+   - Cons: This approach requires some knowledge of scripting, which might be challenging for beginners. It involves writing and maintaining scripts, which can be a hurdle if you're not familiar with the command line or programming.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-09_at_8.50.45_PM.webp"
+     alt="ps command custom script output"
+     caption="ps command custom script output"
+   />
+
 3. sar (System Activity Reporter): `sar` is a powerful tool used to collect and report on various system activities, including memory usage over time. It allows you to gather historical data, making it easier to track trends and diagnose issues.
-    - Pros: `sar` is excellent for historical data collection and is included in many Linux distributions. It provides detailed reports that are invaluable for long-term system monitoring and analysis.
-    - Cons: The tool comes with a learning curve, especially if you're not familiar with command-line tools. Understanding and interpreting the output can be challenging for beginners.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.36.30_AM.webp" alt="sar output" caption="sar output" />
-    
+
+   - Pros: `sar` is excellent for historical data collection and is included in many Linux distributions. It provides detailed reports that are invaluable for long-term system monitoring and analysis.
+   - Cons: The tool comes with a learning curve, especially if you're not familiar with command-line tools. Understanding and interpreting the output can be challenging for beginners.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.36.30_AM.webp"
+     alt="sar output"
+     caption="sar output"
+   />
+
 4. gnuplot: `gnuplot` is a specialized graphing tool that can create detailed and customized memory usage graphs from the data you collect using other tools like `ps` or `sar`.
-    - Pros: It offers extensive customization options, supporting various types of graphs, making it suitable for both simple and complex visualizations. `gnuplot` is highly flexible and can be used to generate professional-grade charts.
-    - Cons: To use `gnuplot` effectively, you need command-line expertise and some programming knowledge. Setting up and generating graphs requires a good understanding of both the tool and the data you want to visualize.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-memory_usage.webp" alt="gnuplot graph" caption="gnuplot graph" />
-    
+
+   - Pros: It offers extensive customization options, supporting various types of graphs, making it suitable for both simple and complex visualizations. `gnuplot` is highly flexible and can be used to generate professional-grade charts.
+   - Cons: To use `gnuplot` effectively, you need command-line expertise and some programming knowledge. Setting up and generating graphs requires a good understanding of both the tool and the data you want to visualize.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-memory_usage.webp"
+     alt="gnuplot graph"
+     caption="gnuplot graph"
+   />
 
 ### Windows-Specific Tools
 
 1. Windows Performance Monitor: Windows Performance Monitor is a built-in program that tracks and displays a variety of performance data, including memory utilization. It offers real-time monitoring, which is important for identifying urgent faults or patterns in system resource utilization.
-    - Pros: Since it is included with Windows, no additional installation is required. The tool provides real-time data, which is helpful for diagnosing problems as they happen. It also offers the ability to log data over time, enabling you to create historical records of memory usage.
-    - Cons: The main limitation is its customization options. While you can track and log a variety of metrics, the interface for creating and viewing graphs is not as flexible as some third-party tools. Advanced users may find the graphing features limited in scope.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-windows_performance.webp" alt="Windows Performance Monitor" caption="Windows Performance Monitor" />
-    
+
+   - Pros: Since it is included with Windows, no additional installation is required. The tool provides real-time data, which is helpful for diagnosing problems as they happen. It also offers the ability to log data over time, enabling you to create historical records of memory usage.
+   - Cons: The main limitation is its customization options. While you can track and log a variety of metrics, the interface for creating and viewing graphs is not as flexible as some third-party tools. Advanced users may find the graphing features limited in scope.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-windows_performance.webp"
+     alt="Windows Performance Monitor"
+     caption="Windows Performance Monitor"
+   />
+
 2. Process Explorer: Process Explorer is a powerful task manager replacement developed by Microsoft. It provides detailed insights into processes running on your system, including in-depth memory usage analysis. You can see which processes are using the most memory and get detailed breakdowns of each process's memory consumption.
-    - Pros: The interface is user-friendly, making it accessible even to those new to memory management. It provides far more detailed information than the standard Task Manager, including the ability to see handles, DLLs, and memory mappings. This makes it an excellent tool for diagnosing memory issues.
-    - Cons: While Process Explorer excels at providing detailed information, it does not offer advanced graphing capabilities. If you need to create detailed visual representations of memory usage over time, you may need to export the data and use another tool for graphing.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-9554c358-df71-4ebb-86d9-63246a43885b.webp" alt="Windows Process Explorer" caption="Windows Process Explorer" />
-    
+
+   - Pros: The interface is user-friendly, making it accessible even to those new to memory management. It provides far more detailed information than the standard Task Manager, including the ability to see handles, DLLs, and memory mappings. This makes it an excellent tool for diagnosing memory issues.
+   - Cons: While Process Explorer excels at providing detailed information, it does not offer advanced graphing capabilities. If you need to create detailed visual representations of memory usage over time, you may need to export the data and use another tool for graphing.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-9554c358-df71-4ebb-86d9-63246a43885b.webp"
+     alt="Windows Process Explorer"
+     caption="Windows Process Explorer"
+   />
+
 3. PowerShell: PowerShell is a powerful scripting language built into Windows, allowing you to automate tasks and create custom solutions for monitoring memory usage. With PowerShell, you can write scripts that collect memory data at specified intervals and even generate basic graphs or export data for use in more advanced graphing tools.
-    - Pros: The flexibility of PowerShell is its greatest strength. You can tailor scripts to collect exactly the data you need and integrate it with other Windows tools. It’s a great option if you have specific requirements that off-the-shelf tools can’t meet.
-    - Cons: PowerShell requires a learning curve, especially if you are new to scripting. Writing and maintaining scripts can be challenging, particularly for beginners. However, once mastered, it provides a level of control that is unmatched by more user-friendly tools.
+   - Pros: The flexibility of PowerShell is its greatest strength. You can tailor scripts to collect exactly the data you need and integrate it with other Windows tools. It’s a great option if you have specific requirements that off-the-shelf tools can’t meet.
+   - Cons: PowerShell requires a learning curve, especially if you are new to scripting. Writing and maintaining scripts can be challenging, particularly for beginners. However, once mastered, it provides a level of control that is unmatched by more user-friendly tools.
 4. Windows Admin Center: Windows Admin Center is a web-based tool designed for managing Windows servers and PCs. It includes features for monitoring memory usage, making it particularly useful for IT professionals managing multiple machines or servers in a network.
-    - Pros: It offers a modern, centralized interface that simplifies the management of multiple systems. You can monitor memory usage across all your servers or PCs from a single dashboard, making it ideal for enterprise environments.
-    - Cons: The tool is primarily designed for server environments, so it may be overkill if you’re only monitoring a single PC or a small network. Additionally, it requires setup and configuration, which might be more complex than necessary for basic monitoring tasks.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-image.webp" alt="Managing Windows Server using [Windows Admin Center" caption="Managing Windows Server using [Windows Admin Center" />
-    
+
+   - Pros: It offers a modern, centralized interface that simplifies the management of multiple systems. You can monitor memory usage across all your servers or PCs from a single dashboard, making it ideal for enterprise environments.
+   - Cons: The tool is primarily designed for server environments, so it may be overkill if you’re only monitoring a single PC or a small network. Additionally, it requires setup and configuration, which might be more complex than necessary for basic monitoring tasks.
+
+   <Figure
+     src="/img/guides/2024/09/graphing-a-process-memory-usage-image.webp"
+     alt="Managing Windows Server using [Windows Admin Center"
+     caption="Managing Windows Server using [Windows Admin Center"
+   />
 
 ### Selecting a Tool for Graphing Process Memory Usage
 
 When selecting a tool for graphing process memory usage on Windows, consider the following factors:
 
 - Ease of use:
-If you’re new to monitoring and graphing memory usage, starting with built-in tools like Windows Performance Monitor may be more straightforward.
+  If you’re new to monitoring and graphing memory usage, starting with built-in tools like Windows Performance Monitor may be more straightforward.
 - Graphing capabilities:
-If visualizing data is a priority, you may need to combine tools or use PowerShell scripts to generate the detailed graphs you need.
+  If visualizing data is a priority, you may need to combine tools or use PowerShell scripts to generate the detailed graphs you need.
 - Data collection frequency:
-Some tools are better suited for real-time monitoring, while others excel at collecting and storing data over longer periods. Choose based on whether you need immediate insights or long-term trends.
+  Some tools are better suited for real-time monitoring, while others excel at collecting and storing data over longer periods. Choose based on whether you need immediate insights or long-term trends.
 - Historical data retention:
-If tracking memory usage over time is important, make sure the tool you choose supports logging and data retention.
+  If tracking memory usage over time is important, make sure the tool you choose supports logging and data retention.
 - Cross-platform compatibility:
-If you are managing a mixed environment with both Windows and Linux systems, consider how well your chosen tools will integrate across different platforms.
+  If you are managing a mixed environment with both Windows and Linux systems, consider how well your chosen tools will integrate across different platforms.
 
 ## Step-by-Step Guide to Graph Process Memory Usage
 
 Before you can collect memory usage data, it's essential to identify the Process ID (PID) of the specific process you want to monitor. The PID is a unique identifier that the operating system assigns to each running process, and you'll need this number to track the memory usage accurately. The steps to identify the PID vary slightly depending on whether you're using a Linux or Windows system.
 
-1. Identify the target process:
-    - On Linux: 
-    Start by launching your terminal application. To find the PID of the process, use the `ps` command combined with `grep` to search for the specific process name.
-        
-        ```bash
-        ps aux | grep process_name
-        ```
-        
-        `ps aux`: This command lists all running processes along with their details, such as the user running the process, the PID, memory usage, CPU usage, etc. 
-        
-        `grep process_name`: This part filters the output of `ps aux` to display only the lines that contain the specified process name.
-        
-        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.43.48_AM.webp" alt="Search for Process ID" caption="Search for Process ID" />
-        
-    - On Windows: 
-    Press `Win + R`, type `cmd`, and hit Enter to open the Command Prompt. To find the PID, use the `tasklist` command combined with `findstr` to filter by the process name.
-        
-        ```bash
-        tasklist | findstr process_name
-        ```
-        
-        `tasklist`: This command displays a list of all running processes on the system along with their PIDs, memory usage, and other details.
-        
-        `findstr process_name`: This filters the list to show only the lines containing the specified process name.
-        
-2. Collect memory usage data:
-Once you have the PID, you can start collecting memory usage data. This data will be used later to create the graph.
-    - On Linux: 
+1.  Identify the target process:
+    - On Linux:
+      Start by launching your terminal application. To find the PID of the process, use the `ps` command combined with `grep` to search for the specific process name.
+          ```bash
+          ps aux | grep process_name
+          ```
+
+          `ps aux`: This command lists all running processes along with their details, such as the user running the process, the PID, memory usage, CPU usage, etc.
+
+          `grep process_name`: This part filters the output of `ps aux` to display only the lines that contain the specified process name.
+
+          <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-02_at_12.43.48_AM.webp" alt="Search for Process ID" caption="Search for Process ID" />
+    - On Windows:
+      Press `Win + R`, type `cmd`, and hit Enter to open the Command Prompt. To find the PID, use the `tasklist` command combined with `findstr` to filter by the process name.
+          ```bash
+          tasklist | findstr process_name
+          ```
+
+          `tasklist`: This command displays a list of all running processes on the system along with their PIDs, memory usage, and other details.
+
+          `findstr process_name`: This filters the list to show only the lines containing the specified process name.
+2.  Collect memory usage data:
+    Once you have the PID, you can start collecting memory usage data. This data will be used later to create the graph. - On Linux:
     In the terminal, run the following command:
-        
-        ```bash
-        ps -p <PID> -o pid,rss,vsz >> memory_data.txt
-        ```
-        
-        Replace `PID` with the actual Process ID. This command appends the memory data (RSS and VSZ) to a file named `memory_data.txt`. Run this command at regular intervals to collect data over time (using a loop or cron job).
-        
-    - On Windows: 
-    In a PowerShell window, use the following command:
-        
-        ```powershell
-        Get-Process -Id PID | Select-Object Id, WorkingSet, VirtualMemorySize | Out-File memory_data.txt -Append
+            ```bash
+            ps -p <PID> -o pid,rss,vsz >> memory_data.txt
+            ```
+
+            Replace `PID` with the actual Process ID. This command appends the memory data (RSS and VSZ) to a file named `memory_data.txt`. Run this command at regular intervals to collect data over time (using a loop or cron job).
+
+        - On Windows:
+        In a PowerShell window, use the following command:
+
+            ```powershell
+            Get-Process -Id PID | Select-Object Id, WorkingSet, VirtualMemorySize | Out-File memory_data.txt -Append
+            ```
+
+            Replace `PID` with the actual Process ID. This command appends the memory data (Working Set and Virtual Memory Size) to `memory_data.txt`. Run this command at regular intervals to collect data over time (using a loop or Task Scheduler).
+
+3.  Choose graphing software:
+    For this example, we'll use Python's `matplotlib` library to create the graph. Ensure you have Python installed on your system, along with the necessary libraries. - Install Python: Download from <a href="https://www.python.org/downloads/" rel="noopener noreferrer nofollow" target="_blank">python.org</a>. - Install the required libraries by running:
+            ```bash
+            pip install matplotlib pandas
+            ```
+
+4.  Create the graph:
+    Once you have collected enough data, you can create a graph to visualize the memory usage over time. 1. Prepare Your Data
+    Ensure your `memory_data.txt` file is formatted correctly with columns for `PID`, `RSS`, and `VSZ` (or `WorkingSet` and `VirtualMemorySize` on Windows). 2. Write the Python Script:
+    Create a new Python script and include the following code:
+        ```python
+        import matplotlib.pyplot as plt
+        import pandas as pd
+
+        # Load the data with the correct separator
+        data = pd.read_csv('memory_data.txt', sep='\s+', header=0)
+
+        # Print the first few rows and column names to understand the structure
+        print("Columns:", data.columns)
+        print("First few rows of data:\n", data.head())
+
+        # Rename columns based on the actual structure
+        data.columns = ['PID', 'RSS (KB)', 'VSZ (KB)', 'Extra1', 'Extra2']
+
+        # Drop extra columns that are not needed
+        data = data[['PID', 'RSS (KB)', 'VSZ (KB)']]
+
+        # Convert RSS and VSZ from KB to MB
+        data['RSS (KB)'] = pd.to_numeric(data['RSS (KB)'], errors='coerce') / 1024
+        data['VSZ (KB)'] = pd.to_numeric(data['VSZ (KB)'], errors='coerce') / 1024
+
+        # Drop rows with NaN values in RSS or VSZ columns
+        data.dropna(subset=['RSS (KB)', 'VSZ (KB)'], inplace=True)
+
+        # Create the graph
+        plt.figure(figsize=(12, 8))
+        plt.plot(data.index, data['RSS (KB)'], label='RSS (MB)', color='blue', marker='o')
+        plt.plot(data.index, data['VSZ (KB)'], label='VSZ (MB)', color='orange', marker='x')
+        plt.xlabel('Time (samples)')
+        plt.ylabel('Memory Usage (MB)')
+        plt.title('Process Memory Usage Over Time')
+        plt.legend()
+        plt.grid(True)
+        plt.tight_layout()  # Adjust layout to prevent clipping
+        plt.savefig('memory_usage_graph.webp')
+        plt.show()
         ```
-        
-        Replace `PID` with the actual Process ID. This command appends the memory data (Working Set and Virtual Memory Size) to `memory_data.txt`. Run this command at regular intervals to collect data over time (using a loop or Task Scheduler).
-        
-3. Choose graphing software: 
-For this example, we'll use Python's `matplotlib` library to create the graph. Ensure you have Python installed on your system, along with the necessary libraries.
-    - Install Python: Download from <a href="https://www.python.org/downloads/" rel="noopener noreferrer nofollow" target="_blank">python.org</a>.
-    - Install the required libraries by running:
-        
+
+        This script reads the memory data, processes it, and generates a graph showing RSS and VSZ (or WorkingSet and VirtualMemorySize) memory usage over time.
+5.  Run the Script:
+    Save the script as `memory_usage_graph.py` and run it in your terminal or command prompt:
         ```bash
-        pip install matplotlib pandas
+        python memory_usage_graph.py
         ```
-        
-4. Create the graph:
-Once you have collected enough data, you can create a graph to visualize the memory usage over time.
-    1. Prepare Your Data
-    Ensure your `memory_data.txt` file is formatted correctly with columns for `PID`, `RSS`, and `VSZ` (or `WorkingSet` and `VirtualMemorySize` on Windows).
-    2. Write the Python Script:
-    Create a new Python script and include the following code:
-    
-    ```python
-    import matplotlib.pyplot as plt
-    import pandas as pd
-    
-    # Load the data with the correct separator
-    data = pd.read_csv('memory_data.txt', sep='\s+', header=0)
-    
-    # Print the first few rows and column names to understand the structure
-    print("Columns:", data.columns)
-    print("First few rows of data:\n", data.head())
-    
-    # Rename columns based on the actual structure
-    data.columns = ['PID', 'RSS (KB)', 'VSZ (KB)', 'Extra1', 'Extra2']
-    
-    # Drop extra columns that are not needed
-    data = data[['PID', 'RSS (KB)', 'VSZ (KB)']]
-    
-    # Convert RSS and VSZ from KB to MB
-    data['RSS (KB)'] = pd.to_numeric(data['RSS (KB)'], errors='coerce') / 1024
-    data['VSZ (KB)'] = pd.to_numeric(data['VSZ (KB)'], errors='coerce') / 1024
-    
-    # Drop rows with NaN values in RSS or VSZ columns
-    data.dropna(subset=['RSS (KB)', 'VSZ (KB)'], inplace=True)
-    
-    # Create the graph
-    plt.figure(figsize=(12, 8))
-    plt.plot(data.index, data['RSS (KB)'], label='RSS (MB)', color='blue', marker='o')
-    plt.plot(data.index, data['VSZ (KB)'], label='VSZ (MB)', color='orange', marker='x')
-    plt.xlabel('Time (samples)')
-    plt.ylabel('Memory Usage (MB)')
-    plt.title('Process Memory Usage Over Time')
-    plt.legend()
-    plt.grid(True)
-    plt.tight_layout()  # Adjust layout to prevent clipping
-    plt.savefig('memory_usage_graph.webp')
-    plt.show()
-    ```
-    
-    This script reads the memory data, processes it, and generates a graph showing RSS and VSZ (or WorkingSet and VirtualMemorySize) memory usage over time.
-    
-5. Run the Script:
-Save the script as `memory_usage_graph.py` and run it in your terminal or command prompt:
-    
-    ```bash
-    python memory_usage_graph.py
-    ```
-    
-    The script will generate a graph (`memory_usage_graph.webp`) and display it, showing how memory usage has changed over time.
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-memory_usage_graph.webp" alt="memory graph using matplotlib and panda" caption="memory graph using matplotlib and panda" />
-    
+
+        The script will generate a graph (`memory_usage_graph.webp`) and display it, showing how memory usage has changed over time.
+
+        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-memory_usage_graph.webp" alt="memory graph using matplotlib and panda" caption="memory graph using matplotlib and panda" />
 
 ### Data Collection Techniques
 
 Collecting memory usage data effectively is essential for accurate monitoring and analysis. Here are some detailed techniques to help you streamline the process:
 
 1. Automate data gathering: Automating the collection of memory usage data ensures that you consistently capture information without manual intervention.
-    1. For Linux: You can write a shell script that runs commands to get information from memory. For instance, a script may track memory usage and send the output to a file by using the `ps` command:
-        
-        ```bash
-        #!/bin/bash
-        while true
-        do
-            ps aux --sort=-%mem | head -n 10 >> /path/to/memory_data.txt
-            sleep 300  # Wait for 5 minutes before collecting data again
-        done
-        ```
-        
-    2. For Windows: Use a batch file or PowerShell script to collect data. A PowerShell script could look like this:
-        
-        ```bash
-        while ($true) {
-            Get-Process | Sort-Object -Property WorkingSet -Descending | Select-Object -First 10 | Out-File -Append -FilePath C:\path\to\memory_data.txt
-            Start-Sleep -Seconds 300  # Wait for 5 minutes before collecting data again
-        }
-        ```
-        
+   1. For Linux: You can write a shell script that runs commands to get information from memory. For instance, a script may track memory usage and send the output to a file by using the `ps` command:
+
+      ```bash
+      #!/bin/bash
+      while true
+      do
+          ps aux --sort=-%mem | head -n 10 >> /path/to/memory_data.txt
+          sleep 300  # Wait for 5 minutes before collecting data again
+      done
+      ```
+
+   2. For Windows: Use a batch file or PowerShell script to collect data. A PowerShell script could look like this:
+
+      ```bash
+      while ($true) {
+          Get-Process | Sort-Object -Property WorkingSet -Descending | Select-Object -First 10 | Out-File -Append -FilePath C:\path\to\memory_data.txt
+          Start-Sleep -Seconds 300  # Wait for 5 minutes before collecting data again
+      }
+      ```
 2. Implement scheduled tasks: To ensure data collection happens regularly without manual effort, you can set up scheduled tasks:
-    - On Linux: Use `cron`, a time-based job scheduler. You can edit your crontab file (`crontab -e`) to add a job that runs your data collection script at specified intervals. For example, to run a script every 5 minutes:
-        
-        ```jsx
-        */5 * * * * /path/to/your_script.sh
-        ```
-        
-    - On Windows: Use Task Scheduler to create a task that runs your data collection script at regular intervals. You can configure triggers and actions to specify how often and when your script should execute.
+   - On Linux: Use `cron`, a time-based job scheduler. You can edit your crontab file (`crontab -e`) to add a job that runs your data collection script at specified intervals. For example, to run a script every 5 minutes:
+     ```jsx
+     */5 * * * * /path/to/your_script.sh
+     ```
+   - On Windows: Use Task Scheduler to create a task that runs your data collection script at regular intervals. You can configure triggers and actions to specify how often and when your script should execute.
 3. Leverage system APIs: For more advanced data collection, you can use system-specific APIs to programmatically retrieve memory data.
-    - Linux: Tools like `libprocps` provide APIs to interact with system processes and retrieve memory usage information programmatically.
-    - Windows: Use Windows Management Instrumentation (WMI) to gather memory data through scripts or applications. PowerShell provides cmdlets like `Get-WmiObject` to query system performance metrics:
-    
-    ```powershell
-    Get-WmiObject -Class Win32_Process | Select-Object Name, WorkingSetSize, VirtualSize
-    ```
-    
+
+   - Linux: Tools like `libprocps` provide APIs to interact with system processes and retrieve memory usage information programmatically.
+   - Windows: Use Windows Management Instrumentation (WMI) to gather memory data through scripts or applications. PowerShell provides cmdlets like `Get-WmiObject` to query system performance metrics:
+
+   ```powershell
+   Get-WmiObject -Class Win32_Process | Select-Object Name, WorkingSetSize, VirtualSize
+   ```
+
 4. Store data efficiently: For large-scale or long-term data storage, consider using specialized databases designed for time-series data:
-    - Time-Series Databases: Tools like InfluxDB or Prometheus are optimized for storing and querying time-series data. They can handle high volumes of data efficiently and provide powerful querying capabilities for historical data analysis.
-    - Database Management: Ensure your data storage solution is well-organized, with appropriate indexing and retention policies to manage storage space and maintain performance.
+   - Time-Series Databases: Tools like InfluxDB or Prometheus are optimized for storing and querying time-series data. They can handle high volumes of data efficiently and provide powerful querying capabilities for historical data analysis.
+   - Database Management: Ensure your data storage solution is well-organized, with appropriate indexing and retention policies to manage storage space and maintain performance.
 
 ### Graphing Techniques and Best Practices
 
 Creating effective graphs to visualize memory usage is crucial for clear analysis and communication. Here are some key techniques and best practices to ensure your graphs are both informative and easy to understand:
 
 1. Choose the right graph type: Selecting the appropriate type of graph is essential for effectively conveying your data:
-    1. Line Graphs: Ideal for displaying changes over time, such as how memory usage evolves. They show trends and patterns clearly, making them suitable for time-series data.
-    2. Bar Charts: Useful for comparing memory usage across different processes or applications at a specific point in time. They provide a clear comparison between categories.
+   1. Line Graphs: Ideal for displaying changes over time, such as how memory usage evolves. They show trends and patterns clearly, making them suitable for time-series data.
+   2. Bar Charts: Useful for comparing memory usage across different processes or applications at a specific point in time. They provide a clear comparison between categories.
 2. Add context with annotations: Annotations help provide additional context and highlight significant events or thresholds on your graph:
-    1. Important Events: Mark events such as application restarts, updates, or known performance issues directly on the graph.
-    2. Thresholds: Draw lines or markers to indicate critical memory usage thresholds. This helps to quickly identify when memory usage exceeds normal limits.
-    
-    Example: If your memory usage exceeds a certain threshold, annotating this on the graph helps in identifying potential performance issues.
-    
+
+   1. Important Events: Mark events such as application restarts, updates, or known performance issues directly on the graph.
+   2. Thresholds: Draw lines or markers to indicate critical memory usage thresholds. This helps to quickly identify when memory usage exceeds normal limits.
+
+   Example: If your memory usage exceeds a certain threshold, annotating this on the graph helps in identifying potential performance issues.
+
 3. Use color effectively: Colors can help differentiate between different data series or metrics:
-    1. Contrast: Use contrasting colors to distinguish between various metrics (e.g., RSS vs. VSZ). This makes it easier to differentiate data at a glance.
-    2. Consistency: Maintain consistent color schemes across multiple graphs or reports to avoid confusion.
-    
-    Example: Use blue for RSS (Resident Set Size) and green for VSZ (Virtual Set Size) across all your graphs to ensure clarity and consistency.
-    
+
+   1. Contrast: Use contrasting colors to distinguish between various metrics (e.g., RSS vs. VSZ). This makes it easier to differentiate data at a glance.
+   2. Consistency: Maintain consistent color schemes across multiple graphs or reports to avoid confusion.
+
+   Example: Use blue for RSS (Resident Set Size) and green for VSZ (Virtual Set Size) across all your graphs to ensure clarity and consistency.
+
 4. Include a legend: A legend is crucial for explaining what each visual element on your graph represents:
-    1. Labeling: Clearly label each line, bar, or section of the graph with its corresponding metric or category.
-    2. Placement: Position the legend in a clear area of the graph where it does not obstruct the data.
-    
-    Example: If your graph includes multiple lines for different metrics, include a legend that specifies what each line represents.
-    
+
+   1. Labeling: Clearly label each line, bar, or section of the graph with its corresponding metric or category.
+   2. Placement: Position the legend in a clear area of the graph where it does not obstruct the data.
+
+   Example: If your graph includes multiple lines for different metrics, include a legend that specifies what each line represents.
+
 5. Scale appropriately: Proper scaling ensures that your graph is accurate and easy to interpret:
-    1. Consistent Units: Use consistent units for measurements (e.g., MB or GB) throughout your graph to avoid confusion.
-    2. Log Scales: For data with large ranges, consider using logarithmic scales to make trends more visible and manageable.
-    
-    Example: If memory usage spans from a few megabytes to several gigabytes, using a logarithmic scale might make the graph more readable.
-    
+
+   1. Consistent Units: Use consistent units for measurements (e.g., MB or GB) throughout your graph to avoid confusion.
+   2. Log Scales: For data with large ranges, consider using logarithmic scales to make trends more visible and manageable.
+
+   Example: If memory usage spans from a few megabytes to several gigabytes, using a logarithmic scale might make the graph more readable.
 
 By following these techniques and best practices, you can create graphs that not only represent memory usage data effectively but also provide valuable insights and facilitate better decision-making. Clear and well-designed graphs are essential for monitoring system performance, identifying issues, and communicating findings to stakeholders.
 
@@ -313,20 +339,20 @@ By following these techniques and best practices, you can create graphs that not
 Interpreting memory usage graphs effectively allows you to diagnose issues and optimize system performance. Here’s how to approach the analysis:
 
 1. Understand the metrics:
-    - RSS (Resident Set Size): Represents the actual physical memory that a process is using. This is crucial for understanding how much of your system’s RAM is being consumed by a specific process.
-    - VSZ (Virtual Set Size): Reflects the total amount of virtual memory allocated for a process, including memory that is not currently in use (e.g., memory that has been swapped out or reserved but not yet accessed). This helps gauge the total memory footprint of a process.
-    - PSS (Proportional Set Size): Provides a more accurate measure of memory usage in environments where memory is shared between processes. PSS accounts for shared memory by dividing it proportionally among the processes using it.
+   - RSS (Resident Set Size): Represents the actual physical memory that a process is using. This is crucial for understanding how much of your system’s RAM is being consumed by a specific process.
+   - VSZ (Virtual Set Size): Reflects the total amount of virtual memory allocated for a process, including memory that is not currently in use (e.g., memory that has been swapped out or reserved but not yet accessed). This helps gauge the total memory footprint of a process.
+   - PSS (Proportional Set Size): Provides a more accurate measure of memory usage in environments where memory is shared between processes. PSS accounts for shared memory by dividing it proportionally among the processes using it.
 2. Identify patterns:
-    - Gradual Increases: If you observe a steady, continuous increase in memory usage, this could be indicative of a memory leak, where memory is not being released back to the system after use.
-    - Sudden Spikes: Large, abrupt increases in memory usage often correspond to resource-intensive operations, such as loading large datasets or running complex algorithms. These spikes should be monitored to ensure they don’t cause system instability.
-    - Cyclical Patterns: Repetitive or cyclical patterns in memory usage might reflect normal application behavior, such as scheduled tasks, periodic data processing, or regular garbage collection cycles.
+   - Gradual Increases: If you observe a steady, continuous increase in memory usage, this could be indicative of a memory leak, where memory is not being released back to the system after use.
+   - Sudden Spikes: Large, abrupt increases in memory usage often correspond to resource-intensive operations, such as loading large datasets or running complex algorithms. These spikes should be monitored to ensure they don’t cause system instability.
+   - Cyclical Patterns: Repetitive or cyclical patterns in memory usage might reflect normal application behavior, such as scheduled tasks, periodic data processing, or regular garbage collection cycles.
 3. Correlate with other metrics: Memory utilization is not a stand-alone statistic. Correlate memory use with other important variables to obtain a more thorough knowledge of system performance:
-    - CPU Utilization: If your program is executing intense computations, it may be the case that both high memory utilization and high CPU usage are present.
-    - Disk I/O: If there is a rise in memory consumption together with a high disc I/O, this may indicate that data is being purged or swapped between RAM and the disc.
-    - Network Activity: In programs that use a lot of networks, spikes in memory utilization may correspond with periods of high network traffic, which might be an indication of data caching or buffer usage.
+   - CPU Utilization: If your program is executing intense computations, it may be the case that both high memory utilization and high CPU usage are present.
+   - Disk I/O: If there is a rise in memory consumption together with a high disc I/O, this may indicate that data is being purged or swapped between RAM and the disc.
+   - Network Activity: In programs that use a lot of networks, spikes in memory utilization may correspond with periods of high network traffic, which might be an indication of data caching or buffer usage.
 4. Set baselines: Establishing baseline memory usage patterns is essential for effective monitoring. By understanding what normal memory usage looks like for your application:
-    - Quick Spot Deviations: Any significant deviation from the established baseline can be an early warning sign of potential issues, such as a memory leak or a misconfiguration.
-    - Performance Optimization: Baselines help in identifying areas where memory usage can be optimized, ensuring that resources are being utilized efficiently.
+   - Quick Spot Deviations: Any significant deviation from the established baseline can be an early warning sign of potential issues, such as a memory leak or a misconfiguration.
+   - Performance Optimization: Baselines help in identifying areas where memory usage can be optimized, ensuring that resources are being utilized efficiently.
 
 ## Advanced Memory Profiling with SigNoz
 
@@ -347,12 +373,16 @@ git clone https://github.com/SigNoz/spring-petclinic.git
 ```
 
 1. Open the Project in your IDE:
-Open the cloned `spring-petclinic` directory in your preferred code editor.
+   Open the cloned `spring-petclinic` directory in your preferred code editor.
 
-<Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_9.28.05_PM.webp" alt="Spring Petclinic running on VS Code" caption="Spring Petclinic running on VS Code" />
+<Figure
+  src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_9.28.05_PM.webp"
+  alt="Spring Petclinic running on VS Code"
+  caption="Spring Petclinic running on VS Code"
+/>
 
 1. Add a `.env` file to the root project folder
-In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
+   In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
 
 ```yaml
 OTEL_COLLECTOR_ENDPOINT=ingest.{region}.signoz.cloud:443
@@ -361,15 +391,17 @@ SIGNOZ_INGESTION_KEY=***
 
 - `OTEL_COLLECTOR_ENDPOINT`: Specifies the address of the SigNoz collector where your application will send its telemetry data.
 - `SIGNOZ_INGESTION_KEY`: Authenticates your application with the SigNoz collector.
-    
-    Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your ingestion key.
-    
+  Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your ingestion key.
 
 To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
 
-<Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Untitled.webp" alt="SigNoz Ingestion Settings Page" caption="SigNoz Ingestion Settings Page" />
+<Figure
+  src="/img/guides/2024/09/graphing-a-process-memory-usage-Untitled.webp"
+  alt="SigNoz Ingestion Settings Page"
+  caption="SigNoz Ingestion Settings Page"
+/>
 
-5. Pre-Configured Changes in the Spring Boot Application: 
+5. Pre-Configured Changes in the Spring Boot Application:
 
 In the cloned repository, the necessary configurations for [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) and Micrometer have already been applied. This includes:
 
@@ -378,132 +410,128 @@ In the cloned repository, the necessary configurations for [Prometheus metrics](
 
 To learn more about how these changes were made, you can follow the [JVM Metrics Setup Guide](https://signoz.io/docs/tutorial/jvm-metrics/) on the SigNoz documentation.
 
-1. Run the Spring Boot application: 
-Navigate to the root directory of your Spring Boot project, and use the following Maven command to build the Spring Boot application:
-    
-    ```bash
-    mvn clean install
-    ```
-    
-    This command cleans the project's build directory and builds the Spring Boot application.
-    
-    ```bash
-    mvn spring-boot:run
-    ```
-    
-    This command runs the Spring Boot application, assuming a clean build is already available.
-    
-2. Configure SigNoz OTel Collector to scrape Prometheus metrics: 
-To configure the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)on your local or virtual machine, follow the steps outlined in the [Documentation](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
-    
-    Add this as the updated `config.yaml` file in the otel-contrib folder. 
-    
-    ```yaml
-    receivers:
-      otlp:
-        protocols:
-          grpc:
-            endpoint: 0.0.0.0:4317
-          http:
-            endpoint: 0.0.0.0:4318
-      hostmetrics:
-        collection_interval: 60s
-        scrapers:
-          cpu: {}
-          disk: {}
-          load: {}
-          filesystem: {}
-          memory: {}
-          network: {}
-          paging: {}
-          process:
-            mute_process_name_error: true
-            mute_process_exe_error: true
-            mute_process_io_error: true
-          processes: {}
-      prometheus:
-        config:
-          scrape_configs:
-            - job_name: "otel-collector"
-              scrape_interval: 60s
-              static_configs:
-                - targets: ["otel-collector:8889"]
-            - job_name: "jvm-metrics"
-              scrape_interval: 10s
-              metrics_path: "/actuator/prometheus"
-              static_configs:
-                - targets: ["localhost:8090"]
-    processors:
-      batch:
-        send_batch_size: 1000
-        timeout: 10s
-      # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-      resourcedetection:
-        detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-        # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-        timeout: 2s
-        system:
-          hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-    extensions:
-      health_check: {}
-      zpages: {}
-    exporters:
-      otlp:
-        endpoint: "ingest.{region}.signoz.cloud:443"
-        tls:
-          insecure: false
-        headers:
-          "signoz-ingestion-key": "<-signoz-ingestion-key->"
-      debug:
-        verbosity: normal
-    service:
-      telemetry:
-        metrics:
-          address: 0.0.0.0:8888
-      extensions: [health_check, zpages]
-      pipelines:
-        metrics:
-          receivers: [otlp]
-          processors: [batch]
-          exporters: [otlp]
-        metrics/internal:
-          receivers: [prometheus, hostmetrics]
-          processors: [resourcedetection, batch]
-          exporters: [otlp]
-        traces:
-          receivers: [otlp]
-          processors: [batch]
-          exporters: [otlp]
-        logs:
-          receivers: [otlp]
-          processors: [batch]
-          exporters: [otlp]
-    ```
-    
-
-Replace `{region}` with your region and `signoz-ingestion-key` with your actual token, or if you have set up the `.env` variables, you can use those. 
-
-1. Download OTel Java binary:
-After setting up the Otel [collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/), follow the steps below to instrument your Java Application. 
-    
-    ```bash
-    wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
-    ```
-    
-2. Run OTel Collector: 
-Once you are done instrumenting your Java application, Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step. 
-    
-    ```bash
-    ./otelcol-contrib --config ./config.yaml
-    
-    ```
-    
-
-<Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_10.37.26_PM.webp" alt="Otel Contrib running logs" caption="Otel Contrib running logs" />
-
-8. Run your application: 
-
-In a new terminal window, start your application using the Java agent. 
+1.  Run the Spring Boot application:
+    Navigate to the root directory of your Spring Boot project, and use the following Maven command to build the Spring Boot application:
+        ```bash
+        mvn clean install
+        ```
+
+        This command cleans the project's build directory and builds the Spring Boot application.
+
+        ```bash
+        mvn spring-boot:run
+        ```
+
+        This command runs the Spring Boot application, assuming a clean build is already available.
+2.  Configure SigNoz OTel Collector to scrape Prometheus metrics:
+    To configure the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)on your local or virtual machine, follow the steps outlined in the [Documentation](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
+        Add this as the updated `config.yaml` file in the otel-contrib folder.
+
+        ```yaml
+        receivers:
+          otlp:
+            protocols:
+              grpc:
+                endpoint: 0.0.0.0:4317
+              http:
+                endpoint: 0.0.0.0:4318
+          hostmetrics:
+            collection_interval: 60s
+            scrapers:
+              cpu: {}
+              disk: {}
+              load: {}
+              filesystem: {}
+              memory: {}
+              network: {}
+              paging: {}
+              process:
+                mute_process_name_error: true
+                mute_process_exe_error: true
+                mute_process_io_error: true
+              processes: {}
+          prometheus:
+            config:
+              scrape_configs:
+                - job_name: "otel-collector"
+                  scrape_interval: 60s
+                  static_configs:
+                    - targets: ["otel-collector:8889"]
+                - job_name: "jvm-metrics"
+                  scrape_interval: 10s
+                  metrics_path: "/actuator/prometheus"
+                  static_configs:
+                    - targets: ["localhost:8090"]
+        processors:
+          batch:
+            send_batch_size: 1000
+            timeout: 10s
+          # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
+          resourcedetection:
+            detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
+            # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
+            timeout: 2s
+            system:
+              hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
+        extensions:
+          health_check: {}
+          zpages: {}
+        exporters:
+          otlp:
+            endpoint: "ingest.{region}.signoz.cloud:443"
+            tls:
+              insecure: false
+            headers:
+              "signoz-ingestion-key": "<-signoz-ingestion-key->"
+          debug:
+            verbosity: normal
+        service:
+          telemetry:
+            metrics:
+              address: 0.0.0.0:8888
+          extensions: [health_check, zpages]
+          pipelines:
+            metrics:
+              receivers: [otlp]
+              processors: [batch]
+              exporters: [otlp]
+            metrics/internal:
+              receivers: [prometheus, hostmetrics]
+              processors: [resourcedetection, batch]
+              exporters: [otlp]
+            traces:
+              receivers: [otlp]
+              processors: [batch]
+              exporters: [otlp]
+            logs:
+              receivers: [otlp]
+              processors: [batch]
+              exporters: [otlp]
+        ```
+
+Replace `{region}` with your region and `signoz-ingestion-key` with your actual token, or if you have set up the `.env` variables, you can use those.
+
+1.  Download OTel Java binary:
+    After setting up the Otel [collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/), follow the steps below to instrument your Java Application.
+        ```bash
+        wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
+        ```
+2.  Run OTel Collector:
+    Once you are done instrumenting your Java application, Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step.
+        ```bash
+        ./otelcol-contrib --config ./config.yaml
+
+        ```
+
+<Figure
+  src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_10.37.26_PM.webp"
+  alt="Otel Contrib running logs"
+  caption="Otel Contrib running logs"
+/>
+
+8. Run your application:
+
+In a new terminal window, start your application using the Java agent.
 
 ```bash
 java -javaagent:<path>/opentelemetry-javaagent.jar -jar <my-app>.jar
@@ -516,48 +544,50 @@ For example:
 java -javaagent:opentelemetry-javaagent.jar -jar ./target/spring-petclinic-2.4.5.jar
 ```
 
-<Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_10.42.48_PM.webp" alt="Java application running" caption="Java application running" />
-
-1. Go to the SigNoz dashboard and plot metrics: 
-If the app and otel-contrib ran without error, all your metrics would be sent to your SigNoz cloud. The next step is to create a dashboard to view the metrics data. For SigNoz, we have shared some commonly used dashboard JSON files [here](https://github.com/SigNoz/dashboards). 
-    
-    For this example, we will use the [JVM Metrics By Service](https://github.com/SigNoz/dashboards/blob/main/jvm/jvm-metrics-by-service.json) JSON file. To know more about how to import & customize Dashboards in SigNoz check our documentation [here](https://signoz.io/docs/userguide/manage-dashboards/). 
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-1c050d4e-34ec-46dd-908e-aa2ee4b2f861.webp" alt="JVM CPU & Memory Metrics" caption="JVM CPU & Memory Metrics" />
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-21c68a0f-63e2-489a-b0ee-a80f3c49d22b.webp" alt="JVM Threads" caption="JVM Threads" />
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-ac2ebd04-027e-49df-9756-bdda382360da.webp" alt="JVM Classes" caption="JVM Classes" />
-    
-    <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-f4ffe057-1e9d-411e-ace5-14b4333c3ba1.webp" alt="JVM GC" caption="JVM GC" />
-    
+<Figure
+  src="/img/guides/2024/09/graphing-a-process-memory-usage-Screenshot_2024-09-11_at_10.42.48_PM.webp"
+  alt="Java application running"
+  caption="Java application running"
+/>
+
+1.  Go to the SigNoz dashboard and plot metrics:
+    If the app and otel-contrib ran without error, all your metrics would be sent to your SigNoz cloud. The next step is to create a dashboard to view the metrics data. For SigNoz, we have shared some commonly used dashboard JSON files [here](https://github.com/SigNoz/dashboards).
+        For this example, we will use the [JVM Metrics By Service](https://github.com/SigNoz/dashboards/blob/main/jvm/jvm-metrics-by-service.json) JSON file. To know more about how to import & customize Dashboards in SigNoz check our documentation [here](https://signoz.io/docs/userguide/manage-dashboards/).
+
+        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-1c050d4e-34ec-46dd-908e-aa2ee4b2f861.webp" alt="JVM CPU & Memory Metrics" caption="JVM CPU & Memory Metrics" />
+
+        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-21c68a0f-63e2-489a-b0ee-a80f3c49d22b.webp" alt="JVM Threads" caption="JVM Threads" />
+
+        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-ac2ebd04-027e-49df-9756-bdda382360da.webp" alt="JVM Classes" caption="JVM Classes" />
+
+        <Figure src="/img/guides/2024/09/graphing-a-process-memory-usage-f4ffe057-1e9d-411e-ace5-14b4333c3ba1.webp" alt="JVM GC" caption="JVM GC" />
 
 ## Troubleshooting Common Memory Issues
 
 Use your memory usage graphs to identify and address common issues:
 
-1. Memory leaks: 
-    - What to Look for: Even during periods of low activity, if you observe a steady, continuous increase in memory consumption over time without any corresponding decrease, it may indicate a potential issue.
-    - Solutions: Programs that neglect to release memory that is no longer required result in memory leaks. This may eventually result in excessive memory use and the depletion of available resources. To fix this:
-        - Utilise memory profiling utilities (such as Memory Profiler and Valgrind) to find objects or data structures that aren't being properly released or garbage collected.
-        - To make sure that appropriate memory management techniques are being implemented, such as releasing unneeded memory or preventing circular references, review and restructure the code.
-2. Memory fragmentation: 
-    - What to Look For: Significant discrepancies between the allocated memory (VSZ) and the memory actually in use (RSS). This can indicate that memory is allocated in a fragmented manner, causing inefficient usage.
-    - Solution: Memory fragmentation can reduce the efficiency of memory usage and lead to poor performance. To mitigate this:
-        - Implement memory pooling techniques to allocate memory in large contiguous blocks, reducing fragmentation.
-        - Adjust memory allocation strategies, such as using custom allocators that minimize fragmentation by organizing memory more efficiently.
-3. Excessive memory usage: 
-    - What to Look For: Processes that consume significantly more memory than expected, which strain system resources and affect overall performance.
-    - Solution: Excessive memory usage can be due to inefficient code or resource-intensive operations. To address this:
-        - Optimize algorithms to reduce their memory footprint. For example, switch from an O(n^2) to an O(n log n) algorithm if applicable.
-        - Use more efficient data structures that consume less memory.
-        - Implement lazy loading techniques to load data only when necessary, rather than all at once.
+1. Memory leaks:
+   - What to Look for: Even during periods of low activity, if you observe a steady, continuous increase in memory consumption over time without any corresponding decrease, it may indicate a potential issue.
+   - Solutions: Programs that neglect to release memory that is no longer required result in memory leaks. This may eventually result in excessive memory use and the depletion of available resources. To fix this:
+     - Utilise memory profiling utilities (such as Memory Profiler and Valgrind) to find objects or data structures that aren't being properly released or garbage collected.
+     - To make sure that appropriate memory management techniques are being implemented, such as releasing unneeded memory or preventing circular references, review and restructure the code.
+2. Memory fragmentation:
+   - What to Look For: Significant discrepancies between the allocated memory (VSZ) and the memory actually in use (RSS). This can indicate that memory is allocated in a fragmented manner, causing inefficient usage.
+   - Solution: Memory fragmentation can reduce the efficiency of memory usage and lead to poor performance. To mitigate this:
+     - Implement memory pooling techniques to allocate memory in large contiguous blocks, reducing fragmentation.
+     - Adjust memory allocation strategies, such as using custom allocators that minimize fragmentation by organizing memory more efficiently.
+3. Excessive memory usage:
+   - What to Look For: Processes that consume significantly more memory than expected, which strain system resources and affect overall performance.
+   - Solution: Excessive memory usage can be due to inefficient code or resource-intensive operations. To address this:
+     - Optimize algorithms to reduce their memory footprint. For example, switch from an O(n^2) to an O(n log n) algorithm if applicable.
+     - Use more efficient data structures that consume less memory.
+     - Implement lazy loading techniques to load data only when necessary, rather than all at once.
 4. Memory thrashing:
-    1. What to Look For: Rapid and frequent increases and decreases in memory usage, often accompanied by high disk I/O. This is a sign of memory thrashing, where the system spends more time swapping data between RAM and disk than executing actual processes.
-    2. Solution: Memory thrashing can severely degrade performance, as the CPU spends more time managing memory than performing useful work. To reduce thrashing:
-        - Adjust memory allocation policies to ensure that critical processes have sufficient memory without excessive swapping.
-        - Increase the amount of available RAM, if possible, to reduce reliance on disk swapping.
-        - Tune the system’s virtual memory settings to balance between performance and memory usage.
+   1. What to Look For: Rapid and frequent increases and decreases in memory usage, often accompanied by high disk I/O. This is a sign of memory thrashing, where the system spends more time swapping data between RAM and disk than executing actual processes.
+   2. Solution: Memory thrashing can severely degrade performance, as the CPU spends more time managing memory than performing useful work. To reduce thrashing:
+      - Adjust memory allocation policies to ensure that critical processes have sufficient memory without excessive swapping.
+      - Increase the amount of available RAM, if possible, to reduce reliance on disk swapping.
+      - Tune the system’s virtual memory settings to balance between performance and memory usage.
 
 By regularly monitoring and analyzing your memory usage graphs, you can identify these issues early and take corrective action. Implementing the appropriate solutions ensures that your applications run efficiently, with minimal disruptions due to memory-related problems. Regular analysis also helps prevent potential issues from escalating, maintaining optimal system performance and stability.
 
@@ -592,4 +622,4 @@ Signs of a memory leak in a usage graph include:
 - Lack of Decrease After Peaks: Memory usage remains high even after a process has finished its peak activity, rather than dropping back to normal levels.
 - Step-Like Patterns: Memory usage appears to jump in increments and never returns to previous levels, creating a stair-step effect.
 
-If you notice these patterns, it's essential to conduct a thorough investigation using memory profiling tools to identify the leak and address the issue promptly.
\ No newline at end of file
+If you notice these patterns, it's essential to conduct a thorough investigation using memory profiling tools to identify the leak and address the issue promptly.
diff --git a/data/guides/how-can-i-group-labels-in-a-prometheus-query.mdx b/data/guides/how-can-i-group-labels-in-a-prometheus-query.mdx
index c1a781d5b..02d021f21 100644
--- a/data/guides/how-can-i-group-labels-in-a-prometheus-query.mdx
+++ b/data/guides/how-can-i-group-labels-in-a-prometheus-query.mdx
@@ -1,154 +1,168 @@
 ---
-
 title: How to Group Labels in Prometheus Queries - A Practical Guide
-slug: how-can-i-group-labels-in-a-prometheus-query
 date: 2024-07-24
 tags: [prometheus, faq]
 authors: [daniel]
 description: Learn how to effectively group labels in Prometheus queries with this comprehensive guide. Master PromQL techniques for better metric analysis and visualization.
-keywords: [Prometheus queries, label grouping, PromQL, metric analysis, data visualization, group() operator, by clause, label_replace()]
-
+keywords:
+  [
+    Prometheus queries,
+    label grouping,
+    PromQL,
+    metric analysis,
+    data visualization,
+    group() operator,
+    by clause,
+    label_replace(),
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Group Labels in Prometheus Queries - A Practical Guide",
-    "alternativeHeadline": "Mastering Label Grouping in Prometheus Queries",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-can-i-group-labels-in-a-prometheus-query/"
-    },
-    "description": "Learn how to effectively group labels in Prometheus queries with this comprehensive guide. Master PromQL techniques for better metric analysis and visualization.",
-    "keywords": "Prometheus queries, label grouping, PromQL, metric analysis, data visualization, group() operator, by clause, label_replace()",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "Label Grouping",
-        "description": "A method in Prometheus to organize and aggregate metrics by their labels for better analysis and visualization."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metric Analysis",
-        "description": "The process of examining and interpreting collected metrics to understand system performance and behavior."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What's the difference between `group()` and `sum()` in Prometheus queries?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "`group()` drops specified labels without modifying values, while `sum()` aggregates values across the grouped labels."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Group Labels in Prometheus Queries - A Practical Guide',
+        alternativeHeadline: 'Mastering Label Grouping in Prometheus Queries',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How does label grouping affect Prometheus' performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Effective grouping can improve query performance by reducing the number of time series processed."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I use label grouping in Prometheus alerting rules?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, label grouping is often used in alerting rules to aggregate metrics across multiple instances or services."
-          }
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-can-i-group-labels-in-a-prometheus-query/',
         },
-        {
-          "@type": "Question",
-          "name": "Are there any limitations to the number of labels I can group in a single query?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While there's no hard limit, grouping by too many labels can impact query performance. It's best to group by only the most relevant labels for your specific use case."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Grouping Labels in Prometheus Queries",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Use the `group()` Operator",
-          "text": "Implement label grouping using the `group()` operator along with the `by` clause. Example: `group(node_cpu_seconds_total) by (instance)`."
+        description:
+          'Learn how to effectively group labels in Prometheus queries with this comprehensive guide. Master PromQL techniques for better metric analysis and visualization.',
+        keywords:
+          'Prometheus queries, label grouping, PromQL, metric analysis, data visualization, group() operator, by clause, label_replace()',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Advanced Techniques with `label_replace()`",
-          "text": "Leverage the `label_replace()` function for more complex grouping patterns. Example: `label_replace(node_cpu_seconds_total, 'node_type', '$1', 'instance', '(.*)-.*')`."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Label Grouping',
+            description:
+              'A method in Prometheus to organize and aggregate metrics by their labels for better analysis and visualization.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metric Analysis',
+            description:
+              'The process of examining and interpreting collected metrics to understand system performance and behavior.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "What's the difference between `group()` and `sum()` in Prometheus queries?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: '`group()` drops specified labels without modifying values, while `sum()` aggregates values across the grouped labels.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How does label grouping affect Prometheus' performance?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Effective grouping can improve query performance by reducing the number of time series processed.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use label grouping in Prometheus alerting rules?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, label grouping is often used in alerting rules to aggregate metrics across multiple instances or services.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Are there any limitations to the number of labels I can group in a single query?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While there's no hard limit, grouping by too many labels can impact query performance. It's best to group by only the most relevant labels for your specific use case.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Combine with Other PromQL Functions",
-          "text": "Combine `group()` with other PromQL functions for powerful queries. Example: `avg(group(node_cpu_seconds_total) by (node_type))`."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Grouping Labels in Prometheus Queries',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Use the `group()` Operator',
+              text: 'Implement label grouping using the `group()` operator along with the `by` clause. Example: `group(node_cpu_seconds_total) by (instance)`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Advanced Techniques with `label_replace()`',
+              text: "Leverage the `label_replace()` function for more complex grouping patterns. Example: `label_replace(node_cpu_seconds_total, 'node_type', '$1', 'instance', '(.*)-.*')`.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Combine with Other PromQL Functions',
+              text: 'Combine `group()` with other PromQL functions for powerful queries. Example: `avg(group(node_cpu_seconds_total) by (node_type))`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Practical Examples',
+              text: 'Explore practical examples such as grouping CPU usage by core: `group(rate(node_cpu_seconds_total[5m])) by (cpu, mode)`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Follow Best Practices',
+              text: 'Choose labels wisely, maintain query readability, balance granularity and performance, and preserve necessary information.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Practical Examples",
-          "text": "Explore practical examples such as grouping CPU usage by core: `group(rate(node_cpu_seconds_total[5m])) by (cpu, mode)`."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Follow Best Practices",
-          "text": "Choose labels wisely, maintain query readability, balance granularity and performance, and preserve necessary information."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus, a powerful open-source monitoring system, relies heavily on labels to identify and organize metrics. As your monitoring setup grows, you may find yourself dealing with an overwhelming number of labels. This is where label grouping comes into play. But how can you group labels in a Prometheus query effectively?
@@ -299,6 +313,7 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With [SigNoz](https://signoz.io/docs/introduction/), you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
diff --git a/data/guides/how-can-i-join-two-metrics-in-a-prometheus-query.mdx b/data/guides/how-can-i-join-two-metrics-in-a-prometheus-query.mdx
index a27e12fcf..cbc904ebf 100644
--- a/data/guides/how-can-i-join-two-metrics-in-a-prometheus-query.mdx
+++ b/data/guides/how-can-i-join-two-metrics-in-a-prometheus-query.mdx
@@ -1,181 +1,193 @@
 ---
-
 title: How can I 'join' two metrics in a Prometheus query? - Joining Metrics in PromQL
-slug: how-can-i-join-two-metrics-in-a-prometheus-query
-date: 2024-07-24 
+date: 2024-07-24
 tags: [faq, prometheus]
 authors: [daniel]
 description: Learn how to join two metrics in Prometheus queries using PromQL. Discover techniques, best practices, and real-world examples for effective metric correlation.
-keywords: [Prometheus, PromQL, metrics, joining metrics, vector matching, label matching, monitoring, time series]
-
+keywords:
+  [
+    Prometheus,
+    PromQL,
+    metrics,
+    joining metrics,
+    vector matching,
+    label matching,
+    monitoring,
+    time series,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How can I 'join' two metrics in a Prometheus query? - Joining Metrics in PromQL",
-    "alternativeHeadline": "Learn Techniques to Join Metrics in Prometheus Using PromQL",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-can-i-join-two-metrics-in-a-prometheus-query/"
-    },
-    "description": "Learn how to join two metrics in Prometheus queries using PromQL. Discover techniques, best practices, and real-world examples for effective metric correlation.",
-    "keywords": "Prometheus, PromQL, metrics, joining metrics, vector matching, label matching, monitoring, time series",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metrics",
-        "description": "Quantitative data used to measure and track the performance of a system."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "How can I 'join' two metrics in a Prometheus query?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Joining two metrics in a Prometheus query allows you to correlate data from different sources. This process involves using PromQL (Prometheus Query Language) to combine metrics based on their labels and apply operations to the resulting data."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, allowing users to query and analyze the data using its powerful query language, PromQL."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is PromQL?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "PromQL is the query language used by Prometheus to query and analyze metrics. It enables you to retrieve, manipulate, and analyze time-series data effectively."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: "How can I 'join' two metrics in a Prometheus query? - Joining Metrics in PromQL",
+        alternativeHeadline: 'Learn Techniques to Join Metrics in Prometheus Using PromQL',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "What are the types of metrics in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus supports several metric types: Counter metrics, Gauge metrics, Histogram metrics, and Summary metrics."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What is vector matching in PromQL?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Vector matching is the primary method for joining metrics in PromQL. It allows you to combine time series based on their label sets."
-          }
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-can-i-join-two-metrics-in-a-prometheus-query/',
         },
-        {
-          "@type": "Question",
-          "name": "What are some common techniques for joining metrics in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Common techniques include vector matching, label matching, and applying mathematical operations. Advanced techniques involve using modifiers like group_left and group_right."
-          }
+        description:
+          'Learn how to join two metrics in Prometheus queries using PromQL. Discover techniques, best practices, and real-world examples for effective metric correlation.',
+        keywords:
+          'Prometheus, PromQL, metrics, joining metrics, vector matching, label matching, monitoring, time series',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "Question",
-          "name": "What are some real-world examples of joined metric queries?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Examples include calculating resource utilization percentage, error rate with traffic metrics, and correlating application latency with CPU usage."
-          }
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metrics',
+            description: 'Quantitative data used to measure and track the performance of a system.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "How can I 'join' two metrics in a Prometheus query?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Joining two metrics in a Prometheus query allows you to correlate data from different sources. This process involves using PromQL (Prometheus Query Language) to combine metrics based on their labels and apply operations to the resulting data.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, allowing users to query and analyze the data using its powerful query language, PromQL.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is PromQL?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'PromQL is the query language used by Prometheus to query and analyze metrics. It enables you to retrieve, manipulate, and analyze time-series data effectively.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the types of metrics in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus supports several metric types: Counter metrics, Gauge metrics, Histogram metrics, and Summary metrics.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is vector matching in PromQL?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Vector matching is the primary method for joining metrics in PromQL. It allows you to combine time series based on their label sets.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some common techniques for joining metrics in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Common techniques include vector matching, label matching, and applying mathematical operations. Advanced techniques involve using modifiers like group_left and group_right.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some real-world examples of joined metric queries?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Examples include calculating resource utilization percentage, error rate with traffic metrics, and correlating application latency with CPU usage.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are common pitfalls when joining metrics in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Common pitfalls include mismatched label sets, performance issues with high-cardinality metrics, and time alignment challenges.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "Question",
-          "name": "What are common pitfalls when joining metrics in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Common pitfalls include mismatched label sets, performance issues with high-cardinality metrics, and time alignment challenges."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Join Two Metrics in a Prometheus Query",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Identify the Metrics",
-          "text": "Identify the metrics you want to join, such as http_requests_total and http_errors_total."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Join Two Metrics in a Prometheus Query',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Identify the Metrics',
+              text: 'Identify the metrics you want to join, such as http_requests_total and http_errors_total.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Analyze Label Sets',
+              text: 'Analyze the label sets of both metrics to find common labels.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Construct the Query',
+              text: 'Construct the basic query structure using the identified metrics and operator.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Label Matching',
+              text: 'Add label matching criteria to the query.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Apply Operations or Aggregations',
+              text: 'Apply additional operations or aggregations to derive meaningful insights.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Analyze Label Sets",
-          "text": "Analyze the label sets of both metrics to find common labels."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Construct the Query",
-          "text": "Construct the basic query structure using the identified metrics and operator."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Add Label Matching",
-          "text": "Add label matching criteria to the query."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Apply Operations or Aggregations",
-          "text": "Apply additional operations or aggregations to derive meaningful insights."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Joining two metrics in a Prometheus query allows you to correlate data from different sources, providing deeper insights into your system's behavior. This process involves using PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) to combine metrics based on their labels and apply operations to the resulting data. By mastering metric joining, you'll unlock powerful analysis capabilities for your monitoring and observability needs.
@@ -358,8 +370,9 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With SigNoz, you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
 - Get high performance with the clickhouse database
-- Take advantage of SigNoz's exceptional exception monitoring capabilities
\ No newline at end of file
+- Take advantage of SigNoz's exceptional exception monitoring capabilities
diff --git a/data/guides/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps.mdx b/data/guides/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps.mdx
index d70b1e38d..6c74404ca 100644
--- a/data/guides/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps.mdx
+++ b/data/guides/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Limit Apache Access Log Size and Archives - A Quick Guide
-slug: how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps
 date: 2024-10-14
 tags: [faq]
 authors: [niyati_thakkar]
 description: Learn how to effectively manage Apache access logs by limiting their size and controlling archives. Optimize server performance and storage with this guide.
-keywords: [Apache access logs, log rotation, log management, server performance, rotatelogs, logrotate, SigNoz]
-
+keywords:
+  [
+    Apache access logs,
+    log rotation,
+    log management,
+    server performance,
+    rotatelogs,
+    logrotate,
+    SigNoz,
+  ]
 ---
 
 Apache access logs are essential for monitoring website traffic, identifying security threats, and troubleshooting performance issues. However, large access logs can consume significant disk space and impact server performance. Effective management of access logs is crucial for maintaining a healthy and efficient web server.
@@ -104,24 +110,23 @@ sudo systemctl restart apache2
 
 To ensure that your log rotation settings are working correctly, follow these steps:
 
-1. Generate traffic: Use a tool like `curl` or browse your website to generate some traffic, which will be written to the Apache logs. For example, 
-    
-    ```bash
-    for i in {1..10000}; do
-        curl http://localhost > /dev/null 2>&1
-    done
-    ```
-    
-    This will generate 10,000 requests to your server, quickly filling up the log files and triggering a rotation based on your size limits.
-    
+1. Generate traffic: Use a tool like `curl` or browse your website to generate some traffic, which will be written to the Apache logs. For example,
+
+   ```bash
+   for i in {1..10000}; do
+       curl http://localhost > /dev/null 2>&1
+   done
+   ```
+
+   This will generate 10,000 requests to your server, quickly filling up the log files and triggering a rotation based on your size limits.
+
 2. Monitor log files: Check the `/var/log/apache2/` directory for new log files using the command:
-    
-    ```bash
-    ls -lh /var/log/apache2/
-    ```
-    
-    You should see the log files following the naming pattern with the date (e.g., `access_log.2023-09-27`).
-    
+
+   ```bash
+   ls -lh /var/log/apache2/
+   ```
+
+   You should see the log files following the naming pattern with the date (e.g., `access_log.2023-09-27`).
 
 3. Check log file sizes: Ensure that the log files are being rotated when they exceed 1 MB in size. You can simulate high traffic using a loop to quickly generate enough logs for rotation:
 
@@ -136,18 +141,14 @@ While the `rotatelogs` utility efficiently handles log rotation based on size or
 If `logrotate` is not already installed on your system, you can easily install it using your package manager. Run the following commands based on your Linux distribution:
 
 - Ubuntu/Debian:
-    
-    ```bash
-    sudo apt-get update
-    sudo apt-get install logrotate
-    ```
-    
+  ```bash
+  sudo apt-get update
+  sudo apt-get install logrotate
+  ```
 - Once installed, you can verify the installation with:
-    
-    ```bash
-    logrotate --version
-    ```
-    
+  ```bash
+  logrotate --version
+  ```
 
 ### Step 2: Configure `logrotate` for Apache Logs
 
@@ -200,7 +201,17 @@ Example:
 
 For the above configuration for test purpose, below is the output:
 
-<Figure src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-image.webp" alt="" caption="" />The output from the `logrotate` command shows that log rotation for the application logs in `/var/log/myapp/*.log` is functioning correctly. It indicates that the log file `my_app.log` has exceeded the 10 MB size limit, triggering a rotation. Old logs are renamed sequentially (e.g., `my_app.log.4` becomes `my_app.log.5`), while a new log file (`my_app.log.1`) is created with the appropriate permissions (0644). The process also removes any empty log files, confirming that the log rotation setup operates as intended for efficient log management.
+<Figure
+  src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-image.webp"
+  alt=""
+  caption=""
+/>
+The output from the `logrotate` command shows that log rotation for the application logs in
+`/var/log/myapp/*.log` is functioning correctly. It indicates that the log file `my_app.log` has
+exceeded the 10 MB size limit, triggering a rotation. Old logs are renamed sequentially (e.g.,
+`my_app.log.4` becomes `my_app.log.5`), while a new log file (`my_app.log.1`) is created with the
+appropriate permissions (0644). The process also removes any empty log files, confirming that the
+log rotation setup operates as intended for efficient log management.
 
 ### Step 4: Apply the Logrotate Configuration
 
@@ -214,9 +225,17 @@ This command will read the configuration file at `/etc/logrotate.d/apache2` and
 
 When the command is run without `-d` single log file is divided into multiple log files as shown below:
 
-<Figure src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-image_(5).webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-image_(5).webp"
+  alt=""
+  caption=""
+/>
 
-<Figure src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-Screenshot_2024-10-05_231748.webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/10/how-can-i-limit-the-size-of-apache-access-log-and-limit-the-number-of-archived-logs-it-keeps-Screenshot_2024-10-05_231748.webp"
+  alt=""
+  caption=""
+/>
 
 ## Advanced Configuration: Managing Logs for Virtual Hosts
 
@@ -319,21 +338,18 @@ While Apache's built-in tools are effective for basic log management, modern obs
 
 To get started with SigNoz for Apache log management:
 
-1. Sign Up for SigNoz Cloud:
-Start by signing up for [SigNoz Cloud](https://signoz.io/teams/). This cloud-based service provides a hassle-free setup and management experience, eliminating the need for infrastructure management.
-    
-    <GetStartedSigNoz />
-    
-2. Configure Apache to Send Logs to SigNoz:
-Once installed, configure the log forwarder to connect to your SigNoz Cloud instance. This typically involves providing the SigNoz Cloud endpoint and your API token. Refer to the [SigNoz documentation](https://signoz.io/guides/apache-log/) for specific instructions.
-3. Access the SigNoz Cloud Dashboard:
-After setting up your logs, access the SigNoz Cloud Dashboard via your web browser. This intuitive interface allows you to view and analyze your Apache logs alongside other observability data.
-    
-    SigNoz Cloud enhances your experience by providing:
-    
-    - Scalability: Easily scale your observability as your infrastructure grows without the complexities of managing on-premises solutions.
-    - Maintenance-Free Operation: With SigNoz Cloud, you don’t need to worry about updates, server maintenance, or scaling challenges.
-    - Integrated Insights: Leverage built-in analytics to gain insights into application performance, log trends, and potential issues across your systems.
+1.  Sign Up for SigNoz Cloud:
+    Start by signing up for [SigNoz Cloud](https://signoz.io/teams/). This cloud-based service provides a hassle-free setup and management experience, eliminating the need for infrastructure management.
+        <GetStartedSigNoz />
+2.  Configure Apache to Send Logs to SigNoz:
+    Once installed, configure the log forwarder to connect to your SigNoz Cloud instance. This typically involves providing the SigNoz Cloud endpoint and your API token. Refer to the [SigNoz documentation](https://signoz.io/guides/apache-log/) for specific instructions.
+3.  Access the SigNoz Cloud Dashboard:
+    After setting up your logs, access the SigNoz Cloud Dashboard via your web browser. This intuitive interface allows you to view and analyze your Apache logs alongside other observability data.
+        SigNoz Cloud enhances your experience by providing:
+
+        - Scalability: Easily scale your observability as your infrastructure grows without the complexities of managing on-premises solutions.
+        - Maintenance-Free Operation: With SigNoz Cloud, you don’t need to worry about updates, server maintenance, or scaling challenges.
+        - Integrated Insights: Leverage built-in analytics to gain insights into application performance, log trends, and potential issues across your systems.
 
 By leveraging SigNoz Cloud, you not only enhance your log management but also improve the overall observability of your Apache server. This integration allows for quicker identification and resolution of issues compared to traditional log analysis methods, making it a valuable addition to your logging strategy. With SigNoz Cloud, enjoy the advantages of a robust observability platform without the overhead of managing the infrastructure, allowing your team to focus on building and improving applications.
 
@@ -384,4 +400,4 @@ Then,
 sudo a2enmod wsgi
 ```
 
-After the above steps, `sudo systemctl reload apache2` will be needed.
\ No newline at end of file
+After the above steps, `sudo systemctl reload apache2` will be needed.
diff --git a/data/guides/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana.mdx b/data/guides/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana.mdx
index ec09e2ef7..081228c94 100644
--- a/data/guides/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana.mdx
+++ b/data/guides/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Sort Legends by Series Name in Prometheus and Grafana
-slug: how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana
 date: 2024-09-24
 tags: [faq, prometheus, grafana]
 authors: [simran_kumari]
 description: Learn how to sort legends by series name in Prometheus and Grafana for improved data visualization and analysis. Discover step-by-step methods and best practices.
-keywords: [legend sorting, Prometheus, Grafana, time series data, data visualization, PromQL, observability, SigNoz]
-
+keywords:
+  [
+    legend sorting,
+    Prometheus,
+    Grafana,
+    time series data,
+    data visualization,
+    PromQL,
+    observability,
+    SigNoz,
+  ]
 ---
 
 In the world of data analysis, getting quick, clear insights is key. When your graphs are cluttered with disorganized legends, spotting trends or comparing time series becomes a headache. This guide will walk you through sorting legends in Prometheus and Grafana, improving your data visualization workflow. We’ll cover everything from built-in options to advanced PromQL techniques.
@@ -16,15 +23,19 @@ In the world of data analysis, getting quick, clear insights is key. When your g
 
 Legends in data visualization serve as keys to interpreting the information displayed in graphs or charts. In the context of Prometheus and Grafana, legends are essential for decoding time series data. They provide context to the plotted lines, helping you distinguish between different metrics or dimensions of your data.
 
-<Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image.webp" alt="Legends in Grafana dashboard based on data collected from Prometheus" caption="Legends in Grafana dashboard based on data collected from Prometheus" />
+<Figure
+  src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image.webp"
+  alt="Legends in Grafana dashboard based on data collected from Prometheus"
+  caption="Legends in Grafana dashboard based on data collected from Prometheus"
+/>
 
 Prometheus generates legends based on the metric names and labels associated with the data it collects. When visualized in Grafana, these legends become critical for interpreting complex, multi-dimensional datasets. A well-organized legend can significantly enhance your ability to analyze trends, spot anomalies, and draw insights from your time series data.
 
-Having understood legends, next thing which comes into mind is `series name`. 
+Having understood legends, next thing which comes into mind is `series name`.
 
 ### What is `Series Name` ?
 
-In the context of Prometheus and Grafana, a series name refers to the unique identifier for a specific set of time series data. 
+In the context of Prometheus and Grafana, a series name refers to the unique identifier for a specific set of time series data.
 
 It typically includes the metric name and a combination of its associated labels. Here's a breakdown:
 
@@ -32,17 +43,17 @@ Components of a Series Name
 
 1. Metric Name: This is the primary identifier for the metric being tracked. For example, `http_requests_total` is a metric name that counts the total number of HTTP requests.
 2. Labels: Labels are key-value pairs that provide additional context for the metric. They help differentiate between different instances of the same metric.
-    
-    For instance, a series might look like:
-    
-    ```lua
-    http_requests_total{method="GET", status="200"}
-    ```
-    
-    In this example:
-    
-    - `http_requests_total` is the metric name
-    - `method="GET"` and `status="200"` are labels
+
+   For instance, a series might look like:
+
+   ```lua
+   http_requests_total{method="GET", status="200"}
+   ```
+
+   In this example:
+
+   - `http_requests_total` is the metric name
+   - `method="GET"` and `status="200"` are labels
 
 Example
 
@@ -78,36 +89,63 @@ There are several methods to sort legends by series name in Grafana:
 
 Grafana 7 and later versions offer built-in options for legend sorting:
 
-1. In the Grafana Dashboard go to `Dashboards` section and select the dashboard for which you want to edit the panel. 
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%201.webp" alt="Selecting dashboards in Grafana" caption="Selecting dashboards in Grafana" />
-    
+1. In the Grafana Dashboard go to `Dashboards` section and select the dashboard for which you want to edit the panel.
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%201.webp"
+     alt="Selecting dashboards in Grafana"
+     caption="Selecting dashboards in Grafana"
+   />
+
 2. Select the panel you want to work with within the dashboard and click the `Edit` option.
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%202.webp" alt="Selecting Panel in Grafana Dashboard" caption="Selecting Panel in Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%202.webp"
+     alt="Selecting Panel in Grafana Dashboard"
+     caption="Selecting Panel in Grafana Dashboard"
+   />
+
 3. Navigate to the "Legend" tab in the panel settings.
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%203.webp" alt="Navigating to Legends tab in Panel settings" caption="Navigating to Legends tab in Panel settings" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%203.webp"
+     alt="Navigating to Legends tab in Panel settings"
+     caption="Navigating to Legends tab in Panel settings"
+   />
+
 4. Under Mode, select Table.
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%204.webp" alt="Selecting Legend Mode" caption="Selecting Legend Mode" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%204.webp"
+     alt="Selecting Legend Mode"
+     caption="Selecting Legend Mode"
+   />
+
 5. Under Values, select the value or calculation that you want to show. The legend table now displays values.
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%205.webp" alt="Selecting Legend Values" caption="Selecting Legend Values" />
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-Screenshot_2024-09-19_212729.webp" alt="Values get added to the Legend table" caption="Values get added to the Legend table" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%205.webp"
+     alt="Selecting Legend Values"
+     caption="Selecting Legend Values"
+   />
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-Screenshot_2024-09-19_212729.webp"
+     alt="Values get added to the Legend table"
+     caption="Values get added to the Legend table"
+   />
+
 6. Click the calculation name header in the legend table to sort the values in the table in ascending or descending order.
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%206.webp" alt="Sorting Legend table based on Values" caption="Sorting Legend table based on Values" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%206.webp"
+     alt="Sorting Legend table based on Values"
+     caption="Sorting Legend table based on Values"
+   />
 
 ### 2. Leveraging Prometheus Query Functions
 
-While Prometheus doesn't have direct sorting functions, you can use label manipulation to influence legend order. 
+While Prometheus doesn't have direct sorting functions, you can use label manipulation to influence legend order.
 
 To use `sort_by_label()` or `sort_by_label_desc()`, you must enable the experimental feature in Prometheus by passing the feature flag:
 
@@ -115,26 +153,34 @@ To use `sort_by_label()` or `sort_by_label_desc()`, you must enable the experime
 --enable-feature=promql-experimental-function
 ```
 
-<Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%207.webp" alt="Enabling experimental feature on Prometheus" caption="Enabling experimental feature on Prometheus" />
+<Figure
+  src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%207.webp"
+  alt="Enabling experimental feature on Prometheus"
+  caption="Enabling experimental feature on Prometheus"
+/>
 
 After enabling the flag, you can sort by label values directly. For example:
 
 - Ascending order by label value (`generation` in this case):
-    
-    ```
-    sort_by_label(python_gc_objects_collected_total, "generation")
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-c21d717b-09a3-4a6b-8136-bf5b03ad29b0.webp" alt="Running PromQL to sort legends in ascending order" caption="Running PromQL to sort legends in ascending order" />
-    
+  ```
+  sort_by_label(python_gc_objects_collected_total, "generation")
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-c21d717b-09a3-4a6b-8136-bf5b03ad29b0.webp"
+    alt="Running PromQL to sort legends in ascending order"
+    caption="Running PromQL to sort legends in ascending order"
+  />
 - Descending order by label value (`generation`):
-    
-    ```
-    sort_by_label_desc(python_gc_objects_collected_total, "generation")
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-1f17fa86-4142-43cc-9d27-19c8adf727fb.webp" alt="Running PromQL to sort legends in descending order" caption="Running PromQL to sort legends in descending order" />
-    
+  ```
+  sort_by_label_desc(python_gc_objects_collected_total, "generation")
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-1f17fa86-4142-43cc-9d27-19c8adf727fb.webp"
+    alt="Running PromQL to sort legends in descending order"
+    caption="Running PromQL to sort legends in descending order"
+  />
 
 ## Best Practices for Legend Management in Time Series Visualizations
 
@@ -143,7 +189,11 @@ Follow these best practices to make the most of your legend sorting efforts:
 - Consistent Naming: Use clear and uniform names for series to enhance readability.
 - Color Selection: Choose contrasting colors for better visibility, considering color blindness.
 
-<Figure src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%208.webp" alt="Consistent naming and Color selection in Grafana Time-series visualization" caption="Consistent naming and Color selection in Grafana Time-series visualization" />
+<Figure
+  src="/img/guides/2024/09/how-can-i-sort-the-legend-by-series-name-in-prometheus-grafana-image%208.webp"
+  alt="Consistent naming and Color selection in Grafana Time-series visualization"
+  caption="Consistent naming and Color selection in Grafana Time-series visualization"
+/>
 
 - Limit Series: Avoid overcrowding the legend; focus on key metrics to maintain clarity.
 - Grouping: Group-related metrics to improve intuitive understanding.
@@ -200,4 +250,4 @@ Yes. You can use [PromQL functions](https://signoz.io/guides/promql-cheat-sheet/
 
 ### What are the alternatives to native legend sorting in Prometheus/Grafana?
 
-Alternatives include using external data processing tools, implementing server-side sorting with middleware, or exploring comprehensive observability platforms like SigNoz that offer advanced legend management features.
\ No newline at end of file
+Alternatives include using external data processing tools, implementing server-side sorting with middleware, or exploring comprehensive observability platforms like SigNoz that offer advanced legend management features.
diff --git a/data/guides/how-do-i-add-alerts-to-prometheus.mdx b/data/guides/how-do-i-add-alerts-to-prometheus.mdx
index 1535a989a..debee9100 100644
--- a/data/guides/how-do-i-add-alerts-to-prometheus.mdx
+++ b/data/guides/how-do-i-add-alerts-to-prometheus.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How Do I Add Alerts to Prometheus - Step-by-Step Guide
-slug: how-do-i-add-alerts-to-prometheus
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Learn how to add alerts to Prometheus with this comprehensive guide. Set up Alertmanager, create rules, and configure notifications for effective monitoring.
 keywords: [Prometheus alerts, Alertmanager, monitoring, PromQL, notification channels, alert rules]
-
 ---
 
 Prometheus, a powerful open-source monitoring system, allows you to set up alerts to stay informed about critical issues in your infrastructure. This guide walks you through the process of adding alerts to Prometheus, from understanding the basics to implementing best practices.
@@ -37,10 +34,9 @@ route:
   receiver: 'email-notifications'
 
 receivers:
-- name: 'email-notifications'
-  email_configs:
-  - to: 'your-email@example.com'
-
+  - name: 'email-notifications'
+    email_configs:
+      - to: 'your-email@example.com'
 ```
 
 1. Start Alertmanager with the configuration file:
@@ -58,17 +54,16 @@ Alerting rules in Prometheus define the conditions that trigger alerts. Here's a
 
 ```yaml
 groups:
-- name: example
-  rules:
-  - alert: HighCPUUsage
-    expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
-    for: 5m
-    labels:
-      severity: warning
-    annotations:
-      summary: "High CPU usage detected"
-      description: "CPU usage is above 80% on {{ $labels.instance }}"
-
+  - name: example
+    rules:
+      - alert: HighCPUUsage
+        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: 'High CPU usage detected'
+          description: 'CPU usage is above 80% on {{ $labels.instance }}'
 ```
 
 This rule alerts when CPU usage exceeds 80% for 5 minutes. To implement alerting rules:
@@ -78,8 +73,7 @@ This rule alerts when CPU usage exceeds 80% for 5 minutes. To implement alerting
 
 ```yaml
 rule_files:
-  - "alert.rules.yml"
-
+  - 'alert.rules.yml'
 ```
 
 1. Reload Prometheus to apply the new rules:
@@ -124,11 +118,10 @@ Add this to your Alertmanager configuration:
 
 ```yaml
 receivers:
-- name: 'slack-notifications'
-  slack_configs:
-  - api_url: '<https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX>'
-    channel: '#alerts'
-
+  - name: 'slack-notifications'
+    slack_configs:
+      - api_url: '<https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX>'
+        channel: '#alerts'
 ```
 
 ### PagerDuty Integration
@@ -137,10 +130,9 @@ For critical alerts, configure PagerDuty:
 
 ```yaml
 receivers:
-- name: 'pagerduty-notifications'
-  pagerduty_configs:
-  - service_key: '<your-pagerduty-service-key>'
-
+  - name: 'pagerduty-notifications'
+    pagerduty_configs:
+      - service_key: '<your-pagerduty-service-key>'
 ```
 
 ### Email Alerts
@@ -149,15 +141,14 @@ Set up email notifications using Gmail:
 
 ```yaml
 receivers:
-- name: 'email-notifications'
-  email_configs:
-  - to: 'your-email@example.com'
-    from: 'alertmanager@example.com'
-    smarthost: 'smtp.gmail.com:587'
-    auth_username: 'your-gmail-username@gmail.com'
-    auth_identity: 'your-gmail-username@gmail.com'
-    auth_password: 'your-gmail-password'
-
+  - name: 'email-notifications'
+    email_configs:
+      - to: 'your-email@example.com'
+        from: 'alertmanager@example.com'
+        smarthost: 'smtp.gmail.com:587'
+        auth_username: 'your-gmail-username@gmail.com'
+        auth_identity: 'your-gmail-username@gmail.com'
+        auth_password: 'your-gmail-password'
 ```
 
 ## Best Practices for Prometheus Alerting
@@ -194,7 +185,6 @@ Yes, Alertmanager supports Go templating for customizing alert notifications. Th
 
 You can silence alerts through the Alertmanager UI or API. Inhibition rules in Alertmanager allow you to suppress certain alerts if others are already firing.
 
-
 ## Enhance Your Monitoring with SigNoz
 
 While Prometheus offers powerful monitoring capabilities, managing and visualizing complex metrics can be challenging. SigNoz provides a comprehensive solution that builds upon Prometheus' strengths while offering enhanced visualization and analysis tools.
@@ -208,4 +198,4 @@ With SigNoz, you can:
 - Set up alerts based on complex queries and thresholds
 - Correlate metrics with traces for deeper insights into application performance
 
-By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
\ No newline at end of file
+By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
diff --git a/data/guides/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts.mdx b/data/guides/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts.mdx
index 6a186fb73..8033eff8b 100644
--- a/data/guides/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts.mdx
+++ b/data/guides/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Delete Time Series Alerts in Prometheus v2
-slug: how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts
 date: 2024-11-14
 tags: [faq, prometheus]
 authors: [nitin_gouda]
 description: Learn how to effectively delete time series alerts in Prometheus v2. This guide covers prerequisites, step-by-step instructions, and best practices for alert management.
-keywords: [Prometheus v2, time series alerts, delete alerts, TSDB Admin API, alert management, monitoring, SigNoz]
-
+keywords:
+  [
+    Prometheus v2,
+    time series alerts,
+    delete alerts,
+    TSDB Admin API,
+    alert management,
+    monitoring,
+    SigNoz,
+  ]
 ---
 
 Prometheus is a powerful monitoring and alerting toolkit, but managing its time series alerts can be challenging. You might need to delete specific alerts to maintain system efficiency or remove outdated data. This guide walks you through the process of deleting time series alerts in Prometheus v2, covering everything from prerequisites to best practices.
@@ -44,38 +50,34 @@ Because alerts are embedded within the time series data, deleting alerts is not
 
 Before proceeding to delete any alerts in Prometheus, it is crucial to ensure that you meet the following prerequisites. This will help safeguard your data and streamline the deletion process:
 
-1. Enable the Admin API: 
-The Admin API must be enabled in your Prometheus v2 configuration to manage alerts effectively. In order to use some of the advanced Prometheus features (like being able to call the snapshot API), you need to enable the Web API which can easily be done with command line flag, to do this, you need to add the following flag to your Prometheus startup command: 
-    
-    ```
-    --web.enable-admin-api
-    ```
-    
-    Enabling this API provides access to administrative functions, including the ability to delete alerts, which is essential for maintaining the integrity of your monitoring setup.
-    
-    Once enabled you can make administrative requests, for example to trigger a snapshot creation like so:
-    
-    ```
-    curl -XPOST http://localhost:9090/api/v1/admin/tsdb/snapshot
-    ```
-    
-    <Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-04_at_5.49.28_PM.webp" alt="Using Prometheus API to create a snapshot of current time series data" caption="Using Prometheus API to create a snapshot of current time series data" />
-    
-2. Permissions: 
-Ensure you have the necessary permissions to access and modify Prometheus data. This typically means having administrative privileges or being part of a user group that has been granted the required access rights. Without appropriate permissions, you may encounter errors or be unable to perform deletion actions.
-3. Understand Label Matchers: 
-Familiarize yourself with Prometheus label matchers, which are critical for targeting specific alerts accurately. Label matchers allow you to filter alerts based on their labels, ensuring that you delete only the alerts you intend to remove. For example, understanding how to use operators like `=`, `!=`, `=~`, and `!~` will enable you to specify which alerts to delete more precisely.
-4. Backup Your Data: 
-Always create a backup of your Prometheus data before performing any deletions. This is a crucial step to prevent data loss in case you need to restore alerts later. You can use the following command to back up your data:
-    
-    ```
-    promtool tsdb dump <data-directory>
-    ```
-    
-    <Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-04_at_9.47.12_PM.webp" alt="Extracting and backing up Prometheus time series data using `promtool tsdb dump`" caption="Extracting and backing up Prometheus time series data using `promtool tsdb dump`" />
-    
-    This command will create a snapshot of your current Prometheus state, allowing you to restore it if necessary. By having a backup, you can confidently manage your alerts, knowing you have a safeguard in place.
-    
+1.  Enable the Admin API:
+    The Admin API must be enabled in your Prometheus v2 configuration to manage alerts effectively. In order to use some of the advanced Prometheus features (like being able to call the snapshot API), you need to enable the Web API which can easily be done with command line flag, to do this, you need to add the following flag to your Prometheus startup command:
+        ```
+        --web.enable-admin-api
+        ```
+
+        Enabling this API provides access to administrative functions, including the ability to delete alerts, which is essential for maintaining the integrity of your monitoring setup.
+
+        Once enabled you can make administrative requests, for example to trigger a snapshot creation like so:
+
+        ```
+        curl -XPOST http://localhost:9090/api/v1/admin/tsdb/snapshot
+        ```
+
+        <Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-04_at_5.49.28_PM.webp" alt="Using Prometheus API to create a snapshot of current time series data" caption="Using Prometheus API to create a snapshot of current time series data" />
+2.  Permissions:
+    Ensure you have the necessary permissions to access and modify Prometheus data. This typically means having administrative privileges or being part of a user group that has been granted the required access rights. Without appropriate permissions, you may encounter errors or be unable to perform deletion actions.
+3.  Understand Label Matchers:
+    Familiarize yourself with Prometheus label matchers, which are critical for targeting specific alerts accurately. Label matchers allow you to filter alerts based on their labels, ensuring that you delete only the alerts you intend to remove. For example, understanding how to use operators like `=`, `!=`, `=~`, and `!~` will enable you to specify which alerts to delete more precisely.
+4.  Backup Your Data:
+    Always create a backup of your Prometheus data before performing any deletions. This is a crucial step to prevent data loss in case you need to restore alerts later. You can use the following command to back up your data:
+        ```
+        promtool tsdb dump <data-directory>
+        ```
+
+        <Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-04_at_9.47.12_PM.webp" alt="Extracting and backing up Prometheus time series data using `promtool tsdb dump`" caption="Extracting and backing up Prometheus time series data using `promtool tsdb dump`" />
+
+        This command will create a snapshot of your current Prometheus state, allowing you to restore it if necessary. By having a backup, you can confidently manage your alerts, knowing you have a safeguard in place.
 
 ## Step-by-Step Guide: Deleting Time Series Alerts
 
@@ -87,26 +89,28 @@ Before deleting alerts, you need to precisely identify which alerts you want to
 
 - Using the Prometheus UI: Navigate to the Alerts page (typically at `/alerts`) in your Prometheus web interface. This provides a visual overview of all configured alerts and their current states.
 - Using PromQL Queries: You can use label matchers in PromQL to identify specific alerts. Label matchers let you precisely target alerts based on their labels, such as `alertname`, `severity`, or `instance`. To identify an alert in Prometheus, use a query with PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)):
-    
-    ```java
-    # Query for a specific alert by name
-    ALERTS{alertname="YourAlertName"}
-    
-    # Query with multiple label matchers
-    ALERTS{alertname="YourAlertName", severity="critical", instance="instance-name"}
-    ```
-    
-    For example, to locate an alert with the name "HighCPUUsage," you can use the following query: 
-    
-    ```
-    ALERTS{alertname="HighCPUUsage"}
-    ```
-    
-    <Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-b40df1f1-96e5-4824-bc8c-f1a81758f9c6.webp" alt="Prometheus Alerts Page" caption="Prometheus Alerts Page" />
-    
-    This query will display any active time series associated with the "HighCPUUsage" alert, allowing you to confirm the alerts you want to delete. Use other label matchers as needed to narrow down results, especially when dealing with multiple alerts with similar names
-    
-1. Construct the API Request: 
+  ```java
+  # Query for a specific alert by name
+  ALERTS{alertname="YourAlertName"}
+
+  # Query with multiple label matchers
+  ALERTS{alertname="YourAlertName", severity="critical", instance="instance-name"}
+  ```
+  For example, to locate an alert with the name "HighCPUUsage," you can use the following query:
+  ```
+  ALERTS{alertname="HighCPUUsage"}
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-b40df1f1-96e5-4824-bc8c-f1a81758f9c6.webp"
+    alt="Prometheus Alerts Page"
+    caption="Prometheus Alerts Page"
+  />
+  This query will display any active time series associated with the "HighCPUUsage" alert, allowing
+  you to confirm the alerts you want to delete. Use other label matchers as needed to narrow down
+  results, especially when dealing with multiple alerts with similar names
+
+1. Construct the API Request:
 
 Once you've identified the alerts, construct a DELETE request to Prometheus's Admin API. The Admin API endpoint for deleting time series is `/api/v1/admin/tsdb/delete_series`. This endpoint requires you to specify the time series you wish to delete using a `match[]` parameter, which accepts label matchers to target specific alerts:
 
@@ -116,13 +120,13 @@ Here's the basic structure of the request:
 POST /api/v1/admin/tsdb/delete_series
 ```
 
-For example, to delete only the "InstanceDown" alert, use: 
+For example, to delete only the "InstanceDown" alert, use:
 
 ```bash
 POST /api/v1/admin/tsdb/delete_series?match[]=ALERTS{alertname="InstanceDown"}
 ```
 
-1. Execute the Deletion: 
+1. Execute the Deletion:
 
 To send the delete request, you can use `curl` or any other HTTP client tool capable of making POST requests. The example below shows how to execute the request with curl. Replace `<http://localhost:9090>` with the address of your Prometheus server if it's hosted on a different URL:
 
@@ -131,7 +135,11 @@ curl -X POST http://localhost:9090/api/v1/admin/tsdb/delete_series \
 -d 'match[]=ALERTS{alertname="InstanceDown"}'
 ```
 
-<Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-f022ee25-c7cb-4571-bae5-faa808327e17.webp" alt="Firing Alerts Deletion" caption="Firing Alerts Deletion" />
+<Figure
+  src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-f022ee25-c7cb-4571-bae5-faa808327e17.webp"
+  alt="Firing Alerts Deletion"
+  caption="Firing Alerts Deletion"
+/>
 
 In this command:
 
@@ -140,7 +148,7 @@ In this command:
 
 Make sure the Admin API is enabled and that you have sufficient permissions to perform this action; otherwise, you may encounter access errors.
 
-1. Verify Deletion: 
+1. Verify Deletion:
 
 After executing the deletion request, it’s essential to verify that the specified alerts have been successfully removed from Prometheus. Run the same PromQL query you used in Step 1 to check if the alert series still exists.
 
@@ -148,7 +156,11 @@ After executing the deletion request, it’s essential to verify that the specif
 ALERTS{alertname="InstanceDown"}
 ```
 
-<Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-05_at_12.36.03_PM.webp" alt="No result for the query" caption="No result for the query" />
+<Figure
+  src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-Screenshot_2024-11-05_at_12.36.03_PM.webp"
+  alt="No result for the query"
+  caption="No result for the query"
+/>
 
 If the deletion was successful, this query should return no results for the specified alert name. This confirms that the alert data has been removed from the [Prometheus database](https://signoz.io/guides/which-database-is-used-in-prometheus/). If the alert still appears in your query results, double-check the API request parameters and try executing the delete command again
 
@@ -161,9 +173,9 @@ TSDB Admin API Endpoints
 The TSDB Admin API offers two primary endpoints for managing time series data:
 
 1. `/api/v1/admin/tsdb/delete_series`:
-    - This endpoint is used to delete time series data that match the provided selectors. By using label matchers, you can specify which series to remove based on their associated labels. This is useful for cleaning up alerts that are no longer relevant or needed.
+   - This endpoint is used to delete time series data that match the provided selectors. By using label matchers, you can specify which series to remove based on their associated labels. This is useful for cleaning up alerts that are no longer relevant or needed.
 2. `/api/v1/admin/tsdb/clean_tombstones`:
-    - After deleting time series data, Prometheus marks the data as deleted but does not immediately remove it from disk. This approach allows for efficient deletion processes but can leave behind "tombstones" (markers indicating deleted data). The `clean_tombstones` endpoint permanently removes these tombstones from the database, freeing up disk space and ensuring that the system remains efficient.
+   - After deleting time series data, Prometheus marks the data as deleted but does not immediately remove it from disk. This approach allows for efficient deletion processes but can leave behind "tombstones" (markers indicating deleted data). The `clean_tombstones` endpoint permanently removes these tombstones from the database, freeing up disk space and ensuring that the system remains efficient.
 
 Syntax for Constructing Deletion Queries
 
@@ -181,27 +193,21 @@ Examples of Common Deletion Scenarios
 
 Here are a few common scenarios where you might need to use the TSDB Admin API for deletion:
 
-1. Deleting a Specific Alert:
-If you have an alert named "HighMemoryUsage" that you want to remove, your request would be structured as follows:
-    
-    ```
-    match[]=ALERTS{alertname="HighMemoryUsage"}
-    ```
-    
-2. Bulk Deleting Alerts Based on Severity:
-If you want to delete all alerts with a specific severity level, such as "warning," the request would look like this:
-    
-    ```
-    match[]=ALERTS{severity="warning"}
-    ```
-    
-3. Deleting Alerts from a Specific Instance:
-To delete alerts related to a specific server, use a query like this:
-    
-    ```
-    match[]=ALERTS{instance="server02:9100"}
-    ```
-    
+1.  Deleting a Specific Alert:
+    If you have an alert named "HighMemoryUsage" that you want to remove, your request would be structured as follows:
+        ```
+        match[]=ALERTS{alertname="HighMemoryUsage"}
+        ```
+2.  Bulk Deleting Alerts Based on Severity:
+    If you want to delete all alerts with a specific severity level, such as "warning," the request would look like this:
+        ```
+        match[]=ALERTS{severity="warning"}
+        ```
+3.  Deleting Alerts from a Specific Instance:
+    To delete alerts related to a specific server, use a query like this:
+        ```
+        match[]=ALERTS{instance="server02:9100"}
+        ```
 
 Each of these examples highlights how to construct deletion requests that are precise and targeted, which is vital for maintaining an organized monitoring environment.
 
@@ -217,50 +223,46 @@ When using the TSDB Admin API, it’s important to handle potential errors effec
 
 Effectively managing alerts in Prometheus is crucial for maintaining an efficient monitoring system. Here are some best practices to help you manage your Prometheus alerts effectively:
 
-1. Regular Audits: 
-Conducting regular audits of your alerts is a fundamental practice in managing your monitoring system. This involves systematically reviewing the alerts you have configured to identify any that may be outdated or unnecessary.
-    
-    Steps to Perform Regular Audits:
-    
-    - Schedule Periodic Reviews: Set a routine, such as monthly or quarterly, to examine your alerts.
-    - Engage Your Team: Collaborate with your team to discuss the relevance of each alert. This collaboration can provide insights into which alerts are useful and which are no longer applicable.
-    - Eliminate Redundant Alerts: Remove alerts that trigger frequently but provide little actionable information. Keeping only meaningful alerts ensures your team can focus on critical notifications.
-2. Alert Retention Policies: 
-Implementing alert retention policies is essential for managing the lifespan of alerts. This practice helps you maintain a clean and organized alerting system, making it easier to navigate and respond to active alerts.
-    
-    Creating Alert Retention Policies:
-    
-    - Define Expiration Criteria: Decide how long alerts should be retained. For instance, you might choose to expire alerts after 30 days if they haven’t triggered.
-    - Automate Expiration: Utilize Prometheus features or scripts to automate the expiration of old alerts. This helps maintain a manageable number of alerts and reduces clutter in your monitoring dashboard.
-3. Automation: 
-Automation can significantly streamline your alert management processes. By leveraging scripts and tools, you can automate repetitive tasks associated with alerts, which can save time and reduce errors.
-    
-    Ways to Automate Alert Management:
-    
-    - Use Alerting Rules: Take advantage of Prometheus’ built-in alerting rules to automate the creation and modification of alerts.
-    - Scripting: Develop scripts in programming languages like Python or Bash to handle routine tasks, such as updating alert configurations or cleaning up obsolete alerts.
-    - Configuration as Code: Consider using tools like Terraform to manage your alert configurations as code. This allows for version control and easier updates.
-4. Performance Monitoring: 
-Monitoring the performance of your alerting system is essential, especially after making changes such as deleting or modifying alerts. Keeping track of performance metrics helps ensure that your system runs efficiently and effectively.
-    
-    Monitoring Performance:
-    
-    - Track Key Metrics: Use Prometheus metrics to monitor query performance and system resource utilization. This can include metrics like query response times and CPU usage.
-    - Evaluate Changes: After any modifications to alerts, evaluate the impact on system performance. If you notice a degradation in performance, revisit your alerting rules to optimize them for better efficiency.
+1.  Regular Audits:
+    Conducting regular audits of your alerts is a fundamental practice in managing your monitoring system. This involves systematically reviewing the alerts you have configured to identify any that may be outdated or unnecessary.
+        Steps to Perform Regular Audits:
+
+        - Schedule Periodic Reviews: Set a routine, such as monthly or quarterly, to examine your alerts.
+        - Engage Your Team: Collaborate with your team to discuss the relevance of each alert. This collaboration can provide insights into which alerts are useful and which are no longer applicable.
+        - Eliminate Redundant Alerts: Remove alerts that trigger frequently but provide little actionable information. Keeping only meaningful alerts ensures your team can focus on critical notifications.
+2.  Alert Retention Policies:
+    Implementing alert retention policies is essential for managing the lifespan of alerts. This practice helps you maintain a clean and organized alerting system, making it easier to navigate and respond to active alerts.
+        Creating Alert Retention Policies:
+
+        - Define Expiration Criteria: Decide how long alerts should be retained. For instance, you might choose to expire alerts after 30 days if they haven’t triggered.
+        - Automate Expiration: Utilize Prometheus features or scripts to automate the expiration of old alerts. This helps maintain a manageable number of alerts and reduces clutter in your monitoring dashboard.
+3.  Automation:
+    Automation can significantly streamline your alert management processes. By leveraging scripts and tools, you can automate repetitive tasks associated with alerts, which can save time and reduce errors.
+        Ways to Automate Alert Management:
+
+        - Use Alerting Rules: Take advantage of Prometheus’ built-in alerting rules to automate the creation and modification of alerts.
+        - Scripting: Develop scripts in programming languages like Python or Bash to handle routine tasks, such as updating alert configurations or cleaning up obsolete alerts.
+        - Configuration as Code: Consider using tools like Terraform to manage your alert configurations as code. This allows for version control and easier updates.
+4.  Performance Monitoring:
+    Monitoring the performance of your alerting system is essential, especially after making changes such as deleting or modifying alerts. Keeping track of performance metrics helps ensure that your system runs efficiently and effectively.
+        Monitoring Performance:
+
+        - Track Key Metrics: Use Prometheus metrics to monitor query performance and system resource utilization. This can include metrics like query response times and CPU usage.
+        - Evaluate Changes: After any modifications to alerts, evaluate the impact on system performance. If you notice a degradation in performance, revisit your alerting rules to optimize them for better efficiency.
 
 ## Alternative Approaches to Alert Management
 
 When managing alerts in Prometheus, outright deletion is not always the best option. Instead, there are several alternative methods you can use to effectively manage alerts without losing important data. These methods not only help in organizing alerts better but also allow more control over your monitoring system.
 
 1. Recording Rules:
-Recording rules in Prometheus allow you to precompute frequently used queries and store their results as new time series. This can be especially useful for alerts, as you can aggregate multiple related alerts into a single time series. By doing this, you reduce the overall number of individual alerts, simplifying the system and improving performance. Rather than deleting alerts, you can use recording rules to compress or group them for easier management.
-For more information on using recording rules in Prometheus, refer to this detailed [blog post](https://signoz.io/guides/what-is-a-prometheus-rule/).
-2. Alert Silencing: 
-Instead of deleting alerts, you can silence them temporarily using Prometheus' Alertmanager. Silencing is a powerful feature that allows you to mute non-critical alerts during specific time periods, such as during maintenance windows or when you know the alert is irrelevant for the moment. This prevents the alert from triggering unnecessarily while keeping it in the system for future use.
-3. External Tools: 
-While Prometheus is great for metrics and alerting, managing alerts through its native interface can become complex over time, especially for large-scale systems. External tools like Grafana or SigNoz offer more intuitive, user-friendly interfaces for managing and visualizing alerts. With these tools, you can easily configure, view, and manage your alerts in a more structured manner. SigNoz, in particular, integrates with Prometheus but provides extended observability features, including easier management of alerts and metrics dashboards.
-4. Time-Based Auto-Expiration: 
-For certain types of alerts, configuring time-based auto-expiration can help in keeping your system clean without manual deletions. Time-based expiration means setting an alert to automatically expire and be removed after a defined period, reducing the need for manual intervention. This is particularly useful for alerts that are relevant only for a short duration, such as alerts related to temporary spikes in usage.
+   Recording rules in Prometheus allow you to precompute frequently used queries and store their results as new time series. This can be especially useful for alerts, as you can aggregate multiple related alerts into a single time series. By doing this, you reduce the overall number of individual alerts, simplifying the system and improving performance. Rather than deleting alerts, you can use recording rules to compress or group them for easier management.
+   For more information on using recording rules in Prometheus, refer to this detailed [blog post](https://signoz.io/guides/what-is-a-prometheus-rule/).
+2. Alert Silencing:
+   Instead of deleting alerts, you can silence them temporarily using Prometheus' Alertmanager. Silencing is a powerful feature that allows you to mute non-critical alerts during specific time periods, such as during maintenance windows or when you know the alert is irrelevant for the moment. This prevents the alert from triggering unnecessarily while keeping it in the system for future use.
+3. External Tools:
+   While Prometheus is great for metrics and alerting, managing alerts through its native interface can become complex over time, especially for large-scale systems. External tools like Grafana or SigNoz offer more intuitive, user-friendly interfaces for managing and visualizing alerts. With these tools, you can easily configure, view, and manage your alerts in a more structured manner. SigNoz, in particular, integrates with Prometheus but provides extended observability features, including easier management of alerts and metrics dashboards.
+4. Time-Based Auto-Expiration:
+   For certain types of alerts, configuring time-based auto-expiration can help in keeping your system clean without manual deletions. Time-based expiration means setting an alert to automatically expire and be removed after a defined period, reducing the need for manual intervention. This is particularly useful for alerts that are relevant only for a short duration, such as alerts related to temporary spikes in usage.
 
 ## Monitoring Alert Deletions with SigNoz
 
@@ -273,7 +275,11 @@ Built on [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)—the em
 3. Detailed Analysis of Alerting Gaps: Utilize both PromQL and SigNoz’s advanced [query builder](https://signoz.io/blog/query-builder-v5/) to analyze potential gaps left by deleted alerts. This enables you to assess whether alert deletions may leave certain metrics unmonitored, ensuring coverage across your monitoring system.
 4. Centralized Dashboards for Alert Management: Create unified dashboards in SigNoz that display metrics, traces, and logs in real time, allowing you to oversee alert deletions alongside key performance indicators. This visibility helps you proactively monitor the effects of alert changes across your infrastructure.
 
-<Figure src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-image.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/11/how-do-i-delete-a-time-series-from-prometheus-v2-specifically-a-series-of-alerts-image.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
 For more information on monitoring alert deletions with SigNoz, refer to the [Alert Management](https://signoz.io/docs/userguide/alerts-management/) documentation.
 
@@ -312,4 +318,4 @@ Yes, the primary risks include accidentally deleting important data and facing a
 - Schedule deletions during off-peak or low-traffic periods.
 - Make sure critical data is backed up to avoid any accidental loss.
 
-By following these best practices, you can manage your Prometheus alerts effectively and safely.
\ No newline at end of file
+By following these best practices, you can manage your Prometheus alerts effectively and safely.
diff --git a/data/guides/how-do-i-monitor-api-in-prometheus.mdx b/data/guides/how-do-i-monitor-api-in-prometheus.mdx
index 7dcf7c338..b5f0e1c1f 100644
--- a/data/guides/how-do-i-monitor-api-in-prometheus.mdx
+++ b/data/guides/how-do-i-monitor-api-in-prometheus.mdx
@@ -1,204 +1,210 @@
 ---
-
 title: How to Monitor REST APIs with Prometheus - A Step-by-Step Guide
-slug: how-do-i-monitor-api-in-prometheus
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Learn how to effectively monitor REST APIs using Prometheus. This comprehensive guide covers setup, instrumentation, health checks, and advanced techniques.
-keywords: [API monitoring, Prometheus, REST APIs, API metrics, Grafana, health checks, API performance]
-
+keywords:
+  [API monitoring, Prometheus, REST APIs, API metrics, Grafana, health checks, API performance]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Monitor REST APIs with Prometheus - A Step-by-Step Guide",
-    "alternativeHeadline": "A Comprehensive Guide to Monitoring REST APIs with Prometheus",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/"
-    },
-    "description": "Learn how to effectively monitor REST APIs using Prometheus. This comprehensive guide covers setup, instrumentation, health checks, and advanced techniques.",
-    "keywords": "API monitoring, Prometheus, REST APIs, API metrics, Grafana, health checks, API performance",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "API Monitoring",
-        "description": "The process of tracking and analyzing the performance of APIs to ensure they are running optimally."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "REST APIs",
-        "description": "Application programming interfaces that use HTTP requests to GET, PUT, POST, and DELETE data."
-      },
-      {
-        "@type": "Thing",
-        "name": "API Metrics",
-        "description": "Key performance indicators that provide insights into API performance, including request rate, response time, and error rate."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What are the key metrics to monitor for REST APIs?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Key metrics include request rate, response time, error rate, and resource utilization. These provide a comprehensive view of your API's performance and health."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How often should Prometheus scrape API metrics?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The optimal scrape interval depends on your specific needs. A common practice is to start with 15-30 seconds and adjust based on your API's traffic and performance characteristics."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can Prometheus monitor APIs across different environments?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, Prometheus can monitor APIs in various environments — development, staging, and production. Configure separate scrape jobs for each environment in your Prometheus configuration."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I set up alerts for API issues in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Define alert rules in Prometheus using PromQL expressions. Specify conditions that trigger alerts, such as high error rates or slow response times. Use Alertmanager to route these alerts to appropriate notification channels."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Monitoring REST APIs with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Prometheus",
-          "text": "Download the latest release from the Prometheus website, extract the files, and navigate to the Prometheus directory."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus",
-          "text": "Create a prometheus.yml file with your API's configuration and set the scrape interval to 15 seconds."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus",
-          "text": "Run the command './prometheus --config.file=prometheus.yml' to start Prometheus."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Integrate with your API",
-          "text": "Modify your API code to expose a /metrics endpoint that Prometheus can scrape."
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Monitor REST APIs with Prometheus - A Step-by-Step Guide',
+        alternativeHeadline: 'A Comprehensive Guide to Monitoring REST APIs with Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Add Prometheus client library",
-          "text": "Install the appropriate library for your programming language, e.g., 'pip install prometheus_client' for Python."
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Define custom metrics",
-          "text": "Create metrics relevant to your API, such as request count and request latency."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Expose metrics endpoint",
-          "text": "Set up a route in your API to expose the metrics."
+        description:
+          'Learn how to effectively monitor REST APIs using Prometheus. This comprehensive guide covers setup, instrumentation, health checks, and advanced techniques.',
+        keywords:
+          'API monitoring, Prometheus, REST APIs, API metrics, Grafana, health checks, API performance',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use metrics in your code",
-          "text": "Instrument your API endpoints with the defined metrics."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'API Monitoring',
+            description:
+              'The process of tracking and analyzing the performance of APIs to ensure they are running optimally.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'REST APIs',
+            description:
+              'Application programming interfaces that use HTTP requests to GET, PUT, POST, and DELETE data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'API Metrics',
+            description:
+              'Key performance indicators that provide insights into API performance, including request rate, response time, and error rate.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are the key metrics to monitor for REST APIs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Key metrics include request rate, response time, error rate, and resource utilization. These provide a comprehensive view of your API's performance and health.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How often should Prometheus scrape API metrics?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "The optimal scrape interval depends on your specific needs. A common practice is to start with 15-30 seconds and adjust based on your API's traffic and performance characteristics.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Prometheus monitor APIs across different environments?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Prometheus can monitor APIs in various environments — development, staging, and production. Configure separate scrape jobs for each environment in your Prometheus configuration.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I set up alerts for API issues in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Define alert rules in Prometheus using PromQL expressions. Specify conditions that trigger alerts, such as high error rates or slow response times. Use Alertmanager to route these alerts to appropriate notification channels.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Create a health check endpoint",
-          "text": "Add a /health route to your API that returns the overall status."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Monitoring REST APIs with Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Prometheus',
+              text: 'Download the latest release from the Prometheus website, extract the files, and navigate to the Prometheus directory.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus',
+              text: "Create a prometheus.yml file with your API's configuration and set the scrape interval to 15 seconds.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Start Prometheus',
+              text: "Run the command './prometheus --config.file=prometheus.yml' to start Prometheus.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with your API',
+              text: 'Modify your API code to expose a /metrics endpoint that Prometheus can scrape.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Prometheus client library',
+              text: "Install the appropriate library for your programming language, e.g., 'pip install prometheus_client' for Python.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Define custom metrics',
+              text: 'Create metrics relevant to your API, such as request count and request latency.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Expose metrics endpoint',
+              text: 'Set up a route in your API to expose the metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use metrics in your code',
+              text: 'Instrument your API endpoints with the defined metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a health check endpoint',
+              text: 'Add a /health route to your API that returns the overall status.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus to monitor health',
+              text: 'Add the health check to your prometheus.yml file.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set up alerting',
+              text: 'Create an alert rule in Prometheus to notify you of failed health checks.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Install Grafana',
+              text: 'Follow the instructions on the Grafana website to install Grafana.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus data source',
+              text: 'In Grafana, add Prometheus as a new data source and enter your Prometheus server URL.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create API monitoring dashboard',
+              text: 'Create a new dashboard in Grafana and add panels for key metrics like request rate, latency, and error rate.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus to monitor health",
-          "text": "Add the health check to your prometheus.yml file."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Set up alerting",
-          "text": "Create an alert rule in Prometheus to notify you of failed health checks."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Install Grafana",
-          "text": "Follow the instructions on the Grafana website to install Grafana."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus data source",
-          "text": "In Grafana, add Prometheus as a new data source and enter your Prometheus server URL."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Create API monitoring dashboard",
-          "text": "Create a new dashboard in Grafana and add panels for key metrics like request rate, latency, and error rate."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Monitoring REST APIs with Prometheus is essential for maintaining high-performance, reliable web services. This guide walks you through the process of setting up Prometheus, instrumenting your API, and implementing advanced monitoring techniques. You'll learn how to track key metrics, set up health checks, and visualize your data for optimal API performance.
@@ -225,120 +231,104 @@ When monitoring REST APIs, focus on these key metrics:
 
 To start monitoring your API with Prometheus, follow these steps:
 
-1. **Install Prometheus**:
+1.  **Install Prometheus**:
     - Download the latest release from the [Prometheus website](https://prometheus.io/download/).
     - Extract the files and navigate to the Prometheus directory.
-2. **Configure Prometheus**:
-Create a `prometheus.yml` file with the following content:
-    
-    ```yaml
-    global:
-      scrape_interval: 15s
-    
-    scrape_configs:
-      - job_name: 'api'
-        static_configs:
-          - targets: ['localhost:8080']
-    
-    ```
-    
-    This configuration tells Prometheus to scrape metrics from your API every 15 seconds.
-    
-3. **Start Prometheus**:
-Run the following command:
-    
-    ```
-    ./prometheus --config.file=prometheus.yml
-    
-    ```
-    
-4. **Integrate with your API**:
-Modify your API code to expose a `/metrics` endpoint that Prometheus can scrape.
+2.  **Configure Prometheus**:
+    Create a `prometheus.yml` file with the following content:
+        ```yaml
+        global:
+          scrape_interval: 15s
+
+        scrape_configs:
+          - job_name: 'api'
+            static_configs:
+              - targets: ['localhost:8080']
+
+        ```
+
+        This configuration tells Prometheus to scrape metrics from your API every 15 seconds.
+3.  **Start Prometheus**:
+    Run the following command:
+        ```
+        ./prometheus --config.file=prometheus.yml
+
+        ```
+4.  **Integrate with your API**:
+    Modify your API code to expose a `/metrics` endpoint that Prometheus can scrape.
 
 ## Instrumenting Your API for Prometheus
 
 To collect meaningful data, you need to instrument your API code:
 
-1. **Add Prometheus client library**:
-Install the appropriate library for your programming language. For example, in Python:
-    
-    ```
-    pip install prometheus_client
-    
-    ```
-    
-2. **Define custom metrics**:
-Create metrics that are relevant to your API:
-    
-    ```python
-    from prometheus_client import Counter, Histogram
-    
-    REQUEST_COUNT = Counter('api_requests_total', 'Total API requests')
-    REQUEST_LATENCY = Histogram('api_request_latency_seconds', 'API request latency')
-    
-    ```
-    
-3. **Expose metrics endpoint**:
-Set up a route in your API to expose the metrics:
-    
-    ```python
-    from prometheus_client import generate_latest
-    
-    @app.route('/metrics')
-    def metrics():
-        return generate_latest()
-    
-    ```
-    
-4. **Use metrics in your code**:
-Instrument your API endpoints:
-    
-    ```python
-    @app.route('/api/data')
-    @REQUEST_LATENCY.time()
-    def get_data():
-        REQUEST_COUNT.inc()
-        # Your API logic here
-    
-    ```
-    
+1.  **Add Prometheus client library**:
+    Install the appropriate library for your programming language. For example, in Python:
+        ```
+        pip install prometheus_client
+
+        ```
+2.  **Define custom metrics**:
+    Create metrics that are relevant to your API:
+        ```python
+        from prometheus_client import Counter, Histogram
+
+        REQUEST_COUNT = Counter('api_requests_total', 'Total API requests')
+        REQUEST_LATENCY = Histogram('api_request_latency_seconds', 'API request latency')
+
+        ```
+3.  **Expose metrics endpoint**:
+    Set up a route in your API to expose the metrics:
+        ```python
+        from prometheus_client import generate_latest
+
+        @app.route('/metrics')
+        def metrics():
+            return generate_latest()
+
+        ```
+4.  **Use metrics in your code**:
+    Instrument your API endpoints:
+        ```python
+        @app.route('/api/data')
+        @REQUEST_LATENCY.time()
+        def get_data():
+            REQUEST_COUNT.inc()
+            # Your API logic here
+
+        ```
 
 ## Implementing API Health Checks with Prometheus
 
 Health checks ensure your API is functioning correctly. Here's how to set them up:
 
-1. **Create a health check endpoint**:
-Add a `/health` route to your API that returns the overall status.
-2. **Configure Prometheus to monitor health**:
-Add the health check to your `prometheus.yml`:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'api_health'
-        metrics_path: '/health'
-        static_configs:
-          - targets: ['localhost:8080']
-    
-    ```
-    
-3. **Set up alerting**:
-Create an alert rule in Prometheus to notify you of failed health checks:
-    
-    ```yaml
-    groups:
-    - name: api_alerts
-      rules:
-      - alert: APIHealthCheckFailed
-        expr: up{job="api_health"} == 0
-        for: 5m
-        labels:
-          severity: critical
-        annotations:
-          summary: "API health check failed"
-          description: "The API health check has been failing for 5 minutes."
-    
-    ```
-    
+1.  **Create a health check endpoint**:
+    Add a `/health` route to your API that returns the overall status.
+2.  **Configure Prometheus to monitor health**:
+    Add the health check to your `prometheus.yml`:
+        ```yaml
+        scrape_configs:
+          - job_name: 'api_health'
+            metrics_path: '/health'
+            static_configs:
+              - targets: ['localhost:8080']
+
+        ```
+3.  **Set up alerting**:
+    Create an alert rule in Prometheus to notify you of failed health checks:
+        ```yaml
+        groups:
+        - name: api_alerts
+          rules:
+          - alert: APIHealthCheckFailed
+            expr: up{job="api_health"} == 0
+            for: 5m
+            labels:
+              severity: critical
+            annotations:
+              summary: "API health check failed"
+              description: "The API health check has been failing for 5 minutes."
+
+        ```
 
 ## Advanced API Monitoring Techniques
 
@@ -355,17 +345,17 @@ Grafana enhances your monitoring setup by providing powerful visualization capab
 
 1. **Install Grafana**: Follow the instructions on the [Grafana website](https://grafana.com/docs/grafana/latest/installation/).
 2. **Configure Prometheus data source**:
-    - In Grafana, go to Configuration > Data Sources.
-    - Add Prometheus as a new data source.
-    - Enter your Prometheus server URL.
+   - In Grafana, go to Configuration > Data Sources.
+   - Add Prometheus as a new data source.
+   - Enter your Prometheus server URL.
 3. **Create API monitoring dashboard**:
-    - Create a new dashboard.
-    - Add panels for key metrics like request rate, latency, and error rate.
-    - Use PromQL queries to fetch and display data.
+   - Create a new dashboard.
+   - Add panels for key metrics like request rate, latency, and error rate.
+   - Use PromQL queries to fetch and display data.
 4. **Design effective dashboards**:
-    - Group related metrics together.
-    - Use appropriate visualization types (graphs, gauges, tables).
-    - Set up alerting thresholds directly in Grafana.
+   - Group related metrics together.
+   - Use appropriate visualization types (graphs, gauges, tables).
+   - Set up alerting thresholds directly in Grafana.
 
 ## SigNoz: A Comprehensive Alternative
 
diff --git a/data/guides/how-does-grafana-get-data-from-prometheus.mdx b/data/guides/how-does-grafana-get-data-from-prometheus.mdx
index 1e885094c..1195575e2 100644
--- a/data/guides/how-does-grafana-get-data-from-prometheus.mdx
+++ b/data/guides/how-does-grafana-get-data-from-prometheus.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How Grafana Retrieves and Visualizes Prometheus Data
-slug: how-does-grafana-get-data-from-prometheus
 date: 2024-08-01
 tags: [prometheus]
 authors: [ankit_anand]
 description: Discover how Grafana retrieves and visualizes Prometheus data, including integration, querying, and optimization techniques for effective monitoring.
 keywords: [Grafana, Prometheus, data visualization, monitoring, PromQL, dashboard optimization]
-
 ---
 
 Grafana retrieves data from Prometheus through a seamless integration process. This integration allows for efficient data retrieval, processing, and display, enabling users to create insightful dashboards for monitoring and analysis. The process involves connecting Grafana to Prometheus as a data source, formulating queries using PromQL, and rendering the results in various visual formats.
@@ -145,4 +142,4 @@ To get started with SigNoz:
 
 <GetStartedSigNoz />
 
-SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
\ No newline at end of file
+SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
diff --git a/data/guides/how-does-prometheus-work.mdx b/data/guides/how-does-prometheus-work.mdx
index 569761c57..34ffc9f7a 100644
--- a/data/guides/how-does-prometheus-work.mdx
+++ b/data/guides/how-does-prometheus-work.mdx
@@ -1,133 +1,134 @@
 ---
-
 title: How Does Prometheus Work?
-slug: how-does-prometheus-work
 date: 2024-07-12
 tags: [faq, prometheus]
 authors: [daniel]
 description: Prometheus periodically scrapes metrics from configured targets (such as applications, services, or infrastructure components) using HTTP endpoints. These targets expose metrics in a specific format that Prometheus understands.
-keywords: [prometheus,monitor,monitoring,metrics]
-
+keywords: [prometheus, monitor, monitoring, metrics]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "How does Prometheus Work?",
-  "description": "Prometheus periodically scrapes metrics from configured targets (such as applications, services, or infrastructure components) using HTTP endpoints. These targets expose metrics in a specific format that Prometheus understands.",
-  "keywords": ["prometheus", "monitor", "monitoring", "metrics"],
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "datePublished": "2024-07-12T00:00:00Z",
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/how-does-prometheus-work/"
-  },
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source monitoring and alerting toolkit"
-    },
-    {
-      "@type": "Thing",
-      "name": "Monitoring",
-      "description": "The process of collecting, analyzing, and using information to track a system's progress and performance"
-    }
-  ],
-  "educationalLevel": "Intermediate",
-  "isAccessibleForFree": true,
-  "image": {
-    "@type": "ImageObject",
-    "url": "https://signoz.io/img/guides/2024/07/how-does-prometheus-work-Untitled.webp",
-    "caption": "How Prometheus works"
-  },
-  "hasPart": [
-    {
-      "@type": "HowTo",
-      "name": "Quick Start with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Download Prometheus",
-          "text": "Visit the Prometheus download page and download the appropriate package for your operating system."
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How does Prometheus Work?',
+        description:
+          'Prometheus periodically scrapes metrics from configured targets (such as applications, services, or infrastructure components) using HTTP endpoints. These targets expose metrics in a specific format that Prometheus understands.',
+        keywords: ['prometheus', 'monitor', 'monitoring', 'metrics'],
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
+        },
+        datePublished: '2024-07-12T00:00:00Z',
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure prometheus.yml file",
-          "text": "Open the prometheus.yml file in a text editor and configure the targets to monitor."
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-does-prometheus-work/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus server",
-          "text": "Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml"
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description: 'An open-source monitoring and alerting toolkit',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              "The process of collecting, analyzing, and using information to track a system's progress and performance",
+          },
+        ],
+        educationalLevel: 'Intermediate',
+        isAccessibleForFree: true,
+        image: {
+          '@type': 'ImageObject',
+          url: 'https://signoz.io/img/guides/2024/07/how-does-prometheus-work-Untitled.webp',
+          caption: 'How Prometheus works',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Access the Prometheus UI",
-          "text": "Open a web browser and visit localhost:9090 to access the Prometheus UI."
-        }
-      ]
-    }
-  ],
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "How does Prometheus work?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus works by scraping metrics from configured endpoints at specified intervals. These targets include applications, servers, databases, and more. They expose their metrics in a format Prometheus understands. Once Prometheus pulls metrics from these endpoints, it stores them for querying and retrieval when needed."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the main components of the Prometheus server?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "The Prometheus server consists of three main components: 1) Time Series Database for storing metrics data, 2) Data Retriever (Scraper) for pulling metrics from various sources, and 3) HTTP Server API for querying the stored metrics data."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "How does Prometheus collect metrics?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus collects metrics by periodically scraping targets. A target is any system or service that exposes metrics via an HTTP endpoint, typically at the /metrics path. These endpoints provide the current state of the target in a plain text format that Prometheus can understand."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What is an exporter in Prometheus?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "An exporter is a service that retrieves metrics from targets and transforms them into a format compatible with Prometheus. These converted metrics are then exposed at the exporter's /metrics endpoint, where Prometheus can scrape them."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "How does Prometheus handle alerting?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus includes a built-in alerting mechanism that allows users to define alerting rules based on PromQL queries. These rules evaluate metrics at regular intervals. When conditions are met, alerts are sent to the Alertmanager, which handles routing the alert to configured receiver integrations (e.g., email, Slack, PagerDuty)."
-      }
-    }
-  ]
-}) }}
+        hasPart: [
+          {
+            '@type': 'HowTo',
+            name: 'Quick Start with Prometheus',
+            step: [
+              {
+                '@type': 'HowToStep',
+                name: 'Download Prometheus',
+                text: 'Visit the Prometheus download page and download the appropriate package for your operating system.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Configure prometheus.yml file',
+                text: 'Open the prometheus.yml file in a text editor and configure the targets to monitor.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Start Prometheus server',
+                text: 'Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Access the Prometheus UI',
+                text: 'Open a web browser and visit localhost:9090 to access the Prometheus UI.',
+              },
+            ],
+          },
+        ],
+        mainEntity: [
+          {
+            '@type': 'Question',
+            name: 'How does Prometheus work?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus works by scraping metrics from configured endpoints at specified intervals. These targets include applications, servers, databases, and more. They expose their metrics in a format Prometheus understands. Once Prometheus pulls metrics from these endpoints, it stores them for querying and retrieval when needed.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the main components of the Prometheus server?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'The Prometheus server consists of three main components: 1) Time Series Database for storing metrics data, 2) Data Retriever (Scraper) for pulling metrics from various sources, and 3) HTTP Server API for querying the stored metrics data.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'How does Prometheus collect metrics?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus collects metrics by periodically scraping targets. A target is any system or service that exposes metrics via an HTTP endpoint, typically at the /metrics path. These endpoints provide the current state of the target in a plain text format that Prometheus can understand.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What is an exporter in Prometheus?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: "An exporter is a service that retrieves metrics from targets and transforms them into a format compatible with Prometheus. These converted metrics are then exposed at the exporter's /metrics endpoint, where Prometheus can scrape them.",
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'How does Prometheus handle alerting?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus includes a built-in alerting mechanism that allows users to define alerting rules based on PromQL queries. These rules evaluate metrics at regular intervals. When conditions are met, alerts are sent to the Alertmanager, which handles routing the alert to configured receiver integrations (e.g., email, Slack, PagerDuty).',
+            },
+          },
+        ],
+      }),
+    }}
   />
 </head>
 
@@ -137,8 +138,11 @@ Prometheus works by scraping metrics from configured endpoints at specified inte
 
 The architecture diagram below provides a summary of [how Prometheus works](https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/) as a monitoring tool.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled.webp" alt="How Prometheus works" caption="How Prometheus works" />
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled.webp"
+  alt="How Prometheus works"
+  caption="How Prometheus works"
+/>
 
 ### The Prometheus Server
 
@@ -154,12 +158,15 @@ Prometheus collects metrics by periodically scraping targets. A target is any sy
 
 For Prometheus to pull metrics from a target, the target must expose a specific HTTP endpoint, typically at the `/metrics` path. The HTTP endpoints follow the format; `hostaddress/metrics`. This endpoint provides the current state of the target in a plain text format that Prometheus can understand.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled%201.webp" alt="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)" caption="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)" />
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled%201.webp"
+  alt="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)"
+  caption="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)"
+/>
 
 ### Exporters
 
-While some systems expose [Prometheus endpoints](https://signoz.io/guides/prometheus-metrics-endpoint/) by default, others don’t and require an exporter. An exporter is a service that retrieves metrics from targets and transforms them into a format compatible with Prometheus. These converted metrics are then exposed at the exporter's `/metrics` endpoint, where Prometheus can scrape them. 
+While some systems expose [Prometheus endpoints](https://signoz.io/guides/prometheus-metrics-endpoint/) by default, others don’t and require an exporter. An exporter is a service that retrieves metrics from targets and transforms them into a format compatible with Prometheus. These converted metrics are then exposed at the exporter's `/metrics` endpoint, where Prometheus can scrape them.
 
 Prometheus has <a href="https://prometheus.io/docs/instrumenting/exporters/" rel="noopener noreferrer nofollow" target="_blank">exporters</a> for different services including MySQL, Elasticssearch, etc. It also provides client libraries for <a href="https://prometheus.io/docs/instrumenting/clientlibs/" rel="noopener noreferrer nofollow" target="_blank">applications</a> that convert metrics data in a Prometheus readable format.
 
@@ -185,17 +192,23 @@ The data is stored locally, providing fast query performance and reliability. Ea
 
 ### Data Query
 
-The stored metrics data can be queried when needed for visualization through the Prometheus web UI or a monitoring tool. 
-
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled%202.webp" alt="Prometheus web UI" caption="Prometheus web UI" />
+The stored metrics data can be queried when needed for visualization through the Prometheus web UI or a monitoring tool.
 
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled%202.webp"
+  alt="Prometheus web UI"
+  caption="Prometheus web UI"
+/>
 
 Prometheus provides a powerful query language called PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) to retrieve and manipulate time-series data. PromQL allows users to perform complex queries, aggregations, and transformations on the collected metrics.
 
 Example of a PromQL query:
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled%203.webp" alt="PromQL query" caption="PromQL query" />
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled%203.webp"
+  alt="PromQL query"
+  caption="PromQL query"
+/>
 
 This query checks the status of targets (Prometheus, node_exporter, cadvisor, or mysqld_exporter) and returns whether they are up (1) or down (0).
 
@@ -227,23 +240,31 @@ An alert can be in one of three states:
 - Pending: The is when the condition specified in the alerting rule has been met, but the `for` clause hasn't expired yet. The `for` clause specifies a duration for which the condition must remain true before the alert fires. This acts as a buffer to prevent alerts from triggering due to transient spikes or temporary issues.
 - Firing: The alert transitions to this state if the condition specified in the alerting rule remains true for the duration specified in the `for` clause.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled%204.webp" alt="Alerting rules in Prometheus" caption="Alerting rules in Prometheus" />
-
-*Alerting rules in Prometheus*
-
-Alerts in the firing state are sent out the alert to Alertmanager, which then handles routing the alert to the configured receiver integrations (e.g., email, Slack, PagerDuty). 
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled%204.webp"
+  alt="Alerting rules in Prometheus"
+  caption="Alerting rules in Prometheus"
+/>
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-4830d151-e3d5-441d-9aa9-f263c75bc007.webp" alt="Alert manager UI" caption="Alert manager UI" />
+_Alerting rules in Prometheus_
 
+Alerts in the firing state are sent out the alert to Alertmanager, which then handles routing the alert to the configured receiver integrations (e.g., email, Slack, PagerDuty).
 
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-4830d151-e3d5-441d-9aa9-f263c75bc007.webp"
+  alt="Alert manager UI"
+  caption="Alert manager UI"
+/>
 
 ### Service Discovery
 
 Prometheus also supports various service discovery mechanisms to find targets automatically. This is particularly useful in dynamic environments like Kubernetes, where services may start and stop frequently. If you also deploy a new application or service in such environments, Prometheus immediately discovers it and starts monitoring it.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Untitled%205.webp" alt="Prometheus service discovery" caption="Prometheus service discovery" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Untitled%205.webp"
+  alt="Prometheus service discovery"
+  caption="Prometheus service discovery"
+/>
 
 Example of how service discovery is configured for Kubernetes:
 
@@ -264,23 +285,29 @@ This quick start guide will help you get Prometheus up and running in a few simp
 
 To download Prometheus on your system, visit the <a href="https://prometheus.io/download/" rel="noopener noreferrer nofollow" target="_blank">Prometheus download</a> page. Set your system architecture and identify the appropriate package for your operating system (Linux, macOS, Windows). Click on the download link for the latest stable release.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.23.50.webp" alt="Download Prometheus" caption="Download Prometheus" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.23.50.webp"
+  alt="Download Prometheus"
+  caption="Download Prometheus"
+/>
 
 1. Configure `prometheus.yml` file
 
 After downloading Prometheus, extract the tarball downloaded file. You'll find a file named `prometheus.yml` in the extracted directory.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.45.09.webp" alt="Extracted Prometheus folder" caption="Extracted Prometheus folder" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.45.09.webp"
+  alt="Extracted Prometheus folder"
+  caption="Extracted Prometheus folder"
+/>
 
 Prometheus uses a configuration file named `prometheus.yml` to specify which targets to monitor and how to scrape them. Open `prometheus.yml` in a text editor.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.25.29.webp" alt="Prometheus.yml file" caption="Prometheus.yml file" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.25.29.webp"
+  alt="Prometheus.yml file"
+  caption="Prometheus.yml file"
+/>
 
 In the `prometheus.yml` file, you will see that Prometheus is configured to scrape metrics from itself. You can add other scrape configurations for Prometheus to scrape metrics from different targets on your system.
 
@@ -294,21 +321,27 @@ Navigate to the directory where you extracted Prometheus and execute the followi
 
 This command will start Prometheus and use the specified configuration file to determine which targets to scrape.
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.42.25.webp" alt="Prometheus started" caption="Prometheus started" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.42.25.webp"
+  alt="Prometheus started"
+  caption="Prometheus started"
+/>
 
 1. Access the Prometheus UI
 
 Once Prometheus has started, in your browser, visit [localhost:9090](http://localhost:9090) to access the Prometheus UI:
 
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.43.47.webp" alt="Prometheus UI" caption="Prometheus UI" />
-
-
-
-<Figure src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.45.59.webp" alt="Prometheus targets" caption="Prometheus targets" />
-
-
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.43.47.webp"
+  alt="Prometheus UI"
+  caption="Prometheus UI"
+/>
+
+<Figure
+  src="/img/guides/2024/07/how-does-prometheus-work-Screenshot_2024-07-12_at_07.45.59.webp"
+  alt="Prometheus targets"
+  caption="Prometheus targets"
+/>
 
 ## Conclusion
 
diff --git a/data/guides/how-should-i-log-while-using-multiprocessing-in-python.mdx b/data/guides/how-should-i-log-while-using-multiprocessing-in-python.mdx
index 08b799ee4..d0f5236dd 100644
--- a/data/guides/how-should-i-log-while-using-multiprocessing-in-python.mdx
+++ b/data/guides/how-should-i-log-while-using-multiprocessing-in-python.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: How to Log Effectively When Using Multiprocessing in Python - A Guide
-slug: how-should-i-log-while-using-multiprocessing-in-python
 date: 2024-08-30
 tags: [faq]
 authors: [soumya_gupta]
 description: Learn how to implement effective logging in Python multiprocessing applications. Discover best practices, advanced techniques, and solutions to common challenges.
-keywords: [Python multiprocessing logging, thread-safe logging, logging performance, multiprocessing challenges, Python logging best practices]
-
+keywords:
+  [
+    Python multiprocessing logging,
+    thread-safe logging,
+    logging performance,
+    multiprocessing challenges,
+    Python logging best practices,
+  ]
 ---
 
 Logging in Python multiprocessing applications presents unique challenges that can trip up even experienced developers. You might find your logs jumbled, incomplete, or worse—corrupted. How do you ensure your logs remain accurate and useful when your code runs across multiple processes? This guide will walk you through the complexities of logging in Python multiprocessing environments, from basic setup to advanced techniques.
@@ -46,10 +50,10 @@ def worker_process(name):
 if __name__ == "__main__":
     # Set up logging for the main process
     logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(processName)s - %(levelname)s - %(message)s')]
-    
+
     # Set up multiprocessing logging
     multiprocessing.log_to_stderr(logging.INFO)
-    
+
     processes = []
     for i in range(3):
         p = multiprocessing.Process(target=worker_process, args=(f"Worker-{i}",))
@@ -86,7 +90,7 @@ All processes have completed.
 [INFO/MainProcess] process shutting down
 ```
 
-Case 2: Parallel Multi-Process Logging 
+Case 2: Parallel Multi-Process Logging
 
 ```python
 import multiprocessing
@@ -105,7 +109,7 @@ def worker_process(name):
 if __name__ == "__main__":
     # Set up logging for the main process
     logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(processName)s - %(levelname)s - %(message)s')
-    
+
     # Set up multiprocessing logging
     multiprocessing.log_to_stderr(logging.INFO)
 
@@ -143,7 +147,7 @@ All processes have completed.
 [INFO/MainProcess] process shutting down
 ```
 
-   In both the cases, the `worker_process` function logs the start and finish times along with the duration of each process. For sequential execution, processes are started one by one and completed before the next starts, ensuring no overlap, while in parallel execution, processes start concurrently, showing overlapping log timestamps. Logging is configured using `logging.basicConfig` and `multiprocessing.log_to_stderr` to handle output from multiple processes. Sequential execution waits for each process to finish using `p.join()`, while parallel execution allows all processes to run simultaneously, with logs indicating their concurrent operation. This approach leverages the built-in capabilities of the multiprocessing module to ensure that logging is handled correctly across multiple processes. 
+In both the cases, the `worker_process` function logs the start and finish times along with the duration of each process. For sequential execution, processes are started one by one and completed before the next starts, ensuring no overlap, while in parallel execution, processes start concurrently, showing overlapping log timestamps. Logging is configured using `logging.basicConfig` and `multiprocessing.log_to_stderr` to handle output from multiple processes. Sequential execution waits for each process to finish using `p.join()`, while parallel execution allows all processes to run simultaneously, with logs indicating their concurrent operation. This approach leverages the built-in capabilities of the multiprocessing module to ensure that logging is handled correctly across multiple processes.
 
 Best Practices for Basic Multiprocessing Logging:
 
@@ -154,7 +158,7 @@ Best Practices for Basic Multiprocessing Logging:
 
 ## Deep Dive: Advanced Logging Techniques for Multiprocessing
 
-A queue-based logging system makes things run smoother, especially in more complex scenarios. Unlike the direct logging approach, we just read about in the previous section, where each process logs its messages independently. This can lead to logging conflicts and inefficiencies, the queue-based method centralizes everything. 
+A queue-based logging system makes things run smoother, especially in more complex scenarios. Unlike the direct logging approach, we just read about in the previous section, where each process logs its messages independently. This can lead to logging conflicts and inefficiencies, the queue-based method centralizes everything.
 
 Each worker process sends its log messages to a shared queue. Then, a dedicated logging thread or process takes care of pulling messages from the queue and writing them out. This setup avoids the chaos of multiple processes trying to log at the same time and improves efficiency by separating the generation of logs from their actual writing. In contrast to the multi-threading approach, where log writing can still cause problems if multiple threads are logging simultaneously, the queue-based system ensures orderly and efficient log handling by managing all logs through a single channel.
 
@@ -231,7 +235,7 @@ if __name__ == "__main__":
 
 ```
 
-This setup uses a `QueueHandler` to send log records to a separate logging process. The logging process receives records from the queue and writes them to the desired output. 
+This setup uses a `QueueHandler` to send log records to a separate logging process. The logging process receives records from the queue and writes them to the desired output.
 
 ### Configuring Formatters and Handlers for Multiprocessing Logs
 
@@ -275,142 +279,140 @@ When working with multiprocessing logging, you might encounter several common is
 
 1. Log Message Overlap: Use a queue-based logging system to centralize log writing and prevent overlap.
 2. Missing Log Entries: Ensure that all processes are properly closing their log handlers before exiting.
-    
-    ```python
-    try:
-        # Your processing logic
-    finally:
-        logger.handlers.clear()  # Close and flush handlers
-    ```
-    
+
+   ```python
+   try:
+       # Your processing logic
+   finally:
+       logger.handlers.clear()  # Close and flush handlers
+   ```
+
 3. Performance Bottlenecks: If logging slows down your application, consider using asynchronous logging or reducing log verbosity.
-    
-    ```python
-    # Asynchronous logging
-    queue_handler = QueueHandler(log_queue)
-    logger.addHandler(queue_handler)
-    
-    # Reducing verbosity
-    logger.setLevel(logging.WARNING)  # Adjust level to reduce logging overhead
-    ```
-    
+
+   ```python
+   # Asynchronous logging
+   queue_handler = QueueHandler(log_queue)
+   logger.addHandler(queue_handler)
+
+   # Reducing verbosity
+   logger.setLevel(logging.WARNING)  # Adjust level to reduce logging overhead
+   ```
+
 4. Logging Failures in Child Processes: Implement error handling in your logging code to catch and report any logging-related exceptions.
-    
-    ```python
-    try:
-        logger.info("Processing data")
-    except Exception as e:
-        logger.error(f"Logging failed: {e}")
-    ```
-    
+
+   ```python
+   try:
+       logger.info("Processing data")
+   except Exception as e:
+       logger.error(f"Logging failed: {e}")
+   ```
 
 To debug logging issues:
 
 1. Temporarily increase log verbosity to capture more details. This helps in diagnosing issues by providing more context around the operations leading to the problem. In production, it's best to configure your logging system to exclude debug logs as it can lead to several problems such as performance overhead, security risks and increase log storage. To exclude debug logs set the log level to `INFO` or higher.
-    
-    ```python
-    logger.setLevel(logging.DEBUG)
-    ```
-    
+
+   ```python
+   logger.setLevel(logging.DEBUG)
+   ```
+
 2. Use process and thread IDs in log messages to trace the source of problematic logs. This is especially useful when logs from multiple processes are being handled by a centralized logger, as it allows you to trace back the source of problematic logs.
-    
-    ```python
-    formatter = logging.Formatter('%(asctime)s - %(process)d - %(thread)d - %(message)s')
-    handler.setFormatter(formatter)
-    ```
-    
+
+   ```python
+   formatter = logging.Formatter('%(asctime)s - %(process)d - %(thread)d - %(message)s')
+   handler.setFormatter(formatter)
+   ```
+
 3. Implement a try-except block around logging calls to catch and report any logging exceptions. This can help prevent your application from crashing due to logging failures and ensures that you are aware of any issues that might be affecting log generation.
-    
-    ```python
-    try:
-        logger.debug("Debugging message")
-    except Exception as e:
-        print(f"Logging error: {e}")
-    ```
-    
+
+   ```python
+   try:
+       logger.debug("Debugging message")
+   except Exception as e:
+       print(f"Logging error: {e}")
+   ```
+
 4. Monitor Resource Usage during logging. Excessive logging can lead to increased CPU and memory usage, which might impact the performance of your application.
-    
-    ```python
-    import psutil
-    
-    memory_usage = psutil.Process().memory_info().rss
-    cpu_usage = psutil.cpu_percent()
-    logger.debug(f"Memory usage: {memory_usage}, CPU usage: {cpu_usage}%")
-    ```
-    
+
+   ```python
+   import psutil
+
+   memory_usage = psutil.Process().memory_info().rss
+   cpu_usage = psutil.cpu_percent()
+   logger.debug(f"Memory usage: {memory_usage}, CPU usage: {cpu_usage}%")
+   ```
+
 5. Test in Isolated Environments by running minimal processes for easier debugging. This can make it easier to replicate and identify issues without the noise of a fully operational system.
-    
-    ```python
-    # For Example: To run only 2 processes for isolated testing
-    for i in range(2):
-        p = multiprocessing.Process(target=your_function)
-        p.start()
-    ```
-    
+
+   ```python
+   # For Example: To run only 2 processes for isolated testing
+   for i in range(2):
+       p = multiprocessing.Process(target=your_function)
+       p.start()
+   ```
 
 ## Optimizing Logging Performance in Multiprocessing Applications
 
 Logging can significantly impact the performance of your multiprocessing application. Here are some strategies to optimize logging performance:
 
-1. Use Asynchronous Logging: Implement a separate logging process to handle log writing asynchronously. This decouples logging from your main processing tasks, reducing the impact on performance. Let’s take an example: 
-    
-    ```python
-    import logging
-    import concurrent.futures
-    import time
-    import queue
-    
-    # Create a logger
-    logger = logging.getLogger('AsyncLogger')
-    logger.setLevel(logging.DEBUG)
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    
-    # Console handler for the logger
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-    
-    # Queue to hold log messages
-    log_queue = queue.Queue()
-    
-    # Thread function to write log messages from the queue
-    def log_writer():
-        while True:
-            message = log_queue.get()
-            if message is None:  # Sentinel value to shut down the thread
-                break
-            logger.log(message['level'], message['msg'])
-    
-    # Function to add a log message to the queue
-    def async_log(level, msg):
-        log_queue.put({'level': level, 'msg': msg})
-    
-    # Start the log writer thread
-    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
-        future = executor.submit(log_writer)
-    
-        # Main application code
-        for i in range(5):
-            async_log(logging.INFO, f'Log message {i}')
-            time.sleep(0.1)  # Simulate some work
-    
-        # Shutdown the log writer
-        log_queue.put(None)  # Send shutdown signal
-        future.result()  # Wait for the log writer thread to finish
-    ```
-    
-    Output: 
-    
-    ```python
-    2024-08-28 12:40:46,762 - AsyncLogger - INFO - Log message 0
-    2024-08-28 12:40:46,862 - AsyncLogger - INFO - Log message 1
-    2024-08-28 12:40:46,963 - AsyncLogger - INFO - Log message 2
-    2024-08-28 12:40:47,064 - AsyncLogger - INFO - Log message 3
-    2024-08-28 12:40:47,165 - AsyncLogger - INFO - Log message 4
-    ```
-    
-    This example uses Python's `concurrent.futures` and queue for efficient asynchronous logging. The `async_log` function adds messages to a queue, acting as a buffer between main tasks and logging. A separate thread, managed by `ThreadPoolExecutor`, runs the `log_writer` function, which continuously processes messages from the queue and writes them using the logger. The future object ensures that all log messages are processed before the application exits, with `future.result()` used to wait for the logging thread to complete after receiving a shutdown signal `(None)`. This setup keeps the main loop unblocked by logging operations, ensuring smooth application performance.
-    
+1. Use Asynchronous Logging: Implement a separate logging process to handle log writing asynchronously. This decouples logging from your main processing tasks, reducing the impact on performance. Let’s take an example:
+
+   ```python
+   import logging
+   import concurrent.futures
+   import time
+   import queue
+
+   # Create a logger
+   logger = logging.getLogger('AsyncLogger')
+   logger.setLevel(logging.DEBUG)
+   formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+   # Console handler for the logger
+   console_handler = logging.StreamHandler()
+   console_handler.setFormatter(formatter)
+   logger.addHandler(console_handler)
+
+   # Queue to hold log messages
+   log_queue = queue.Queue()
+
+   # Thread function to write log messages from the queue
+   def log_writer():
+       while True:
+           message = log_queue.get()
+           if message is None:  # Sentinel value to shut down the thread
+               break
+           logger.log(message['level'], message['msg'])
+
+   # Function to add a log message to the queue
+   def async_log(level, msg):
+       log_queue.put({'level': level, 'msg': msg})
+
+   # Start the log writer thread
+   with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+       future = executor.submit(log_writer)
+
+       # Main application code
+       for i in range(5):
+           async_log(logging.INFO, f'Log message {i}')
+           time.sleep(0.1)  # Simulate some work
+
+       # Shutdown the log writer
+       log_queue.put(None)  # Send shutdown signal
+       future.result()  # Wait for the log writer thread to finish
+   ```
+
+   Output:
+
+   ```python
+   2024-08-28 12:40:46,762 - AsyncLogger - INFO - Log message 0
+   2024-08-28 12:40:46,862 - AsyncLogger - INFO - Log message 1
+   2024-08-28 12:40:46,963 - AsyncLogger - INFO - Log message 2
+   2024-08-28 12:40:47,064 - AsyncLogger - INFO - Log message 3
+   2024-08-28 12:40:47,165 - AsyncLogger - INFO - Log message 4
+   ```
+
+   This example uses Python's `concurrent.futures` and queue for efficient asynchronous logging. The `async_log` function adds messages to a queue, acting as a buffer between main tasks and logging. A separate thread, managed by `ThreadPoolExecutor`, runs the `log_writer` function, which continuously processes messages from the queue and writes them using the logger. The future object ensures that all log messages are processed before the application exits, with `future.result()` used to wait for the logging thread to complete after receiving a shutdown signal `(None)`. This setup keeps the main loop unblocked by logging operations, ensuring smooth application performance.
+
 2. Batch Log Messages: Instead of writing each log message immediately, batch multiple messages and write them together. It reduces the number of I/O operations by writing multiple log messages at once instead of individually.
 3. Implement Log Levels: Use appropriate log levels to control the amount of information logged in production environments. This helps to minimize the performance impact of logging by avoiding unnecessary log entries.
 4. Use Memory Handlers: For high-throughput scenarios, consider using `MemoryHandler` to buffer log records in memory before flushing to disk. This can significantly reduce the frequency of I/O operations, improving performance.
@@ -514,11 +516,11 @@ app = Flask(__name__)
 def worker_process(worker_id):
     logger = logging.getLogger(f"Worker-{worker_id}")
     logger.info(f"Worker {worker_id} started")
-    
+
     for _ in range(5):
         time.sleep(random.uniform(0.5, 2))
         logger.info(f"Worker {worker_id} is processing")
-    
+
     logger.info(f"Worker {worker_id} finished")
 
 @app.route('/')
@@ -529,10 +531,10 @@ def trigger_workers():
         p = multiprocessing.Process(target=worker_process, args=(i,))
         processes.append(p)
         p.start()
-    
+
     for p in processes:
         p.join()
-    
+
     return "Workers completed their tasks. Check the logs!"
 
 if __name__ == '__main__':
@@ -570,10 +572,20 @@ Viewing Logs
 After running your application and generating some logs:
 
 1. Check your terminal to see the logs printed to the console.
-    
-    <Figure src="/img/guides/2024/08/how-should-i-log-while-using-multiprocessing-in-python-CleanShot_2024-08-30_at_14.28.512x.webp" alt="" caption="" />2. Log in to your SigNoz dashboard to view the logs sent to SigNoz.
-    
-    <Figure src="/img/guides/2024/08/how-should-i-log-while-using-multiprocessing-in-python-CleanShot_2024-08-30_at_14.29.482x.webp" alt="" caption="" />You should now see your application logs both in the terminal and in the SigNoz dashboard.
+
+   <Figure
+     src="/img/guides/2024/08/how-should-i-log-while-using-multiprocessing-in-python-CleanShot_2024-08-30_at_14.28.512x.webp"
+     alt=""
+     caption=""
+   />
+   2. Log in to your SigNoz dashboard to view the logs sent to SigNoz.
+
+   <Figure
+     src="/img/guides/2024/08/how-should-i-log-while-using-multiprocessing-in-python-CleanShot_2024-08-30_at_14.29.482x.webp"
+     alt=""
+     caption=""
+   />
+   You should now see your application logs both in the terminal and in the SigNoz dashboard.
 
 ## Key Takeaways
 
@@ -617,4 +629,4 @@ To prevent log corruption in multiprocessing:
 1. Use a queue-based logging system with a separate logging process.
 2. Implement proper locking mechanisms if multiple processes write to the same file.
 3. Use atomic operations for log writes when possible.
-4. Consider using a centralized logging service like SigNoz to handle log aggregation and storage.
\ No newline at end of file
+4. Consider using a centralized logging service like SigNoz to handle log aggregation and storage.
diff --git a/data/guides/how-to-add-target-specific-label-in-prometheus.mdx b/data/guides/how-to-add-target-specific-label-in-prometheus.mdx
index 1cf01d922..c800c999a 100644
--- a/data/guides/how-to-add-target-specific-label-in-prometheus.mdx
+++ b/data/guides/how-to-add-target-specific-label-in-prometheus.mdx
@@ -1,159 +1,170 @@
 ---
-
 title: How to Add Target-Specific Labels in Prometheus - A Guide
-slug: how-to-add-target-specific-label-in-prometheus
 date: 2024-07-24
 tags: [prometheus, faq]
 authors: [yuvraj]
 description: Learn how to add target-specific labels in Prometheus for better metric organization and querying. Step-by-step guide for static and dynamic label addition.
-keywords: [Prometheus, target-specific labels, metric organization, service discovery, relabeling, monitoring]
-
+keywords:
+  [
+    Prometheus,
+    target-specific labels,
+    metric organization,
+    service discovery,
+    relabeling,
+    monitoring,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Add Target-Specific Labels in Prometheus: A Guide",
-    "alternativeHeadline": "Step-by-Step Guide to Adding Target-Specific Labels in Prometheus",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-add-target-specific-label-in-prometheus/"
-    },
-    "description": "Learn how to add target-specific labels in Prometheus for better metric organization and querying. Step-by-step guide for static and dynamic label addition.",
-    "keywords": "Prometheus, target-specific labels, metric organization, service discovery, relabeling, monitoring",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The process of continuously observing and checking the performance and behavior of a system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Service Discovery",
-        "description": "A method to automatically detect and connect to services in a network."
-      },
-      {
-        "@type": "Thing",
-        "name": "Relabeling",
-        "description": "The process of modifying or adding labels to metrics in Prometheus."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Can I add labels to targets after they've been scraped?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "No, Prometheus adds labels during the scraping process. To add new labels, you need to update your configuration and re-scrape the targets."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do target-specific labels affect Prometheus' performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While labels provide valuable context, excessive use can impact performance. Keep label cardinality (number of unique label combinations) in check to maintain optimal performance."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Add Target-Specific Labels in Prometheus: A Guide',
+        alternativeHeadline: 'Step-by-Step Guide to Adding Target-Specific Labels in Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "Is it possible to remove or modify existing labels on targets?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, you can use relabeling rules to drop or modify existing labels. Use the `action: labeldrop` or `action: labelmap` directives in your `relabel_configs`."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What's the difference between labels and annotations in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Labels are used for identifying time series and can be used in queries. Annotations provide additional metadata but are not queryable and don't create new time series."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Adding Target-Specific Labels in Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Open Prometheus Configuration",
-          "text": "Open your Prometheus configuration file (usually prometheus.yml)."
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-add-target-specific-label-in-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Locate scrape_configs Section",
-          "text": "Locate the scrape_configs section in the configuration file."
+        description:
+          'Learn how to add target-specific labels in Prometheus for better metric organization and querying. Step-by-step guide for static and dynamic label addition.',
+        keywords:
+          'Prometheus, target-specific labels, metric organization, service discovery, relabeling, monitoring',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Add Labels to Static Targets",
-          "text": "Find or add a job for your target and add labels under the labels key for each target."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The process of continuously observing and checking the performance and behavior of a system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Service Discovery',
+            description: 'A method to automatically detect and connect to services in a network.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Relabeling',
+            description: 'The process of modifying or adding labels to metrics in Prometheus.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "Can I add labels to targets after they've been scraped?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'No, Prometheus adds labels during the scraping process. To add new labels, you need to update your configuration and re-scrape the targets.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How do target-specific labels affect Prometheus' performance?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'While labels provide valuable context, excessive use can impact performance. Keep label cardinality (number of unique label combinations) in check to maintain optimal performance.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is it possible to remove or modify existing labels on targets?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, you can use relabeling rules to drop or modify existing labels. Use the `action: labeldrop` or `action: labelmap` directives in your `relabel_configs`.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What's the difference between labels and annotations in Prometheus?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Labels are used for identifying time series and can be used in queries. Annotations provide additional metadata but are not queryable and don't create new time series.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Verify Label Addition",
-          "text": "Restart Prometheus to apply the changes and open the Prometheus UI to verify the new labels."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Adding Target-Specific Labels in Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Open Prometheus Configuration',
+              text: 'Open your Prometheus configuration file (usually prometheus.yml).',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Locate scrape_configs Section',
+              text: 'Locate the scrape_configs section in the configuration file.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Labels to Static Targets',
+              text: 'Find or add a job for your target and add labels under the labels key for each target.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Verify Label Addition',
+              text: 'Restart Prometheus to apply the changes and open the Prometheus UI to verify the new labels.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use Service Discovery for Dynamic Labels',
+              text: "Configure Prometheus' service discovery mechanisms to automatically add labels.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Advanced Relabeling Techniques',
+              text: 'Use label_replace and conditional statements for more complex labeling needs.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use Service Discovery for Dynamic Labels",
-          "text": "Configure Prometheus' service discovery mechanisms to automatically add labels."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Advanced Relabeling Techniques",
-          "text": "Use label_replace and conditional statements for more complex labeling needs."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Adding target-specific labels in Prometheus is a powerful way to organize and query your metrics effectively. This guide will walk you through the process of implementing these labels, from basic static configurations to advanced dynamic techniques. You'll learn how to enhance your monitoring setup and improve your ability to troubleshoot and analyze your systems.
@@ -203,7 +214,6 @@ scrape_configs:
           environment: 'production'
           service: 'api'
           region: 'us-west-2'
-
 ```
 
 This configuration adds three labels to the `api-server` target: `environment`, `service`, and `region`.
@@ -228,7 +238,6 @@ scrape_configs:
         target_label: namespace
       - source_labels: [__meta_kubernetes_pod_name]
         target_label: pod
-
 ```
 
 This configuration automatically adds `namespace` and `pod` labels to metrics scraped from Kubernetes pods.
@@ -245,7 +254,6 @@ relabel_configs:
     regex: '(.+):(.+)'
     replacement: '${1}'
     target_label: 'host'
-
 ```
 
 This example extracts the host from the `__address__` label and creates a new `host` label.
@@ -259,7 +267,6 @@ relabel_configs:
     action: replace
     replacement: 'web'
     target_label: 'service'
-
 ```
 
 This configuration adds a `service: web` label to targets with port 8080.
@@ -289,7 +296,6 @@ Yes, you can use relabeling rules to drop or modify existing labels. Use the `ac
 
 Labels are used for identifying time series and can be used in queries. Annotations provide additional metadata but are not queryable and don't create new time series.
 
-
 ## Enhance Your Monitoring with SigNoz
 
 While Prometheus offers powerful monitoring capabilities, managing retention and scaling can become challenging as your infrastructure grows. SigNoz provides a comprehensive monitoring solution that builds upon Prometheus' strengths while addressing its limitations.
@@ -297,8 +303,9 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With SigNoz, you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
 - Get high performance with the clickhouse database
-- Take advantage of SigNoz's exceptional exception monitoring capabilities
\ No newline at end of file
+- Take advantage of SigNoz's exceptional exception monitoring capabilities
diff --git a/data/guides/how-to-authenticate-and-embedded-grafana-charts-into-iframe.mdx b/data/guides/how-to-authenticate-and-embedded-grafana-charts-into-iframe.mdx
index 2fb5dd55c..9f8e37b15 100644
--- a/data/guides/how-to-authenticate-and-embedded-grafana-charts-into-iframe.mdx
+++ b/data/guides/how-to-authenticate-and-embedded-grafana-charts-into-iframe.mdx
@@ -1,27 +1,33 @@
 ---
-
 title: How to Embed Grafana Charts with Authentication - Step-by-Step Guide
-slug: how-to-authenticate-and-embedded-grafana-charts-into-iframe
 date: 2024-11-14
 tags: [grafana, monitoring, authentication, iframe, dashboards]
 authors: [simran_kumari]
 description: Learn how to securely embed Grafana charts with authentication using iframes. Step-by-step guide covering multiple auth methods and security best practices.
-keywords: [grafana embed charts, grafana authentication, iframe embedding, grafana dashboard integration, grafana security, grafana api key, grafana jwt]
-
+keywords:
+  [
+    grafana embed charts,
+    grafana authentication,
+    iframe embedding,
+    grafana dashboard integration,
+    grafana security,
+    grafana api key,
+    grafana jwt,
+  ]
 ---
 
-Embedding Grafana charts directly into your web applications allows users to access dashboards seamlessly, but securely implementing this can be tricky. Grafana, by default, prompts for login when embedding charts, which disrupts the user experience. This guide will take you through various methods to embed Grafana charts with authentication, covering everything from configuration to securing access. 
+Embedding Grafana charts directly into your web applications allows users to access dashboards seamlessly, but securely implementing this can be tricky. Grafana, by default, prompts for login when embedding charts, which disrupts the user experience. This guide will take you through various methods to embed Grafana charts with authentication, covering everything from configuration to securing access.
 
 ## Understanding Grafana Embedding Options
 
 When embedding Grafana charts, each method offers unique benefits and limitations:
 
 - Iframe Embedding: The simplest way to embed Grafana charts in an external site using HTML iframes.
-    - Limitations: Requires separate authentication handling, often resulting in login prompts or issues with token-based authentication. Additionally, iframes can expose your dashboard to potential cross-site security risks.
+  - Limitations: Requires separate authentication handling, often resulting in login prompts or issues with token-based authentication. Additionally, iframes can expose your dashboard to potential cross-site security risks.
 - Panel Plugins: Some Grafana plugins allow embedding without iframes, enhancing security and flexibility.
-    - Limitations: Often more complex to set up, requiring additional configuration and possibly specific Grafana or plugin versions to work correctly.
+  - Limitations: Often more complex to set up, requiring additional configuration and possibly specific Grafana or plugin versions to work correctly.
 - Direct URL Access: Sharing dashboards via a direct URL provides quick access to Grafana dashboards.
-    - Limitations: Lacks the flexibility to control access programmatically, making it less secure for embedding in applications. URL-based access can also expose dashboards if URLs are shared or intercepted.
+  - Limitations: Lacks the flexibility to control access programmatically, making it less secure for embedding in applications. URL-based access can also expose dashboards if URLs are shared or intercepted.
 
 ### Security Considerations for Embedded Dashboards
 
@@ -33,23 +39,23 @@ Below are the steps to securely configure and embed Grafana charts in iframes, a
 
 ### Setting Up Grafana Configuration
 
-1. Enable Anonymous Access (optional):
-    
-    In `grafana.ini`, you can enable anonymous access to public dashboards. 
-    
+1.  Enable Anonymous Access (optional):
+
+    In `grafana.ini`, you can enable anonymous access to public dashboards.
+
     ```toml
     [auth.anonymous]
     enabled = true
     org_name = Main Org.
     org_role = Viewer
     ```
-    
+
     However, for secure implementations, it's best to skip this step to prevent unrestricted access.
-    
-2. Configure CORS Settings:
-    
+
+2.  Configure CORS Settings:
+
     Ensure cross-origin resource sharing (CORS) is enabled in `grafana.ini`:
-    
+
     ```toml
     [server]
     allow_embedding = true
@@ -57,174 +63,170 @@ Below are the steps to securely configure and embed Grafana charts in iframes, a
     enabled = true
     allowed_origins = <https://yourapp.com>
     ```
-    
-3. Set Up Service Account Tokens: 
-    
+
+3.  Set Up Service Account Tokens:
+
     Grafana supports service account tokens instead of traditional API keys. These tokens allow programmatic access to Grafana while enhancing security and supporting finer-grained permissions.
-    
+
     Here are the detailed steps for generating a service account token:
-    
+
     - Login to Grafana as an admin.
     - Go to Administration → Users and access → Service accounts, and click on the `Add service account` button.
-        
-        <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%208.webp" alt="Adding service account in Grafana" caption="Adding service account in Grafana" />
-        
+      {' '}
+      <Figure
+        src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%208.webp"
+        alt="Adding service account in Grafana"
+        caption="Adding service account in Grafana"
+      />
     - Add the display name for the service account, choose the corresponding role, and click on the `Create` button.
-        
-        <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%209.webp" alt="Creating service account in Grafana" caption="Creating service account in Grafana" />
-        
+      {' '}
+      <Figure
+        src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%209.webp"
+        alt="Creating service account in Grafana"
+        caption="Creating service account in Grafana"
+      />
     - Next, click on the `Add Service account token`
-        
-        <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2010.webp" alt="Add service account token" caption="Add service account token" />
-        
+      {' '}
+      <Figure
+        src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2010.webp"
+        alt="Add service account token"
+        caption="Add service account token"
+      />
     - Generate a token, you can also set an expiration date if you want. The token will be used for access.
-        
-        <Figure src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2011.webp" alt="Generate token for service account" caption="Generate token for service account" />
-        
+      {' '}
+      <Figure
+        src="/img/guides/2024/10/embedding-a-website-in-a-grafana-dashboard-image%2011.webp"
+        alt="Generate token for service account"
+        caption="Generate token for service account"
+      />
     - Copy and securely store the token for use in authenticated requests.
-4. Manage Authentication Domains:
-Ensure that only trusted domains can embed these dashboards. This helps protect against unauthorized access from unintended sites.
-    
-    You can specify which domains are allowed to embed Grafana dashboards in `grafana.ini`. For example:
-    
-    ```toml
-    [server]
-    allow_embedding = true
-    # Only allow specific domains to embed dashboards
-    # Example: allow embedding from "https://yourtrusteddomain.com"
-    # Use a comma to separate multiple domains
-    allow_embedding_from = domain1.com, domain2.com
-    ```
-    
+
+4.  Manage Authentication Domains:
+    Ensure that only trusted domains can embed these dashboards. This helps protect against unauthorized access from unintended sites.
+        You can specify which domains are allowed to embed Grafana dashboards in `grafana.ini`. For example:
+
+        ```toml
+        [server]
+        allow_embedding = true
+        # Only allow specific domains to embed dashboards
+        # Example: allow embedding from "https://yourtrusteddomain.com"
+        # Use a comma to separate multiple domains
+        allow_embedding_from = domain1.com, domain2.com
+        ```
 
 ### Implementing Authentication Methods
 
 Grafana supports several secure authentication methods for embedded dashboards. Here are some of the most effective options:
 
 1. JWT Token Authentication
-    - Overview: This method allows you to generate JSON Web Tokens (JWT) for users in your application, which Grafana will accept for authentication.
-    - Steps:
-        - In your application, create a function to generate a JWT token that encodes user information (like user ID, roles, etc.).
-        - Include a secret key for signing the token, ensuring it is kept secure.
-            
-            ```python
-            import jwt
-            from datetime import datetime, timedelta
-            
-            def create_jwt(user_id):
-                payload = {
-                    'sub': user_id,
-                    'exp': datetime.utcnow() + timedelta(minutes=30)  # Token expiration time
-                }
-                return jwt.encode(payload, 'your_secret_key', algorithm='HS256')
-            ```
-            
-        - Configure Grafana to accept JWTs by adding an authentication provider in the `grafana.ini` file.
-            
-            ```toml
-            [auth.jwt]
-            enabled = true
-            # HTTP header to look into to get a JWT token.
-            header_name = X-JWT-Assertion
-            ```
-            
-        - Pass the JWT token as part of the iframe's URL or in the HTTP headers when making requests to Grafana.
-            
-            ```python
-            def embed_with_jwt(user_id):
-                # Generate the JWT token for the given user_id
-                token = create_jwt(user_id)
-                
-                # Create an HTML page with the iframe
-                html_content = f"""
-                <!DOCTYPE html>
-                <html lang="en">
-                <head>
-                    <title>Embed Grafana Chart</title>
-                </head>
-                <body>
-                    <iframe src="https://<grafana-server>/d/<dashboard-id>?orgId=1&auth_token={token}"></iframe>
-                </body>
-                </html>
-                """
-                return render_template_string(html_content) 
-            ```
-            
-    
-    Read more on JWT Configuration in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/jwt/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
-    
+
+   - Overview: This method allows you to generate JSON Web Tokens (JWT) for users in your application, which Grafana will accept for authentication.
+   - Steps:
+     - In your application, create a function to generate a JWT token that encodes user information (like user ID, roles, etc.).
+     - Include a secret key for signing the token, ensuring it is kept secure.
+       ```python
+       import jwt
+       from datetime import datetime, timedelta
+
+       def create_jwt(user_id):
+           payload = {
+               'sub': user_id,
+               'exp': datetime.utcnow() + timedelta(minutes=30)  # Token expiration time
+           }
+           return jwt.encode(payload, 'your_secret_key', algorithm='HS256')
+       ```
+     - Configure Grafana to accept JWTs by adding an authentication provider in the `grafana.ini` file.
+       ```toml
+       [auth.jwt]
+       enabled = true
+       # HTTP header to look into to get a JWT token.
+       header_name = X-JWT-Assertion
+       ```
+     - Pass the JWT token as part of the iframe's URL or in the HTTP headers when making requests to Grafana.
+       ```python
+       def embed_with_jwt(user_id):
+           # Generate the JWT token for the given user_id
+           token = create_jwt(user_id)
+
+           # Create an HTML page with the iframe
+           html_content = f"""
+           <!DOCTYPE html>
+           <html lang="en">
+           <head>
+               <title>Embed Grafana Chart</title>
+           </head>
+           <body>
+               <iframe src="https://<grafana-server>/d/<dashboard-id>?orgId=1&auth_token={token}"></iframe>
+           </body>
+           </html>
+           """
+           return render_template_string(html_content)
+       ```
+
+   Read more on JWT Configuration in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/jwt/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
+
 2. OAuth2 Implementation
-    - Overview: OAuth2 allows users to authenticate through third-party providers such as Google or GitHub, providing a secure way to access Grafana dashboards without exposing credentials.
-    - Steps:
-        - Configure OAuth2 in the `grafana.ini` file to define your OAuth settings.
-            
-            ```toml
-            [auth.google] # provider name is replacable e.g., google, github 
-            enabled = true
-            client_id = <your_client_id>
-            client_secret = <your_client_secret>
-            scopes = <comma_separated_scopes>
-            redirect_uri = http://yourapp.com/oauth2/callback
-            ```
-            
-        - Set up the redirect URI in the OAuth provider’s settings to ensure the provider can redirect users back to your application after authentication.
-        - In your application, implement a login flow where users are redirected to the OAuth provider for authentication, and then handle the callback to retrieve the access token.
-        - Use the access token to authenticate API requests to Grafana, ensuring your application can access protected resources.
-    - Read more on OAuth2 Configuration in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/generic-oauth/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
+   - Overview: OAuth2 allows users to authenticate through third-party providers such as Google or GitHub, providing a secure way to access Grafana dashboards without exposing credentials.
+   - Steps:
+     - Configure OAuth2 in the `grafana.ini` file to define your OAuth settings.
+       ```toml
+       [auth.google] # provider name is replacable e.g., google, github
+       enabled = true
+       client_id = <your_client_id>
+       client_secret = <your_client_secret>
+       scopes = <comma_separated_scopes>
+       redirect_uri = http://yourapp.com/oauth2/callback
+       ```
+     - Set up the redirect URI in the OAuth provider’s settings to ensure the provider can redirect users back to your application after authentication.
+     - In your application, implement a login flow where users are redirected to the OAuth provider for authentication, and then handle the callback to retrieve the access token.
+     - Use the access token to authenticate API requests to Grafana, ensuring your application can access protected resources.
+   - Read more on OAuth2 Configuration in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/generic-oauth/" rel="noopener noreferrer nofollow" target="_blank">here</a>.
 3. Service Account Token Authentication
-    - Overview: Service account tokens allow programmatic access to Grafana using tokens that are securely generated and managed, typically for backend applications or scripts.
-    - Steps:
-        - Generate a service account token in your application that can be used to authenticate with Grafana.
-        - In your Grafana configuration (`grafana.ini`), enable the use of service account tokens.
-            
-            ```toml
-            [auth.service_account]
-            enabled = true
-            ```
-            
-        - Include the service account token in the iframe’s URL when embedding the Grafana dashboard.
-            
-            ```python
-            def embed_with_service_account():
-                token = generate_service_account_token()
-                html_content = f"""
-                <!DOCTYPE html>
-                <html lang="en">
-                <head>
-                    <title>Embed Grafana Chart</title>
-                </head>
-                <body>
-                    <iframe src="https://grafana.example.com/d/dashboard-id?orgId=1&access_token={token}"></iframe>
-                </body>
-                </html>
-                """
-                return render_template_string(html_content)
-            ```
-            
-    - Note: Service account tokens are ideal for dashboards that don’t require granular user-specific access control but need secure, automated access.
+   - Overview: Service account tokens allow programmatic access to Grafana using tokens that are securely generated and managed, typically for backend applications or scripts.
+   - Steps:
+     - Generate a service account token in your application that can be used to authenticate with Grafana.
+     - In your Grafana configuration (`grafana.ini`), enable the use of service account tokens.
+       ```toml
+       [auth.service_account]
+       enabled = true
+       ```
+     - Include the service account token in the iframe’s URL when embedding the Grafana dashboard.
+       ```python
+       def embed_with_service_account():
+           token = generate_service_account_token()
+           html_content = f"""
+           <!DOCTYPE html>
+           <html lang="en">
+           <head>
+               <title>Embed Grafana Chart</title>
+           </head>
+           <body>
+               <iframe src="https://grafana.example.com/d/dashboard-id?orgId=1&access_token={token}"></iframe>
+           </body>
+           </html>
+           """
+           return render_template_string(html_content)
+       ```
+   - Note: Service account tokens are ideal for dashboards that don’t require granular user-specific access control but need secure, automated access.
 4. Session-Based Authentication
-    - Overview: Session-based authentication uses cookies stored in the user's browser to manage user sessions, allowing seamless access to Grafana dashboards for logged-in users.
-    - Steps:
-        - Ensure your application sets up user sessions upon successful login, managing session cookies correctly.
-            
-            ```python
-            from flask import session
-            
-            def login_user(user):
-                session['user_id'] = user.id  # Save user ID in session
-                # Set any other session parameters as needed
-            ```
-            
-        - In your Grafana configuration (`grafana.ini`), ensure that session authentication is enabled.
-            
-            ```toml
-            [auth.session]
-            enabled = true
-            cookie_samesite = None  # Needed if embedding cross-domain
-            ```
-            
-        - When embedding the Grafana dashboard, ensure that the session cookie is sent along with requests to Grafana. This typically happens automatically if the iframe is served from the same domain or subdomain.
-    - Read more on Session-Based Authentication in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/grafana/" rel="noopener noreferrer nofollow" target="_blank">here.</a>
+   - Overview: Session-based authentication uses cookies stored in the user's browser to manage user sessions, allowing seamless access to Grafana dashboards for logged-in users.
+   - Steps:
+     - Ensure your application sets up user sessions upon successful login, managing session cookies correctly.
+       ```python
+       from flask import session
+
+       def login_user(user):
+           session['user_id'] = user.id  # Save user ID in session
+           # Set any other session parameters as needed
+       ```
+     - In your Grafana configuration (`grafana.ini`), ensure that session authentication is enabled.
+       ```toml
+       [auth.session]
+       enabled = true
+       cookie_samesite = None  # Needed if embedding cross-domain
+       ```
+     - When embedding the Grafana dashboard, ensure that the session cookie is sent along with requests to Grafana. This typically happens automatically if the iframe is served from the same domain or subdomain.
+   - Read more on Session-Based Authentication in Grafana <a href="https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/grafana/" rel="noopener noreferrer nofollow" target="_blank">here.</a>
 
 ## Security Best Practices
 
@@ -256,54 +258,45 @@ Here’s how to resolve common problems with embedded Grafana charts:
 
 - CORS Errors: Double-check `grafana.ini` settings, ensuring `allow_embedding` is true and proper origins are allowed.
 - Authentication Loops: If Grafana repeatedly prompts for login, verify token or session validity, and make sure tokens aren’t expiring prematurely.
-    
-    Example code to check token validity and expiration:
-    
-    ```python
-    def is_token_valid(token):
-        try:
-            payload = jwt.decode(token, 'your_secret_key', algorithms=['HS256'])
-            return payload['exp'] > datetime.utcnow()
-        except jwt.ExpiredSignatureError:
-            return False  # Token has expired
-        except jwt.InvalidTokenError:
-            return False  # Token is invalid
-    ```
-    
+  Example code to check token validity and expiration:
+  ```python
+  def is_token_valid(token):
+      try:
+          payload = jwt.decode(token, 'your_secret_key', algorithms=['HS256'])
+          return payload['exp'] > datetime.utcnow()
+      except jwt.ExpiredSignatureError:
+          return False  # Token has expired
+      except jwt.InvalidTokenError:
+          return False  # Token is invalid
+  ```
 - Iframe Rendering Issues: Some browsers restrict iframes from accessing cross-origin content; check browser settings or consider using a reverse proxy.
-    
-    Example: Use a reverse proxy like Nginx to handle cross-origin requests.
-    
-    ```
-    server {
-        listen 80;
-    
-        location /grafana/ {
-            proxy_pass http://localhost:3000/;  # Assuming Grafana runs on port 3000
-            proxy_set_header Host $host;
-            proxy_set_header X-Real-IP $remote_addr;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header X-Forwarded-Proto $scheme;
-        }
-    }
-    ```
-    
+  Example: Use a reverse proxy like Nginx to handle cross-origin requests.
+  ```
+  server {
+      listen 80;
+
+      location /grafana/ {
+          proxy_pass http://localhost:3000/;  # Assuming Grafana runs on port 3000
+          proxy_set_header Host $host;
+          proxy_set_header X-Real-IP $remote_addr;
+          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+          proxy_set_header X-Forwarded-Proto $scheme;
+      }
+  }
+  ```
 - Token Validation Problems: Ensure tokens are correctly signed and within expiration limits. Test token flows thoroughly in development.
-    
-    Example: Ensure proper signing and testing of tokens.
-    
-    ```python
-    def create_and_validate_jwt(user_id):
-    	token = create_jwt(user_id)
-    	try:
-    		payload = jwt.decode(token, 'your_secret_key', algorithms=['HS256'])
-    		print("Token valid:", payload)
-    	except jwt.ExpiredSignatureError:
-    		print("Token expired.")
-    	except jwt.InvalidTokenError:
-    		print("Invalid token.")
-    ```
-    
+  Example: Ensure proper signing and testing of tokens.
+  ```python
+  def create_and_validate_jwt(user_id):
+  	token = create_jwt(user_id)
+  	try:
+  		payload = jwt.decode(token, 'your_secret_key', algorithms=['HS256'])
+  		print("Token valid:", payload)
+  	except jwt.ExpiredSignatureError:
+  		print("Token expired.")
+  	except jwt.InvalidTokenError:
+  		print("Invalid token.")
+  ```
 
 ## Exploring SigNoz as an Alternative Monitoring Solution
 
@@ -314,13 +307,19 @@ While Grafana is a powerful visualization tool, it primarily focuses on displayi
 Key Advantages of SigNoz:
 
 - [Unified Observability](https://signoz.io/unified-observability/): SigNoz integrates metrics, traces, and logs, providing a comprehensive view of application health that simplifies troubleshooting.
-    
-    <Figure src="/img/guides/2024/11/how-to-authenticate-and-embedded-grafana-charts-into-iframe-image.webp" alt="Unified Observability" caption="Unified Observability" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-authenticate-and-embedded-grafana-charts-into-iframe-image.webp"
+    alt="Unified Observability"
+    caption="Unified Observability"
+  />
 - Real-time Performance Monitoring: Unlike Grafana, which focuses on historical data, SigNoz enables real-time analysis of application performance, helping identify bottlenecks and issues as they occur.
-    
-    <Figure src="/img/guides/2024/11/how-to-authenticate-and-embedded-grafana-charts-into-iframe-image%201.webp" alt="Real-Time Performance Monitoring" caption="Real-Time Performance Monitoring" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-authenticate-and-embedded-grafana-charts-into-iframe-image%201.webp"
+    alt="Real-Time Performance Monitoring"
+    caption="Real-Time Performance Monitoring"
+  />
 - Cost-Effective and Simplified Setup: As an open-source solution, SigNoz offers a cost-effective alternative to paid services. Its built-in support for [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) simplifies the setup process, allowing developers to start monitoring quickly without extensive configuration.
 
 <GetStartedSigNoz />
@@ -349,4 +348,4 @@ Use a refresh mechanism within your app to update tokens before they expire. You
 
 ### What are the limitations of iframe embedding in Grafana?
 
-Iframe embedding faces issues with cross-origin authentication requires proper CORS settings, and can run into problems with third-party cookies or token expiry.
\ No newline at end of file
+Iframe embedding faces issues with cross-origin authentication requires proper CORS settings, and can run into problems with third-party cookies or token expiry.
diff --git a/data/guides/how-to-best-capture-and-log-scp-output.mdx b/data/guides/how-to-best-capture-and-log-scp-output.mdx
index ae235eed4..71a4166fe 100644
--- a/data/guides/how-to-best-capture-and-log-scp-output.mdx
+++ b/data/guides/how-to-best-capture-and-log-scp-output.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Capture and Log SCP Output - A Step-by-Step Guide
-slug: how-to-best-capture-and-log-scp-output
 date: 2024-09-06
 tags: [faq, logging]
 authors: [nitin_gouda]
 description: Learn effective techniques to capture and log SCP output for better monitoring, troubleshooting, and auditing of secure file transfers.
-keywords: [SCP output, log SCP, capture SCP, secure file transfer, SCP monitoring, troubleshoot SCP, SCP logging techniques]
-
+keywords:
+  [
+    SCP output,
+    log SCP,
+    capture SCP,
+    secure file transfer,
+    SCP monitoring,
+    troubleshoot SCP,
+    SCP logging techniques,
+  ]
 ---
 
 Secure Copy Protocol (SCP) is a vital tool for transferring files securely between systems. However, capturing and logging its output can be challenging due to its dynamic nature. This guide will walk you through various methods to effectively capture and log SCP output, helping you monitor, troubleshoot, and audit your file transfers with ease.
@@ -19,7 +25,7 @@ Secure Copy Protocol (SCP) is a network protocol that allows for secure file tra
 When using SCP, it typically generates two types of output:
 
 1. Progress Information: This includes real-time details such as the speed of the transfer, the percentage of the file that has been transferred, and an estimate of how much time remains until the transfer is complete. This information helps monitor the progress of file transfer and ensures that everything is moving as expected.
-2. Error Messages: Error messages provide feedback when something goes wrong during the transfer process, such as network outages, permission issues, or connection dropouts. They are critical for troubleshooting since they explain what went wrong and how to solve it. 
+2. Error Messages: Error messages provide feedback when something goes wrong during the transfer process, such as network outages, permission issues, or connection dropouts. They are critical for troubleshooting since they explain what went wrong and how to solve it.
 
 Capturing this output is crucial for several reasons:
 
@@ -34,42 +40,34 @@ The challenge in capturing SCP output lies in its dynamic nature—the progress
 
 Capturing SCP output can help you monitor, troubleshoot, and analyze your file transfers. Here are some quick and effective methods:
 
-1. Use the `script` command to record the entire terminal session: 
-This method records your entire terminal session, capturing all output generated by the SCP command.
-    
-    ```jsx
-    script -c \
-    "scp -i /path/to/private/key /path/to/source/file \
-    username@remote-server:/path/to/destination/" output.txt
-    ```
-    
-    For example:
-    
-    <Figure src="/img/guides/2024/09/how-to-best-capture-and-log-scp-output-Screenshot_2024-08-30_at_10.50.38.webp" alt="Using the script command" caption="Using the script command" />
-    
-    The above command executes an SCP operation to copy `logfile.txt` from one server to another. The `script` command records the output of this SCP operation, displays the output in the terminal, and saves this output to a local file called `scp.txt`.
-    
-2. Redirect SCP output to a file: 
-This technique redirects both standard output and error messages to a file while displaying them on your terminal.
-    
-    ```bash
-    scp /path/to/source /path/to/destination 2>&1 | tee logfile.txt
-    ```
-    
-3. Utilize SCP's verbose mode: 
-Verbose mode provides detailed information about the transfer process, which is useful for debugging.
-    
-    ```bash
-    scp -v /path/to/source /path/to/destination 2>&1 | tee logfile.txt
-    ```
-    
-4. Combine methods for comprehensive capture: 
-By combining the `script` command with verbose mode and output redirection, you can capture the most detailed log of your SCP session.
-    
-    ```bash
-    script -c "scp -v /path/to/source /path/to/destination 2>&1 | tee logfile.txt" session_log.txt
-    ```
-    
+1.  Use the `script` command to record the entire terminal session:
+    This method records your entire terminal session, capturing all output generated by the SCP command.
+        ```jsx
+        script -c \
+        "scp -i /path/to/private/key /path/to/source/file \
+        username@remote-server:/path/to/destination/" output.txt
+        ```
+
+        For example:
+
+        <Figure src="/img/guides/2024/09/how-to-best-capture-and-log-scp-output-Screenshot_2024-08-30_at_10.50.38.webp" alt="Using the script command" caption="Using the script command" />
+
+        The above command executes an SCP operation to copy `logfile.txt` from one server to another. The `script` command records the output of this SCP operation, displays the output in the terminal, and saves this output to a local file called `scp.txt`.
+2.  Redirect SCP output to a file:
+    This technique redirects both standard output and error messages to a file while displaying them on your terminal.
+        ```bash
+        scp /path/to/source /path/to/destination 2>&1 | tee logfile.txt
+        ```
+3.  Utilize SCP's verbose mode:
+    Verbose mode provides detailed information about the transfer process, which is useful for debugging.
+        ```bash
+        scp -v /path/to/source /path/to/destination 2>&1 | tee logfile.txt
+        ```
+4.  Combine methods for comprehensive capture:
+    By combining the `script` command with verbose mode and output redirection, you can capture the most detailed log of your SCP session.
+        ```bash
+        script -c "scp -v /path/to/source /path/to/destination 2>&1 | tee logfile.txt" session_log.txt
+        ```
 
 Each method has its strengths, depending on your needs, and in the detailed sections, you’ll learn the pros and cons of each approach.
 
@@ -79,34 +77,30 @@ Each method has its strengths, depending on your needs, and in the detailed sect
 
 The `script` command is a handy tool in Unix-like systems that records everything displayed on your terminal during a session. This can be incredibly useful for capturing SCP output, especially when you want to log the entire process, including dynamic elements like the progress bar.
 
-1. Start the script: 
-    
+1.  Start the script:
+
     ```bash
     script <filename>
     ```
-    
+
     For example:
-    
+
     ```jsx
     script logfile.txt
     ```
-    
+
     This command starts recording everything that appears in your terminal and saves it to `logfile.txt`.
-    
-2. Run your SCP command:
-Run your SCP command as you normally would. The progress information, error messages, and everything else will be captured in the `logfile.txt`. 
-    
-    ```bash
-    scp /path/to/source /path/to/destination
-    ```
-    
-3. Exit the script session:
-Type `exit` to stop the script session. The complete log of your terminal session, including the SCP command, is now saved.
-    
-    ```bash
-    exit
-    ```
-    
+
+2.  Run your SCP command:
+    Run your SCP command as you normally would. The progress information, error messages, and everything else will be captured in the `logfile.txt`.
+        ```bash
+        scp /path/to/source /path/to/destination
+        ```
+3.  Exit the script session:
+    Type `exit` to stop the script session. The complete log of your terminal session, including the SCP command, is now saved.
+        ```bash
+        exit
+        ```
 
 Advantages:
 
@@ -148,7 +142,7 @@ Limitations:
 
 ### Leveraging SCP's Verbose Mode
 
-Verbose mode in SCP, enabled with the `-v` option, provides a detailed account of the entire file transfer process. This mode is particularly useful when you need to gain deeper insights into how the transfer is progressing and to diagnose any issues that might arise. 
+Verbose mode in SCP, enabled with the `-v` option, provides a detailed account of the entire file transfer process. This mode is particularly useful when you need to gain deeper insights into how the transfer is progressing and to diagnose any issues that might arise.
 
 Here's how you can use it:
 
@@ -158,10 +152,10 @@ scp -v /path/to/source /path/to/destination 2>&1 | tee logfile.txt
 
 Benefits of verbose mode:
 
-- In-Depth Diagnostics: 
-Verbose mode is invaluable for troubleshooting. It provides you with granular details about every step of the file transfer, which can help you pinpoint where a transfer might be failing. For instance, if there’s a problem with the SSH connection or file permissions, the verbose output will highlight exactly where and why the issue is occurring. This makes it much easier to identify and fix problems quickly, without having to guess or rely on less detailed error messages.
+- In-Depth Diagnostics:
+  Verbose mode is invaluable for troubleshooting. It provides you with granular details about every step of the file transfer, which can help you pinpoint where a transfer might be failing. For instance, if there’s a problem with the SSH connection or file permissions, the verbose output will highlight exactly where and why the issue is occurring. This makes it much easier to identify and fix problems quickly, without having to guess or rely on less detailed error messages.
 - Debugging:
-The verbose output often includes lines that start with "debug," which offers deep insights into the SSH connection and file transfer. These debug messages are particularly useful for diagnosing complex issues that go beyond simple connection problems.
+  The verbose output often includes lines that start with "debug," which offers deep insights into the SSH connection and file transfer. These debug messages are particularly useful for diagnosing complex issues that go beyond simple connection problems.
 - For example, if there’s an issue with SSH key authentication or with the way SCP is handling the connection, these debug lines can provide the necessary clues to resolve the issue. This level of debugging information is crucial for system administrators and developers who need to ensure reliable file transfers in their workflows.
 
 When interpreting verbose output, look for lines starting with "debug1" for detailed information about the connection and transfer process.
@@ -171,36 +165,33 @@ When interpreting verbose output, look for lines starting with "debug1" for deta
 ### Custom Shell Scripts for Automated Logging
 
 1. Create a shell script to automate the logging process:
- Save the following code as `scp_log.sh`
-    
-    ```bash
-    #!/bin/bash
-    log_file="/path/to/scp_log_$(date +%Y%m%d_%H%M%S).txt"
-    scp -v "$1" "$2" 2>&1 | tee "$log_file"
-    ```
-    
-    The above script does the following: 
-    
+   Save the following code as `scp_log.sh`
+   ```bash
+   #!/bin/bash
+   log_file="/path/to/scp_log_$(date +%Y%m%d_%H%M%S).txt"
+   scp -v "$1" "$2" 2>&1 | tee "$log_file"
+   ```
+   The above script does the following:
+
 - Defines `log_file` with a filename that includes a timestamp, ensuring unique log files for each execution.
 - Runs the `scp` command in verbose mode (`v`), capturing both standard output and error streams.
 - Pipes the combined output to `tee`, which writes it to the specified log file while also displaying it in the terminal.
-1. Make the Script Executable:
-    
+
+1.  Make the Script Executable:
+
     Run the following command to make the script executable:
-    
+
     ```bash
     chmod +x scp_log.sh
     ```
-    
-2. Use the Script:
-Execute the script with the source and destination paths as arguments:
-    
-    ```
-    ./scp_log.sh /path/to/source /path/to/destination
-    ```
-    
-    This will start the SCP transfer and log all output, including detailed information about the transfer process, to a timestamped log file.
-    
+
+2.  Use the Script:
+    Execute the script with the source and destination paths as arguments:
+        ```
+        ./scp_log.sh /path/to/source /path/to/destination
+        ```
+
+        This will start the SCP transfer and log all output, including detailed information about the transfer process, to a timestamped log file.
 
 ### Using `tee` for Simultaneous Display and Logging
 
@@ -220,25 +211,23 @@ This command achieves the following:
 
 When using SCP frequently, the log files can quickly become large and unmanageable. To address this, you can implement log rotation, which automatically manages log file sizes by rotating, compressing, and deleting old logs. Here's how to set it up:
 
-1. If `logrotate` is not already installed on your system, you can install it using your package manager. For example, on a Debian-based system, use:
-    
+1.  If `logrotate` is not already installed on your system, you can install it using your package manager. For example, on a Debian-based system, use:
+
     ```bash
     sudo apt-get install logrotate
     ```
-    
-2. Create a configuration file:
-Set up a configuration file for your SCP logs at `/etc/logrotate.d/scp_logs`. This file will tell `logrotate` how to manage your log files.
-    
-    ```bash
-    /path/to/scp_logs/*.log {
-        rotate 7
-        daily
-        compress
-        missingok
-        notifempty
-    }
-    ```
-    
+
+2.  Create a configuration file:
+    Set up a configuration file for your SCP logs at `/etc/logrotate.d/scp_logs`. This file will tell `logrotate` how to manage your log files.
+        ```bash
+        /path/to/scp_logs/*.log {
+            rotate 7
+            daily
+            compress
+            missingok
+            notifempty
+        }
+        ```
 
 With this configuration, your SCP logs will be automatically rotated every day, and only the last 7 days' logs will be kept. Older logs will be compressed to save space, ensuring that your log directory remains organized and manageable.
 
@@ -246,25 +235,21 @@ With this configuration, your SCP logs will be automatically rotated every day,
 
 Once you have SCP logs, you may want to extract specific information for analysis. Tools like `awk` and `sed` are powerful for this purpose:
 
-1. Extracting Transfer Speeds with `awk`:
-If your SCP logs contain lines that show transfer speeds, you can use `awk` to extract this data.
-    
-    ```bash
-    awk '/Transferred/ {print $10}' scp_log.txt
-    ```
-    
-    This command looks for lines containing the word "Transferred" and prints the 10th field, which might represent the transfer speed.
-    
-2. Filtering Error Messages with `sed` and `grep`:
-You can use `sed` to filter out unwanted lines or `grep` to search for specific error messages.
-    
-    ```bash
-    # Extract error messages
-    sed -n '/^debug1/!p' scp_log.txt | grep -i error
-    ```
-    
-    This command searches for lines containing "error" (case-insensitive) and excludes lines starting with "debug1," focusing on relevant error messages.
-    
+1.  Extracting Transfer Speeds with `awk`:
+    If your SCP logs contain lines that show transfer speeds, you can use `awk` to extract this data.
+        ```bash
+        awk '/Transferred/ {print $10}' scp_log.txt
+        ```
+
+        This command looks for lines containing the word "Transferred" and prints the 10th field, which might represent the transfer speed.
+2.  Filtering Error Messages with `sed` and `grep`:
+    You can use `sed` to filter out unwanted lines or `grep` to search for specific error messages.
+        ```bash
+        # Extract error messages
+        sed -n '/^debug1/!p' scp_log.txt | grep -i error
+        ```
+
+        This command searches for lines containing "error" (case-insensitive) and excludes lines starting with "debug1," focusing on relevant error messages.
 
 ## Troubleshooting Common SCP Output Capture Issues
 
@@ -277,26 +262,20 @@ The SCP progress indicator refreshes repeatedly on the same line, which might in
 Solutions:
 
 - Use the `q` (quiet) Option:
-    - Run SCP with the `q` option to suppress the progress meter. This prevents the progress bar from cluttering the output, making it easier to log:
-        
-        ```bash
-        scp -q /path/to/source /path/to/destinatio 2>&1 | tee logfile.txt
-        ```
-        
+  - Run SCP with the `q` option to suppress the progress meter. This prevents the progress bar from cluttering the output, making it easier to log:
+    ```bash
+    scp -q /path/to/source /path/to/destinatio 2>&1 | tee logfile.txt
+    ```
 - Employ `script` or `tee`:
-    - Use the `script` command to capture the entire terminal session, including the dynamic progress bar:
-        
-        ```bash
-        script -c "scp /path/to/source /path/to/destination" logfile.txt
-        ```
-        
-    - Alternatively, use `tee` to capture and display the output simultaneously:
-        
-        ```bash
-        scp /path/to/source /path/to/destination 2>&1 | tee logfile.txt
-        ```
-        
-    - While `tee` won’t solve progress bar interference, it ensures you capture all output in real-time.
+  - Use the `script` command to capture the entire terminal session, including the dynamic progress bar:
+    ```bash
+    script -c "scp /path/to/source /path/to/destination" logfile.txt
+    ```
+  - Alternatively, use `tee` to capture and display the output simultaneously:
+    ```bash
+    scp /path/to/source /path/to/destination 2>&1 | tee logfile.txt
+    ```
+  - While `tee` won’t solve progress bar interference, it ensures you capture all output in real-time.
 
 ### Handling Large File Transfers
 
@@ -305,36 +284,30 @@ Large file transfers can create exceptionally large log files, which might be di
 Solutions:
 
 - Use `tail -f` for Real-Time Monitoring:
-    - Monitor the log file in real-time using `tail -f`:
-        
-        ```bash
-        tail -f logfile.txt
-        ```
-        
-    - This command displays new log entries as they are written, allowing you to track transfer progress live.
+  - Monitor the log file in real-time using `tail -f`:
+    ```bash
+    tail -f logfile.txt
+    ```
+  - This command displays new log entries as they are written, allowing you to track transfer progress live.
 - Implement Log Rotation:
-    - Use tools like `logrotate` to manage log file sizes by rotating and compressing old logs. This ensures log files don’t grow too large:
-        - Create a logrotate configuration file (e.g., `/etc/logrotate.d/scp_logs`):
-            
-            ```bash
-            /path/to/scp_logs/*.log {
-                rotate 7
-                daily
-                compress
-                missingok
-                notifempty
-            }
-            ```
-            
-        - This setup rotates logs daily, keeps the last 7 days of logs, and compresses older logs to save space.
+  - Use tools like `logrotate` to manage log file sizes by rotating and compressing old logs. This ensures log files don’t grow too large:
+    - Create a logrotate configuration file (e.g., `/etc/logrotate.d/scp_logs`):
+      ```bash
+      /path/to/scp_logs/*.log {
+          rotate 7
+          daily
+          compress
+          missingok
+          notifempty
+      }
+      ```
+    - This setup rotates logs daily, keeps the last 7 days of logs, and compresses older logs to save space.
 - Consider `rsync` with `--progress`:
-    - For detailed transfer information and better control, use `rsync` instead of SCP. 
+  - For detailed transfer information and better control, use `rsync` instead of SCP.
     The `--progress` option provides a detailed progress report:
-        
         ```bash
         rsync --progress source destination
         ```
-        
 
 ### Addressing Permission-Related Logging Problems
 
@@ -343,20 +316,16 @@ Permissions issues can prevent logging processes from creating or writing to log
 Solutions:
 
 - Run SCP with `sudo` if Necessary:
-    - If you encounter permission errors, try running the SCP command with `sudo` to ensure it has the necessary permissions:
-        
-        ```bash
-        sudo scp source destination 2>&1 | tee logfile.txt
-        ```
-        
+  - If you encounter permission errors, try running the SCP command with `sudo` to ensure it has the necessary permissions:
+    ```bash
+    sudo scp source destination 2>&1 | tee logfile.txt
+    ```
 - Check and Set Correct Permissions:
-    - Ensure that the directories and files used for logging have appropriate permissions. Set permissions using `chmod`:
-        
-        ```bash
-        chmod 755 /path/to/log_directory
-        chmod 644 /path/to/logfile.txt
-        ```
-        
+  - Ensure that the directories and files used for logging have appropriate permissions. Set permissions using `chmod`:
+    ```bash
+    chmod 755 /path/to/log_directory
+    chmod 644 /path/to/logfile.txt
+    ```
 
 ### Resolving Network-Related Output Capture Issues
 
@@ -365,23 +334,19 @@ Network issues can cause interruptions or incomplete transfers, affecting log ca
 Solutions:
 
 - Use the `C` Option with SCP:
-    - Enable compression with the `C` option to potentially improve transfer speeds and reduce the likelihood of network interruptions:
-        
-        ```bash
-        scp -C source destination 2>&1 | tee logfile.txt
-        ```
-        
+  - Enable compression with the `C` option to potentially improve transfer speeds and reduce the likelihood of network interruptions:
+    ```bash
+    scp -C source destination 2>&1 | tee logfile.txt
+    ```
 - Implement Retry Logic:
-    - Add retry logic to your scripts to handle network interruptions gracefully. For example:
-        
-        ```bash
-        #!/bin/bash
-        for i in {1..5}; do
-            scp source destination && break || sleep 10
-        done
-        ```
-        
-    - This script attempts the SCP transfer up to 5 times, waiting 10 seconds between attempts if it fails.
+  - Add retry logic to your scripts to handle network interruptions gracefully. For example:
+    ```bash
+    #!/bin/bash
+    for i in {1..5}; do
+        scp source destination && break || sleep 10
+    done
+    ```
+  - This script attempts the SCP transfer up to 5 times, waiting 10 seconds between attempts if it fails.
 
 By addressing these common issues with the outlined solutions, you can effectively capture and manage SCP output, ensuring a smoother file transfer experience.
 
@@ -409,7 +374,7 @@ This file represents a log file of your application. You can choose any file tha
 
 1. Download the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector
 
-The [OpenTelemetry collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) provides a vendor-neutral way to collect, process, and export your telemetry data such as logs, metrics, and traces. 
+The [OpenTelemetry collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) provides a vendor-neutral way to collect, process, and export your telemetry data such as logs, metrics, and traces.
 
 Follow this [guide](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to download and extract the OpenTelemetry Collector on your machine, but stop after the extraction step. Ensure you download the <a href="https://github.com/open-telemetry/opentelemetry-collector/releases" rel="noopener noreferrer nofollow" target="_blank">latest version</a> available.
 
@@ -420,7 +385,7 @@ Create a `config.yaml` file in the `otelcol-contrib` folder and paste the be
 ```yaml
 receivers:
   filelog/app:
-    include: [ /tmp/app.log ] #include the full path to your log file
+    include: [/tmp/app.log] #include the full path to your log file
 
 processors:
   batch:
@@ -429,11 +394,11 @@ processors:
 
 exporters:
   otlp:
-    endpoint: "ingest.{region}.signoz.cloud:443"
+    endpoint: 'ingest.{region}.signoz.cloud:443'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"
+      'signoz-ingestion-key': '<SIGNOZ_INGESTION_KEY>'
   debug:
     verbosity: normal
 
@@ -459,24 +424,28 @@ To run the collector service, navigate to the `otelcol-contrib` folder and run t
 
 The logs will be sent to your SigNoz account. You can view them on the “Logs” page.
 
-<Figure src="/img/guides/2024/09/how-to-best-capture-and-log-scp-output-application-logs-output.webp" alt="Sample log file data shown in SigNoz" caption="Sample log file data shown in SigNoz" />
+<Figure
+  src="/img/guides/2024/09/how-to-best-capture-and-log-scp-output-application-logs-output.webp"
+  alt="Sample log file data shown in SigNoz"
+  caption="Sample log file data shown in SigNoz"
+/>
 
 ## Best Practices for SCP Output Management
 
 Here are some best practices to follow in managing SCP outputs:
 
 1. Establish consistent logging conventions:
-    - Use a consistent format for your log files and a clear naming system. For example, always include the date and the type of transfer in the filename. This makes it easier to find and understand your logs quickly.
-    - Include the time when each log entry was made and any unique identifiers for the transfers. This helps you track when things happened and link specific log entries to particular file transfers.
+   - Use a consistent format for your log files and a clear naming system. For example, always include the date and the type of transfer in the filename. This makes it easier to find and understand your logs quickly.
+   - Include the time when each log entry was made and any unique identifiers for the transfers. This helps you track when things happened and link specific log entries to particular file transfers.
 2. Implement secure log storage and access control:
-    - To protect your logs, encrypt them. This entails converting your log data into a code that only authorized users can see, so protecting sensitive information from unauthorized access.
-    - Allow just specified personnel to read or manage your log files. This guarantees that only authorized workers have access to the logs, lowering the risk of data breaches or unauthorized changes.
+   - To protect your logs, encrypt them. This entails converting your log data into a code that only authorized users can see, so protecting sensitive information from unauthorized access.
+   - Allow just specified personnel to read or manage your log files. This guarantees that only authorized workers have access to the logs, lowering the risk of data breaches or unauthorized changes.
 3. Conduct regular log analysis:
-    - Set up automated systems to regularly check your logs for issues. This can help you spot problems or trends without having to manually review every log entry.
-    - Employ sophisticated tools like SigNoz or ELK Stack to analyze your logs in-depth. These tools can provide detailed insights and visualizations, helping you understand performance issues or other problems more clearly.
+   - Set up automated systems to regularly check your logs for issues. This can help you spot problems or trends without having to manually review every log entry.
+   - Employ sophisticated tools like SigNoz or ELK Stack to analyze your logs in-depth. These tools can provide detailed insights and visualizations, helping you understand performance issues or other problems more clearly.
 4. Integrate SCP logs with broader system monitoring:
-    - Connect your SCP logs with other system performance data. This helps you see how file transfers affect the overall system and identify any issues that might be impacting performance.
-    - Use a [centralized logging](https://signoz.io/blog/centralized-logging/) system to collect logs from different sources, including SCP transfers. This way, you have a single place to monitor and manage all your logs, making it easier to get a complete view of your system’s activities.
+   - Connect your SCP logs with other system performance data. This helps you see how file transfers affect the overall system and identify any issues that might be impacting performance.
+   - Use a [centralized logging](https://signoz.io/blog/centralized-logging/) system to collect logs from different sources, including SCP transfers. This way, you have a single place to monitor and manage all your logs, making it easier to get a complete view of your system’s activities.
 
 ## Key Takeaways
 
@@ -498,7 +467,7 @@ Standard output redirection doesn’t work well with SCP because SCP updates its
 To capture SCP output without disrupting its progress display, you can use the `script` command or the `tee` command combined with process substitution. Here's how:
 
 1. Using `script`:
-The `script` command records everything displayed in the terminal:
+   The `script` command records everything displayed in the terminal:
 
 ```bash
 script -c "scp source destination" logfile.txt
@@ -506,13 +475,11 @@ script -c "scp source destination" logfile.txt
 
 This will capture the SCP output, including the progress display, without affecting the terminal output.
 
-1. Using `tee` with Process Substitution:
-This method captures the output while still displaying the progress bar:
-    
-    ```bash
-    scp source destination 2>&1 | tee logfile.txt
-    ```
-    
+1.  Using `tee` with Process Substitution:
+    This method captures the output while still displaying the progress bar:
+        ```bash
+        scp source destination 2>&1 | tee logfile.txt
+        ```
 
 This command allows you to see the progress on the screen while logging the output to a file.
 
@@ -528,4 +495,4 @@ scp "$1" "$2" 2>&1 | tee "$log_file"
 
 ### What's the best way to analyze large volumes of SCP logs?
 
-The best way to analyze large volumes of SCP logs is to use [log analysis tools](https://signoz.io/comparisons/log-analysis-tools/#signoz) like SigNoz or the ELK stack for comprehensive, large-scale analysis. For quicker insights, you can use command-line tools like `awk`, `sed`, and `grep` to filter and extract relevant information directly from the logs.
\ No newline at end of file
+The best way to analyze large volumes of SCP logs is to use [log analysis tools](https://signoz.io/comparisons/log-analysis-tools/#signoz) like SigNoz or the ELK stack for comprehensive, large-scale analysis. For quicker insights, you can use command-line tools like `awk`, `sed`, and `grep` to filter and extract relevant information directly from the logs.
diff --git a/data/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring.mdx b/data/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring.mdx
index 66a67a047..4a585dfb2 100644
--- a/data/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring.mdx
+++ b/data/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring.mdx
@@ -1,169 +1,177 @@
 ---
-
 title: How to Monitor Kubernetes CPU Usage with Prometheus - A Guide
-slug: how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring
 date: 2024-07-24
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Learn how to monitor and calculate container CPU usage in Kubernetes using Prometheus. Explore key metrics, PromQL queries, and optimization strategies.
-keywords: [Kubernetes, CPU usage, Prometheus, container monitoring, PromQL, Grafana, resource optimization]
-
+keywords:
+  [Kubernetes, CPU usage, Prometheus, container monitoring, PromQL, Grafana, resource optimization]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Monitor Kubernetes CPU Usage with Prometheus: A Guide",
-    "alternativeHeadline": "Calculate Container CPU Usage in Kubernetes with Prometheus Monitoring",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring/"
-    },
-    "description": "Learn how to monitor and calculate container CPU usage in Kubernetes using Prometheus. Explore key metrics, PromQL queries, and optimization strategies.",
-    "keywords": "Kubernetes, CPU usage, Prometheus, container monitoring, PromQL, Grafana, resource optimization",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Kubernetes",
-        "description": "An open-source container orchestration platform designed to automate deploying, scaling, and operating application containers."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "CPU Usage",
-        "description": "A measure of the amount of computational power used by processes in a computing environment."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "Grafana",
-        "description": "An open-source platform for monitoring and observability, used for visualizing time series data."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is the difference between CPU requests and limits in Kubernetes?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "CPU requests guarantee a minimum amount of CPU resources, while limits cap the maximum CPU a container can use. Requests help with scheduling, ensuring nodes have enough resources. Limits prevent containers from consuming excessive CPU."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How often should I collect CPU metrics in a Kubernetes environment?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Collect CPU metrics every 15-30 seconds for real-time monitoring. For long-term analysis, aggregate data over longer intervals (e.g., 5 minutes) to reduce storage requirements while maintaining useful insights."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can Prometheus monitor CPU usage of individual containers within a pod?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, Prometheus can monitor CPU usage of individual containers within a pod. Use the `container` label in your queries to differentiate between containers in the same pod."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Monitor Kubernetes CPU Usage with Prometheus: A Guide',
+        alternativeHeadline:
+          'Calculate Container CPU Usage in Kubernetes with Prometheus Monitoring',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "How do I handle CPU usage spikes in my Kubernetes cluster?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "To handle CPU usage spikes: 1. Set up alerts for sudden increases in CPU usage 2. Implement Horizontal Pod Autoscaling to automatically scale during high load 3. Use Vertical Pod Autoscaling to adjust resource requests and limits 4. Analyze the cause of spikes and optimize application code if necessary."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Monitoring Kubernetes CPU Usage with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Deploy Prometheus",
-          "text": "Deploy Prometheus in your Kubernetes cluster using the provided YAML file."
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus",
-          "text": "Configure Prometheus to scrape Kubernetes CPU metrics by applying the provided configuration file."
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-calculate-containers-cpu-usage-in-kubernetes-with-prometheus-as-monitoring/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Calculate CPU Usage",
-          "text": "Use the `rate()` function with the `container_cpu_usage_seconds_total` metric to calculate CPU usage."
+        description:
+          'Learn how to monitor and calculate container CPU usage in Kubernetes using Prometheus. Explore key metrics, PromQL queries, and optimization strategies.',
+        keywords:
+          'Kubernetes, CPU usage, Prometheus, container monitoring, PromQL, Grafana, resource optimization',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use PromQL Queries",
-          "text": "Implement useful PromQL queries to gain insights into CPU usage, such as overall cluster CPU utilization, top CPU-consuming pods, and detecting CPU throttling."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes',
+            description:
+              'An open-source container orchestration platform designed to automate deploying, scaling, and operating application containers.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'CPU Usage',
+            description:
+              'A measure of the amount of computational power used by processes in a computing environment.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Grafana',
+            description:
+              'An open-source platform for monitoring and observability, used for visualizing time series data.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is the difference between CPU requests and limits in Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'CPU requests guarantee a minimum amount of CPU resources, while limits cap the maximum CPU a container can use. Requests help with scheduling, ensuring nodes have enough resources. Limits prevent containers from consuming excessive CPU.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How often should I collect CPU metrics in a Kubernetes environment?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Collect CPU metrics every 15-30 seconds for real-time monitoring. For long-term analysis, aggregate data over longer intervals (e.g., 5 minutes) to reduce storage requirements while maintaining useful insights.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Prometheus monitor CPU usage of individual containers within a pod?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Prometheus can monitor CPU usage of individual containers within a pod. Use the `container` label in your queries to differentiate between containers in the same pod.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I handle CPU usage spikes in my Kubernetes cluster?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To handle CPU usage spikes: 1. Set up alerts for sudden increases in CPU usage 2. Implement Horizontal Pod Autoscaling to automatically scale during high load 3. Use Vertical Pod Autoscaling to adjust resource requests and limits 4. Analyze the cause of spikes and optimize application code if necessary.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize with Grafana",
-          "text": "Integrate Grafana with Prometheus and create dashboards to visualize CPU usage metrics."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Monitoring Kubernetes CPU Usage with Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Deploy Prometheus',
+              text: 'Deploy Prometheus in your Kubernetes cluster using the provided YAML file.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus',
+              text: 'Configure Prometheus to scrape Kubernetes CPU metrics by applying the provided configuration file.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Calculate CPU Usage',
+              text: 'Use the `rate()` function with the `container_cpu_usage_seconds_total` metric to calculate CPU usage.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use PromQL Queries',
+              text: 'Implement useful PromQL queries to gain insights into CPU usage, such as overall cluster CPU utilization, top CPU-consuming pods, and detecting CPU throttling.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize with Grafana',
+              text: 'Integrate Grafana with Prometheus and create dashboards to visualize CPU usage metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize with SigNoz',
+              text: 'Integrate SigNoz with your Kubernetes cluster, create dashboards, and set up alerts for CPU usage thresholds.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Kubernetes Deployments',
+              text: 'Analyze CPU usage patterns to right-size container resources and implement Horizontal Pod Autoscaling based on CPU metrics.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize with SigNoz",
-          "text": "Integrate SigNoz with your Kubernetes cluster, create dashboards, and set up alerts for CPU usage thresholds."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Kubernetes Deployments",
-          "text": "Analyze CPU usage patterns to right-size container resources and implement Horizontal Pod Autoscaling based on CPU metrics."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Kubernetes has revolutionized container orchestration, but managing resources like CPU usage in a dynamic environment can be challenging. This guide shows you how to calculate and monitor container CPU usage in Kubernetes using Prometheus.
@@ -204,41 +212,38 @@ Monitoring at container, pod, and cluster levels provides a comprehensive view o
 To set up Prometheus for Kubernetes CPU monitoring:
 
 1. Deploy Prometheus in your Kubernetes cluster:
-    
-    ```yaml
-    kubectl apply -f <https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/main/bundle.yaml>
-    
-    ```
-    
+
+   ```yaml
+   kubectl apply -f <https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/main/bundle.yaml>
+   ```
+
 2. Configure Prometheus to scrape Kubernetes CPU metrics:
-    
-    ```yaml
-    apiVersion: monitoring.coreos.com/v1
-    kind: Prometheus
-    metadata:
-      name: prometheus
-      namespace: monitoring
-    spec:
-      serviceAccountName: prometheus
-      serviceMonitorSelector:
-        matchLabels:
-          team: frontend
-      ruleSelector:
-        matchLabels:
-          team: frontend
-      resources:
-        requests:
-          memory: 400Mi
-    
-    ```
-    
+
+   ```yaml
+   apiVersion: monitoring.coreos.com/v1
+   kind: Prometheus
+   metadata:
+     name: prometheus
+     namespace: monitoring
+   spec:
+     serviceAccountName: prometheus
+     serviceMonitorSelector:
+       matchLabels:
+         team: frontend
+     ruleSelector:
+       matchLabels:
+         team: frontend
+     resources:
+       requests:
+         memory: 400Mi
+   ```
+
 3. Apply the configuration:
-    
-    ```
-    kubectl apply -f prometheus-config.yaml
-    
-    ```
-    
+
+   ```
+   kubectl apply -f prometheus-config.yaml
+
+   ```
 
 Best practices for Prometheus deployment in production:
 
@@ -275,66 +280,65 @@ To convert raw CPU usage to a percentage of available resources:
 Here are some useful PromQL queries for CPU usage insights:
 
 1. Overall cluster CPU utilization:
-    
-    ```
-    sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) / sum(machine_cpu_cores) * 100
-    
-    ```
-    
+
+   ```
+   sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) / sum(machine_cpu_cores) * 100
+
+   ```
+
 2. Top CPU-consuming pods:
-    
-    ```
-    topk(10, sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod))
-    
-    ```
-    
+
+   ```
+   topk(10, sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod))
+
+   ```
+
 3. CPU usage vs. requests:
-    
-    ```
-    sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod) / sum(kube_pod_container_resource_requests_cpu_cores) by (pod)
-    
-    ```
-    
+
+   ```
+   sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod) / sum(kube_pod_container_resource_requests_cpu_cores) by (pod)
+
+   ```
+
 4. Detecting CPU throttling:
-    
-    ```
-    sum(rate(container_cpu_cfs_throttled_seconds_total{}[5m])) by (pod) > 0
-    
-    ```
-    
+
+   ```
+   sum(rate(container_cpu_cfs_throttled_seconds_total{}[5m])) by (pod) > 0
+
+   ```
 
 ## Visualizing CPU Usage with Grafana
 
 To visualize CPU usage with Grafana:
 
 1. Integrate Grafana with Prometheus:
-    - Add Prometheus as a data source in Grafana
-    - Configure the Prometheus server URL
+   - Add Prometheus as a data source in Grafana
+   - Configure the Prometheus server URL
 2. Create CPU usage dashboards:
-    - Use the queries mentioned above
-    - Add time series graphs, gauges, and tables
+   - Use the queries mentioned above
+   - Add time series graphs, gauges, and tables
 3. Set up alerts for CPU usage thresholds:
-    - Define alert rules based on CPU utilization percentages
-    - Configure notification channels (email, Slack, etc.)
+   - Define alert rules based on CPU utilization percentages
+   - Configure notification channels (email, Slack, etc.)
 
 ## Visualizing CPU Usage with SigNoz
 
 To visualize CPU usage with SigNoz:
 
 1. SetUp SigNoz
-    
-    <GetStartedSigNoz />
-    
+
+   <GetStartedSigNoz />
+
 2. Integrate [SigNoz](https://signoz.io/docs/introduction/) with your Kubernetes cluster:
-    - Deploy SigNoz using Helm or Kubernetes manifests
-    - Configure SigNoz to scrape Prometheus metrics from your cluster
+   - Deploy SigNoz using Helm or Kubernetes manifests
+   - Configure SigNoz to scrape Prometheus metrics from your cluster
 3. Create CPU usage dashboards:
-    - Use the PromQL queries mentioned earlier
-    - Add various visualization types such as time series graphs, gauges, and tables
-    - Leverage SigNoz's built-in Kubernetes dashboards for quick insights
+   - Use the PromQL queries mentioned earlier
+   - Add various visualization types such as time series graphs, gauges, and tables
+   - Leverage SigNoz's built-in Kubernetes dashboards for quick insights
 4. Set up alerts for CPU usage thresholds:
-    - Define alert rules based on CPU utilization percentages
-    - Configure notification channels (email, Slack, PagerDuty, etc.)
+   - Define alert rules based on CPU utilization percentages
+   - Configure notification channels (email, Slack, PagerDuty, etc.)
 
 SigNoz offers several advantages for Kubernetes CPU monitoring:
 
@@ -366,11 +370,10 @@ spec:
   minReplicas: 2
   maxReplicas: 10
   metrics:
-  - type: Resource
-    resource:
-      name: cpu
-      targetAverageUtilization: 50
-
+    - type: Resource
+      resource:
+        name: cpu
+        targetAverageUtilization: 50
 ```
 
 To identify and resolve CPU bottlenecks:
@@ -421,6 +424,7 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With SigNoz, you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
@@ -428,5 +432,6 @@ With SigNoz, you can:
 - Take advantage of SigNoz's exceptional exception monitoring capabilities
 
 ## Resources
+
 - [How to Monitor Kubernetes Clusters using Prometheus](https://signoz.io/guides/kubernetes-monitoring-prometheus/)
-- [Kubernetes Monitoring - 8 Best Practices for Effective Cluster Monitoring](https://signoz.io/guides/kubernetes-monitoring-best-practices/)
\ No newline at end of file
+- [Kubernetes Monitoring - 8 Best Practices for Effective Cluster Monitoring](https://signoz.io/guides/kubernetes-monitoring-best-practices/)
diff --git a/data/guides/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile.mdx b/data/guides/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile.mdx
index 237e2ef9a..55d326430 100644
--- a/data/guides/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile.mdx
+++ b/data/guides/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Check Pod Ports with kubectl - A Quick Guide
-slug: how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile
 date: 2024-09-04
 tags: [faq, kubernetes]
 authors: [bhavya_sachdeva]
 description: Learn how to check pod ports using kubectl without relying on Dockerfiles. This guide covers quick commands, advanced techniques, and best practices for Kubernetes port management.
-keywords: [kubectl, pod ports, Kubernetes, container orchestration, network debugging, port management]
-
+keywords:
+  [kubectl, pod ports, Kubernetes, container orchestration, network debugging, port management]
 ---
 
 Kubernetes has revolutionized container orchestration, but it can be challenging to navigate its complexities. One common task that often stumps developers is checking which port a pod is listening on, especially when you are not using Dockerfile, deployment file, or defining a port manually. This guide will show you how to use kubectl to quickly and efficiently check pod ports, enhancing your ability to troubleshoot and manage Kubernetes deployments.
@@ -28,25 +26,28 @@ Knowing which port a pod is listening on is crucial for:
 Here's how you can quickly check pod ports using kubectl:
 
 1. Use `kubectl describe pod`
-    
-    This command provides a detailed view of a specific pod's configuration and status. When you run `kubectl describe pod <pod-name>`, it gives you output about that particular port such as containers, images, ports that each container is configured to listen on, environment variables, volumes, and network settings.
-    
-    ```bash
-    kubectl describe pod <pod-name>
-    ```
-    
-     You can use this command to check for the port and for that, you need to replace `<pod-name>` with your actual pod. Let’s say you have nginx-pod running in your system. You want to check for its port by looking for the Containers section  in the output, you will be able to see a pod named nginx-pod and search for a port property like it is shown below: 
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_11.15.09_AM.webp" alt="Describe pod" caption="Describe pod" />
-    
-    Let’s say you need to check the port for the pod in any specific namespace, so for that you need  to use the below command:
-    
-    ```bash
-    Kubectl describe pod <pod-name> -n <namespace>
-    ```
-    
-    You can see the below output: 
-    
+
+   This command provides a detailed view of a specific pod's configuration and status. When you run `kubectl describe pod <pod-name>`, it gives you output about that particular port such as containers, images, ports that each container is configured to listen on, environment variables, volumes, and network settings.
+
+   ```bash
+   kubectl describe pod <pod-name>
+   ```
+
+   You can use this command to check for the port and for that, you need to replace `<pod-name>` with your actual pod. Let’s say you have nginx-pod running in your system. You want to check for its port by looking for the Containers section in the output, you will be able to see a pod named nginx-pod and search for a port property like it is shown below:
+
+   <Figure
+     src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_11.15.09_AM.webp"
+     alt="Describe pod"
+     caption="Describe pod"
+   />
+
+   Let’s say you need to check the port for the pod in any specific namespace, so for that you need to use the below command:
+
+   ```bash
+   Kubectl describe pod <pod-name> -n <namespace>
+   ```
+
+   You can see the below output:
 
 <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-29_at_9.30.07_AM.webp" alt="" caption="" />1.    Check container port mappings.
     
@@ -57,83 +58,110 @@ Here's how you can quickly check pod ports using kubectl:
     ```bash
     kubectl get pod <pod-name> -o yaml | grep ports: -A 5
     ```
-    
+
 
       You should see a similar output:
 
-<Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.45.23_AM.webp" alt="Ports information using YAML" caption="Ports information using YAML" />
+<Figure
+  src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.45.23_AM.webp"
+  alt="Ports information using YAML"
+  caption="Ports information using YAML"
+/>
+
+1.  Inspect running processes
 
-1. Inspect running processes
-    
     To see which processes are listening on ports:
-    
+
     ```bash
     kubectl exec <pod-name> -- netstat -tulpn
     ```
-    
-    This command runs `netstat` inside the pod, showing active network connections and listening ports. The `-tulpn` options specify that it should show TCP and UDP connections, listening ports, process IDs, and numerical addresses. 
-    
+
+    This command runs `netstat` inside the pod, showing active network connections and listening ports. The `-tulpn` options specify that it should show TCP and UDP connections, listening ports, process IDs, and numerical addresses.
+
     Let’s say if you are running this command in your Macbook then you do need to install net-tools because it is supported in Linux only.
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_1.02.25_AM.webp" alt="Using Exec command" caption="Using Exec command" />
-    
 
-        
+    <Figure
+      src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_1.02.25_AM.webp"
+      alt="Using Exec command"
+      caption="Using Exec command"
+    />
 
         You should see a similar output below:
 
-<Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_3.53.41_PM.webp" alt="Output" caption="Output" />
+<Figure
+  src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_3.53.41_PM.webp"
+  alt="Output"
+  caption="Output"
+/>
 
 ### Advanced Kubectl commands for Port Information
 
 When you need precise and detailed information about the ports that Kubernetes pods are using, some advanced kubectl commands can provide deeper insights. Here's how you can leverage these commands to get more specific port information:
 
 1. Use JSON output with jq
-    
-    To extract just the port information, you can use the `jq` tool, which is a powerful JSON processor. The command used for this is below:
-    
-    ```bash
-    kubectl get pod <pod-name> -o json | jq '.spec.containers[].ports'
-    ```
-    
-    This command filters the JSON output to show only the port configurations of the containers within the specified pod. It is incredibly useful for automation scripts or when you need to programmatically process port information across multiple containers and pods.
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.46.29_AM.webp" alt="Using jq tool" caption="Using jq tool" />
-    
+
+   To extract just the port information, you can use the `jq` tool, which is a powerful JSON processor. The command used for this is below:
+
+   ```bash
+   kubectl get pod <pod-name> -o json | jq '.spec.containers[].ports'
+   ```
+
+   This command filters the JSON output to show only the port configurations of the containers within the specified pod. It is incredibly useful for automation scripts or when you need to programmatically process port information across multiple containers and pods.
+
+   <Figure
+     src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.46.29_AM.webp"
+     alt="Using jq tool"
+     caption="Using jq tool"
+   />
+
 2. Checking Service Endpoints
-    
-    Kubernetes services abstract pod IP addresses and ports into a single access point. To find out where a service points and which ports it exposes, use:
-    
-    ```bash
-    kubectl get endpoints <service-name>
-    ```
-    
-    This command retrieves the endpoints associated with a service, showing IP addresses and ports that are available for communication. This is crucial for debugging service connectivity issues and ensuring that services are correctly linked to their underlying pods.
-    
+
+   Kubernetes services abstract pod IP addresses and ports into a single access point. To find out where a service points and which ports it exposes, use:
+
+   ```bash
+   kubectl get endpoints <service-name>
+   ```
+
+   This command retrieves the endpoints associated with a service, showing IP addresses and ports that are available for communication. This is crucial for debugging service connectivity issues and ensuring that services are correctly linked to their underlying pods.
+
 3. Custom Output Columns for Quick Reference
-    
-    When managing multiple pods, it can be helpful to have a concise view of their configurations, especially ports. The custom columns output feature of `kubectl` allows you to specify exactly which data to display:
-    
-    ```bash
-    kubectl get pods -o custom-columns="POD:.metadata.name,PORTS:.spec.containers[*].ports[*].containerPort"
-    ```
-    
-    This creates a table with pod names and their corresponding ports.
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_2.43.13_PM.webp" alt="" caption="" />4. Creating Command Aliases for Efficiency
-    
-    To simplify frequent checks, create an alias in your shell. Regularly used commands can be shortened by creating aliases in your shell. 
-    
-    ```bash
-    alias kports='kubectl get pods -o custom-columns="POD:.metadata.name,PORTS:.spec.containers[*].ports[*].containerPort"'
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.48.23_AM.webp" alt="" caption="" />Now you can simply type `kports` to get a quick overview of pod ports. This saves time and reduces the chance of errors:
-    
-    <Figure src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.48.38_AM.webp" alt="alias in kubernetes" caption="alias in kubernetes" />
-    
-    Using these aliases, anyone in your team can quickly check port configurations by typing `kports` in the terminal, making it a handy tool for ongoing monitoring and troubleshooting.
-    
+
+   When managing multiple pods, it can be helpful to have a concise view of their configurations, especially ports. The custom columns output feature of `kubectl` allows you to specify exactly which data to display:
+
+   ```bash
+   kubectl get pods -o custom-columns="POD:.metadata.name,PORTS:.spec.containers[*].ports[*].containerPort"
+   ```
+
+   This creates a table with pod names and their corresponding ports.
+
+   <Figure
+     src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_2.43.13_PM.webp"
+     alt=""
+     caption=""
+   />
+   4. Creating Command Aliases for Efficiency
+
+   To simplify frequent checks, create an alias in your shell. Regularly used commands can be shortened by creating aliases in your shell.
+
+   ```bash
+   alias kports='kubectl get pods -o custom-columns="POD:.metadata.name,PORTS:.spec.containers[*].ports[*].containerPort"'
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.48.23_AM.webp"
+     alt=""
+     caption=""
+   />
+   Now you can simply type `kports` to get a quick overview of pod ports. This saves time and
+   reduces the chance of errors:
+
+   <Figure
+     src="/img/guides/2024/09/how-to-check-what-port-a-pod-is-listening-on-with-kubectl-and-not-looking-at-the-dockerfile-Screenshot_2024-08-26_at_12.48.38_AM.webp"
+     alt="alias in kubernetes"
+     caption="alias in kubernetes"
+   />
+
+   Using these aliases, anyone in your team can quickly check port configurations by typing `kports` in the terminal, making it a handy tool for ongoing monitoring and troubleshooting.
 
 ## Why Not to Rely on Dockerfile for Port Information
 
@@ -157,7 +185,7 @@ Common port-related issues and their solutions:
 
 ## Monitoring Pod Network Activity with SigNoz
 
-For ongoing monitoring of pod network activity and port usage, consider using SigNoz. SigNoz is an open-source APM tool that provides detailed insights into your Kubernetes cluster's performance. You can check out the  SigNoz  [here](https://signoz.io/):
+For ongoing monitoring of pod network activity and port usage, consider using SigNoz. SigNoz is an open-source APM tool that provides detailed insights into your Kubernetes cluster's performance. You can check out the SigNoz [here](https://signoz.io/):
 
 With [SigNoz](https://signoz.io/docs/introduction/), you can:
 
@@ -198,4 +226,4 @@ No, Kubernetes configurations can override Dockerfile settings. Always verify ac
 
 ### What's the difference between ContainerPort and HostPort in Kubernetes?
 
-ContainerPort specifies which port the application inside the container is listening on. HostPort maps a container port directly to the same port on the node — use this cautiously as it can lead to conflicts.
\ No newline at end of file
+ContainerPort specifies which port the application inside the container is listening on. HostPort maps a container port directly to the same port on the node — use this cautiously as it can lead to conflicts.
diff --git a/data/guides/how-to-completely-uninstall-grafana.mdx b/data/guides/how-to-completely-uninstall-grafana.mdx
index c89302b48..7dcc7fc36 100644
--- a/data/guides/how-to-completely-uninstall-grafana.mdx
+++ b/data/guides/how-to-completely-uninstall-grafana.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Complete Guide - How to Uninstall Grafana Step-by-Step
-slug: how-to-completely-uninstall-grafana
 date: 2024-10-22
 tags: [grafana, faq]
 authors: [simran_kumari]
 description: Learn how to completely uninstall Grafana from various operating systems with our comprehensive step-by-step guide. Ensure a clean removal and explore alternatives.
-keywords: [uninstall Grafana, remove Grafana, Grafana uninstallation, delete Grafana, clean Grafana removal]
-
+keywords:
+  [uninstall Grafana, remove Grafana, Grafana uninstallation, delete Grafana, clean Grafana removal]
 ---
 
 Grafana, a popular open-source platform for monitoring and visualization, sometimes needs to be removed from your system. Whether you're troubleshooting issues, upgrading to a new version, or simply cleaning up your system, knowing how to uninstall Grafana completely is crucial. This guide walks you through the process of removing Grafana from various operating systems, ensuring no leftover files or configurations remain.
@@ -106,168 +104,170 @@ Backup any important data before deletion.
 For Red Hat-based systems, including CentOS, follow these steps to uninstall Grafana:
 
 1. Stop the Grafana service:
-    
-    ```
-    sudo systemctl stop grafana-server
-    ```
-    
+
+   ```
+   sudo systemctl stop grafana-server
+   ```
+
 2. Remove Grafana packages:
-    
-    ```
-    # For systems using dnf
-    sudo dnf remove -y grafana
-    
-    # For systems using yum
-    sudo yum remove -y grafana
-    ```
-    
+
+   ```
+   # For systems using dnf
+   sudo dnf remove -y grafana
+
+   # For systems using yum
+   sudo yum remove -y grafana
+   ```
+
 3. Delete Grafana repository files:
-    
-    ```
-    sudo rm /etc/yum.repos.d/grafana.repo
-    ```
-    
+
+   ```
+   sudo rm /etc/yum.repos.d/grafana.repo
+   ```
+
 4. Clean up remaining configuration files and logs:
-    
-    ```
-    sudo rm -rf /var/lib/grafana
-    sudo rm -rf /var/log/grafana
-    sudo rm -rf /etc/grafana
-    ```
-    
+
+   ```
+   sudo rm -rf /var/lib/grafana
+   sudo rm -rf /var/log/grafana
+   sudo rm -rf /etc/grafana
+   ```
+
 5. Verify uninstallation using rpm queries:
-    
-    ```
-    rpm -qa | grep grafana
-    ```
-    
-    If the command returns no output, it indicates that Grafana has been successfully uninstalled. If it returns any lines, those packages are still installed.
-    
+
+   ```
+   rpm -qa | grep grafana
+   ```
+
+   If the command returns no output, it indicates that Grafana has been successfully uninstalled. If it returns any lines, those packages are still installed.
 
 ## How to Completely Remove Grafana from Windows
 
 Uninstalling Grafana from Windows involves using both the Control Panel and PowerShell commands:
 
 1. Uninstall Grafana using Windows Control Panel:
-    - Open Control Panel > Programs > Programs and Features
-    - Find Grafana in the list and click "Uninstall"
-    
-    <Figure src="/img/guides/2024/10/how-to-completely-uninstall-grafana-image.webp" alt="Uninstall Grafana using Windows Control Panel" caption="Uninstall Grafana using Windows Control Panel" />
-    
+
+   - Open Control Panel > Programs > Programs and Features
+   - Find Grafana in the list and click "Uninstall"
+
+   <Figure
+     src="/img/guides/2024/10/how-to-completely-uninstall-grafana-image.webp"
+     alt="Uninstall Grafana using Windows Control Panel"
+     caption="Uninstall Grafana using Windows Control Panel"
+   />
+
 2. Remove Grafana service using PowerShell:
-    
-    ```powershell
-    sc.exe delete Grafana
-    ```
-    
+
+   ```powershell
+   sc.exe delete Grafana
+   ```
+
 3. Delete the Grafana installation directory:
-    
-    ```powershell
-    Remove-Item -Path "C:\\Program Files\\GrafanaLabs\\grafana" -Recurse -Force
-    ```
-    
+
+   ```powershell
+   Remove-Item -Path "C:\\Program Files\\GrafanaLabs\\grafana" -Recurse -Force
+   ```
+
 4. Clean up registry entries (be cautious when modifying the registry):
-    
-    ```powershell
-    Remove-Item -Path "HKLM:\\SOFTWARE\\Grafana Labs" -Recurse -Force
-    ```
-    
-    Back up the registry before making any modifications. You can use the following command to create a backup:
-    
-    ```sql
-    reg export "HKLM\SOFTWARE\Grafana Labs" "C:\path\to\backup\grafana_backup.reg"
-    ```
-    
+
+   ```powershell
+   Remove-Item -Path "HKLM:\\SOFTWARE\\Grafana Labs" -Recurse -Force
+   ```
+
+   Back up the registry before making any modifications. You can use the following command to create a backup:
+
+   ```sql
+   reg export "HKLM\SOFTWARE\Grafana Labs" "C:\path\to\backup\grafana_backup.reg"
+   ```
+
 5. Remove any remaining data files and logs:
-    
-    ```powershell
-    Remove-Item -Path "C:\\ProgramData\\Grafana" -Recurse -Force
-    
-    ```
-    
+
+   ```powershell
+   Remove-Item -Path "C:\\ProgramData\\Grafana" -Recurse -Force
+
+   ```
 
 ## Uninstalling Grafana on macOS
 
 For macOS users, the uninstallation process depends on how Grafana was installed. If you used Homebrew, follow these steps:
 
 1. Stop the Grafana service:
-    
-    ```
-    brew services stop grafana
-    ```
-    
-    For non-Homebrew installations, you can stop the service with `launchctl` :
-    
-    ```sql
-    launchctl unload /Library/LaunchDaemons/com.grafana.grafana.plist
-    ```
-    
+
+   ```
+   brew services stop grafana
+   ```
+
+   For non-Homebrew installations, you can stop the service with `launchctl` :
+
+   ```sql
+   launchctl unload /Library/LaunchDaemons/com.grafana.grafana.plist
+   ```
+
 2. Uninstall Grafana using Homebrew:
-    
-    ```
-    brew uninstall grafana
-    ```
-    
+
+   ```
+   brew uninstall grafana
+   ```
+
 3. Manually remove Grafana files and directories:
-    
-    ```
-    sudo rm -rf /usr/local/var/lib/grafana
-    sudo rm -rf /usr/local/var/log/grafana
-    sudo rm -rf /usr/local/etc/grafana
-    ```
-    
-    Note: The actual installation paths might vary depending on the user's configuration. 
-    
-    With Homebrew installation, you are likely to find them at the following paths:
-    
-    ```sql
-    /opt/homebrew/etc/grafana
-    /opt/homebrew/var/lib/grafana/
-    /opt/homebrew/var/log/grafana/
-    ```
-    
-4. Grafana, like many other applications on macOS, stores user preferences, configuration files, and support files in the Application Support directory. 
-    
-    To remove them run the command:
-    
-    ```
-    rm -rf ~/Library/Application Support/Grafana
-    ```
-    
+
+   ```
+   sudo rm -rf /usr/local/var/lib/grafana
+   sudo rm -rf /usr/local/var/log/grafana
+   sudo rm -rf /usr/local/etc/grafana
+   ```
+
+   Note: The actual installation paths might vary depending on the user's configuration.
+
+   With Homebrew installation, you are likely to find them at the following paths:
+
+   ```sql
+   /opt/homebrew/etc/grafana
+   /opt/homebrew/var/lib/grafana/
+   /opt/homebrew/var/log/grafana/
+   ```
+
+4. Grafana, like many other applications on macOS, stores user preferences, configuration files, and support files in the Application Support directory.
+
+   To remove them run the command:
+
+   ```
+   rm -rf ~/Library/Application Support/Grafana
+   ```
+
 5. Verify complete removal using the find command:
-    
-    ```
-    sudo find / -name "*grafana*"
-    ```
-    
+
+   ```
+   sudo find / -name "*grafana*"
+   ```
 
 ## Post-Uninstallation Steps and Verification
 
 After uninstalling Grafana, take these additional steps to ensure a complete removal:
 
 1. Check for remaining processes:
-    
-    ```
-    # On Unix-based systems
-    ps aux | grep grafana
-    
-    # On Windows (PowerShell)
-    Get-Process | Where-Object {$_.Name -like "*grafana*"}
-    ```
-    
+
+   ```
+   # On Unix-based systems
+   ps aux | grep grafana
+
+   # On Windows (PowerShell)
+   Get-Process | Where-Object {$_.Name -like "*grafana*"}
+   ```
+
 2. Verify the removal of all Grafana-related files and directories:
-    
-    ```
-    # On Unix-based systems
-    sudo find / -name "*grafana*"
-    
-    # On Windows (PowerShell)
-    Get-ChildItem -Path C:\\ -Recurse -ErrorAction SilentlyContinue | Where-Object {$_.Name -like "*grafana*"}
-    ```
-    
+
+   ```
+   # On Unix-based systems
+   sudo find / -name "*grafana*"
+
+   # On Windows (PowerShell)
+   Get-ChildItem -Path C:\\ -Recurse -ErrorAction SilentlyContinue | Where-Object {$_.Name -like "*grafana*"}
+   ```
+
 3. Clean up environment variables and system paths:
-    - Check your system's environment variables for any Grafana-related entries
-    - Remove Grafana paths from your system's PATH variable if present
+   - Check your system's environment variables for any Grafana-related entries
+   - Remove Grafana paths from your system's PATH variable if present
 4. Reboot your system to ensure complete removal and clear any lingering processes or cached data.
 5. If you plan to reinstall Grafana, test with a fresh installation to confirm the previous version was completely removed.
 
@@ -276,35 +276,27 @@ After uninstalling Grafana, take these additional steps to ensure a complete rem
 In some cases, you might not need to completely uninstall Grafana. Consider these alternatives:
 
 - Temporarily disable the Grafana service:
-    
-    ```
-    sudo systemctl stop grafana-server
-    sudo systemctl disable grafana-server
-    ```
-    
+  ```
+  sudo systemctl stop grafana-server
+  sudo systemctl disable grafana-server
+  ```
 - If you installed Grafana using Docker, then you can use the following commands for easier management and removal:
-    
-    ```
-    docker stop grafana
-    docker rm grafana
-    ```
-    
+  ```
+  docker stop grafana
+  docker rm grafana
+  ```
 - Archive Grafana data for future reference:
-    
-    ```
-    tar -czf grafana_backup.tar.gz /var/lib/grafana
-    ```
-    
+  ```
+  tar -czf grafana_backup.tar.gz /var/lib/grafana
+  ```
 - Downgrade the Grafana version instead of complete removal:
-    
-    ```
-    sudo apt-get install grafana=<previous_version>
-    ```
-    
+  ```
+  sudo apt-get install grafana=<previous_version>
+  ```
 
 ## Monitoring Your System After Grafana Removal
 
-After uninstalling Grafana, it's crucial to continue monitoring your system and applications. 
+After uninstalling Grafana, it's crucial to continue monitoring your system and applications.
 Consider switching to SigNoz, a modern open-source alternative that supports both metrics and traces. [SigNoz](https://signoz.io/) is designed to provide comprehensive observability with a user-friendly interface and support for [distributed tracing](https://signoz.io/distributed-tracing/), making it a powerful replacement for Grafana. Here are some benefits of using SigNoz:
 
 - Open-source solution with a user-friendly interface
@@ -350,4 +342,4 @@ If standard uninstallation methods fail:
 1. Check for running Grafana processes and force-stop them
 2. Use system-specific tools to investigate locked files or directories
 3. Boot into safe mode (Windows) or single-user mode (Linux) to remove stubborn files
-4. Consult <a href="https://community.grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana's community</a> forums or support channels for specific troubleshooting advice
\ No newline at end of file
+4. Consult <a href="https://community.grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana's community</a> forums or support channels for specific troubleshooting advice
diff --git a/data/guides/how-to-correctly-use-or-logical-operator-in-prometheus.mdx b/data/guides/how-to-correctly-use-or-logical-operator-in-prometheus.mdx
index b8e3181cf..dcd39de71 100644
--- a/data/guides/how-to-correctly-use-or-logical-operator-in-prometheus.mdx
+++ b/data/guides/how-to-correctly-use-or-logical-operator-in-prometheus.mdx
@@ -1,154 +1,157 @@
 ---
-
 title: How to Use the OR Operator in Prometheus PromQL Queries
-slug: how-to-correctly-use-or-logical-operator-in-prometheus
 date: 2024-07-24
 tags: [prometheus, faq]
 authors: [ankit_anand]
 description: Learn how to implement OR logic in Prometheus PromQL queries using regex, vector selectors, and advanced techniques for efficient data querying.
 keywords: [Prometheus, PromQL, OR operator, vector selectors, regex, query optimization]
-
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Use the OR Operator in Prometheus PromQL Queries",
-    "alternativeHeadline": "Mastering OR Logic in Prometheus PromQL Queries",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-correctly-use-or-logical-operator-in-prometheus/"
-    },
-    "description": "Learn how to implement OR logic in Prometheus PromQL queries using regex, vector selectors, and advanced techniques for efficient data querying.",
-    "keywords": "Prometheus, PromQL, OR operator, vector selectors, regex, query optimization",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "OR Operator",
-        "description": "Logical operator used to combine multiple conditions in Prometheus queries."
-      },
-      {
-        "@type": "Thing",
-        "name": "Regex",
-        "description": "A sequence of characters that define a search pattern, often used for string matching within Prometheus queries."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Why doesn't Prometheus have a direct OR operator?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus prioritizes performance and simplicity in its query language. The regex-based approach offers flexibility without adding complexity to the core language."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Use the OR Operator in Prometheus PromQL Queries',
+        alternativeHeadline: 'Mastering OR Logic in Prometheus PromQL Queries',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "How does regex performance compare to other query methods in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Regex can be slower, especially with complex patterns or large datasets. For simple OR conditions, the performance impact is usually negligible. However, for high-cardinality data or frequent queries, consider alternative approaches or query optimization."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I use OR logic across different metrics in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, you can use OR logic across different metrics using binary operators or functions like `or` and `unless`. However, ensure that the resulting time series are compatible for the operation you're performing."
-          }
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-correctly-use-or-logical-operator-in-prometheus/',
         },
-        {
-          "@type": "Question",
-          "name": "Are there any limitations to using regex for OR operations in large-scale deployments?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "In large-scale deployments, complex regex patterns can lead to increased query execution time and resource usage. Consider using recording rules, federation, or alternative query structures for frequently used complex OR logic in high-volume environments."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Using the OR Operator in Prometheus PromQL Queries",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Use Regex for OR Logic",
-          "text": "Implement OR logic using regex within vector selectors. Example: `{job=~\"job1|job2\"}`."
+        description:
+          'Learn how to implement OR logic in Prometheus PromQL queries using regex, vector selectors, and advanced techniques for efficient data querying.',
+        keywords: 'Prometheus, PromQL, OR operator, vector selectors, regex, query optimization',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Combine Multiple Label Values",
-          "text": "Extend the regex pattern to combine multiple label values. Example: `{environment=~\"production|staging\", instance=~\"server1|server2\"}`."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'OR Operator',
+            description:
+              'Logical operator used to combine multiple conditions in Prometheus queries.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Regex',
+            description:
+              'A sequence of characters that define a search pattern, often used for string matching within Prometheus queries.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "Why doesn't Prometheus have a direct OR operator?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus prioritizes performance and simplicity in its query language. The regex-based approach offers flexibility without adding complexity to the core language.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does regex performance compare to other query methods in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Regex can be slower, especially with complex patterns or large datasets. For simple OR conditions, the performance impact is usually negligible. However, for high-cardinality data or frequent queries, consider alternative approaches or query optimization.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use OR logic across different metrics in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Yes, you can use OR logic across different metrics using binary operators or functions like `or` and `unless`. However, ensure that the resulting time series are compatible for the operation you're performing.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Are there any limitations to using regex for OR operations in large-scale deployments?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'In large-scale deployments, complex regex patterns can lead to increased query execution time and resource usage. Consider using recording rules, federation, or alternative query structures for frequently used complex OR logic in high-volume environments.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use Advanced Techniques",
-          "text": "Employ the `unless` operator, scalar comparisons, and subqueries for more complex scenarios."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Using the OR Operator in Prometheus PromQL Queries',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Use Regex for OR Logic',
+              text: 'Implement OR logic using regex within vector selectors. Example: `{job=~"job1|job2"}`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Combine Multiple Label Values',
+              text: 'Extend the regex pattern to combine multiple label values. Example: `{environment=~"production|staging", instance=~"server1|server2"}`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use Advanced Techniques',
+              text: 'Employ the `unless` operator, scalar comparisons, and subqueries for more complex scenarios.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Queries',
+              text: 'Optimize queries by starting with specific conditions, using regex sparingly, and avoiding overcomplicated queries.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Troubleshoot OR Queries',
+              text: 'Address common issues by ensuring proper regex syntax, verifying label names and values, and analyzing query execution time.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Queries",
-          "text": "Optimize queries by starting with specific conditions, using regex sparingly, and avoiding overcomplicated queries."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Troubleshoot OR Queries",
-          "text": "Address common issues by ensuring proper regex syntax, verifying label names and values, and analyzing query execution time."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 [Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/) (PromQL) is a powerful tool for querying time-series data, but it lacks a direct OR operator. This limitation often confuses users seeking to combine multiple conditions in their queries. Fear not—there are effective ways to implement OR logic in Prometheus. Let's explore how to achieve this functionality and optimize your PromQL queries.
@@ -265,8 +268,9 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With [SigNoz](https://signoz.io/docs/introduction/), you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
 - Get high performance with the clickhouse database
-- Take advantage of SigNoz's exceptional exception monitoring capabilities
\ No newline at end of file
+- Take advantage of SigNoz's exceptional exception monitoring capabilities
diff --git a/data/guides/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api.mdx b/data/guides/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api.mdx
index 9804509f4..2ceda53a9 100644
--- a/data/guides/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api.mdx
+++ b/data/guides/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Retrieve All Prometheus Metrics - A Step-by-Step Guide
-slug: how-to-get-all-the-metrics-of-an-instance-with-prometheus-api
 date: 2024-10-30
 tags: [prometheus]
 authors: [nitin_gouda]
 description: Learn how to retrieve all metrics from a Prometheus instance using its API. This comprehensive guide covers PromQL, best practices, and advanced analysis techniques.
-keywords: [Prometheus metrics, Prometheus API, PromQL, metric retrieval, monitoring, observability, SigNoz]
-
+keywords:
+  [Prometheus metrics, Prometheus API, PromQL, metric retrieval, monitoring, observability, SigNoz]
 ---
 
 Prometheus has become a cornerstone of modern monitoring and observability solutions. Its powerful metric collection and querying capabilities make it an essential tool for DevOps and SRE teams. But how do you retrieve all metrics from a Prometheus instance? This guide will walk you through the process step-by-step, covering everything from basic API usage to advanced querying techniques.
@@ -21,17 +19,29 @@ Prometheus metrics are numerical measurements collected at regular intervals to
 Prometheus collects four main types of metrics, each serving a specific purpose in monitoring system behavior and performance:
 
 1. Counters: A counter is a cumulative metric that can only increase over time (or reset to zero upon restart). It’s used to track the number of times an event has occurred, e.g., the total number of requests a system has handled or the number of errors that have occurred.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.46.46_PM.webp" alt="Counter graph" caption="Counter graph" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.46.46_PM.webp"
+     alt="Counter graph"
+     caption="Counter graph"
+   />
+
 2. Gauges: Unlike counters, gauges can go up or down. They measure values that fluctuate, like CPU usage, memory consumption, or the number of active users. For instance, if you monitor memory usage, the gauge will show you that the system is using 50% of the memory at one point and 40% later on. Gauges provide real-time data about current resource usage.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.47.52_PM.webp" alt="Gauges" caption="Gauges" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.47.52_PM.webp"
+     alt="Gauges"
+     caption="Gauges"
+   />
+
 3. Histograms: Histograms are used to measure the distribution of values over time, which is useful for monitoring things like request durations or response sizes. A histogram groups data into buckets; for example, you could measure how many requests are completed in under 1 second, between 1 and 2 seconds, and so on.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.52.58_PM.webp" alt="Histograms" caption="Histograms" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-10_at_10.52.58_PM.webp"
+     alt="Histograms"
+     caption="Histograms"
+   />
+
 4. Summaries: Summaries are similar to histograms but focus on calculating quantiles (like the 95th percentile) over a sliding time window. They help you get precise measurements of how long requests take, providing more detail on performance, especially when you need specific statistical data for latency or response times.
 
 For a more in-depth explanation of Prometheus Core Metric Types, refer to [this guide](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/).
@@ -67,7 +77,7 @@ To retrieve all the metrics from a Prometheus instance, you can make use of the
 
 ### Overview of the Prometheus HTTP API
 
-The Prometheus HTTP API is an essential tool for interacting with the Prometheus server. It allows you to perform a wide range of operations such as querying data, managing alerts, and fetching metadata about the metrics being collected. The API endpoints are designed to be accessible, making it simple to integrate with other services or tools. By using this API, you can programmatically access the data you need for analysis or automation purposes. One of the core endpoints in the [Prometheus API](https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/) is `/api/v1/query`, which is specifically designed for querying metrics. This endpoint is used when you want to retrieve the current value of a specific set of metrics or perform queries based on Prometheus Query Language (PromQL). 
+The Prometheus HTTP API is an essential tool for interacting with the Prometheus server. It allows you to perform a wide range of operations such as querying data, managing alerts, and fetching metadata about the metrics being collected. The API endpoints are designed to be accessible, making it simple to integrate with other services or tools. By using this API, you can programmatically access the data you need for analysis or automation purposes. One of the core endpoints in the [Prometheus API](https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/) is `/api/v1/query`, which is specifically designed for querying metrics. This endpoint is used when you want to retrieve the current value of a specific set of metrics or perform queries based on Prometheus Query Language (PromQL).
 
 The `/api/v1/query` endpoint is the most commonly used endpoint in Prometheus for querying time-series data. This endpoint allows you to run PromQL queries against the [Prometheus database](https://signoz.io/guides/which-database-is-used-in-prometheus/) and fetch results for metrics, giving you a direct way to analyze and monitor your systems.
 
@@ -75,27 +85,21 @@ The `/api/v1/query` endpoint is the most commonly used endpoint in Prometheus fo
 
 Here's a step-by-step guide to forming a query that fetches all metrics:
 
-1. Construct the API URL:
-Start by forming the base URL to access your Prometheus server. If your Prometheus server is running on `localhost` and using the default port `9090`, the URL would look like this:
-    
-    ```
-    http://localhost:9090/api/v1/query
-    ```
-    
-2. Form the query parameter: 
-The query parameter should be constructed to fetch all metrics. Use the following PromQL query for this purpose:
-    
-    ```
-    query={__name__=~".+"}
-    ```
-    
-3. **Combine the URL and query: 
-C**ombine the base API URL and the query to create the final request. Here’s an example:
-    
-    ```
-    http://localhost:9090/api/v1/query?query={__name__=~".+"}
-    ```
-    
+1.  Construct the API URL:
+    Start by forming the base URL to access your Prometheus server. If your Prometheus server is running on `localhost` and using the default port `9090`, the URL would look like this:
+        ```
+        http://localhost:9090/api/v1/query
+        ```
+2.  Form the query parameter:
+    The query parameter should be constructed to fetch all metrics. Use the following PromQL query for this purpose:
+        ```
+        query={__name__=~".+"}
+        ```
+3.  **Combine the URL and query:
+    C**ombine the base API URL and the query to create the final request. Here’s an example:
+        ```
+        http://localhost:9090/api/v1/query?query={__name__=~".+"}
+        ```
 
 Here's an example using curl to make the API request:
 
@@ -107,7 +111,11 @@ curl 'http://localhost:9090/api/v1/query?query={__name__=~".+"}'
 
 This command will return a JSON response containing all the metrics and their current values.
 
-<Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-08_at_12.31.49_AM.webp" alt="All metrics from Prometheus Query Instance" caption="All metrics from Prometheus Query Instance" /> 
+<Figure
+  src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-08_at_12.31.49_AM.webp"
+  alt="All metrics from Prometheus Query Instance"
+  caption="All metrics from Prometheus Query Instance"
+/>{' '}
 
 ### Using PromQL to Retrieve All Metrics
 
@@ -128,7 +136,7 @@ Let's break it down:
 
 How to Filter Metrics by Specific Labels or Instances
 
-You can refine your queries further by filtering metrics using specific labels. Labels in Prometheus provide additional context, such as the job or instance from which the metric originates. For example, if you only want metrics related to a specific service 
+You can refine your queries further by filtering metrics using specific labels. Labels in Prometheus provide additional context, such as the job or instance from which the metric originates. For example, if you only want metrics related to a specific service
 (like `api-server`), you can include label-based filtering:
 
 ```
@@ -137,117 +145,130 @@ You can refine your queries further by filtering metrics using specific labels.
 
 This query will return all metrics that are associated with the job labeled as "api-server."
 
-<Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-cc9c886f-1b24-40df-8e6c-36a66b38ffc4.webp" alt="Returned metrics for the 'api-server' job using PromQL label filtering" caption="Returned metrics for the 'api-server' job using PromQL label filtering" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-cc9c886f-1b24-40df-8e6c-36a66b38ffc4.webp"
+  alt="Returned metrics for the 'api-server' job using PromQL label filtering"
+  caption="Returned metrics for the 'api-server' job using PromQL label filtering"
+/>
 
 ## Accessing Prometheus Metrics Through Different Methods
 
 While the HTTP API is powerful, there are several other ways to access Prometheus metrics:
 
-1. [Prometheus Web UI](https://signoz.io/guides/how-does-prometheus-work/): 
-    
-    This offers a quick way to explore metrics and run queries. You can access the web UI at:
-    
-    ```
-    http://<prometheus-server>:<port>
-    ```
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-13_at_7.49.56_PM.webp" alt="Prometheus landing page" caption="Prometheus landing page" />
-    
-2. Grafana: 
-    
-    Grafana is a popular visualization tool that integrates well with Prometheus. It provides rich dashboarding capabilities for your metrics.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-22_at_6.50.56_PM.webp" alt="Grafana Dashboard" caption="Grafana Dashboard" />
-    
-3. Client Libraries: 
-    
-    Prometheus offers client libraries in <a href="https://prometheus.io/docs/instrumenting/clientlibs/" rel="noopener noreferrer nofollow" target="_blank">various languages</a>. Here's is an example in Python:
-    
-    ```python
-    from prometheus_api_client import PrometheusConnect
-    
-    # Connect to Prometheus
-    prom = PrometheusConnect(url="http://localhost:9090", disable_ssl=True)
-    
-    # Get all metrics
-    metrics = prom.all_metrics()
-    
-    # Print the metrics in a formatted way
-    print("### Output from Prometheus Metrics Script ###\n")
-    # Print each metric in a bullet point format
-    for metric in metrics:
-        print(f"- {metric}")
-    ```
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-14_at_11.03.20_PM.webp" alt="Collecting metrics using client library" caption="Collecting metrics using client library" />
-    
+1. [Prometheus Web UI](https://signoz.io/guides/how-does-prometheus-work/):
+
+   This offers a quick way to explore metrics and run queries. You can access the web UI at:
+
+   ```
+   http://<prometheus-server>:<port>
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-13_at_7.49.56_PM.webp"
+     alt="Prometheus landing page"
+     caption="Prometheus landing page"
+   />
+
+2. Grafana:
+
+   Grafana is a popular visualization tool that integrates well with Prometheus. It provides rich dashboarding capabilities for your metrics.
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-22_at_6.50.56_PM.webp"
+     alt="Grafana Dashboard"
+     caption="Grafana Dashboard"
+   />
+
+3. Client Libraries:
+
+   Prometheus offers client libraries in <a href="https://prometheus.io/docs/instrumenting/clientlibs/" rel="noopener noreferrer nofollow" target="_blank">various languages</a>. Here's is an example in Python:
+
+   ```python
+   from prometheus_api_client import PrometheusConnect
+
+   # Connect to Prometheus
+   prom = PrometheusConnect(url="http://localhost:9090", disable_ssl=True)
+
+   # Get all metrics
+   metrics = prom.all_metrics()
+
+   # Print the metrics in a formatted way
+   print("### Output from Prometheus Metrics Script ###\n")
+   # Print each metric in a bullet point format
+   for metric in metrics:
+       print(f"- {metric}")
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-14_at_11.03.20_PM.webp"
+     alt="Collecting metrics using client library"
+     caption="Collecting metrics using client library"
+   />
+
 4. Command-Line Tools:
-    
-    Tools like `promtool` can query Prometheus from the command line:
-    
-    ```bash
-    promtool query instant http://localhost:9090 '{__name__=~".+"}'
-    ```
-    
-    <Figure src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-14_at_11.08.49_PM.webp" alt="Using promtool to query prometheus metrics" caption="Using promtool to query prometheus metrics" />
-    
+
+   Tools like `promtool` can query Prometheus from the command line:
+
+   ```bash
+   promtool query instant http://localhost:9090 '{__name__=~".+"}'
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-all-the-metrics-of-an-instance-with-prometheus-api-Screenshot_2024-10-14_at_11.08.49_PM.webp"
+     alt="Using promtool to query prometheus metrics"
+     caption="Using promtool to query prometheus metrics"
+   />
 
 ## Best Practices for Handling Large Volumes of Metrics
 
 When dealing with large volumes of metrics in Prometheus, it's essential to follow certain best practices to ensure that your monitoring system remains efficient and manageable. Below are some key strategies to keep in mind:
 
-1. Implement Naming Conventions:
-Establish consistent and meaningful naming conventions for your metrics. This helps you and your team understand what each metric represents at a glance. For instance, use names like `http_requests_total` for a counter tracking total HTTP requests. Good naming practices make it easier to query and manage your metrics over time.
-2. Use Labels Effectively:
-Labels allow you to add dimensions to your metrics, offering richer insights into your data. For example, if you're measuring HTTP requests, you can include labels for different HTTP methods and endpoints, like `http_requests_total{method="GET",endpoint="/api/users"}`. This lets you filter and aggregate metrics based on these dimensions, providing more detailed analysis.
-3. Be Cautious with [High Cardinality](https://signoz.io/blog/high-cardinality-data/):
-High cardinality occurs when a metric has too many unique label combinations, which can lead to performance issues. Labels that change frequently, such as user IDs, should be avoided to prevent excessive cardinality. Instead, focus on labels that give valuable, stable dimensions without overwhelming your system with millions of unique combinations.
-4. Query Optimization: 
-When querying a large dataset, it's crucial to optimize your queries to avoid fetching excessive data unnecessarily. Use time ranges and step intervals to manage the volume of data returned. For example:
-    
-    ```
-    {__name__=~".+"}[5m:1m]
-    ```
-    
-    This query fetches data for all metrics over the last 5 minutes, with a 1-minute interval between data points. By setting specific time ranges and intervals, you reduce the data volume and speed up query execution.
-    
+1.  Implement Naming Conventions:
+    Establish consistent and meaningful naming conventions for your metrics. This helps you and your team understand what each metric represents at a glance. For instance, use names like `http_requests_total` for a counter tracking total HTTP requests. Good naming practices make it easier to query and manage your metrics over time.
+2.  Use Labels Effectively:
+    Labels allow you to add dimensions to your metrics, offering richer insights into your data. For example, if you're measuring HTTP requests, you can include labels for different HTTP methods and endpoints, like `http_requests_total{method="GET",endpoint="/api/users"}`. This lets you filter and aggregate metrics based on these dimensions, providing more detailed analysis.
+3.  Be Cautious with [High Cardinality](https://signoz.io/blog/high-cardinality-data/):
+    High cardinality occurs when a metric has too many unique label combinations, which can lead to performance issues. Labels that change frequently, such as user IDs, should be avoided to prevent excessive cardinality. Instead, focus on labels that give valuable, stable dimensions without overwhelming your system with millions of unique combinations.
+4.  Query Optimization:
+    When querying a large dataset, it's crucial to optimize your queries to avoid fetching excessive data unnecessarily. Use time ranges and step intervals to manage the volume of data returned. For example:
+        ```
+        {__name__=~".+"}[5m:1m]
+        ```
+
+        This query fetches data for all metrics over the last 5 minutes, with a 1-minute interval between data points. By setting specific time ranges and intervals, you reduce the data volume and speed up query execution.
 
 ## Analyzing and Interpreting Prometheus Metrics
 
 Once you've retrieved your metrics, the next step is analysis. Here are some techniques:
 
-1. Identify Key Performance Indicators (KPIs): 
-Focus on the key metrics that impact your service level objectives (SLOs) and service level agreements (SLAs). In Kubernetes, these may include pod CPU and memory usage, pod restarts, and network traffic. For example, metrics like `container_cpu_usage_seconds_total` or `container_memory_usage_bytes` are essential for evaluating resource usage in your cluster.
-2. Spot Trends and Anomalies: 
-Prometheus metrics help identify patterns or abnormalities over time. You can leverage PromQL functions like `rate()` and `increase()` to track resource utilization. For example, monitoring CPU usage trends in containers can help you detect issues before they escalate:
-    
-    ```
-    rate(container_cpu_usage_seconds_total[5m])
-    ```
-    
-    This query reveals the per-second rate of CPU usage by containers over a 5-minute window, helping identify spikes in resource consumption.
-    
-3. Analyze Counter Metrics with `rate()` and `increase()` Functions:
-    
+1.  Identify Key Performance Indicators (KPIs):
+    Focus on the key metrics that impact your service level objectives (SLOs) and service level agreements (SLAs). In Kubernetes, these may include pod CPU and memory usage, pod restarts, and network traffic. For example, metrics like `container_cpu_usage_seconds_total` or `container_memory_usage_bytes` are essential for evaluating resource usage in your cluster.
+2.  Spot Trends and Anomalies:
+    Prometheus metrics help identify patterns or abnormalities over time. You can leverage PromQL functions like `rate()` and `increase()` to track resource utilization. For example, monitoring CPU usage trends in containers can help you detect issues before they escalate:
+        ```
+        rate(container_cpu_usage_seconds_total[5m])
+        ```
+
+        This query reveals the per-second rate of CPU usage by containers over a 5-minute window, helping identify spikes in resource consumption.
+3.  Analyze Counter Metrics with `rate()` and `increase()` Functions:
+
     For counter metrics (e.g., request counts), the `rate()` function calculates the per-second average rate of increase over a specified time window, while `increase()` provides the total increase over that period. These functions are crucial for understanding throughput and performance trends. For example, to track pod restarts:
-    
+
     ```scss
     increase(kube_pod_container_status_restarts_total[5m])
     ```
-    
+
     This query highlights pod restart events over a 5-minute period, which can indicate stability issues in your deployments.
-    
-4. Combine Metrics: 
-Create compound queries by combining multiple metrics to derive deeper insights. For instance, you might want to calculate the ratio of pods in a failed state compared to the total number of pods. 
-    
-    For example, to assess the error rate in your application, you can compare the number of failed requests (`http_requests_failed_total`) to the total number of requests (`http_requests_total`). This gives a clearer view of your application's reliability.
-    
-    ```
-    rate(kube_pod_status_failed[5m]) / rate(kube_pod_status_phase{phase="Running"}[5m])
-    ```
-    
-    This query computes the percentage of failed pods relative to the total number of running pods in the last 5 minutes, helping assess the health of your cluster.
-    
+
+4.  Combine Metrics:
+    Create compound queries by combining multiple metrics to derive deeper insights. For instance, you might want to calculate the ratio of pods in a failed state compared to the total number of pods.
+        For example, to assess the error rate in your application, you can compare the number of failed requests (`http_requests_failed_total`) to the total number of requests (`http_requests_total`). This gives a clearer view of your application's reliability.
+
+        ```
+        rate(kube_pod_status_failed[5m]) / rate(kube_pod_status_phase{phase="Running"}[5m])
+        ```
+
+        This query computes the percentage of failed pods relative to the total number of running pods in the last 5 minutes, helping assess the health of your cluster.
 
 ## Enhancing Metric Collection with SigNoz
 
@@ -289,4 +310,4 @@ Yes, you can either use Prometheus federation to [aggregate metrics](https://sig
 
 ### How frequently should I query for all metrics in a production environment?
 
-Query frequency should be based on the level of detail required and the capacity of your system. Frequent queries, such as every few seconds, can overload your Prometheus server. For general monitoring, querying every few minutes works well. For real-time insights, you might want to explore push-based systems or streaming solutions instead.
\ No newline at end of file
+Query frequency should be based on the level of detail required and the capacity of your system. Frequent queries, such as every few seconds, can overload your Prometheus server. For general monitoring, querying every few minutes works well. For real-time insights, you might want to explore push-based systems or streaming solutions instead.
diff --git a/data/guides/how-to-get-number-of-pods-running-in-prometheus.mdx b/data/guides/how-to-get-number-of-pods-running-in-prometheus.mdx
index ce13f7c84..7ca3e3224 100644
--- a/data/guides/how-to-get-number-of-pods-running-in-prometheus.mdx
+++ b/data/guides/how-to-get-number-of-pods-running-in-prometheus.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Monitor Pod Count in Prometheus - A Quick Guide
-slug: how-to-get-number-of-pods-running-in-prometheus
 date: 2024-10-30
 tags: [prometheus]
 authors: [nitin_gouda]
 description: Learn how to monitor and query pod count in Kubernetes using Prometheus. Discover PromQL queries, best practices, and troubleshooting tips for effective pod management.
-keywords: [pod count monitoring, Prometheus, Kubernetes, PromQL queries, pod metrics, cluster health, Grafana visualization, SigNoz]
-
+keywords:
+  [
+    pod count monitoring,
+    Prometheus,
+    Kubernetes,
+    PromQL queries,
+    pod metrics,
+    cluster health,
+    Grafana visualization,
+    SigNoz,
+  ]
 ---
 
 Monitoring pod count in Kubernetes is crucial for maintaining a healthy and efficient cluster. Prometheus, a popular open-source monitoring system, provides powerful tools to track and analyze pod metrics. This guide will show you how to get the number of pods running in Prometheus and leverage this information for effective cluster management.
@@ -21,17 +28,17 @@ Pod count monitoring in Kubernetes refers to the process of tracking the number
 Monitoring pod count is vital for maintaining the health and stability of your Kubernetes cluster. The number of running pods directly affects how efficiently your resources are being used and whether your applications are running smoothly. Here are some key reasons why monitoring pod count is important:
 
 1. Resource Optimization
-Monitoring pod count helps ensure that your system is using resources efficiently. By keeping track of how many pods are running, you can make sure you're not overusing or underusing your CPU, memory, or storage resources. If too many pods are running, you may be wasting resources; if too few are running, your applications may not perform optimally.
+   Monitoring pod count helps ensure that your system is using resources efficiently. By keeping track of how many pods are running, you can make sure you're not overusing or underusing your CPU, memory, or storage resources. If too many pods are running, you may be wasting resources; if too few are running, your applications may not perform optimally.
 2. Scaling Decisions
-In a dynamic environment like Kubernetes, where workloads can change frequently, you need to know when to scale your applications up (add more pods) or down (reduce the number of pods). Pod count trends over time can show you when demand is increasing, helping you decide when to automatically scale up or when to scale down to save on resources.
+   In a dynamic environment like Kubernetes, where workloads can change frequently, you need to know when to scale your applications up (add more pods) or down (reduce the number of pods). Pod count trends over time can show you when demand is increasing, helping you decide when to automatically scale up or when to scale down to save on resources.
 3. Troubleshooting
-Changes in pod count that are unexpected—like sudden spikes or drops—can be a sign of problems in your cluster. For example, if pods are frequently being restarted or terminated, it could indicate an issue like a failed deployment, resource constraints (e.g., running out of memory), or a misconfiguration in your Kubernetes setup. Monitoring pod count helps you catch these problems early so you can resolve them quickly.
+   Changes in pod count that are unexpected—like sudden spikes or drops—can be a sign of problems in your cluster. For example, if pods are frequently being restarted or terminated, it could indicate an issue like a failed deployment, resource constraints (e.g., running out of memory), or a misconfiguration in your Kubernetes setup. Monitoring pod count helps you catch these problems early so you can resolve them quickly.
 
 ### Role of Prometheus in Kubernetes Monitoring
 
 Prometheus plays a crucial role in Kubernetes monitoring due to its powerful integration with the Kubernetes ecosystem. Its native support for service discovery allows Prometheus to automatically discover new pods and services as they are deployed, without requiring manual intervention. This automatic discovery ensures that your monitoring adapts in real-time, maintaining visibility over the dynamically changing environment in Kubernetes clusters.
 
-Moreover, Prometheus is designed to efficiently scrape metrics from various Kubernetes components, such as nodes, pods, and services. It monitors resource usage like CPU, memory, and network bandwidth, and provides insights into the overall health of the cluster. 
+Moreover, Prometheus is designed to efficiently scrape metrics from various Kubernetes components, such as nodes, pods, and services. It monitors resource usage like CPU, memory, and network bandwidth, and provides insights into the overall health of the cluster.
 
 Some important roles Prometheus plays in Kubernetes monitoring include:
 
@@ -62,7 +69,11 @@ count(kube_pod_info)
 
 This query gives you a snapshot of how many pods are running in your cluster at the moment. It’s a good starting point for understanding the overall scale of your applications.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_10.46.56_PM.webp" alt="Count all pods" caption="Count all pods" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_10.46.56_PM.webp"
+  alt="Count all pods"
+  caption="Count all pods"
+/>
 
 1. Count Running Pods
 
@@ -74,7 +85,11 @@ count(kube_pod_status_phase{phase="Running"})
 
 This is useful when you need to ensure that your applications are actively running, as pods in other phases (e.g., "Pending" or "Failed") may indicate issues.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_10.47.52_PM.webp" alt="Count pods which are in running state" caption="Count pods which are in running state" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_10.47.52_PM.webp"
+  alt="Count pods which are in running state"
+  caption="Count pods which are in running state"
+/>
 
 1. Count Pods by Namespace
 
@@ -86,7 +101,11 @@ count(kube_pod_info) by (namespace)
 
 This query gives you a clearer picture of how pods are distributed across different namespaces, helping you understand resource allocation at a more granular level.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.09.26_PM.webp" alt="Count kube from a specific namespace" caption="Count kube from a specific namespace" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.09.26_PM.webp"
+  alt="Count kube from a specific namespace"
+  caption="Count kube from a specific namespace"
+/>
 
 ### Advanced Pod Count Queries
 
@@ -102,7 +121,11 @@ rate(kube_pod_start_time[1h])
 
 This query shows the rate of pod creation over the last hour, helping you understand how your cluster scales and responds to workload changes.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.08.24_PM.webp" alt="Number of pods changing over 1 hour" caption="Number of pods changing over 1 hour" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.08.24_PM.webp"
+  alt="Number of pods changing over 1 hour"
+  caption="Number of pods changing over 1 hour"
+/>
 
 1. Detect Abnormal Pod Count Fluctuations
 
@@ -114,7 +137,11 @@ abs(delta(count(kube_pod_info)[1h:5m]))
 
 This query tracks changes in the number of pods over the last hour (sampled every 5 minutes) and returns the magnitude of the change (ignoring whether it increased or decreased). This is useful for spotting unexpected behavior that might need investigation.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_1.07.21_AM.webp" alt="Checking any abnormalities during a time range" caption="Checking any abnormalities during a time range" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_1.07.21_AM.webp"
+  alt="Checking any abnormalities during a time range"
+  caption="Checking any abnormalities during a time range"
+/>
 
 As there is no fluctuation and the pods are running well, the query returns a zero value.
 
@@ -133,7 +160,7 @@ Integrating Grafana with Prometheus unlocks powerful visualization capabilities
 
 ### Creating Dashboards for Pod Count Metrics
 
-A well-structured Grafana dashboard helps you consolidate pod count data and other relevant metrics into a single view. To create a dashboard in Grafana, refer to [this guide](https://signoz.io/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count/#connect-prometheus-to-grafana). 
+A well-structured Grafana dashboard helps you consolidate pod count data and other relevant metrics into a single view. To create a dashboard in Grafana, refer to [this guide](https://signoz.io/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count/#connect-prometheus-to-grafana).
 
 When designing your dashboard for pod count metrics, consider adding these key metrics to ensure comprehensive visibility and insights into your Kubernetes environment:
 
@@ -147,7 +174,11 @@ count(kube_pod_info)
 
 This will display the overall pod count across all namespaces, helping you track the scale of your applications at a glance.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.49.23_PM.webp" alt="Count pods in grafana" caption="Count pods in grafana" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.49.23_PM.webp"
+  alt="Count pods in grafana"
+  caption="Count pods in grafana"
+/>
 
 1. Pod Count by Namespace
 
@@ -159,7 +190,11 @@ count(kube_pod_info) by (namespace)
 
 This query groups the pod count by namespace, giving you visibility into which parts of your cluster are consuming the most resources.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.50.28_PM.webp" alt="Count pods by namespace in grafana" caption="Count pods by namespace in grafana" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.50.28_PM.webp"
+  alt="Count pods by namespace in grafana"
+  caption="Count pods by namespace in grafana"
+/>
 
 1. Pod Count Trends Over Time
 
@@ -169,7 +204,11 @@ Understanding how your pod count changes over time is critical for identifying p
 count(kube_pod_info)
 ```
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.49.23_PM.webp" alt="Count pods in Grafana" caption="Count pods in Grafana" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-06_at_11.49.23_PM.webp"
+  alt="Count pods in Grafana"
+  caption="Count pods in Grafana"
+/>
 
 Then, apply a time range in the Grafana panel to display how the number of pods has fluctuated. This is particularly useful for spotting anomalies like sudden increases or decreases in the number of running pods.
 
@@ -178,29 +217,27 @@ Then, apply a time range in the Grafana panel to display how the number of pods
 To monitor the health of your pods effectively, it’s essential to track the distribution of pods across different statuses—such as Running, Pending, and Failed. This can quickly show if any pods are stuck in an undesired state. Use the following queries for the different statuses:
 
 - For running pods:
-    
-    ```
-    count(kube_pod_status_phase{phase="Running"})
-    ```
-    
+  ```
+  count(kube_pod_status_phase{phase="Running"})
+  ```
 - For pending pods:
-    
-    ```
-    count(kube_pod_status_phase{phase="Pending"})
-    ```
-    
+  ```
+  count(kube_pod_status_phase{phase="Pending"})
+  ```
 - For failed pods:
-    
-    ```
-    count(kube_pod_status_phase{phase="Failed"})
-    ```
-    
+  ```
+  count(kube_pod_status_phase{phase="Failed"})
+  ```
 
-These queries will give you the counts of pods in each phase. 
+These queries will give you the counts of pods in each phase.
 
 Visualizing this data as a pie chart or stacked bar chart in Grafana provides a clear view of the overall pod health.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_12.42.07_AM.webp" alt="Pie chart for pods running, pending and failed" caption="Pie chart for pods running, pending and failed" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_12.42.07_AM.webp"
+  alt="Pie chart for pods running, pending and failed"
+  caption="Pie chart for pods running, pending and failed"
+/>
 
 ### Setting Up Time-Based Pod Count Graphs
 
@@ -210,7 +247,11 @@ Understanding how your pod count changes over time is critical for identifying p
 count(kube_pod_info)
 ```
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_1.06.03_AM.webp" alt="Pod count graph for 24 hours range" caption="Pod count graph for 24 hours range" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_1.06.03_AM.webp"
+  alt="Pod count graph for 24 hours range"
+  caption="Pod count graph for 24 hours range"
+/>
 
 Apply a time range in the Grafana panel to display how the number of pods has fluctuated. This is particularly useful for spotting anomalies like sudden increases or decreases in the number of running pods.
 
@@ -220,9 +261,17 @@ Grafana allows you to create drill-down views for detailed information on specif
 
 For example, you can use Grafana variables to create dynamic dashboards that filter metrics based on the selected pod or namespace. This level of interactivity enhances your ability to troubleshoot issues in real-time.
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-120f8dd1-1ae7-4a7f-86f6-df6d37934572.webp" alt="Setting up variable" caption="Setting up variable" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-120f8dd1-1ae7-4a7f-86f6-df6d37934572.webp"
+  alt="Setting up variable"
+  caption="Setting up variable"
+/>
 
-<Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_12.34.57_AM.webp" alt="Using variable name instead of using the query" caption="Using variable name instead of using the query" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-22_at_12.34.57_AM.webp"
+  alt="Using variable name instead of using the query"
+  caption="Using variable name instead of using the query"
+/>
 
 ## Troubleshooting Common Pod Count Issues
 
@@ -234,18 +283,25 @@ Sometimes, pods fail to be scheduled on nodes due to various reasons, such as re
 
 - Use the command `kubectl describe pod <pod-name>` to get detailed information about the pod.
 - Look for messages in the Events section of the output, which may indicate why the pod couldn’t be scheduled (e.g., insufficient CPU, memory, or unavailable nodes).
-    
-    <Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_5.39.13_PM.webp" alt="Kubernetes pod description" caption="Kubernetes pod description" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_5.39.13_PM.webp"
+    alt="Kubernetes pod description"
+    caption="Kubernetes pod description"
+  />
+
 1. Review Resource Constraints
 
 A common reason for failed pods or fluctuating pod counts is that the nodes in your cluster don’t have enough resources (CPU, memory, etc.) to handle the scheduled pods. To ensure this isn’t the issue:
 
 - Check the resource requests and limits for your pods using the command `kubectl get pod <pod-name> -o yaml`.
 - Make sure your nodes have sufficient available resources by using `kubectl describe nodes` or `kubectl top nodes` to check the current resource usage on each node.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.49.41_PM.webp" alt="Kubernetes pod description in yaml format" caption="Kubernetes pod description in yaml format" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.49.41_PM.webp"
+    alt="Kubernetes pod description in yaml format"
+    caption="Kubernetes pod description in yaml format"
+  />
 
 If your nodes are running low on resources, you may need to either increase the number of nodes in your cluster or optimize the resource requests and limits for your pods.
 
@@ -255,9 +311,12 @@ If a pod is crashing or failing to start, it’s essential to look at the logs t
 
 - Use the command `kubectl logs <pod-name>` to retrieve the logs from the pod.
 - If the pod contains multiple containers, specify the container name like this: `kubectl logs <pod-name> -c <container-name>`.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.50.38_PM.webp" alt="Pod logs" caption="Pod logs" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.50.38_PM.webp"
+    alt="Pod logs"
+    caption="Pod logs"
+  />
 
 Look through the logs for errors or exceptions that may explain the pod’s failure. Common issues include application crashes, misconfigurations, or missing dependencies.
 
@@ -267,9 +326,12 @@ Sometimes, recent changes in your Kubernetes Deployments can cause pod count flu
 
 - Use `kubectl get deployment <deployment-name>` to see the current status of your deployments.
 - Check for any recent deployment updates or changes to scaling rules by using `kubectl describe deployment <deployment-name>`.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.51.41_PM.webp" alt="More info about pod deployment" caption="More info about pod deployment" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-number-of-pods-running-in-prometheus-Screenshot_2024-10-07_at_6.51.41_PM.webp"
+    alt="More info about pod deployment"
+    caption="More info about pod deployment"
+  />
 
 Rolling updates or changes in replica counts can cause a temporary increase or decrease in pod count. If the pod count changes unexpectedly after a deployment, review the deployment's update strategy and replica settings.
 
@@ -323,4 +385,4 @@ Several factors can cause unexpected changes in pod count, including:
 - Resource constraints: If there are insufficient resources (like CPU or memory), Kubernetes might prevent new pods from being scheduled or scale down existing pods.
 - Misconfigured liveness or readiness probes: These probes monitor pod health, and if they detect issues, Kubernetes might restart the affected pods, resulting in fluctuations.
 
-By keeping an eye on pod count and understanding these common causes, you can ensure better stability and performance in your Kubernetes environment.
\ No newline at end of file
+By keeping an eye on pod count and understanding these common causes, you can ensure better stability and performance in your Kubernetes environment.
diff --git a/data/guides/how-to-get-the-95th-percentile-of-an-average-in-prometheus.mdx b/data/guides/how-to-get-the-95th-percentile-of-an-average-in-prometheus.mdx
index f87a815ff..a3143297a 100644
--- a/data/guides/how-to-get-the-95th-percentile-of-an-average-in-prometheus.mdx
+++ b/data/guides/how-to-get-the-95th-percentile-of-an-average-in-prometheus.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Calculate 95th Percentile of an average in Prometheus - A Step-by-Step Guide
-slug: how-to-get-the-95th-percentile-of-an-average-in-prometheus
 date: 2024-10-03
 tags: [faq, prometheus, grafana]
 authors: [simran_kumari]
 description: Learn how to calculate the 95th percentile of an average in Prometheus with this comprehensive guide. Master advanced techniques and visualization.
-keywords: [Prometheus, 95th percentile, data analysis, performance monitoring, histograms, summaries, Grafana, SigNoz]
-
+keywords:
+  [
+    Prometheus,
+    95th percentile,
+    data analysis,
+    performance monitoring,
+    histograms,
+    summaries,
+    Grafana,
+    SigNoz,
+  ]
 ---
 
 When monitoring system performance, the 95th percentile is a powerful metric, often preferred over averages for highlighting performance for the vast majority of users, while minimizing the impact of extreme outliers. But what if you want to focus on both? This guide will walk you through calculating this metric using Prometheus and PromQL, specifically focusing on how to find the 95th percentile of an average—such as the average HTTP response time experienced by 95% of your users.
@@ -18,7 +25,7 @@ A percentile is a way to understand how a value compares to other values in a se
 
 For example, if you score in the 90th percentile on a test, it means you did better than 90% of the people who took the test, and only 10% scored higher than you. Percentiles divide data into 100 equal parts, so each percentile represents 1% of the data.
 
-In simpler terms, the N-th percentile is the value below which N% of the data falls.  In the context of Prometheus, percentiles help you understand the distribution of your data and identify outliers.
+In simpler terms, the N-th percentile is the value below which N% of the data falls. In the context of Prometheus, percentiles help you understand the distribution of your data and identify outliers.
 
 ### Average vs Percentile
 
@@ -29,19 +36,12 @@ Response Times:
 `100ms, 110ms, 120ms, 130ms, 140ms, 150ms, 500ms, 1000ms, 1500ms, 2000ms`
 
 - Average (Mean):
-    
-    The average response time is calculated by summing all the times and dividing by the number of requests:
-    
-    `(100 + 110 + 120 + 130 + 140 + 150 + 500 + 1000 + 1500 + 2000) / 10 = 575ms`
-    
+  The average response time is calculated by summing all the times and dividing by the number of requests:
+  `(100 + 110 + 120 + 130 + 140 + 150 + 500 + 1000 + 1500 + 2000) / 10 = 575ms`
 - 95th Percentile:
-    
-    The 95th percentile is calculated by sorting the response times in ascending order and finding the value below which 95% of the requests fall.
-    
-    `100ms, 110ms, 120ms, 130ms, 140ms, 150ms, 500ms, 1000ms, 1500ms, 2000ms`
-    
-    With 10 data points, we calculate the 95th percentile as 0.95 * 10 = 9.5, which rounds down to the 9th value for percentile calculations. Therefore, the 95th percentile is 1500ms, meaning 95% of the requests have a response time at or below 1500ms.
-    
+  The 95th percentile is calculated by sorting the response times in ascending order and finding the value below which 95% of the requests fall.
+  `100ms, 110ms, 120ms, 130ms, 140ms, 150ms, 500ms, 1000ms, 1500ms, 2000ms`
+  With 10 data points, we calculate the 95th percentile as 0.95 \* 10 = 9.5, which rounds down to the 9th value for percentile calculations. Therefore, the 95th percentile is 1500ms, meaning 95% of the requests have a response time at or below 1500ms.
 
 Key Difference:
 
@@ -70,11 +70,11 @@ Histograms vs. Summaries in Prometheus
 In Prometheus, calculating the 95th percentile of an average is valuable because it provides a more balanced view of system performance than averages alone. Here’s why this approach matters:
 
 - Outlier Detection:
-    - Averages can hide spikes or outliers in performance data, making your system seem more stable than it is.
-    - The 95th percentile focuses on the upper limit of your most common performance, highlighting performance issues that affect a smaller percentage of users, such as the slowest requests or the highest resource consumption.
+  - Averages can hide spikes or outliers in performance data, making your system seem more stable than it is.
+  - The 95th percentile focuses on the upper limit of your most common performance, highlighting performance issues that affect a smaller percentage of users, such as the slowest requests or the highest resource consumption.
 - Balancing Trends with Exceptions:
-    - By combining the 95th percentile with the average (like response times), you can track long-term trends while also monitoring worst-case scenarios for most users.
-    - For example, rather than just looking at average HTTP response times, using the 95th percentile allows you to see where the slowest 5% of responses fall, giving you more actionable data.
+  - By combining the 95th percentile with the average (like response times), you can track long-term trends while also monitoring worst-case scenarios for most users.
+  - For example, rather than just looking at average HTTP response times, using the 95th percentile allows you to see where the slowest 5% of responses fall, giving you more actionable data.
 - SLA Compliance: Many service-level agreements (SLAs) are based on percentiles like the 95th or 99th percentile to ensure that most users have a good experience, even though some small percentage might experience slower performance.
 - Detecting Performance Degradation: Calculating the 95th percentile of an average metric, such as response time or memory usage, allows you to detect gradual performance degradation in the worst-performing parts of your system. This makes it easier to take proactive steps before larger problems arise.
 
@@ -89,25 +89,31 @@ Before calculating the 95th percentile, ensure that your application is exposing
 ### 1. Using the `quantile()` Function for Percentile Calculation
 
 - Summaries: If you’re using summaries, retrieving the 95th percentile is straightforward:
-    
-    ```
-    quantile(0.95, http_requests_total)
-    ```
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image.webp" alt="Using quantile()" caption="Using quantile()" />
-    
+  ```
+  quantile(0.95, http_requests_total)
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image.webp"
+    alt="Using quantile()"
+    caption="Using quantile()"
+  />
 - Histograms: For histograms, you can use the `histogram_quantile()` function. This function estimates the desired quantiles based on the bucket counts:
-    
-    ```
-    histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
-    ```
-    
-    This query calculates the 95th percentile of HTTP request durations over the last 5 minutes.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%201.webp" alt="Using histogram_quantile() in table view" caption="Using histogram_quantile() in table view" />
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%202.webp" alt="Using histogram_quantile() in graph view" caption="Using histogram_quantile() in graph view" />
-    
+  ```
+  histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
+  ```
+  This query calculates the 95th percentile of HTTP request durations over the last 5 minutes.
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%201.webp"
+    alt="Using histogram_quantile() in table view"
+    caption="Using histogram_quantile() in table view"
+  />
+  <Figure
+    src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%202.webp"
+    alt="Using histogram_quantile() in graph view"
+    caption="Using histogram_quantile() in graph view"
+  />
 
 ### 2. Combining `avg()` and `quantile()` Functions for Average Percentiles
 
@@ -124,26 +130,30 @@ Here’s a breakdown of the query:
 
 This query provides insights into how response times vary across different web identifiers, helping you identify potential performance issues.
 
-<Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%203.webp" alt="Combining `avg()` and `quantile()` in prometheus" caption="Combining `avg()` and `quantile()` in prometheus" />
+<Figure
+  src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%203.webp"
+  alt="Combining `avg()` and `quantile()` in prometheus"
+  caption="Combining `avg()` and `quantile()` in prometheus"
+/>
 
 ### 3. Handling Time Ranges and Aggregation in Your Queries
 
 Prometheus allows you to apply percentile calculations over specific time ranges, providing flexibility in your analysis. For example:
 
 - 5-Minute Window:
-    
-    ```
-    histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
-    ```
-    
+  ```
+  histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
+  ```
 - 1-Hour Window:
-    
-    ```
-    histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[1h])) 
-    ```
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%204.webp" alt="Handling Time Ranges and Aggregation" caption="Handling Time Ranges and Aggregation" />
-    
+  ```
+  histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[1h]))
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%204.webp"
+    alt="Handling Time Ranges and Aggregation"
+    caption="Handling Time Ranges and Aggregation"
+  />
 
 ### Optimizing Query Performance for Large Datasets
 
@@ -167,39 +177,68 @@ Clear naming conventions and effective labeling are essential for successful mon
 Grafana is an excellent tool for visualizing Prometheus data, including percentiles. Here's how to create effective dashboards:
 
 1. Connect Grafana to your [Prometheus data](https://signoz.io/guides/how-does-grafana-get-data-from-prometheus/) source.
-    - In Grafana, visit the “Data sources” section, and click on the `+ Add new data source` button
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%205.webp" alt="Create new data souce in Grafana" caption="Create new data souce in Grafana" />
-    
-    - Select `Prometheus` as the data source
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%206.webp" alt="Selecting Prometheus as the data source" caption="Selecting Prometheus as the data source" />
-    
-    - Update the name and URL and save the data source.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%207.webp" alt="Specifying data source details" caption="Specifying data source details" />
-    
+
+   - In Grafana, visit the “Data sources” section, and click on the `+ Add new data source` button
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%205.webp"
+     alt="Create new data souce in Grafana"
+     caption="Create new data souce in Grafana"
+   />
+
+   - Select `Prometheus` as the data source
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%206.webp"
+     alt="Selecting Prometheus as the data source"
+     caption="Selecting Prometheus as the data source"
+   />
+
+   - Update the name and URL and save the data source.
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%207.webp"
+     alt="Specifying data source details"
+     caption="Specifying data source details"
+   />
+
 2. Create a new dashboard and add a panel.
-    - Visit the `Dashboards` section and click on the `New` button.
-        
-        <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%208.webp" alt="Creating new dashboards" caption="Creating new dashboards" />
-        
-    - Add `New Dashboard` and click the `Add visualization` button.
-        
-        <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%209.webp" alt="Adding visualization" caption="Adding visualization" />
-        
-    - Select the data source created
-        
-        <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2010.webp" alt="Selecting the datasource" caption="Selecting the datasource" />
-        
+   - Visit the `Dashboards` section and click on the `New` button.
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%208.webp"
+       alt="Creating new dashboards"
+       caption="Creating new dashboards"
+     />
+   - Add `New Dashboard` and click the `Add visualization` button.
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%209.webp"
+       alt="Adding visualization"
+       caption="Adding visualization"
+     />
+   - Select the data source created
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2010.webp"
+       alt="Selecting the datasource"
+       caption="Selecting the datasource"
+     />
 3. Use PromQL to query your average of 95th percentile data.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2011.webp" alt="Using PromQL to query average of 95th percentile data." caption="Using PromQL to query average of 95th percentile data." />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2011.webp"
+     alt="Using PromQL to query average of 95th percentile data."
+     caption="Using PromQL to query average of 95th percentile data."
+   />
+
 4. Choose appropriate visualization types—line charts or gauge work well for tracking average of percentiles over time.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2012.webp" alt="Choosing appropriate visualization type" caption="Choosing appropriate visualization type" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2012.webp"
+     alt="Choosing appropriate visualization type"
+     caption="Choosing appropriate visualization type"
+   />
 
 ## Common Challenges and Troubleshooting
 
@@ -217,16 +256,19 @@ To optimize resource usage:
 - Use recording rules for complex calculations
 - Adjust your scrape interval and retention period as needed
 - Consider using query federation for large-scale deployments
-</aside>
+  </aside>
 
 ## Enhancing Observability with SigNoz
 
 While Prometheus is powerful, tools like SigNoz can simplify percentile calculations and visualization. SigNoz offers:
 
 - Built-in Advanced Percentile Calculations: SigNoz effortlessly calculates and displays various percentile metrics, such as p50, p90, and p99.
-    
-    <Figure src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2013.webp" alt="SigNoz Built-in percentile calculations" caption="SigNoz Built-in percentile calculations" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-get-the-95th-percentile-of-an-average-in-prometheus-image%2013.webp"
+    alt="SigNoz Built-in percentile calculations"
+    caption="SigNoz Built-in percentile calculations"
+  />
 - User-Friendly Dashboards: Visualize performance metrics with intuitive dashboards that make data interpretation straightforward.
 - Integration with Tracing Data: Gain deeper insights through the integration of tracing data, allowing for more comprehensive performance analysis.
 
@@ -258,4 +300,4 @@ Yes, you can use aggregation functions like `sum()` or `avg()` in combination wi
 
 ### How do I choose between client-side and server-side percentile calculations?
 
-Choose client-side (summaries) for higher accuracy and lower query load, or server-side (histograms) for more flexibility and the ability to aggregate across multiple series.
\ No newline at end of file
+Choose client-side (summaries) for higher accuracy and lower query load, or server-side (histograms) for more flexibility and the ability to aggregate across multiple series.
diff --git a/data/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus.mdx b/data/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus.mdx
index 94d251bdd..8912929df 100644
--- a/data/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus.mdx
+++ b/data/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus.mdx
@@ -1,159 +1,172 @@
 ---
-
 title: How to Measure Total Requests with Prometheus - A Time-Based Guide
-slug: how-to-get-total-requests-in-a-period-of-time-with-prometheus
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Learn how to measure total requests over time using Prometheus. This guide covers PromQL, time-based metrics, and best practices for accurate request tracking.
-keywords: [Prometheus, request tracking, PromQL, time-series data, metrics, monitoring, Grafana, data visualization]
-
+keywords:
+  [
+    Prometheus,
+    request tracking,
+    PromQL,
+    time-series data,
+    metrics,
+    monitoring,
+    Grafana,
+    data visualization,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Measure Total Requests with Prometheus: A Time-Based Guide",
-    "alternativeHeadline": "Track Total Requests Over Time Using Prometheus",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-25T00:00:00Z",
-    "dateModified": "2024-07-25T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus/"
-    },
-    "description": "Learn how to measure total requests over time using Prometheus. This guide covers PromQL, time-based metrics, and best practices for accurate request tracking.",
-    "keywords": "Prometheus, request tracking, PromQL, time-series data, metrics, monitoring, Grafana, data visualization",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to select and aggregate time-series data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Grafana",
-        "description": "An open-source platform for monitoring and observability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metrics",
-        "description": "Numerical data points associated with specific timestamps."
-      },
-      {
-        "@type": "Thing",
-        "name": "Time-Series Data",
-        "description": "Data points collected or recorded at regular time intervals."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "How often should I scrape request metrics in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "For most web applications, a 15-30 second scrape interval provides a good balance between accuracy and performance."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Measure Total Requests with Prometheus: A Time-Based Guide',
+        alternativeHeadline: 'Track Total Requests Over Time Using Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "Can I track requests by specific endpoints or user types?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, use labels in your counter metrics to track requests by various dimensions such as endpoints, user types, or status codes."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What's the difference between `rate()` and `increase()` for request counting?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "`rate()` calculates the per-second average over a time range, while `increase()` gives the total increase. Use `rate()` for longer periods and `increase()` for shorter intervals."
-          }
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-get-total-requests-in-a-period-of-time-with-prometheus/',
         },
-        {
-          "@type": "Question",
-          "name": "How do I handle counter resets when measuring total requests?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use `increase()` or `rate()` functions in your queries, as they automatically account for counter resets when calculating values over a time range."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Tracking Total Requests with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Set up a counter metric for requests",
-          "text": "Create a counter metric in your code to track total HTTP requests."
+        description:
+          'Learn how to measure total requests over time using Prometheus. This guide covers PromQL, time-based metrics, and best practices for accurate request tracking.',
+        keywords:
+          'Prometheus, request tracking, PromQL, time-series data, metrics, monitoring, Grafana, data visualization',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Calculate total requests using `increase()`",
-          "text": "Use the `increase()` function in PromQL to calculate the total requests over a specific time range."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to select and aggregate time-series data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Grafana',
+            description: 'An open-source platform for monitoring and observability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metrics',
+            description: 'Numerical data points associated with specific timestamps.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Time-Series Data',
+            description: 'Data points collected or recorded at regular time intervals.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'How often should I scrape request metrics in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'For most web applications, a 15-30 second scrape interval provides a good balance between accuracy and performance.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I track requests by specific endpoints or user types?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, use labels in your counter metrics to track requests by various dimensions such as endpoints, user types, or status codes.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What's the difference between `rate()` and `increase()` for request counting?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: '`rate()` calculates the per-second average over a time range, while `increase()` gives the total increase. Use `rate()` for longer periods and `increase()` for shorter intervals.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I handle counter resets when measuring total requests?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use `increase()` or `rate()` functions in your queries, as they automatically account for counter resets when calculating values over a time range.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Aggregate requests across instances",
-          "text": "Use the `sum()` function to aggregate request counts across all monitored instances."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Tracking Total Requests with Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Set up a counter metric for requests',
+              text: 'Create a counter metric in your code to track total HTTP requests.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Calculate total requests using `increase()`',
+              text: 'Use the `increase()` function in PromQL to calculate the total requests over a specific time range.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Aggregate requests across instances',
+              text: 'Use the `sum()` function to aggregate request counts across all monitored instances.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize request data in Grafana',
+              text: 'Create dashboards in Grafana to visualize total requests over time using PromQL queries.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize request data in Grafana",
-          "text": "Create dashboards in Grafana to visualize total requests over time using PromQL queries."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus offers powerful tools to track total requests over specific time periods. This guide will walk you through the process of setting up, querying, and analyzing request data using Prometheus and its query language, PromQL. You'll learn how to leverage time-series data for accurate request tracking and gain insights into your system's performance.
@@ -302,4 +315,4 @@ Yes, use labels in your counter metrics to track requests by various dimensions
 
 ### How do I handle counter resets when measuring total requests?
 
-Use `increase()` or `rate()` functions in your queries, as they automatically account for counter resets when calculating values over a time range.
\ No newline at end of file
+Use `increase()` or `rate()` functions in your queries, as they automatically account for counter resets when calculating values over a time range.
diff --git a/data/guides/how-to-handle-counters-on-servers-in-prometheus.mdx b/data/guides/how-to-handle-counters-on-servers-in-prometheus.mdx
index 73d333dd2..e0ade7616 100644
--- a/data/guides/how-to-handle-counters-on-servers-in-prometheus.mdx
+++ b/data/guides/how-to-handle-counters-on-servers-in-prometheus.mdx
@@ -1,149 +1,160 @@
 ---
-
 title: How to Manage Prometheus Counters - Best Practices for Servers
-slug: how-to-handle-counters-on-servers-in-prometheus
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [daniel]
 description: Learn how to effectively manage Prometheus counters on servers, handle resets, and implement best practices for accurate monitoring and data analysis.
-keywords: [Prometheus counters, server monitoring, counter resets, metric management, data consistency, Prometheus functions, counter recovery]
-
+keywords:
+  [
+    Prometheus counters,
+    server monitoring,
+    counter resets,
+    metric management,
+    data consistency,
+    Prometheus functions,
+    counter recovery,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Manage Prometheus Counters: Best Practices for Servers",
-    "alternativeHeadline": "Effectively Manage Prometheus Counters on Servers",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-25T00:00:00Z",
-    "dateModified": "2024-07-25T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-handle-counters-on-servers-in-prometheus/"
-    },
-    "description": "Learn how to effectively manage Prometheus counters on servers, handle resets, and implement best practices for accurate monitoring and data analysis.",
-    "keywords": "Prometheus counters, server monitoring, counter resets, metric management, data consistency, Prometheus functions, counter recovery",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to select and aggregate time-series data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metrics",
-        "description": "Numerical data points associated with specific timestamps."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What causes counter resets in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Counter resets typically occur due to server or application restarts, process crashes, or intentional metric resets in the application code."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Manage Prometheus Counters: Best Practices for Servers',
+        alternativeHeadline: 'Effectively Manage Prometheus Counters on Servers',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How does Prometheus handle counter resets internally?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus doesn't handle counter resets automatically. It's up to you to use functions like `increase()` or `rate()` to calculate meaningful values across resets."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I prevent counter resets altogether?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While you can't completely prevent resets, you can minimize their impact by implementing persistent storage for counter values, using graceful shutdown procedures, and designing your application to recover counter states on startup."
-          }
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-handle-counters-on-servers-in-prometheus/',
         },
-        {
-          "@type": "Question",
-          "name": "What's the difference between `increase()` and `rate()` functions in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "`increase()` calculates the total increase in counter value over a specified time range, while `rate()` computes the per-second average rate of increase over a time range. Use `increase()` for total counts and `rate()` for per-second rates."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Managing Prometheus Counters on Servers",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Understand counter behavior",
-          "text": "Counters only increase or reset to zero. They are used for tracking cumulative metrics like total requests or errors."
+        description:
+          'Learn how to effectively manage Prometheus counters on servers, handle resets, and implement best practices for accurate monitoring and data analysis.',
+        keywords:
+          'Prometheus counters, server monitoring, counter resets, metric management, data consistency, Prometheus functions, counter recovery',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Handle counter resets properly",
-          "text": "Use Prometheus functions like `increase()` and `rate()` to calculate values across resets. Configure counters to minimize reset impact with persistent storage and graceful shutdown procedures."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to select and aggregate time-series data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metrics',
+            description: 'Numerical data points associated with specific timestamps.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What causes counter resets in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Counter resets typically occur due to server or application restarts, process crashes, or intentional metric resets in the application code.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does Prometheus handle counter resets internally?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Prometheus doesn't handle counter resets automatically. It's up to you to use functions like `increase()` or `rate()` to calculate meaningful values across resets.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I prevent counter resets altogether?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While you can't completely prevent resets, you can minimize their impact by implementing persistent storage for counter values, using graceful shutdown procedures, and designing your application to recover counter states on startup.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What's the difference between `increase()` and `rate()` functions in Prometheus?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: '`increase()` calculates the total increase in counter value over a specified time range, while `rate()` computes the per-second average rate of increase over a time range. Use `increase()` for total counts and `rate()` for per-second rates.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Implement recovery mechanisms",
-          "text": "Store counter values persistently, retrieve last known values, and implement recovery in your application code to maintain counter consistency across server restarts."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Managing Prometheus Counters on Servers',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Understand counter behavior',
+              text: 'Counters only increase or reset to zero. They are used for tracking cumulative metrics like total requests or errors.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Handle counter resets properly',
+              text: 'Use Prometheus functions like `increase()` and `rate()` to calculate values across resets. Configure counters to minimize reset impact with persistent storage and graceful shutdown procedures.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement recovery mechanisms',
+              text: 'Store counter values persistently, retrieve last known values, and implement recovery in your application code to maintain counter consistency across server restarts.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Utilize advanced techniques',
+              text: 'Leverage `CounterVec` for multi-dimensional counters and implement custom logic for handling discontinuities and frequent resets in distributed systems.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Monitor and troubleshoot counter issues',
+              text: 'Set up alerts for unexpected behaviors, analyze counter data to detect anomalies, and visualize counter data effectively using tools like Grafana.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Utilize advanced techniques",
-          "text": "Leverage `CounterVec` for multi-dimensional counters and implement custom logic for handling discontinuities and frequent resets in distributed systems."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Monitor and troubleshoot counter issues",
-          "text": "Set up alerts for unexpected behaviors, analyze counter data to detect anomalies, and visualize counter data effectively using tools like Grafana."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus counters are essential tools for tracking cumulative metrics on servers. They provide valuable insights into system behavior, but managing them effectively can be challenging. This guide explores best practices for handling counters on servers in Prometheus, focusing on dealing with resets and maintaining data consistency.
@@ -167,107 +178,105 @@ Counter resets occur when a server restarts or an application resets its metrics
 To manage counter resets effectively:
 
 1. Use Prometheus functions:
-    - `increase()`: Calculate the increase in counter value over a time range.
-    - `rate()`: Compute the per-second average rate of increase.
+   - `increase()`: Calculate the increase in counter value over a time range.
+   - `rate()`: Compute the per-second average rate of increase.
 2. Configure counters to minimize reset impact:
-    - Use persistent storage for counter values when possible.
-    - Implement graceful shutdown procedures to save counter states.
+   - Use persistent storage for counter values when possible.
+   - Implement graceful shutdown procedures to save counter states.
 3. Maintain data consistency across server restarts:
-    - Implement a recovery mechanism to restore counter values.
-    - Use time-based analysis to detect and account for resets.
+   - Implement a recovery mechanism to restore counter values.
+   - Use time-based analysis to detect and account for resets.
 
 ### Implementing Counter Recovery Mechanisms
 
 To maintain counter consistency across server restarts:
 
 1. Store counter values persistently:
-    - Use a local database or file storage on the client-side.
-    - Implement periodic snapshots of counter values.
+   - Use a local database or file storage on the client-side.
+   - Implement periodic snapshots of counter values.
 2. Retrieve last known values:
-    - Query the Prometheus server for the most recent counter value before the reset.
-    - Use the [Prometheus API](https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/) or PromQL to fetch historical data.
+   - Query the Prometheus server for the most recent counter value before the reset.
+   - Use the [Prometheus API](https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/) or PromQL to fetch historical data.
 3. Implement recovery in your application code:
-    
-    ```python
-    import prometheus_client as prom
-    import pickle
-    
-    class PersistentCounter:
-        def __init__(self, name, description):
-            self.counter = prom.Counter(name, description)
-            self.filename = f"{name}_backup.pkl"
-            self._load_value()
-    
-        def _load_value(self):
-            try:
-                with open(self.filename, 'rb') as f:
-                    value = pickle.load(f)
-                    self.counter._value.set(value)
-            except FileNotFoundError:
-                pass
-    
-        def inc(self, amount=1):
-            self.counter.inc(amount)
-            self._save_value()
-    
-        def _save_value(self):
-            with open(self.filename, 'wb') as f:
-                pickle.dump(self.counter._value.get(), f)
-    
-    ```
-    
+
+   ```python
+   import prometheus_client as prom
+   import pickle
+
+   class PersistentCounter:
+       def __init__(self, name, description):
+           self.counter = prom.Counter(name, description)
+           self.filename = f"{name}_backup.pkl"
+           self._load_value()
+
+       def _load_value(self):
+           try:
+               with open(self.filename, 'rb') as f:
+                   value = pickle.load(f)
+                   self.counter._value.set(value)
+           except FileNotFoundError:
+               pass
+
+       def inc(self, amount=1):
+           self.counter.inc(amount)
+           self._save_value()
+
+       def _save_value(self):
+           with open(self.filename, 'wb') as f:
+               pickle.dump(self.counter._value.get(), f)
+
+   ```
+
 4. Balance recovery accuracy with performance:
-    - Implement asynchronous saving to reduce I/O impact.
-    - Use in-memory caching with periodic persistence for high-frequency counters.
+   - Implement asynchronous saving to reduce I/O impact.
+   - Use in-memory caching with periodic persistence for high-frequency counters.
 
 ## Advanced Techniques for Counter Management
 
 To handle counters on servers in Prometheus more effectively:
 
 1. Utilize `CounterVec` for multi-dimensional counters:
-    
-    ```python
-    request_counter = prom.CounterVec(
-        'http_requests_total',
-        'Total HTTP Requests',
-        ['method', 'endpoint']
-    )
-    
-    request_counter.labels(method='GET', endpoint='/api/users').inc()
-    
-    ```
-    
+
+   ```python
+   request_counter = prom.CounterVec(
+       'http_requests_total',
+       'Total HTTP Requests',
+       ['method', 'endpoint']
+   )
+
+   request_counter.labels(method='GET', endpoint='/api/users').inc()
+
+   ```
+
 2. Implement custom logic for handling discontinuities:
-    - Detect large jumps in counter values.
-    - Use historical data to estimate missing values during resets.
+   - Detect large jumps in counter values.
+   - Use historical data to estimate missing values during resets.
 3. Deal with frequent resets in distributed systems:
-    - Implement a centralized counter aggregation service.
-    - Use distributed storage solutions for counter persistence.
+   - Implement a centralized counter aggregation service.
+   - Use distributed storage solutions for counter persistence.
 4. Leverage Prometheus client libraries:
-    - Use official client libraries for your programming language.
-    - Implement custom collectors for complex counter scenarios.
+   - Use official client libraries for your programming language.
+   - Implement custom collectors for complex counter scenarios.
 
 ## Monitoring and Troubleshooting Counter Issues
 
 To ensure reliable counter data:
 
 1. Set up alerts for unexpected behaviors:
-    - Alert on sudden drops in counter values.
-    - Monitor for unusually high increase rates.
+   - Alert on sudden drops in counter values.
+   - Monitor for unusually high increase rates.
 2. Analyze counter data to detect anomalies:
-    - Use PromQL to identify inconsistencies:
-        
-        ```
-        changes(http_requests_total[1h]) > 1
-        
-        ```
-        
+   - Use PromQL to identify inconsistencies:
+     ```
+     changes(http_requests_total[1h]) > 1
+
+     ```
 3. Debug common counter-related problems:
-    - Check for code paths that might reset counters unintentionally.
-    - Verify that all relevant events increment the counter.
+   - Check for code paths that might reset counters unintentionally.
+   - Verify that all relevant events increment the counter.
 4. Visualize counter data effectively:
-    - Use Grafana or similar tools to create dashboards.
-    - Implement heat maps for multi-dimensional counters.
+   - Use Grafana or similar tools to create dashboards.
+   - Implement heat maps for multi-dimensional counters.
 
 ## Key Takeaways
 
@@ -326,4 +335,4 @@ By combining Prometheus counters with SigNoz's advanced features, you can achiev
 ## Resources
 
 - [Prometheus Documentation: Counter](https://prometheus.io/docs/concepts/metric_types/#counter)
-- [Prometheus Best Practices](https://prometheus.io/docs/practices/naming/)
\ No newline at end of file
+- [Prometheus Best Practices](https://prometheus.io/docs/practices/naming/)
diff --git a/data/guides/how-to-implement-jaeger.mdx b/data/guides/how-to-implement-jaeger.mdx
index fa9915aeb..a38c47e8b 100644
--- a/data/guides/how-to-implement-jaeger.mdx
+++ b/data/guides/how-to-implement-jaeger.mdx
@@ -1,164 +1,179 @@
 ---
-
 title: How to Implement Jaeger? - A Step-by-Step Guide for Developers
-slug: how-to-implement-jaeger
 date: 2024-07-30
 tags: [faq, jaeger]
 authors: [daniel]
 description: Learn how to implement Jaeger, the open-source distributed tracing system, with this comprehensive guide for developers. Master setup, instrumentation, and best practices.
-keywords: [Jaeger, distributed tracing, microservices, OpenTelemetry, instrumentation, monitoring, troubleshooting, observability]
-
+keywords:
+  [
+    Jaeger,
+    distributed tracing,
+    microservices,
+    OpenTelemetry,
+    instrumentation,
+    monitoring,
+    troubleshooting,
+    observability,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to implement Jaeger? - A Step-by-Step Guide for Developers",
-    "alternativeHeadline": "Master Jaeger Implementation: Setup, Instrumentation, and Best Practices for Developers",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-implement-jaeger/"
-    },
-    "description": "Learn how to implement Jaeger, the open-source distributed tracing system, with this comprehensive guide for developers. Master setup, instrumentation, and best practices.",
-    "keywords": "Jaeger, distributed tracing, microservices, OpenTelemetry, instrumentation, monitoring, troubleshooting, observability",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Jaeger",
-        "description": "An open-source, end-to-end distributed tracing system."
-      },
-      {
-        "@type": "Thing",
-        "name": "OpenTelemetry",
-        "description": "A collection of tools, APIs, and SDKs for instrumenting, generating, collecting, and exporting telemetry data such as metrics, logs, and traces."
-      },
-      {
-        "@type": "Thing",
-        "name": "Distributed Tracing",
-        "description": "A method used to monitor applications built on a microservices architecture."
-      },
-      {
-        "@type": "Thing",
-        "name": "Microservices",
-        "description": "An architectural style that structures an application as a collection of loosely coupled services."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Jaeger",
-        "applicationCategory": "Distributed Tracing"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "OpenTelemetry",
-        "applicationCategory": "Observability Framework"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What's the difference between Jaeger and other tracing systems like Zipkin?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Jaeger and Zipkin are both open-source distributed tracing systems, but Jaeger offers more advanced features like adaptive sampling and a more scalable architecture. Jaeger also has better support for OpenTelemetry, making it more future-proof."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How does Jaeger handle data retention and storage?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Jaeger allows you to configure data retention policies based on your needs. When using Elasticsearch or Cassandra as a backend, you can set up index rotation and deletion to manage data volume and retention periods."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can Jaeger be used with applications not written in Java?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, Jaeger supports multiple programming languages. It offers client libraries for Java, Go, Python, Node.js, C++, and C#. Additionally, its compatibility with OpenTelemetry expands its language support even further."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to implement Jaeger? - A Step-by-Step Guide for Developers',
+        alternativeHeadline:
+          'Master Jaeger Implementation: Setup, Instrumentation, and Best Practices for Developers',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How does Jaeger impact application performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While Jaeger does add some overhead to your application, it's designed to be lightweight. The impact can be minimized through proper sampling strategies and configuration. In most cases, the performance impact is negligible compared to the benefits of distributed tracing."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Implementing Jaeger for Distributed Tracing",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Docker",
-          "text": "Install Docker on your system if you haven't already."
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Run Jaeger All-in-One Container",
-          "text": "Run the Jaeger All-in-One container using the command: `docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14250:14250 -p 14268:14268 -p 14269:14269 -p 9411:9411 jaegertracing/all-in-one:1.59`."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-implement-jaeger/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Access Jaeger UI",
-          "text": "Open a web browser and navigate to `http://localhost:16686` to access the Jaeger UI."
+        description:
+          'Learn how to implement Jaeger, the open-source distributed tracing system, with this comprehensive guide for developers. Master setup, instrumentation, and best practices.',
+        keywords:
+          'Jaeger, distributed tracing, microservices, OpenTelemetry, instrumentation, monitoring, troubleshooting, observability',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Verify Installation",
-          "text": "Verify the installation by sending test spans using Jaeger client libraries or OpenTelemetry SDK."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Jaeger',
+            description: 'An open-source, end-to-end distributed tracing system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'OpenTelemetry',
+            description:
+              'A collection of tools, APIs, and SDKs for instrumenting, generating, collecting, and exporting telemetry data such as metrics, logs, and traces.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Distributed Tracing',
+            description:
+              'A method used to monitor applications built on a microservices architecture.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Microservices',
+            description:
+              'An architectural style that structures an application as a collection of loosely coupled services.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Jaeger',
+            applicationCategory: 'Distributed Tracing',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'OpenTelemetry',
+            applicationCategory: 'Observability Framework',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "What's the difference between Jaeger and other tracing systems like Zipkin?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Jaeger and Zipkin are both open-source distributed tracing systems, but Jaeger offers more advanced features like adaptive sampling and a more scalable architecture. Jaeger also has better support for OpenTelemetry, making it more future-proof.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does Jaeger handle data retention and storage?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Jaeger allows you to configure data retention policies based on your needs. When using Elasticsearch or Cassandra as a backend, you can set up index rotation and deletion to manage data volume and retention periods.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Jaeger be used with applications not written in Java?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Jaeger supports multiple programming languages. It offers client libraries for Java, Go, Python, Node.js, C++, and C#. Additionally, its compatibility with OpenTelemetry expands its language support even further.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does Jaeger impact application performance?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While Jaeger does add some overhead to your application, it's designed to be lightweight. The impact can be minimized through proper sampling strategies and configuration. In most cases, the performance impact is negligible compared to the benefits of distributed tracing.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Instrument Your Application",
-          "text": "Use Jaeger's native client libraries or the OpenTelemetry SDK to instrument your application code and generate traces."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Implementing Jaeger for Distributed Tracing',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Docker',
+              text: "Install Docker on your system if you haven't already.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Run Jaeger All-in-One Container',
+              text: 'Run the Jaeger All-in-One container using the command: `docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14250:14250 -p 14268:14268 -p 14269:14269 -p 9411:9411 jaegertracing/all-in-one:1.59`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Access Jaeger UI',
+              text: 'Open a web browser and navigate to `http://localhost:16686` to access the Jaeger UI.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Verify Installation',
+              text: 'Verify the installation by sending test spans using Jaeger client libraries or OpenTelemetry SDK.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Instrument Your Application',
+              text: "Use Jaeger's native client libraries or the OpenTelemetry SDK to instrument your application code and generate traces.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Analyze Traces',
+              text: 'Use the Jaeger UI to search for and analyze traces to understand the performance and behavior of your distributed system.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Analyze Traces",
-          "text": "Use the Jaeger UI to search for and analyze traces to understand the performance and behavior of your distributed system."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Distributed tracing has become essential for developers working with microservices architectures. Jaeger, an open-source distributed tracing system, offers a powerful solution for monitoring and troubleshooting complex distributed systems. This guide will walk you through the process of implementing Jaeger, from setup to advanced usage.
@@ -330,4 +345,4 @@ To learn more about how SigNoz compares to Jaeger and how it can enhance your [o
 
 - [Jaeger Official Documentation](https://www.jaegertracing.io/docs/1.59/)
 - [OpenTelemetry Integration Guide](https://opentelemetry.io/docs/instrumentation/java/manual/)
-- [Jaeger Sampling Strategies](https://www.jaegertracing.io/docs/1.59/sampling/)
\ No newline at end of file
+- [Jaeger Sampling Strategies](https://www.jaegertracing.io/docs/1.59/sampling/)
diff --git a/data/guides/how-to-increase-prometheus-storage-retention.mdx b/data/guides/how-to-increase-prometheus-storage-retention.mdx
index 7a28f6288..f93ab8477 100644
--- a/data/guides/how-to-increase-prometheus-storage-retention.mdx
+++ b/data/guides/how-to-increase-prometheus-storage-retention.mdx
@@ -1,149 +1,162 @@
 ---
-
 title: How to Increase Prometheus Storage Retention - A Step-by-Step Guide
-slug: how-to-increase-prometheus-storage-retention
 date: 2024-07-24
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Learn how to increase Prometheus storage retention with our comprehensive guide. Boost your monitoring capabilities and enhance long-term data analysis.
-keywords: [Prometheus, storage retention, monitoring, data analysis, configuration, troubleshooting, best practices]
-
+keywords:
+  [
+    Prometheus,
+    storage retention,
+    monitoring,
+    data analysis,
+    configuration,
+    troubleshooting,
+    best practices,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Increase Prometheus Storage Retention - A Step-by-Step Guide",
-    "alternativeHeadline": "Extend Prometheus Storage Retention with This Comprehensive Guide",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-increase-prometheus-storage-retention/"
-    },
-    "description": "Learn how to increase Prometheus storage retention with our comprehensive guide. Boost your monitoring capabilities and enhance long-term data analysis.",
-    "keywords": "Prometheus, storage retention, monitoring, data analysis, configuration, troubleshooting, best practices",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Storage Retention",
-        "description": "The duration for which time-series data is kept before being automatically purged."
-      },
-      {
-        "@type": "Thing",
-        "name": "Data Analysis",
-        "description": "The process of inspecting, cleaning, transforming, and modeling data with the goal of discovering useful information."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is the default retention period for Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The default retention period is 15 days."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Increase Prometheus Storage Retention - A Step-by-Step Guide',
+        alternativeHeadline: 'Extend Prometheus Storage Retention with This Comprehensive Guide',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "Can I change retention settings without restarting Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "No, changes to retention settings require a Prometheus restart to take effect."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "How does increasing retention affect Prometheus performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Extended retention may impact query performance and increase storage requirements. Monitor system resources and optimize as needed."
-          }
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-increase-prometheus-storage-retention/',
         },
-        {
-          "@type": "Question",
-          "name": "Is there a maximum limit to Prometheus retention time?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "There's no hard limit, but practical constraints like storage capacity and query performance should be considered when setting retention periods."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Increasing Prometheus Storage Retention",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Check Current Retention Settings",
-          "text": "Locate the Prometheus configuration file (usually `prometheus.yml`). Look for the `-storage.tsdb.retention.time` flag in the startup command or configuration. Access the Prometheus UI and navigate to the `/config` endpoint to view current settings. Use the Prometheus API to query retention information."
+        description:
+          'Learn how to increase Prometheus storage retention with our comprehensive guide. Boost your monitoring capabilities and enhance long-term data analysis.',
+        keywords:
+          'Prometheus, storage retention, monitoring, data analysis, configuration, troubleshooting, best practices',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Modify Retention Period",
-          "text": "Open the Prometheus configuration file in a text editor. Locate or add the `-storage.tsdb.retention.time` flag. Set the desired retention period (e.g., `30d` for 30 days, `720h` for 30 days, or `1y` for 1 year). Save the changes and restart Prometheus to apply the new settings."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Storage Retention',
+            description:
+              'The duration for which time-series data is kept before being automatically purged.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Data Analysis',
+            description:
+              'The process of inspecting, cleaning, transforming, and modeling data with the goal of discovering useful information.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is the default retention period for Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The default retention period is 15 days.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I change retention settings without restarting Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'No, changes to retention settings require a Prometheus restart to take effect.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does increasing retention affect Prometheus performance?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Extended retention may impact query performance and increase storage requirements. Monitor system resources and optimize as needed.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is there a maximum limit to Prometheus retention time?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "There's no hard limit, but practical constraints like storage capacity and query performance should be considered when setting retention periods.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Increase Retention for Dockerized Prometheus",
-          "text": "Modify the Docker run command or docker-compose file. Add or update the `-storage.tsdb.retention.time` flag in the command arguments. Ensure persistent storage is configured to retain data across container restarts."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Increasing Prometheus Storage Retention',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Check Current Retention Settings',
+              text: 'Locate the Prometheus configuration file (usually `prometheus.yml`). Look for the `-storage.tsdb.retention.time` flag in the startup command or configuration. Access the Prometheus UI and navigate to the `/config` endpoint to view current settings. Use the Prometheus API to query retention information.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Modify Retention Period',
+              text: 'Open the Prometheus configuration file in a text editor. Locate or add the `-storage.tsdb.retention.time` flag. Set the desired retention period (e.g., `30d` for 30 days, `720h` for 30 days, or `1y` for 1 year). Save the changes and restart Prometheus to apply the new settings.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Increase Retention for Dockerized Prometheus',
+              text: 'Modify the Docker run command or docker-compose file. Add or update the `-storage.tsdb.retention.time` flag in the command arguments. Ensure persistent storage is configured to retain data across container restarts.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Best Practices',
+              text: 'Estimate storage requirements. Implement data compression. Utilize remote storage. Monitor system performance regularly after increasing retention.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Troubleshoot Common Issues',
+              text: 'Address insufficient disk space by adding storage or implementing data compression. Verify data integrity and consider restarting Prometheus with a clean storage directory. Optimize queries and consider implementing recording rules for frequently accessed metrics. Check logs for retention-related errors and ensure proper configuration syntax.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Implement Best Practices",
-          "text": "Estimate storage requirements. Implement data compression. Utilize remote storage. Monitor system performance regularly after increasing retention."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Troubleshoot Common Issues",
-          "text": "Address insufficient disk space by adding storage or implementing data compression. Verify data integrity and consider restarting Prometheus with a clean storage directory. Optimize queries and consider implementing recording rules for frequently accessed metrics. Check logs for retention-related errors and ensure proper configuration syntax."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus, a powerful open-source monitoring system, collects and stores time-series data for analysis and alerting. However, its default storage retention period may not suffice for long-term trend analysis or compliance requirements. This guide will walk you through the process of increasing Prometheus storage retention, enabling you to harness the full potential of your monitoring data.
@@ -178,10 +191,10 @@ curl -s http://localhost:9090/api/v1/status/runtimeinfo | jq '.data.storageReten
 
 Follow these steps to extend Prometheus storage retention:
 
-1. Open the ****[Prometheus service](https://signoz.io/guides/cannot-start-prometheus-by-using-systemd/) file. It is usually located at `/etc/systemd/system/prometheus.service`.
+1. Open the \*\*\*\*[Prometheus service](https://signoz.io/guides/cannot-start-prometheus-by-using-systemd/) file. It is usually located at `/etc/systemd/system/prometheus.service`.
 
 ```jsx
-vi /etc/systemd/system/prometheus.service
+vi / etc / systemd / system / prometheus.service
 ```
 
 1. Locate or add the `-storage.tsdb.retention.time` flag.
@@ -212,7 +225,7 @@ If you have Prometheus installed on macOS using Homebrew:
 1. Confirm the location of your `prometheus.yml` file. It is usually located at `/opt/homebrew/etc/prometheus.yml`.
 
 ```jsx
-ls /opt/homebrew/etc/prometheus.yml
+ls / opt / homebrew / etc / prometheus.yml
 ```
 
 1. When starting Prometheus, explicitly state the location of the configuration file and pass in the `--storage.tsdb.retention.time` flag. Set this to your desired retention period.
@@ -244,7 +257,6 @@ services:
     volumes:
       - ./prometheus.yml:/etc/prometheus/prometheus.yml
       - prometheus_data:/prometheus
-
 ```
 
 ## Best Practices for Managing Increased Retention
@@ -303,4 +315,4 @@ With SigNoz, you can:
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics
 
-By leveraging [SigNoz](https://signoz.io/docs/introduction/), you can focus on deriving insights from your monitoring data rather than managing the underlying infrastructure. Whether you choose the cloud offering or the open-source version, SigNoz empowers you to take your monitoring to the next level.
\ No newline at end of file
+By leveraging [SigNoz](https://signoz.io/docs/introduction/), you can focus on deriving insights from your monitoring data rather than managing the underlying infrastructure. Whether you choose the cloud offering or the open-source version, SigNoz empowers you to take your monitoring to the next level.
diff --git a/data/guides/how-to-insert-newline-in-python-logging.mdx b/data/guides/how-to-insert-newline-in-python-logging.mdx
index 78109928a..6f47807a7 100644
--- a/data/guides/how-to-insert-newline-in-python-logging.mdx
+++ b/data/guides/how-to-insert-newline-in-python-logging.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: Python Logging - How to Insert Newlines Correctly
-slug: how-to-insert-newline-in-python-logging
 date: 2024-09-06
 tags: [faq]
 authors: [soumya_gupta]
 description: Learn how to insert newlines in Python logging correctly. Improve log readability, avoid common pitfalls, and explore advanced techniques for effective logging.
-keywords: [Python logging, newline insertion, log formatting, log readability, Python newline, logging best practices]
-
+keywords:
+  [
+    Python logging,
+    newline insertion,
+    log formatting,
+    log readability,
+    Python newline,
+    logging best practices,
+  ]
 ---
 
 Python's logging module is a powerful tool for tracking events and debugging applications. However, formatting logs for optimal readability often requires inserting newlines — a task that can be trickier than it appears. This guide explores various methods to insert newlines in Python logging, from basic techniques to advanced strategies. You'll learn how to enhance log clarity, avoid common pitfalls, and leverage modern logging solutions for improved efficiency.
@@ -21,51 +26,49 @@ A newline, represented by `\n` in Python, is a special character that indicates
 Common challenges when inserting newlines in log messages include:
 
 1. Inconsistent formatting across different handlers: When you use multiple logging handlers, like a `StreamHandler` for console output and a `FileHandler` for file logging, adding newlines in your log messages can sometimes mess with the formatting across these handlers. Because each handler might process the log data differently, you could end up with inconsistent appearances between what you see in the console and what’s written to the log file. For Example:
-    
-    Output in the Console (`StreamHandler`)
-    
-    ```powershell
-    2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - This is a warning message.
-    Details: Unable to connect to the server.
-    ```
-    
-    Output in the Log File (`FileHandler`)
-    
-    ```powershell
-    2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - This is a warning message.
-    2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - Details: Unable to connect to the server.
-    ```
-    
-    In the console, newlines typically work as you’d expect, so your log message appears spread across two lines. But in the log file, things can get tricky. The newline might be interpreted differently, making it look like two separate log entries. This can happen if the file handler or formatter processes newlines in a unique way, possibly causing timestamps to repeat or logs to be split unexpectedly.
-    
+
+   Output in the Console (`StreamHandler`)
+
+   ```powershell
+   2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - This is a warning message.
+   Details: Unable to connect to the server.
+   ```
+
+   Output in the Log File (`FileHandler`)
+
+   ```powershell
+   2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - This is a warning message.
+   2024-08-29 12:18:32,320 - multiHandlerLogger - WARNING - Details: Unable to connect to the server.
+   ```
+
+   In the console, newlines typically work as you’d expect, so your log message appears spread across two lines. But in the log file, things can get tricky. The newline might be interpreted differently, making it look like two separate log entries. This can happen if the file handler or formatter processes newlines in a unique way, possibly causing timestamps to repeat or logs to be split unexpectedly.
+
 2. Unexpected behavior in log rotation: When log messages include newlines, they can make your log file larger than anticipated, which might trigger log rotation sooner than you'd like. This isn't usually a concern for single-line entries, but for multi-line messages, it can cause the log file to become fragmented. This fragmentation can make it tricky to follow and correlate logs across different rotated files.
 3. Improper handling in log parsers: Log parsers are tools or scripts that handle logs to extract, format, or analyze data. When a log message includes newlines, it can throw off the parser’s ability to accurately read the log’s structure, especially if the parser is built for single-line entries. This might result in parsing errors, incorrect data extraction, or even the log message being split into multiple entries.
 4. Multiline Log Aggregation Issues: It's generally best to avoid using newlines in log messages because many log aggregators interpret each new line as a separate entry. This can create issues with how logs are aggregated and displayed. Especially stack traces, they often contain newlines when printed. Ensure these are logged as a single message to avoid breaking them into multiple entries. For example:
-    
-    ```jsx
-    2024–08–29 12:18:32,320 - appLog - WARNING - Request failed with:
-    2024–08–29 12:18:32,348 - appLog - INFO - User login: 986
-    Unable to read from pipe.
-    2024–08–29 12:18:32,485 - appLog - INFO - User logout: 986
-    ```
-    
-    The newline in the `WARNING` log splits the message, making `Unable to read from pipe` appear without a timestamp. This split indicates that the message wasn’t logged as a single entry, which can confuse the log’s sequence, especially when mixed with other messages.
-    
-    To avoid this, we need to ensure that the entire `WARNING` message is logged in one line, keeping all relevant information together and maintaining clear context.
-    
-    ```jsx
-    2024–08–29 12:18:32,320 - appLog - WARNING - Request failed with: Unable to read from pipe.
-    ```
-    
+
+   ```jsx
+   2024–08–29 12:18:32,320 - appLog - WARNING - Request failed with:
+   2024–08–29 12:18:32,348 - appLog - INFO - User login: 986
+   Unable to read from pipe.
+   2024–08–29 12:18:32,485 - appLog - INFO - User logout: 986
+   ```
+
+   The newline in the `WARNING` log splits the message, making `Unable to read from pipe` appear without a timestamp. This split indicates that the message wasn’t logged as a single entry, which can confuse the log’s sequence, especially when mixed with other messages.
+
+   To avoid this, we need to ensure that the entire `WARNING` message is logged in one line, keeping all relevant information together and maintaining clear context.
+
+   ```jsx
+   2024–08–29 12:18:32,320 - appLog - WARNING - Request failed with: Unable to read from pipe.
+   ```
 
 ## Quick Guide: Inserting Newlines in Python Logging
 
 Let's explore some straightforward methods to insert newlines in your Python logs:
 
 1. Using the '\n' escape character:
-    
-    The simplest way to add a newline is by including `\n` in your log message:
-    
+
+   The simplest way to add a newline is by including `\n` in your log message:
 
 ```python
 import logging
@@ -85,10 +88,9 @@ This is line 2.
 
 ```
 
-1. Modifying the `StreamHandler`'s terminator: 
-    
-    You can change the default line ending for a `StreamHandler`:
-    
+1. Modifying the `StreamHandler`'s terminator:
+
+   You can change the default line ending for a `StreamHandler`:
 
 ```python
 import logging
@@ -97,7 +99,7 @@ import sys
 logger = logging.getLogger(__name__)
 handler = logging.StreamHandler(sys.stdout)
 # Double newline
-handler.terminator = "\n\n"  
+handler.terminator = "\n\n"
 logger.addHandler(handler)
 
 logger.setLevel(logging.INFO)
@@ -116,9 +118,8 @@ Message 2
 ```
 
 1. Employing triple quotes for multi-line messages:
-    
-    For complex multi-line messages, use triple quotes:
-    
+
+   For complex multi-line messages, use triple quotes:
 
 ```python
 logger.info("""
@@ -129,9 +130,8 @@ preserved formatting.
 ```
 
 1. Customize Log Format
-    
-    If you want to add newlines between different log entries, you can customize the logging format to append a newline character to the end of each message.
-    
+
+   If you want to add newlines between different log entries, you can customize the logging format to append a newline character to the end of each message.
 
 ```python
 import logging
@@ -156,7 +156,7 @@ This is the second message.
 
 - Use a consistent method throughout your application: A single approach for inserting newlines ensures consistent log output, simplifying parsing and analysis. Whether you modify log messages directly or adjust handler attributes, maintaining consistency helps prevent confusion and errors when interpreting logs.
 - Consider the impact on log parsers and analyzers: Log parsers and analysis tools depend on specific formats and delimiters to extract meaningful data. Adding inconsistent or excessive newlines can disrupt this process, causing misinterpretation or missing log entries. It's important to consider how your newline strategy will impact these downstream tools and to ensure that it doesn’t interfere with the expected log structure.
-- Test logging output across different platforms to ensure consistency:  Newline characters can vary between operating systems such as Windows uses `\r\n`, while Unix-based systems use `\n`. Testing your logging output across different platforms helps catch and fix formatting issues, ensuring that logs are consistent no matter the environment. This cross-platform testing is crucial for applications that run in diverse settings or are distributed to users with different system configurations.
+- Test logging output across different platforms to ensure consistency: Newline characters can vary between operating systems such as Windows uses `\r\n`, while Unix-based systems use `\n`. Testing your logging output across different platforms helps catch and fix formatting issues, ensuring that logs are consistent no matter the environment. This cross-platform testing is crucial for applications that run in diverse settings or are distributed to users with different system configurations.
 - Encrypt sensitive log data: Encrypt logs that contain sensitive information to safeguard against unauthorized access. This practice is crucial for maintaining data confidentiality and integrity. Also ensure that encryption keys are stored securely and are rotated regularly to minimize the risk of compromise.
 - Use role-based access control for log files: Implement role-based access control for log files, ensuring only authorized personnel can view or modify logs based on their assigned roles.
 - Sanitize log entries before storage: To prevent sensitive data exposure, you can sanitize log entries by removing or masking sensitive information like passwords, credit card numbers, and personally identifiable information (PII).
@@ -166,10 +166,9 @@ This is the second message.
 
 For more control over newline insertion, consider these advanced techniques:
 
-1. Customizing log formatters: 
-    
-    Creating a custom log formatter allows you to insert newlines dynamically based on criteria like message content or length. Unlike basic configurations, a custom formatter offers the flexibility to programmatically adjust formatting rules, giving you more control over how your logs is structured.
-    
+1. Customizing log formatters:
+
+   Creating a custom log formatter allows you to insert newlines dynamically based on criteria like message content or length. Unlike basic configurations, a custom formatter offers the flexibility to programmatically adjust formatting rules, giving you more control over how your logs is structured.
 
 ```python
 import logging
@@ -208,7 +207,7 @@ As you can see, `\\n` in the log message is replaced by actual newlines, with ea
 
 1. Implementing newline-aware log handlers
 
-It involves creating a custom log handler to manage newlines in a specific way. This approach is useful when you need to format log output with custom line breaks or delimiters. You can design a custom handler that handles newlines according to your requirements. 
+It involves creating a custom log handler to manage newlines in a specific way. This approach is useful when you need to format log output with custom line breaks or delimiters. You can design a custom handler that handles newlines according to your requirements.
 
 Here’s how you can create such a handler:
 
@@ -283,7 +282,7 @@ log_user_action("Alice", "Login", "IP: 192.168.1.1")
 Output
 
 ```python
-2024-08-29 22:30:38,939 - __main__ - INFO - 
+2024-08-29 22:30:38,939 - __main__ - INFO -
 User Action:
     User: Alice
     Action: Login
@@ -291,9 +290,8 @@ User Action:
 ```
 
 1. Using Super Method with Conditional Formatting
-    
-    Alternatively, you can call the superclass method to handle the basic formatting and then modify the result to insert newlines or other formatting changes as needed. Let’s take an example:
-    
+
+   Alternatively, you can call the superclass method to handle the basic formatting and then modify the result to insert newlines or other formatting changes as needed. Let’s take an example:
 
 ```python
 class MyFormatter(logging.Formatter):
@@ -317,231 +315,217 @@ In this approach, `MyFormatter` uses the superclass's `format` method to generat
 While newlines enhance log readability, they can pose security risks if not handled properly, especially in applications exposed to user inputs. Below are some key threats to keep in mind and common ways to address them:
 
 1. Log injection attacks: Malicious users might inject newlines to manipulate log structure by splitting a log entry into multiple lines thereby making it harder to analyze log information for the purpose of obscuring important information. They can also disrupt log file formats causing errors and preventing proper detection of security incidents. Always sanitize user input before logging. You can also use libraries or functions that escape or remove potentially dangerous characters from user input.
-    
-    ```python
-    def sanitize_input(input_string):
-        # Remove potentially dangerous characters from input
-        return re.sub(r'[\r\n]', '', input_string)
-    ```
-    
+
+   ```python
+   def sanitize_input(input_string):
+       # Remove potentially dangerous characters from input
+       return re.sub(r'[\r\n]', '', input_string)
+   ```
+
 2. Quoting newlines in formatters: Use `repr()` to safely represent strings with newlines, ensuring that log messages are recorded in a safe and predictable format. This method helps to clearly show the presence of newlines and other special characters in your logs. Such as a string with escape sequences would be represented with it as: `'hello\tworld\n"quotes"'`
-    
-    Let’s take an example,
-    
-    ```python
-    import logging
-    
-    class SafeFormatter(logging.Formatter):
-        def format(self, record):
-            # Use repr() to safely represent the log message
-            record.msg = repr(record.msg)
-            return super().format(record)
-    
-    # Create a formatter with the SafeFormatter class
-    formatter = SafeFormatter('%(asctime)s - %(message)s')
-    handler = logging.StreamHandler()
-    handler.setFormatter(formatter)
-    
-    logger = logging.getLogger(__name__)
-    logger.setLevel(logging.INFO)  # Set the log level to INFO
-    logger.addHandler(handler)
-    
-    # Log a message with special characters
-    logger.info("Potentially\nmalicious\nuser input")
-    ```
-    
-    Output:
-    
-    ```powershell
-    2024-09-03 11:56:07,075 - 'Potentially\nmalicious\nuser input'
-    ```
-    
-    Here, `repr()` ensures that newlines and other special characters in log messages are safely represented which might not be immediately visible. This helps prevent logs from being misinterpreted or tampered with, providing a clearer and more secure log output.
-    
+
+   Let’s take an example,
+
+   ```python
+   import logging
+
+   class SafeFormatter(logging.Formatter):
+       def format(self, record):
+           # Use repr() to safely represent the log message
+           record.msg = repr(record.msg)
+           return super().format(record)
+
+   # Create a formatter with the SafeFormatter class
+   formatter = SafeFormatter('%(asctime)s - %(message)s')
+   handler = logging.StreamHandler()
+   handler.setFormatter(formatter)
+
+   logger = logging.getLogger(__name__)
+   logger.setLevel(logging.INFO)  # Set the log level to INFO
+   logger.addHandler(handler)
+
+   # Log a message with special characters
+   logger.info("Potentially\nmalicious\nuser input")
+   ```
+
+   Output:
+
+   ```powershell
+   2024-09-03 11:56:07,075 - 'Potentially\nmalicious\nuser input'
+   ```
+
+   Here, `repr()` ensures that newlines and other special characters in log messages are safely represented which might not be immediately visible. This helps prevent logs from being misinterpreted or tampered with, providing a clearer and more secure log output.
+
 3. Implement safeguards: To enhance security, implement a whitelist approach for characters allowed in log messages, especially when dealing with user-generated content. This strategy helps prevent the logging of harmful or unwanted input that could misuse newline characters. By specifying acceptable character sets and filtering out any non-conforming input, you minimize the risk of log injection and other security issues.
-    
-    ```python
-    def filter_message(message):
-        allowed_characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
-        return ''.join(char for char in message if char in allowed_characters)
-    ```
-    
+
+   ```python
+   def filter_message(message):
+       allowed_characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
+       return ''.join(char for char in message if char in allowed_characters)
+   ```
 
 ## Troubleshooting Newline Issues in Python Logging
 
 Common pitfalls when inserting newlines in logs include:
 
 1. Inconsistent line endings: Different platforms and tools use various line endings such as Unix/Linux uses `\n`, Windows uses `\r\n`, and old Mac systems use `\r`. To ensure consistent line endings across different environments, use `os.linesep`, which aligns with the operating system’s conventions and maintains uniformity in your logs.
-    
-    ```python
-    # Log message with consistent line endings
-    message = f"Line 1{os.linesep}Line 2{os.linesep}Line 3"
-    logger.info(message)
-    ```
-    
-    Output
-    
-    ```python
-    2024-08-29 22:42:25,380 - __main__ - INFO - Line 1
-    Line 2
-    Line 3
-    ```
-    
+
+   ```python
+   # Log message with consistent line endings
+   message = f"Line 1{os.linesep}Line 2{os.linesep}Line 3"
+   logger.info(message)
+   ```
+
+   Output
+
+   ```python
+   2024-08-29 22:42:25,380 - __main__ - INFO - Line 1
+   Line 2
+   Line 3
+   ```
+
 2. Unexpected formatting in log files: Some log rotation tools might not handle multi-line entries correctly. Test your logging setup with your chosen rotation mechanism.
 3. Issues with log parsers: Ensure your [log parsing tools](https://signoz.io/comparisons/log-analysis-tools/) can handle multi-line log entries. This may require configuring regular expressions or developing custom parsers capable of processing log messages that span multiple lines.
 
 ## Debugging Techniques for Newline Issues:
 
 - Use a `logging.Formatter` with `%(message)s` to see raw messages. This formatter displays raw log messages without additional formatting, helping identify issues with newline characters.
-    
-    ```python
-    import logging
-    
-    # Configure logger
-    logger = logging.getLogger(__name__)
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(message)s')  # Use raw message format
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    logger.setLevel(logging.INFO)
-    
-    # Log multi-line message
-    logger.info("Start\nIntermediate\nEnd")
-    
-    ```
-    
-    Output
-    
-    ```python
-    Start
-    Intermediate
-    End
-    ```
-    
+  ```python
+  import logging
+
+  # Configure logger
+  logger = logging.getLogger(__name__)
+  handler = logging.StreamHandler()
+  formatter = logging.Formatter('%(message)s')  # Use raw message format
+  handler.setFormatter(formatter)
+  logger.addHandler(handler)
+  logger.setLevel(logging.INFO)
+
+  # Log multi-line message
+  logger.info("Start\nIntermediate\nEnd")
+
+  ```
+  Output
+  ```python
+  Start
+  Intermediate
+  End
+  ```
 - Inspect log files with a hex editor to identify hidden characters. By using a hex editor, you can see the exact byte representation of log files, which is useful for spotting hidden characters or unexpected byte sequences that might affect how newlines are handled. This technique helps diagnose issues related to unusual characters or formatting. To use a hex editor, follow the mentioned steps:
-    - Select a Hex Editor best suited for your system
-        - Windows: <a href="https://hxd.en.lo4d.com/windows" rel="noopener noreferrer nofollow" target="_blank">HxD</a>
-        - Mac: <a href="https://hexfiend.com/" rel="noopener noreferrer nofollow" target="_blank">Hex Fiend</a>
-        - Linux: <a href="https://github.com/afrantzis/bless" rel="noopener noreferrer nofollow" target="_blank">Bless</a>
-    - Open your log file in the hex editor, the file will be displayed as a series of hexadecimal values in the `hexadecimal view` pane alongside their `ASCII` representation in the `ASCII view` pane. Each byte would be represented by a set of hexadecimal digits
-    - Analyze the sequence of bytes that might highlight problems with newline handling where newline characters are represented according to the type of system such as `0A` in Unix/Linux, `0D` in Mac systems and `0D0A` in Windows. Here `0A` represents line feed and `0D` represents carriage return.
-    - Edit the file accordingly to resolve issues and save after changes are made.
+  - Select a Hex Editor best suited for your system
+    - Windows: <a href="https://hxd.en.lo4d.com/windows" rel="noopener noreferrer nofollow" target="_blank">HxD</a>
+    - Mac: <a href="https://hexfiend.com/" rel="noopener noreferrer nofollow" target="_blank">Hex Fiend</a>
+    - Linux: <a href="https://github.com/afrantzis/bless" rel="noopener noreferrer nofollow" target="_blank">Bless</a>
+  - Open your log file in the hex editor, the file will be displayed as a series of hexadecimal values in the `hexadecimal view` pane alongside their `ASCII` representation in the `ASCII view` pane. Each byte would be represented by a set of hexadecimal digits
+  - Analyze the sequence of bytes that might highlight problems with newline handling where newline characters are represented according to the type of system such as `0A` in Unix/Linux, `0D` in Mac systems and `0D0A` in Windows. Here `0A` represents line feed and `0D` represents carriage return.
+  - Edit the file accordingly to resolve issues and save after changes are made.
 - Test logging on different platforms to ensure consistency.
-    
-    ```python
-    import logging
-    import os
-    
-    # Configure logger
-    logger = logging.getLogger(__name__)
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    logger.setLevel(logging.INFO)
-    
-    # Log message with platform-specific line endings
-    message = f"Log entry on {os.name}\nLine 1{os.linesep}Line 2"
-    logger.info(message)
-    
-    ```
-    
-    This ensures that logs are formatted correctly across different operating systems, which is essential for maintaining consistent logging behavior.
-    
-    Output
-    
-    ```python
-    2024-08-29 22:59:25,870 - __main__ - INFO - Log entry on nt
-    Line 1
-    Line 2
-    ```
-    
+  ```python
+  import logging
+  import os
+
+  # Configure logger
+  logger = logging.getLogger(__name__)
+  handler = logging.StreamHandler()
+  formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+  handler.setFormatter(formatter)
+  logger.addHandler(handler)
+  logger.setLevel(logging.INFO)
+
+  # Log message with platform-specific line endings
+  message = f"Log entry on {os.name}\nLine 1{os.linesep}Line 2"
+  logger.info(message)
+
+  ```
+  This ensures that logs are formatted correctly across different operating systems, which is essential for maintaining consistent logging behavior.
+  Output
+  ```python
+  2024-08-29 22:59:25,870 - __main__ - INFO - Log entry on nt
+  Line 1
+  Line 2
+  ```
 
 ## Eliminating Newlines in Python Logging
 
-During logging in python when we capture error messages from modules like requests, newline characters can sometimes sneak into your logs, cluttering the output and making it harder to read or parse. Let’s take a look at different ways by which we can eliminate newlines in python logging: 
+During logging in python when we capture error messages from modules like requests, newline characters can sometimes sneak into your logs, cluttering the output and making it harder to read or parse. Let’s take a look at different ways by which we can eliminate newlines in python logging:
+
+1.  Using `str.replace()`
 
-1. Using `str.replace()`
-    
     One approach is to explicitly replace newline characters with spaces, ensuring that your logs remain on a single line.
-    
+
     ```python
     logger.error(
         "There was a problem importing the uploaded file: "
         f"{response.text}".replace("\n", " ")
     )
     ```
-    
+
     The `str.replace("\n", " ")` ensures that all newline characters in the error message are replaced with spaces, keeping the log entry compact and readable. However, doing this repeatedly can make your code less clean and harder to maintain.
-    
-2. Using `str.strip()`
-If the newlines are only at the beginning or end of the log message, you could use the `strip()` method: 
-    
-    ```python
-    logger.error(
-        "There was a problem importing the uploaded file: "
-        f"{response.text.strip()}"
-    )
-    ```
-    
-    This method trims any leading or trailing whitespace, including newlines, but won’t remove newlines within the text itself.
-    
-3. Custom Logging Formatter
-    
+
+2.  Using `str.strip()`
+    If the newlines are only at the beginning or end of the log message, you could use the `strip()` method:
+        ```python
+        logger.error(
+            "There was a problem importing the uploaded file: "
+            f"{response.text.strip()}"
+        )
+        ```
+
+        This method trims any leading or trailing whitespace, including newlines, but won’t remove newlines within the text itself.
+3.  Custom Logging Formatter
+
     We can also use a custom [logging formatter](https://signoz.io/guides/what-is-pythons-default-logging-formatter/#example-of-a-simple-logging-formatter) that automatically strips or replaces newlines in every log message. Let’s take an example:
-    
+
     ```python
     import logging
-    
+
     class SingleLineFormatter(logging.Formatter):
         def format(self, record):
             original = super().format(record)
             return original.replace("\n", " ")
-    
+
     handler = logging.StreamHandler()
     handler.setFormatter(SingleLineFormatter())
     logger = logging.getLogger()
     logger.addHandler(handler)
     logger.setLevel(logging.ERROR)
-    
+
     logger.error("There was a problem importing the uploaded file: "
                  f"{response.text}")
     ```
-    
+
     In this example, the `SingleLineFormatter` ensures that every log message has its newline characters replaced with spaces. This approach centralizes the newline handling, making your logging cleaner and less repetitive.
-    
-4. Modifying `handler.terminator`
-You can set the `terminator` attribute of a `StreamHandler` to an empty string for preventing newlines from being added at the end of log messages. 
-    
-    ```python
-    handler = logging.StreamHandler()
-    handler.terminator = ""
-    ```
-    
-    This method can be useful if you want to keep your log output on a single line but still allow for newlines within the message body.
-    
+
+4.  Modifying `handler.terminator`
+    You can set the `terminator` attribute of a `StreamHandler` to an empty string for preventing newlines from being added at the end of log messages.
+        ```python
+        handler = logging.StreamHandler()
+        handler.terminator = ""
+        ```
+
+        This method can be useful if you want to keep your log output on a single line but still allow for newlines within the message body.
 
 ## Optimizing Log Readability with Strategic Newline Usage
 
 Strategic use of newlines can significantly improve log readability:
 
 1. Design log formats leveraging newlines: Structuring log messages with newlines can help organize detailed information, making logs more readable and easier to parse.
-    
-    ```python
-    logger.info(f"""
-    Transaction Details:
-    ID: {transaction_id}
-    Amount: ${amount:.2f}
-    Status: {status}
-    """)
-    ```
-    
+
+   ```python
+   logger.info(f"""
+   Transaction Details:
+   ID: {transaction_id}
+   Amount: ${amount:.2f}
+   Status: {status}
+   """)
+   ```
+
 2. Balance verbosity and conciseness:
-    - Use newlines to separate logical sections of complex log messages. For system health checks or other intricate logs, newlines effectively delineate different sections, enhancing readability.
-    - Avoid overusing newlines for simple, single-line logs. For straightforward entries, such as system start-up messages, extra newlines are unnecessary and may clutter the output.
+   - Use newlines to separate logical sections of complex log messages. For system health checks or other intricate logs, newlines effectively delineate different sections, enhancing readability.
+   - Avoid overusing newlines for simple, single-line logs. For straightforward entries, such as system start-up messages, extra newlines are unnecessary and may clutter the output.
 3. Implement log rotation with newline consideration:
-    - Ensure your log rotation tool respects multi-line entries.
-    - Consider using a custom log rotator that understands your newline usage.
+   - Ensure your log rotation tool respects multi-line entries.
+   - Consider using a custom log rotator that understands your newline usage.
 
 ## Enhancing Logging with SigNoz: A Modern Approach
 
@@ -549,7 +533,11 @@ While traditional Python logging methods offer flexibility, modern solutions lik
 
 SigNoz is an open-source APM (Application Performance Monitoring) tool that offers comprehensive logging and monitoring capabilities. It handles newlines and log formatting seamlessly, providing a user-friendly interface for log analysis.
 
-<Figure src="/img/guides/2024/09/how-to-insert-newline-in-python-logging-image.webp" alt="Logging in SigNoz" caption="Logging in SigNoz" /> 
+<Figure
+  src="/img/guides/2024/09/how-to-insert-newline-in-python-logging-image.webp"
+  alt="Logging in SigNoz"
+  caption="Logging in SigNoz"
+/>{' '}
 
 Key benefits of using SigNoz for logging:
 
@@ -577,22 +565,21 @@ By leveraging SigNoz, you can focus on writing meaningful log messages without w
 To add a newline between log messages, you can either:
 
 1. Modify the `StreamHandler`'s terminator:
-    
-    ```python
-    handler = logging.StreamHandler()
-    handler.terminator = '\\n\\n'
-    
-    ```
-    
+
+   ```python
+   handler = logging.StreamHandler()
+   handler.terminator = '\\n\\n'
+
+   ```
+
 2. Use a custom formatter that adds an extra newline:
-    
-    ```python
-    class DoubleNewlineFormatter(logging.Formatter):
-        def format(self, record):
-            return super().format(record) + '\\n'
-    
-    ```
-    
+
+   ```python
+   class DoubleNewlineFormatter(logging.Formatter):
+       def format(self, record):
+           return super().format(record) + '\\n'
+
+   ```
 
 ### Can newlines in log messages pose security risks?
 
@@ -643,4 +630,4 @@ SigNoz enhances traditional Python logging in several ways:
 4. Visualization: Provides intuitive dashboards for log analysis
 5. Alerting: Enables setting up alerts based on log patterns or anomalies
 
-These features allow developers to gain deeper insights from their logs and troubleshoot issues more efficiently compared to traditional logging methods.
\ No newline at end of file
+These features allow developers to gain deeper insights from their logs and troubleshoot issues more efficiently compared to traditional logging methods.
diff --git a/data/guides/how-to-install-prometheus-and-grafana-on-docker.mdx b/data/guides/how-to-install-prometheus-and-grafana-on-docker.mdx
index 2c5e26359..d550ba6be 100644
--- a/data/guides/how-to-install-prometheus-and-grafana-on-docker.mdx
+++ b/data/guides/how-to-install-prometheus-and-grafana-on-docker.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Set Up Prometheus and Grafana on Docker - A Guide
-slug: how-to-install-prometheus-and-grafana-on-docker
 date: 2025-06-09
 tags: [prometheus, grafana, docker, monitoring, containerization, metrics, visualization]
 authors: [adil_shaikh, ankit_anand]
 description: Learn how to install Prometheus and Grafana on Docker with this comprehensive guide. Step-by-step instructions for setup, configuration, and monitoring.
-keywords: [Prometheus, Grafana, Docker, monitoring, installation, containerization, metrics, visualization]
-
+keywords:
+  [Prometheus, Grafana, Docker, monitoring, installation, containerization, metrics, visualization]
 ---
 
 Monitoring containerized environments effectively is crucial for debugging, capacity planning, and maintaining uptime. In this guide, we'll walk through a hands-on setup of Prometheus and Grafana entirely on Docker, ideal for local development, POCs, or staging environments, no Kubernetes required.
@@ -17,21 +15,20 @@ Monitoring containerized environments effectively is crucial for debugging, capa
 Docker simplifies and secures the deployment of Prometheus and Grafana with these key benefits:
 
 1. **Isolation & Security**
-    
-    Containers provide process isolation via namespaces and cgroups. Combined with Docker's security features like seccomp and read-only filesystems, this reduces risk and surface area for attacks.
-    
+
+   Containers provide process isolation via namespaces and cgroups. Combined with Docker's security features like seccomp and read-only filesystems, this reduces risk and surface area for attacks.
+
 2. **Persistent Storage**
-    
-    Docker volumes retain Prometheus TSDB data and Grafana configs across restarts, ensuring observability data isn’t lost during container lifecycle events.
-    
+
+   Docker volumes retain Prometheus TSDB data and Grafana configs across restarts, ensuring observability data isn’t lost during container lifecycle events.
+
 3. **Network Control**
-    
-    Docker networks (bridge, overlay) enable secure, isolated communication. Port mapping and firewall rules limit external exposure (e.g., 9090, 3000), enhancing security.
-    
+
+   Docker networks (bridge, overlay) enable secure, isolated communication. Port mapping and firewall rules limit external exposure (e.g., 9090, 3000), enhancing security.
+
 4. **Environment Consistency**
-    
-    Docker guarantees consistent behavior across dev, staging, and prod, eliminating environment drift and simplifying debugging.
-    
+
+   Docker guarantees consistent behavior across dev, staging, and prod, eliminating environment drift and simplifying debugging.
 
 ## Prerequisites for Installing Prometheus and Grafana on Docker
 
@@ -47,77 +44,85 @@ Before setting up, ensure the following prerequisites are met to avoid compatibi
 Prometheus is a robust monitoring and alerting system, and Docker makes it easy to deploy and manage. Follow these steps to containerize Prometheus using Docker Compose.
 
 1. **Create a Dedicated Docker Network**
-    
-    Create a user-defined bridge network for Prometheus and Grafana to enable container-to-container communication without exposing internal ports externally.
-    
-    ```jsx
-    docker network create monitoring
-    ```
-    
-    <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image.webp" alt="command: docker network ls" caption="command: docker network ls" />
-    
+
+   Create a user-defined bridge network for Prometheus and Grafana to enable container-to-container communication without exposing internal ports externally.
+
+   ```jsx
+   docker network create monitoring
+   ```
+
+   <Figure
+     src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image.webp"
+     alt="command: docker network ls"
+     caption="command: docker network ls"
+   />
+
 2. **Create a [Prometheus Configuration](https://signoz.io/guides/what-is-prometheus-target/) File**
-    
-    Define scrape settings and specify the Prometheus server itself as a target in a file named `prometheus.yml`:
-    
-    ```
-    global:
-      scrape_interval: 15s  # Frequency of metric scraping
-    
-    scrape_configs:
-      - job_name: 'prometheus'
-        static_configs:
-          - targets: ['localhost:9090']
-    ```
-    
-    📌 *This configuration tells Prometheus to scrape metrics from itself every 15 seconds.*
-    
+
+   Define scrape settings and specify the Prometheus server itself as a target in a file named `prometheus.yml`:
+
+   ```
+   global:
+     scrape_interval: 15s  # Frequency of metric scraping
+
+   scrape_configs:
+     - job_name: 'prometheus'
+       static_configs:
+         - targets: ['localhost:9090']
+   ```
+
+   📌 _This configuration tells Prometheus to scrape metrics from itself every 15 seconds._
+
 3. **Create a Docker Compose File**
-    
-    Define the Prometheus container setup in `docker-compose.yml`. Pin the image version for stability and map the configuration file as a volume.
-    
-    ```jsx
-    version: '3.8'
-    
-    services:
-      prometheus:
-        image: prom/prometheus:v2.52.0
-        container_name: prometheus
-        ports:
-          - "9090:9090"
-        volumes:
-          - ./prometheus.yml:/etc/prometheus/prometheus.yml
-        networks:
-          - monitoring
-        restart: unless-stopped
-    
-    networks:
-      monitoring:
-        external: true
-    ```
-    
-    📝 *Using `restart: unless-stopped` ensures Prometheus restarts automatically if it crashes or the system reboots.*
-    
+
+   Define the Prometheus container setup in `docker-compose.yml`. Pin the image version for stability and map the configuration file as a volume.
+
+   ```jsx
+   version: '3.8'
+
+   services:
+     prometheus:
+       image: prom/prometheus:v2.52.0
+       container_name: prometheus
+       ports:
+         - "9090:9090"
+       volumes:
+         - ./prometheus.yml:/etc/prometheus/prometheus.yml
+       networks:
+         - monitoring
+       restart: unless-stopped
+
+   networks:
+     monitoring:
+       external: true
+   ```
+
+   📝 _Using `restart: unless-stopped` ensures Prometheus restarts automatically if it crashes or the system reboots._
+
 4. **Launch Prometheus**
-    
-    Start the service in detached mode:
-    
-    ```jsx
-    docker-compose up -d
-    ```
-    
+
+   Start the service in detached mode:
+
+   ```jsx
+   docker-compose up -d
+   ```
+
 5. **Verify Prometheus is Running**
-    
-    Check if the container is active:
-    
-    ```
-    docker ps
-    ```
-    
-    You should see the `prometheus` container listed and listening on port `9090`.
-    
-    <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%201.webp" alt="command: docker ps" caption="command: docker ps" />
-    
+
+   Check if the container is active:
+
+   ```
+   docker ps
+   ```
+
+   You should see the `prometheus` container listed and listening on port `9090`.
+
+   <Figure
+     src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%201.webp"
+     alt="command: docker ps"
+     caption="command: docker ps"
+   />
+
 6. **Access the Prometheus UI**
 
 Navigate to `http://localhost:9090` in your browser. You should see the Prometheus web interface.
@@ -127,11 +132,9 @@ Navigate to `http://localhost:9090` in your browser. You should see the Promethe
 If Prometheus doesn't start:
 
 - Check logs:
-    
-    ```bash
-    docker-compose logs prometheus
-    ```
-    
+  ```bash
+  docker-compose logs prometheus
+  ```
 - Ensure the config file path and syntax are correct.
 - Confirm port `9090` is not in use.
 
@@ -140,137 +143,156 @@ If Prometheus doesn't start:
 To monitor your services, Prometheus must know where to pull metrics from. This is done by defining scrape jobs in the configuration file.
 
 1. **Add a New Scrape Job to `prometheus.yml`**
-    
-    Each job in Prometheus represents a set of targets that expose metrics. Update your configuration file to include your app:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'my-app'  # Descriptive name for the service
-        static_configs:
-          - targets: ['app-host:8000']  # Replace with container name or IP and port
-    ```
-    
-    📌 *Ensure `app-host` is resolvable from within the Prometheus container—use a Docker service name or internal container name if they're on the same network.*
-    
-    💡 *You can also customize the scrape interval per job:*
-    
-    ```yaml
-    scrape_interval: 10s
-    scrape_timeout: 5s
-    ```
-    
+
+   Each job in Prometheus represents a set of targets that expose metrics. Update your configuration file to include your app:
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'my-app' # Descriptive name for the service
+       static_configs:
+         - targets: ['app-host:8000'] # Replace with container name or IP and port
+   ```
+
+   📌 _Ensure `app-host` is resolvable from within the Prometheus container—use a Docker service name or internal container name if they're on the same network._
+
+   💡 _You can also customize the scrape interval per job:_
+
+   ```yaml
+   scrape_interval: 10s
+   scrape_timeout: 5s
+   ```
+
 2. **Restart Prometheus to Apply the New Configuration**
-    
-    Use Docker Compose to reload the updated configuration:
-    
-    ```bash
-    docker-compose restart prometheus
-    ```
-    
-    🔍 *Alternatively, use `docker exec` to test the config before restarting:*
-    
-    ```bash
-    docker exec -it prometheus promtool check config /etc/prometheus/prometheus.yml
-    ```
-    
+
+   Use Docker Compose to reload the updated configuration:
+
+   ```bash
+   docker-compose restart prometheus
+   ```
+
+   🔍 _Alternatively, use `docker exec` to test the config before restarting:_
+
+   ```bash
+   docker exec -it prometheus promtool check config /etc/prometheus/prometheus.yml
+   ```
+
 3. **Verify Metric Collection in the Prometheus UI**
-    - Open: <a href="http://localhost:9090/" rel="noopener noreferrer nofollow" target="_blank">http://localhost:9090</a>
-    - Go to **Status → Targets** to ensure your new job appears and is marked as **UP**
-    - Use the **Graph** tab to query example metrics, such as:
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%202.webp" alt="Prometheus graph using PromQL Query" caption="Prometheus graph using PromQL Query" />
-        
+   - Open: <a href="http://localhost:9090/" rel="noopener noreferrer nofollow" target="_blank">http://localhost:9090</a>
+   - Go to **Status → Targets** to ensure your new job appears and is marked as **UP**
+   - Use the **Graph** tab to query example metrics, such as:
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%202.webp"
+       alt="Prometheus graph using PromQL Query"
+       caption="Prometheus graph using PromQL Query"
+     />
 
 ## Installing Grafana on Docker
 
 Grafana is a powerful visualization tool that complements Prometheus by turning raw metrics into insightful dashboards. By containerizing Grafana with Docker, you can easily manage, deploy, and persist your monitoring setup alongside Prometheus.
 
 1. **Update Your `docker-compose.yml` to Include Grafana**
-    
-    Update your Docker Compose file to include Grafana as a service. This setup ensures persistent storage, environment configuration, and seamless integration with your monitoring network:
-    
-    ```yaml
-    version: '3.8'
-    
-    services:
-      prometheus:
-        image: prom/prometheus:v2.52.0
-        # ... existing Prometheus config
-    
-      grafana:
-        image: grafana/grafana:10.2.2
-        container_name: grafana
-        ports:
-          - "3000:3000"
-        environment:
-          - GF_SECURITY_ADMIN_PASSWORD=your_password
-        volumes:
-          - grafana-storage:/var/lib/grafana
-        networks:
-          - monitoring
-        restart: unless-stopped
-    
-    volumes:
-      grafana-storage:
-    
-    networks:
-      monitoring:
-        external: true
-    ```
-    
-    📌 *Using a named volume ensures Grafana persists dashboards and data sources across container restarts.*
-    
+
+   Update your Docker Compose file to include Grafana as a service. This setup ensures persistent storage, environment configuration, and seamless integration with your monitoring network:
+
+   ```yaml
+   version: '3.8'
+
+   services:
+     prometheus:
+       image: prom/prometheus:v2.52.0
+       # ... existing Prometheus config
+
+     grafana:
+       image: grafana/grafana:10.2.2
+       container_name: grafana
+       ports:
+         - '3000:3000'
+       environment:
+         - GF_SECURITY_ADMIN_PASSWORD=your_password
+       volumes:
+         - grafana-storage:/var/lib/grafana
+       networks:
+         - monitoring
+       restart: unless-stopped
+
+   volumes:
+     grafana-storage:
+
+   networks:
+     monitoring:
+       external: true
+   ```
+
+   📌 _Using a named volume ensures Grafana persists dashboards and data sources across container restarts._
+
 2. **Launch Grafana**
-    
-    Run the following command to bring up the updated stack:
-    
-    ```bash
-    docker-compose up -d
-    ```
-    
-    <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%203.webp" alt="Command: docker-compose up -d" caption="Command: docker-compose up -d" />
-    
-    Once running, access the web interface at:
-    
-    ➡️ <a href="http://localhost:3000/" rel="noopener noreferrer nofollow" target="_blank">**http://localhost:3000**</a>
-    
+
+   Run the following command to bring up the updated stack:
+
+   ```bash
+   docker-compose up -d
+   ```
+
+   <Figure
+     src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%203.webp"
+     alt="Command: docker-compose up -d"
+     caption="Command: docker-compose up -d"
+   />
+
+   Once running, access the web interface at:
+
+   ➡️ <a href="http://localhost:3000/" rel="noopener noreferrer nofollow" target="_blank">**http://localhost:3000**</a>
 
 ## Connecting Grafana to Prometheus
 
 To visualize [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) effectively in Grafana, the first step is to establish a connection between the two. This involves configuring Prometheus as a data source and building a dashboard to display meaningful insights.
 
 1. **Set up Prometheus as a Data Source in Grafana**
-    - Navigate to Connections → Data Sources → Add data source in the left side panel.
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%204.webp" alt="Adding a data source in Grafana" caption="Adding a data source in Grafana" />
-        
-    - Enter the **Prometheus server URL** in the configuration field.
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%205.webp" alt="Enter Prometheus server URL in the config field" caption="Enter Prometheus server URL in the config field" />
-        
-    - Configure authentication settings (if required).
-    - Click "**Save & Test**" to verify the connection
+   - Navigate to Connections → Data Sources → Add data source in the left side panel.
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%204.webp"
+       alt="Adding a data source in Grafana"
+       caption="Adding a data source in Grafana"
+     />
+   - Enter the **Prometheus server URL** in the configuration field.
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%205.webp"
+       alt="Enter Prometheus server URL in the config field"
+       caption="Enter Prometheus server URL in the config field"
+     />
+   - Configure authentication settings (if required).
+   - Click "**Save & Test**" to verify the connection
 2. **Create a New Dashboard and Panel**
-    - Navigate to **Dashboards** → **New Dashboard** → Click on the **Add Visualization** button
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%206.webp" alt="Create a new dashboard and add a visualization" caption="Create a new dashboard and add a visualization" />
-        
-    - Select **Prometheus** from the data source dropdown
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%207.webp" alt="Select Prometheus as the data source" caption="Select Prometheus as the data source" />
-        
-    - Choose the appropriate visualization type
+   - Navigate to **Dashboards** → **New Dashboard** → Click on the **Add Visualization** button
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%206.webp"
+       alt="Create a new dashboard and add a visualization"
+       caption="Create a new dashboard and add a visualization"
+     />
+   - Select **Prometheus** from the data source dropdown
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image%207.webp"
+       alt="Select Prometheus as the data source"
+       caption="Select Prometheus as the data source"
+     />
+   - Choose the appropriate visualization type
 3. **Input Your PromQL Expression**
-    - In the query editor, enter your metric division expression. For example, to calculate CPU usage for each core:
-        
-        ```
-        100 - (rate(node_cpu_seconds_total{mode="idle"}[5m]) * 100
-        ```
-        
-        This query breaks down CPU usage for each core individually, showing how much time each core is spending on active tasks over a 5-minute interval.
-        
-        <Figure src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image_(6).webp" alt="PromQL expression for CPU usage" caption="PromQL expression for CPU usage" />
-        
+   - In the query editor, enter your metric division expression. For example, to calculate CPU usage for each core:
+     ```
+     100 - (rate(node_cpu_seconds_total{mode="idle"}[5m]) * 100
+     ```
+     This query breaks down CPU usage for each core individually, showing how much time each core is spending on active tasks over a 5-minute interval.
+     {' '}
+     <Figure
+       src="/img/guides/2025/06/how-to-install-prometheus-and-grafana-on-docker-image_(6).webp"
+       alt="PromQL expression for CPU usage"
+       caption="PromQL expression for CPU usage"
+     />
 
 ## Monitoring Docker with cAdvisor
 
@@ -284,70 +306,68 @@ While Prometheus is excellent at scraping and storing metrics, it needs exporter
 This makes cAdvisor an essential tool for gaining **container-level observability**, especially when you're working with microservices or multiple Docker containers.
 
 1. **Add cAdvisor to Your `docker-compose.yml`:**
-    
-    Add the following service to your existing Docker Compose setup:
-    
-    ```yaml
-    cadvisor:
-        image: gcr.io/cadvisor/cadvisor:v0.47.2
-        container_name: cadvisor
-        ports:
-          - "8080:8080"
-        volumes:
-          - /:/rootfs:ro
-          - /var/run:/var/run:ro
-          - /sys:/sys:ro
-          - /var/lib/docker/:/var/lib/docker:ro
-          - /var/run/docker.sock:/var/run/docker.sock:ro  # Only needed on Docker Desktop for Mac
-        networks:
-          - monitoring
-        restart: unless-stopped
-    
-    ```
-    
-    📝 *cAdvisor provides insights like memory, CPU, and network usage for each container.*
-    
+
+   Add the following service to your existing Docker Compose setup:
+
+   ```yaml
+   cadvisor:
+     image: gcr.io/cadvisor/cadvisor:v0.47.2
+     container_name: cadvisor
+     ports:
+       - '8080:8080'
+     volumes:
+       - /:/rootfs:ro
+       - /var/run:/var/run:ro
+       - /sys:/sys:ro
+       - /var/lib/docker/:/var/lib/docker:ro
+       - /var/run/docker.sock:/var/run/docker.sock:ro # Only needed on Docker Desktop for Mac
+     networks:
+       - monitoring
+     restart: unless-stopped
+   ```
+
+   📝 _cAdvisor provides insights like memory, CPU, and network usage for each container._
+
 2. **Update `prometheus.yml` to Scrape cAdvisor**
-    
-    Now that cAdvisor is part of your stack, configure Prometheus to collect metrics from it:
-    
-    ```yaml
-    scrape_configs:
-      - job_name: 'cadvisor'
-        static_configs:
-          - targets: ['cadvisor:8080']
-    ```
-    
+
+   Now that cAdvisor is part of your stack, configure Prometheus to collect metrics from it:
+
+   ```yaml
+   scrape_configs:
+     - job_name: 'cadvisor'
+       static_configs:
+         - targets: ['cadvisor:8080']
+   ```
+
 3. **Restart the Stack**
-    
-    Apply your changes and restart the Docker stack:
-    
-    ```bash
-    docker-compose up -d
-    ```
-    
-    Once it's up and running, you’ll start seeing per-container metrics in Prometheus and can visualize them in Grafana for deeper analysis.
-    
+
+   Apply your changes and restart the Docker stack:
+
+   ```bash
+   docker-compose up -d
+   ```
+
+   Once it's up and running, you’ll start seeing per-container metrics in Prometheus and can visualize them in Grafana for deeper analysis.
 
 ## Best Practices and Optimization
 
 To maximize performance, reliability, and security in your monitoring setup:
 
 - **Secure your stack**:
-    - Enable authentication for both Prometheus and Grafana.
-    - Serve both tools behind a reverse proxy with HTTPS (e.g., Nginx + Let's Encrypt).
-    - Use network policies or firewalls to restrict access to monitoring ports.
+  - Enable authentication for both Prometheus and Grafana.
+  - Serve both tools behind a reverse proxy with HTTPS (e.g., Nginx + Let's Encrypt).
+  - Use network policies or firewalls to restrict access to monitoring ports.
 - **Optimize storage**:
-    - Configure Prometheus's `-storage.tsdb.retention.time` to limit historical data retention based on your storage capacity.
-    - Regularly clean up unused dashboards or data sources in Grafana.
+  - Configure Prometheus's `-storage.tsdb.retention.time` to limit historical data retention based on your storage capacity.
+  - Regularly clean up unused dashboards or data sources in Grafana.
 - **Alert proactively**:
-    - Define alerting rules in Prometheus and route them using Alertmanager.
-    - Integrate alerts with tools like Slack, PagerDuty, or email.
-    - Use Grafana's alerting engine for panel-based threshold alerts.
+  - Define alerting rules in Prometheus and route them using Alertmanager.
+  - Integrate alerts with tools like Slack, PagerDuty, or email.
+  - Use Grafana's alerting engine for panel-based threshold alerts.
 - **Maintain your stack**:
-    - Pin image versions to avoid unexpected changes (`grafana/grafana:10.2.2`, `prom/prometheus:v2.52.0`).
-    - Monitor Prometheus's own metrics (e.g., `prometheus_tsdb_head_series`) to detect performance bottlenecks.
-    - Backup volumes (`prometheus-data`, `grafana-storage`) regularly.
+  - Pin image versions to avoid unexpected changes (`grafana/grafana:10.2.2`, `prom/prometheus:v2.52.0`).
+  - Monitor Prometheus's own metrics (e.g., `prometheus_tsdb_head_series`) to detect performance bottlenecks.
+  - Backup volumes (`prometheus-data`, `grafana-storage`) regularly.
 
 ## Key Takeaways
 
@@ -386,12 +406,12 @@ Yes. Prometheus can scrape metrics from:
 
 ### What are common setup issues and their solutions?
 
-| Issue | Solution |
-| --- | --- |
-| Prometheus can’t scrape metrics | Verify targets in `prometheus.yml` and container DNS |
+| Issue                               | Solution                                              |
+| ----------------------------------- | ----------------------------------------------------- |
+| Prometheus can’t scrape metrics     | Verify targets in `prometheus.yml` and container DNS  |
 | Grafana can’t connect to Prometheus | Check `http://prometheus:9090` URL and Docker network |
-| High memory usage | Tune scrape intervals and retention time |
-| Dashboard data is missing | Ensure correct time range and valid PromQL queries |
+| High memory usage                   | Tune scrape intervals and retention time              |
+| Dashboard data is missing           | Ensure correct time range and valid PromQL queries    |
 
 ## Visualizing Prometheus Metrics with SigNoz
 
@@ -415,4 +435,4 @@ cd signoz/deploy/docker
 docker-compose up -d
 ```
 
-Once running, access the UI at `http://localhost:8080`.
\ No newline at end of file
+Once running, access the UI at `http://localhost:8080`.
diff --git a/data/guides/how-to-install-prometheus-and-grafana-on-kubernetes.mdx b/data/guides/how-to-install-prometheus-and-grafana-on-kubernetes.mdx
index 61e65d261..d48e12707 100644
--- a/data/guides/how-to-install-prometheus-and-grafana-on-kubernetes.mdx
+++ b/data/guides/how-to-install-prometheus-and-grafana-on-kubernetes.mdx
@@ -1,199 +1,214 @@
 ---
-
 title: How to Install Prometheus and Grafana on Kubernetes with Helm
-slug: how-to-install-prometheus-and-grafana-on-kubernetes
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Learn how to install Prometheus and Grafana on Kubernetes using Helm. Follow our step-by-step guide for efficient monitoring and visualization.
-keywords: [Kubernetes monitoring, Prometheus installation, Grafana setup, Helm charts, container orchestration, metrics visualization, Kubernetes observability]
-
+keywords:
+  [
+    Kubernetes monitoring,
+    Prometheus installation,
+    Grafana setup,
+    Helm charts,
+    container orchestration,
+    metrics visualization,
+    Kubernetes observability,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Install Prometheus and Grafana on Kubernetes with Helm",
-    "alternativeHeadline": "Step-by-Step Guide to Install Prometheus and Grafana on Kubernetes Using Helm",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-install-prometheus-and-grafana-on-kubernetes/"
-    },
-    "description": "Learn how to install Prometheus and Grafana on Kubernetes using Helm. Follow our step-by-step guide for efficient monitoring and visualization.",
-    "keywords": "Kubernetes monitoring, Prometheus installation, Grafana setup, Helm charts, container orchestration, metrics visualization, Kubernetes observability",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Kubernetes Monitoring",
-        "description": "The process of tracking and analyzing the performance of Kubernetes clusters to ensure optimal performance and reliability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Grafana",
-        "description": "An open-source platform for monitoring and observability, used for visualizing time series data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Helm Charts",
-        "description": "A package manager for Kubernetes that simplifies the deployment and management of applications."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Helm",
-        "applicationCategory": "Package Manager"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Kubernetes",
-        "applicationCategory": "Container Orchestration"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What are the system requirements for running Prometheus and Grafana on Kubernetes?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The requirements depend on your cluster size and monitoring needs. Generally, start with at least 2 CPU cores and 4GB RAM for each tool, scaling as necessary."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can I use Prometheus and Grafana for monitoring non-Kubernetes workloads?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, both tools can monitor various systems. Use exporters to collect metrics from non-Kubernetes sources and visualize them in Grafana."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I update Prometheus and Grafana installed via Helm?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use `helm upgrade` with the latest chart version:\n\n```\nhelm upgrade prometheus prometheus-community/prometheus\nhelm upgrade grafana grafana/grafana\n```\n"
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What are some alternatives to Prometheus and Grafana for Kubernetes monitoring?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Alternatives include:\n\n- Datadog\n- Elastic Stack (ELK)\n- New Relic\n- Dynatrace\n- SigNoz"
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Installing Prometheus and Grafana on Kubernetes with Helm",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Helm",
-          "text": "Install Helm by following the official documentation: [Helm Installation Guide](https://helm.sh/docs/intro/install/)"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Add Prometheus Helm repository",
-          "text": "Run `helm repo add prometheus-community https://prometheus-community.github.io/helm-charts` and `helm repo update`."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Create Prometheus values file",
-          "text": "Create a `prometheus-values.yaml` file with your desired configurations."
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Install Prometheus and Grafana on Kubernetes with Helm',
+        alternativeHeadline:
+          'Step-by-Step Guide to Install Prometheus and Grafana on Kubernetes Using Helm',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Install Prometheus with Helm",
-          "text": "Run `helm install prometheus prometheus-community/prometheus -f prometheus-values.yaml`."
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Verify Prometheus installation",
-          "text": "Run `kubectl get pods -l app=prometheus` to ensure Prometheus pods are running."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-install-prometheus-and-grafana-on-kubernetes/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Add Grafana Helm repository",
-          "text": "Run `helm repo add grafana https://grafana.github.io/helm-charts` and `helm repo update`."
+        description:
+          'Learn how to install Prometheus and Grafana on Kubernetes using Helm. Follow our step-by-step guide for efficient monitoring and visualization.',
+        keywords:
+          'Kubernetes monitoring, Prometheus installation, Grafana setup, Helm charts, container orchestration, metrics visualization, Kubernetes observability',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Create Grafana values file",
-          "text": "Create a `grafana-values.yaml` file with your desired configurations."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes Monitoring',
+            description:
+              'The process of tracking and analyzing the performance of Kubernetes clusters to ensure optimal performance and reliability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Grafana',
+            description:
+              'An open-source platform for monitoring and observability, used for visualizing time series data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Helm Charts',
+            description:
+              'A package manager for Kubernetes that simplifies the deployment and management of applications.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Helm',
+            applicationCategory: 'Package Manager',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Kubernetes',
+            applicationCategory: 'Container Orchestration',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are the system requirements for running Prometheus and Grafana on Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The requirements depend on your cluster size and monitoring needs. Generally, start with at least 2 CPU cores and 4GB RAM for each tool, scaling as necessary.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use Prometheus and Grafana for monitoring non-Kubernetes workloads?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, both tools can monitor various systems. Use exporters to collect metrics from non-Kubernetes sources and visualize them in Grafana.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I update Prometheus and Grafana installed via Helm?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use `helm upgrade` with the latest chart version:\n\n```\nhelm upgrade prometheus prometheus-community/prometheus\nhelm upgrade grafana grafana/grafana\n```\n',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some alternatives to Prometheus and Grafana for Kubernetes monitoring?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Alternatives include:\n\n- Datadog\n- Elastic Stack (ELK)\n- New Relic\n- Dynatrace\n- SigNoz',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Install Grafana with Helm",
-          "text": "Run `helm install grafana grafana/grafana -f grafana-values.yaml`."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Installing Prometheus and Grafana on Kubernetes with Helm',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Helm',
+              text: 'Install Helm by following the official documentation: [Helm Installation Guide](https://helm.sh/docs/intro/install/)',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Prometheus Helm repository',
+              text: 'Run `helm repo add prometheus-community https://prometheus-community.github.io/helm-charts` and `helm repo update`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create Prometheus values file',
+              text: 'Create a `prometheus-values.yaml` file with your desired configurations.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Install Prometheus with Helm',
+              text: 'Run `helm install prometheus prometheus-community/prometheus -f prometheus-values.yaml`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Verify Prometheus installation',
+              text: 'Run `kubectl get pods -l app=prometheus` to ensure Prometheus pods are running.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Grafana Helm repository',
+              text: 'Run `helm repo add grafana https://grafana.github.io/helm-charts` and `helm repo update`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create Grafana values file',
+              text: 'Create a `grafana-values.yaml` file with your desired configurations.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Install Grafana with Helm',
+              text: 'Run `helm install grafana grafana/grafana -f grafana-values.yaml`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Retrieve Grafana admin password',
+              text: 'Run `kubectl get secret --namespace default grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Access Grafana dashboard',
+              text: 'Use the LoadBalancer IP or port-forwarding to access Grafana: `kubectl port-forward service/grafana 3000:80`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Prometheus data source to Grafana',
+              text: 'In Grafana, navigate to Configuration > Data Sources, add a new Prometheus data source, and set the URL to `http://prometheus-server`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create API monitoring dashboard',
+              text: 'Create a new dashboard in Grafana and add panels for key metrics like request rate, latency, and error rate.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Retrieve Grafana admin password",
-          "text": "Run `kubectl get secret --namespace default grafana -o jsonpath=\"{.data.admin-password}\" | base64 --decode ; echo`."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Access Grafana dashboard",
-          "text": "Use the LoadBalancer IP or port-forwarding to access Grafana: `kubectl port-forward service/grafana 3000:80`."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Add Prometheus data source to Grafana",
-          "text": "In Grafana, navigate to Configuration > Data Sources, add a new Prometheus data source, and set the URL to `http://prometheus-server`."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Create API monitoring dashboard",
-          "text": "Create a new dashboard in Grafana and add panels for key metrics like request rate, latency, and error rate."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Monitoring Kubernetes clusters is crucial for maintaining optimal performance and reliability. Prometheus and Grafana are powerful tools that work together to provide comprehensive monitoring and visualization capabilities. This guide walks you through the process of installing Prometheus and Grafana on Kubernetes using Helm, simplifying deployment and management.
@@ -260,7 +275,6 @@ server:
 alertmanager:
   persistentVolume:
     size: 2Gi
-
 ```
 
 1. Install Prometheus using Helm:
@@ -297,8 +311,7 @@ spec:
     matchLabels:
       app.kubernetes.io/name: kube-state-metrics
   endpoints:
-  - port: http-metrics
-
+    - port: http-metrics
 ```
 
 1. Configure RBAC permissions for Prometheus:
@@ -309,14 +322,13 @@ kind: ClusterRole
 metadata:
   name: prometheus
 rules:
-- apiGroups: [""]
-  resources:
-  - nodes
-  - services
-  - endpoints
-  - pods
-  verbs: ["get", "list", "watch"]
-
+  - apiGroups: ['']
+    resources:
+      - nodes
+      - services
+      - endpoints
+      - pods
+    verbs: ['get', 'list', 'watch']
 ```
 
 1. Enable relevant exporters like node-exporter and kube-state-metrics in your Helm values file.
@@ -341,7 +353,6 @@ persistence:
   size: 5Gi
 service:
   type: LoadBalancer
-
 ```
 
 1. Install Grafana:
@@ -445,4 +456,4 @@ Alternatives include:
 ## Resources
 
 - [Official Prometheus Documentation](https://prometheus.io/docs/introduction/overview/)
-- [Helm Charts Repository for Prometheus and Grafana](https://github.com/prometheus-community/helm-charts)
\ No newline at end of file
+- [Helm Charts Repository for Prometheus and Grafana](https://github.com/prometheus-community/helm-charts)
diff --git a/data/guides/how-to-log-all-the-processes-running-inside-a-docker-container.mdx b/data/guides/how-to-log-all-the-processes-running-inside-a-docker-container.mdx
index e0d85484c..8e4bc0fca 100644
--- a/data/guides/how-to-log-all-the-processes-running-inside-a-docker-container.mdx
+++ b/data/guides/how-to-log-all-the-processes-running-inside-a-docker-container.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to log all the processes running inside a Docker container - Step by Step Guide
-slug: how-to-log-all-the-processes-running-inside-a-docker-container
 date: 2024-09-24
 tags: [logging]
 authors: [nitin_gouda]
 description: Learn how to effectively log and monitor processes in Docker containers. This guide covers methods, best practices, and tools for comprehensive process logging.
-keywords: [Docker container processes, process logging, container monitoring, Docker logging, SigNoz, container management]
-
+keywords:
+  [
+    Docker container processes,
+    process logging,
+    container monitoring,
+    Docker logging,
+    SigNoz,
+    container management,
+  ]
 ---
 
 Docker containers have revolutionized application deployment and management. However, understanding what's happening inside these containers can be challenging. One crucial aspect of container management is logging processes — but how do you effectively track all the processes running inside a Docker container?
@@ -22,8 +27,8 @@ Key differences include:
 
 - Namespace isolation: One of the core features of Docker containers is their use of namespaces to isolate processes. Namespaces provide each container with its own isolated view of the system, meaning that processes running inside a container cannot directly interact with processes or resources outside of it.
 - Resource constraints: In addition to isolation, Docker containers allow for precise control over system resource usage, such as CPU, memory, disk I/O, and network bandwidth. This is achieved through cgroups (control groups), which allow Docker to set limits on CPU, memory, disk I/O, and network bandwidth by allocating specific portions of system resources to each container, ensuring they do not exceed predefined thresholds.
-- Process hierarchy: In Docker, each container typically runs a main process, also referred to as the init process, which is assigned a PID (Process ID) of 1. This main process is critical because, in Docker’s process model, when the main process (PID 1) exits, the entire container stops. While Docker containers are often associated with running a single main process, it’s important to note that this process can spawn multiple subprocesses within the container. 
-These subprocesses have their own unique PIDs but remain dependent on the lifecycle of the main process. If the main process exits, all its subprocesses are also terminated, and the container shuts down.
+- Process hierarchy: In Docker, each container typically runs a main process, also referred to as the init process, which is assigned a PID (Process ID) of 1. This main process is critical because, in Docker’s process model, when the main process (PID 1) exits, the entire container stops. While Docker containers are often associated with running a single main process, it’s important to note that this process can spawn multiple subprocesses within the container.
+  These subprocesses have their own unique PIDs but remain dependent on the lifecycle of the main process. If the main process exits, all its subprocesses are also terminated, and the container shuts down.
 
 Understanding these differences is vital for effective monitoring and logging of container processes.
 
@@ -31,24 +36,17 @@ Understanding these differences is vital for effective monitoring and logging of
 
 Logging processes inside Docker containers is a crucial practice for ensuring your applications' reliability, performance, and security. Containers are often used to deploy services in dynamic environments, making them lightweight and portable. However, the isolated nature of containers presents unique challenges in monitoring and managing the processes running inside them. By logging and tracking container processes, you can gain valuable insights into how your applications behave, troubleshoot issues efficiently, and optimize resource usage.
 
-1. Enhanced visibility
-Docker containers encapsulate processes, creating an isolated environment where applications run independently from the host system. While this isolation benefits security and consistency, it can also obscure visibility into what’s happening inside the container. Without proper logging, it’s difficult to know how your application performs or if anything is going wrong. Process logging provides a clear view of all the activities happening within the container. 
-By capturing detailed logs, you can:
-    - See which processes are running at any given time.
-    - Monitor process start times, resource consumption, and completion.
-    - Understand the sequence of operations within the container.
-    
-    This visibility is particularly useful in complex environments where multiple containers run different services. Process logs give you a window into the behaviour of each container, allowing you to identify potential bottlenecks or issues early.
-    
-2. Troubleshooting
-Process logs are one of the first places to look for clues when something goes wrong in a containerised application. Because containers are often ephemeral (i.e., they can be spun up, scaled, or removed quickly), tracking down the root cause of a problem can be challenging without logs.
-Logging processes help in several ways during troubleshooting:
-    - Identifying abnormal process behaviour: If a process consumes too much memory, uses excessive CPU, or behaves unpredictably, process logs can help pinpoint when and why it happened.
-    - Diagnosing container crashes: Since containers stop when the main process exits, logs can reveal whether the process exited due to an error, a resource limitation, or other issues.
-    - Tracking failed operations: Logs can capture details about failed operations or tasks within the container, providing context for debugging and recovery.
-3. Performance optimization
-One of the main advantages of utilising Docker containers is efficient resource utilisation. To guarantee peak performance, it's crucial to continuously check resource utilisation in production settings. You can gauge the CPU, memory, disk I/O, and network bandwidth each process consumes by tracking metrics rather than relying on logs.
-With this information, you can:
+1.  Enhanced visibility
+    Docker containers encapsulate processes, creating an isolated environment where applications run independently from the host system. While this isolation benefits security and consistency, it can also obscure visibility into what’s happening inside the container. Without proper logging, it’s difficult to know how your application performs or if anything is going wrong. Process logging provides a clear view of all the activities happening within the container.
+    By capturing detailed logs, you can: - See which processes are running at any given time. - Monitor process start times, resource consumption, and completion. - Understand the sequence of operations within the container.
+        This visibility is particularly useful in complex environments where multiple containers run different services. Process logs give you a window into the behaviour of each container, allowing you to identify potential bottlenecks or issues early.
+2.  Troubleshooting
+    Process logs are one of the first places to look for clues when something goes wrong in a containerised application. Because containers are often ephemeral (i.e., they can be spun up, scaled, or removed quickly), tracking down the root cause of a problem can be challenging without logs.
+    Logging processes help in several ways during troubleshooting: - Identifying abnormal process behaviour: If a process consumes too much memory, uses excessive CPU, or behaves unpredictably, process logs can help pinpoint when and why it happened. - Diagnosing container crashes: Since containers stop when the main process exits, logs can reveal whether the process exited due to an error, a resource limitation, or other issues. - Tracking failed operations: Logs can capture details about failed operations or tasks within the container, providing context for debugging and recovery.
+3.  Performance optimization
+    One of the main advantages of utilising Docker containers is efficient resource utilisation. To guarantee peak performance, it's crucial to continuously check resource utilisation in production settings. You can gauge the CPU, memory, disk I/O, and network bandwidth each process consumes by tracking metrics rather than relying on logs.
+    With this information, you can:
+
 - Optimize resource allocation: If a process consistently consumes more resources than expected, you can adjust the container's resource limits (using cgroups) to ensure better performance across the entire system.
 - Identify inefficient processes: Process logs can reveal processes that may be hogging resources, running inefficiently, or causing performance bottlenecks. For example, if a background process uses too much CPU, you can optimize or scale it accordingly.
 - Plan for scaling: By tracking resource consumption over time, you can predict when additional containers or resources will be needed to handle increasing workloads. This helps in scaling your applications effectively while maintaining performance standards.
@@ -76,24 +74,20 @@ There are several approaches to logging processes in [Docker containers](https:/
 
 One of the simplest and most widely used methods to view running processes in a Docker container is by using the `ps` command. This command provides a snapshot of the current processes running within the container.
 
-1. Access the container's shell:
-To enter a container and execute commands, use `docker exec.`
-    
-    ```docker
-    docker exec -it <container_name> /bin/bash
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-c19803cc-03d2-4707-afe7-f6e8c85e20af.webp" alt="" caption="" />`/bin/bash` provides an interactive shell interface and script execution environment within Docker containers, enabling command execution and process control.
-    
-2. Run the 'ps' command:
-Once inside the container, execute the following:
-    
-    ```bash
-    ps -eaf
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-11_at_11.26.01_AM.webp" alt="" caption="" />The `ps -eaf` command provides a comprehensive view of all processes running inside the Docker container, including detailed process information, which aids in monitoring and performance optimization.
-    
+1.  Access the container's shell:
+    To enter a container and execute commands, use `docker exec.`
+        ```docker
+        docker exec -it <container_name> /bin/bash
+        ```
+
+        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-c19803cc-03d2-4707-afe7-f6e8c85e20af.webp" alt="" caption="" />`/bin/bash` provides an interactive shell interface and script execution environment within Docker containers, enabling command execution and process control.
+2.  Run the 'ps' command:
+    Once inside the container, execute the following:
+        ```bash
+        ps -eaf
+        ```
+
+        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-11_at_11.26.01_AM.webp" alt="" caption="" />The `ps -eaf` command provides a comprehensive view of all processes running inside the Docker container, including detailed process information, which aids in monitoring and performance optimization.
 
 This will list all active processes within the container, including important details such as:
 
@@ -115,37 +109,31 @@ Limitations:
 
 Docker's built-in logging drivers automatically capture logs from containers, streamlining the process of collecting output without requiring manual intervention. Commonly used logging drivers like `json-file` or `syslog` can store and manage logs, but they focus primarily on capturing the standard output and error streams of the running containerized processes.
 
-1. Configure [Docker logging driver](https://signoz.io/blog/docker-logging/):
-When starting a container or globally, you can configure a specific logging driver through the [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration file (`/etc/docker/daemon.json`). For example, to use the `json-file` logging driver with rotation options:
-    
-    ```json
-    {
-      "log-driver": "json-file",
-      "log-opts": {
-        "max-size": "10m",
-        "max-file": "3"
-      }
-    }
-    ```
-    
-2. Restart Docker daemon:
-After modifying the configuration, restart the Docker service to apply the changes:
-    
-    ```bash
-    sudo systemctl restart docker
-    ```
-    
-    This ensures that all new containers will log their output according to the new driver and options.
-    
-3. View logs:
-To view the logs from a running container, use the `docker logs` command:
-    
-    ```docker
-    docker logs <container_name>
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-11_at_11.28.29_AM.webp" alt="" caption="" />This command will display the logs from the container’s standard output and standard error streams.
-    
+1.  Configure [Docker logging driver](https://signoz.io/blog/docker-logging/):
+    When starting a container or globally, you can configure a specific logging driver through the [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration file (`/etc/docker/daemon.json`). For example, to use the `json-file` logging driver with rotation options:
+        ```json
+        {
+          "log-driver": "json-file",
+          "log-opts": {
+            "max-size": "10m",
+            "max-file": "3"
+          }
+        }
+        ```
+2.  Restart Docker daemon:
+    After modifying the configuration, restart the Docker service to apply the changes:
+        ```bash
+        sudo systemctl restart docker
+        ```
+
+        This ensures that all new containers will log their output according to the new driver and options.
+3.  View logs:
+    To view the logs from a running container, use the `docker logs` command:
+        ```docker
+        docker logs <container_name>
+        ```
+
+        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-11_at_11.28.29_AM.webp" alt="" caption="" />This command will display the logs from the container’s standard output and standard error streams.
 
 Key Considerations:
 
@@ -159,75 +147,67 @@ Docker's native logging is ideal for basic application monitoring but may need t
 
 Implementing a comprehensive logging solution for processes running in a Docker container can provide continuous insights into container activity. Below is a simple, customizable approach to logging processes using a wrapper script that logs process information regularly.
 
-1. Create a wrapper script:
-This script will run your main application and log the container's active processes to a file.
-    
-    ```bash
-    #!/bin/bash
-    
-    # Log initial processes
-    echo "Initial processes:" >> /var/log/container_processes.log
-    ps -eaf >> /var/log/container_processes.log
-    
-    # Start your main application
-    /path/to/your/app &
-    
-    # Continuously log processes every minute
-    while true; do
-      echo "$(date): Current processes:" >> /var/log/container_processes.log
-      ps -eaf >> /var/log/container_processes.log
-      sleep 60  # Log every minute
-    done
-    ```
-    
-2. Modify your Dockerfile: 
-Next, update your Dockerfile to include the wrapper script and ensure it's executable.
-    
-    ```docker
-    # Replace "your-base-image" with the actual image you need.
-    FROM your-base-image
-    
-    # Copy the wrapper script into the container
-    COPY wrapper.sh /wrapper.sh
-    
-    # Make the wrapper script executable
-    # The chmod command changes file permissions; 
-    # +x makes the file executable.
-    RUN chmod +x /wrapper.sh
-    
-    # Set the default command to run the wrapper script
-    CMD ["/wrapper.sh"]
-    ```
-    
-3. Build and run your container:
-Now that the Dockerfile is set up, build and run your container.
-    - Build the Docker image:
-    This command is used to build an image from a Dockerfile in the current directory `(.)`. The `-t` flag tags the image with a name. Here, `<my-logging-container>` is a placeholder for the image name.
-        
-        ```docker
-        docker build -t <my-logging-container> .
-        ```
-        
-    - Run the container in detached mode:
-        
-        ```
-        docker run -d <my-logging-container>
+1.  Create a wrapper script:
+    This script will run your main application and log the container's active processes to a file.
+        ```bash
+        #!/bin/bash
+
+        # Log initial processes
+        echo "Initial processes:" >> /var/log/container_processes.log
+        ps -eaf >> /var/log/container_processes.log
+
+        # Start your main application
+        /path/to/your/app &
+
+        # Continuously log processes every minute
+        while true; do
+          echo "$(date): Current processes:" >> /var/log/container_processes.log
+          ps -eaf >> /var/log/container_processes.log
+          sleep 60  # Log every minute
+        done
         ```
-        
-4. Accessing the Logs
-The container logs processes every minute into the `/var/log/container_processes.log` file. To access the log file:
-    1. Enter the container’s shell:
-        
+2.  Modify your Dockerfile:
+    Next, update your Dockerfile to include the wrapper script and ensure it's executable.
         ```docker
-        docker exec -it <container_name> /bin/bash
-        ```
-        
-    2. View the log file:
-        
-        ```bash
-        cat /var/log/container_processes.log
+        # Replace "your-base-image" with the actual image you need.
+        FROM your-base-image
+
+        # Copy the wrapper script into the container
+        COPY wrapper.sh /wrapper.sh
+
+        # Make the wrapper script executable
+        # The chmod command changes file permissions;
+        # +x makes the file executable.
+        RUN chmod +x /wrapper.sh
+
+        # Set the default command to run the wrapper script
+        CMD ["/wrapper.sh"]
         ```
-        
+3.  Build and run your container:
+    Now that the Dockerfile is set up, build and run your container. - Build the Docker image:
+    This command is used to build an image from a Dockerfile in the current directory `(.)`. The `-t` flag tags the image with a name. Here, `<my-logging-container>` is a placeholder for the image name.
+            ```docker
+            docker build -t <my-logging-container> .
+            ```
+
+        - Run the container in detached mode:
+
+            ```
+            docker run -d <my-logging-container>
+            ```
+
+4.  Accessing the Logs
+    The container logs processes every minute into the `/var/log/container_processes.log` file. To access the log file: 1. Enter the container’s shell:
+            ```docker
+            docker exec -it <container_name> /bin/bash
+            ```
+
+        2. View the log file:
+
+            ```bash
+            cat /var/log/container_processes.log
+            ```
+
 
 This setup allows you to log and monitor all active processes running in your container over time, offering a more detailed view than a simple snapshot with a single `ps` command.The log file `container_processes.log` will update automatically without concurrency issues as long as only one process writes to it; for multiple processes, file locking should be implemented to avoid conflicts.
 
@@ -235,244 +215,234 @@ This setup allows you to log and monitor all active processes running in your co
 
 Basic logging is essential for monitoring, but advanced strategies can offer deeper insights, more control, and greater efficiency in managing your containerized applications. Below are some advanced techniques that can enhance your process logging efforts:
 
-1. Use process managers: 
-In more complex container environments, managing multiple processes efficiently is critical. While Docker containers typically run a single process, there are situations where you may need to run multiple processes inside the same container. You can use a process manager like Supervisor to manage these processes effectively.
-Supervisor is a powerful tool for controlling and monitoring multiple processes within a container. It allows you to:
-    - Automatically restart failed processes: If a process inside the container crashes, Supervisor can detect the failure and restart it automatically, ensuring high availability.
-        
-        Eg. In your `supervisord.conf` file, you can configure the process to restart automatically with the following directives:
-        
-        ```bash
-        # Starts the process when Supervisor starts
-        autostart=true
-        # Automatically restarts the process if it crashes
-        autorestart=true
-        ```
-        
-    - Log process output: Supervisor provides built-in logging features, capturing each managed process's standard output and [error logs](https://signoz.io/guides/error-log/), which you can use for troubleshooting and performance analysis.
-        
-        Eg. You can configure the log files for each process in the `supervisord.conf` file:
-        
-        ```bash
-        # Logs standard output
-        stdout_logfile=/var/log/supervisor/my_app.out.log 
-        # Logs error output
-        stderr_logfile=/var/log/supervisor/my_app.err.log  
-        ```
-        
-        Supervisor is better than `ps -eaf` because it actively manages processes by automatically restarting them if they fail and provides detailed logs for troubleshooting, while `ps -eaf` only lists processes without offering control or monitoring capabilities.
-        
-    - Control process lifecycle: You can configure Supervisor to start, stop, or restart processes based on predefined rules, helping you maintain control over container behavior.
-        
-        ```bash
-        # Start automatically when Supervisor starts
-        autostart=true                                    
-        # Restart automatically if the process crashes
-        autorestart=true                                  
-        # Number of attempts to restart the process
-        startretries=3                                    
-        # Consider the process started after 5 seconds
-        startsecs=5                     
-        ```
-        
-    
-    Let's walk through an example of using Supervisor to manage processes inside a Docker container.
-    
-    1. Clone the Sample Application Repository: 
-    First, clone a sample Python application:
-        
-        ```bash
-        git clone https://github.com/SigNoz/sample-flask-app
-        ```
-        
-    2. Update the Dockerfile: 
-    Modify the `Dockerfile` to include Supervisor and configure it to manage your application:
-        
-        ```bash
-        # install Supervisor
-        RUN apt-get update && apt-get install -y supervisor
-        
-        # Create Supervisor directory for logs
-        RUN mkdir -p /var/log/supervisor
-        
-        # Copy Supervisor config file
-        COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
-        
-        # expose the application's port
-        EXPOSE 5002
-        
-        # Set the entry point to run Supervisor (which will manage your app)
-        CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/supervisord.conf"]
-        ```
-        
-    3. Create a Supervisor Configuration File: 
-    Create a `supervisord.conf` file in the same directory as your Dockerfile to configure Supervisor to manage your Python app.
-        
-        ```bash
-        [supervisord]
-        nodaemon=true 
-        [program:python_app]
-        command=opentelemetry-instrument python ./app.py
-        autostart=true
-        autorestart=true
-        stderr_logfile=/var/log/supervisor/python_app.err.log
-        stdout_logfile=/var/log/supervisor/python_app.out.log
-        startretries=3                                    
-        startsecs=5                     
-        ```
-        
-    4. Build and Run the Docker Container
-        - Build the Docker image:
-        
-        ```bash
-        docker build -t python-supervisor-app .
-        ```
-        
-        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_11.45.40_AM.webp" alt="" caption="" />- Run the Docker container:
-        
-        ```bash
-        docker run -d python-supervisor-app
-        ```
-        
-        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_11.47.03_AM.webp" alt="" caption="" />5. Where to See Supervisor Logs: 
-    You can access Supervisor logs directly within the container:
-        1. Application logs:
-            
+1.  Use process managers:
+    In more complex container environments, managing multiple processes efficiently is critical. While Docker containers typically run a single process, there are situations where you may need to run multiple processes inside the same container. You can use a process manager like Supervisor to manage these processes effectively.
+    Supervisor is a powerful tool for controlling and monitoring multiple processes within a container. It allows you to: - Automatically restart failed processes: If a process inside the container crashes, Supervisor can detect the failure and restart it automatically, ensuring high availability.
+            Eg. In your `supervisord.conf` file, you can configure the process to restart automatically with the following directives:
+
             ```bash
-            docker exec -it <container_id> cat /var/log/supervisor/python_app.out.log
+            # Starts the process when Supervisor starts
+            autostart=true
+            # Automatically restarts the process if it crashes
+            autorestart=true
             ```
-            
-            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_12.17.41_PM.webp" alt="" caption="" />2. Process status:
-            
+
+        - Log process output: Supervisor provides built-in logging features, capturing each managed process's standard output and [error logs](https://signoz.io/guides/error-log/), which you can use for troubleshooting and performance analysis.
+
+            Eg. You can configure the log files for each process in the `supervisord.conf` file:
+
             ```bash
-            docker exec -it <container_id> supervisorctl status
+            # Logs standard output
+            stdout_logfile=/var/log/supervisor/my_app.out.log
+            # Logs error output
+            stderr_logfile=/var/log/supervisor/my_app.err.log
             ```
-            
-            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_12.19.32_PM.webp" alt="" caption="" />Using a process manager like Supervisor is particularly useful in environments requiring high reliability and more granular control over process execution within containers.
-    
-2. Implement custom logging libraries:
-While Docker provides basic logging mechanisms, integrating custom logging libraries into your application code can give you more detailed and tailored process logging. By adding logging directly into your application, you gain several benefits:
-    - Granular logging: Custom logging allows you to log specific events, variables, and process states that are important for your application. This can include detailed logs about internal operations, performance metrics, or application-specific errors.
-    - [structured logging](https://signoz.io/blog/structured-logs/): Libraries like [Logrus](https://signoz.io/guides/golang-logrus/) (for Go) or Winston (for Node.js) allow you to create structured logs, which are easier to parse and analyze. Structured logs can include key-value pairs, timestamps, and contextual information that make troubleshooting much faster.
-    - Enhanced log formats: With custom libraries, you can log in formats like JSON, making integrating with [log management tools](https://signoz.io/blog/open-source-log-management/) or dashboards easier.
-    - Application-level insights: By embedding logging into your code, you can capture information unavailable through system-level logging. For example, you can track specific user actions, API calls, or business logic execution paths.
-    
-    Sample:
-    
-    Let's walk through an example of integrating a custom logging library to handle log management. 
-    
-    1. Clone the Sample Application Repository: 
-    First, clone a sample Python application:
-        
-        ```bash
-        git clone https://github.com/SigNoz/sample-flask-app
-        ```
-        
-    2. Choose a Custom Logging Library: 
-    For this example, we'll use `loguru`, a popular logging library that offers a more flexible and user-friendly setup than Python's built-in `logging` module.
-    3. Update Your Application Code:
-    Integrate the custom logging library into your application code. For this example, we will add it to our `app.py` file.
-        1. Install `loguru:`  Ensure `loguru` is installed via pip:
-            
+
+            Supervisor is better than `ps -eaf` because it actively manages processes by automatically restarting them if they fail and provides detailed logs for troubleshooting, while `ps -eaf` only lists processes without offering control or monitoring capabilities.
+
+        - Control process lifecycle: You can configure Supervisor to start, stop, or restart processes based on predefined rules, helping you maintain control over container behavior.
+
             ```bash
-            pip install loguru
+            # Start automatically when Supervisor starts
+            autostart=true
+            # Restart automatically if the process crashes
+            autorestart=true
+            # Number of attempts to restart the process
+            startretries=3
+            # Consider the process started after 5 seconds
+            startsecs=5
             ```
-            
-        2. Update Your `app.py`
-            - Add the following imports:
-            
-            ```python
-            from loguru import logger
+
+
+        Let's walk through an example of using Supervisor to manage processes inside a Docker container.
+
+        1. Clone the Sample Application Repository:
+        First, clone a sample Python application:
+
+            ```bash
+            git clone https://github.com/SigNoz/sample-flask-app
             ```
-            
-            - Configure `loguru` at the top of your file:
-            
-            ```python
-            # Configure loguru
-            logger.add("logs/app.log", rotation="1 week", level="DEBUG", retention="1 month")
+
+        2. Update the Dockerfile:
+        Modify the `Dockerfile` to include Supervisor and configure it to manage your application:
+
+            ```bash
+            # install Supervisor
+            RUN apt-get update && apt-get install -y supervisor
+
+            # Create Supervisor directory for logs
+            RUN mkdir -p /var/log/supervisor
+
+            # Copy Supervisor config file
+            COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+
+            # expose the application's port
+            EXPOSE 5002
+
+            # Set the entry point to run Supervisor (which will manage your app)
+            CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/supervisord.conf"]
             ```
-            
-            Add logging statements to your existing routes and functions:
-            
-            - Log request information and exceptions:
-                
-                ```python
-                @app.route("/list")
-                def lists():
-                    logger.info("Request to /list endpoint")
-                    try:
-                        # Your existing code...
-                    except requests.RequestException as e:
-                        logger.error(f"Request failed: {e}")
+
+        3. Create a Supervisor Configuration File:
+        Create a `supervisord.conf` file in the same directory as your Dockerfile to configure Supervisor to manage your Python app.
+
+            ```bash
+            [supervisord]
+            nodaemon=true
+            [program:python_app]
+            command=opentelemetry-instrument python ./app.py
+            autostart=true
+            autorestart=true
+            stderr_logfile=/var/log/supervisor/python_app.err.log
+            stdout_logfile=/var/log/supervisor/python_app.out.log
+            startretries=3
+            startsecs=5
+            ```
+
+        4. Build and Run the Docker Container
+            - Build the Docker image:
+
+            ```bash
+            docker build -t python-supervisor-app .
+            ```
+
+            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_11.45.40_AM.webp" alt="" caption="" />- Run the Docker container:
+
+            ```bash
+            docker run -d python-supervisor-app
+            ```
+
+            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_11.47.03_AM.webp" alt="" caption="" />5. Where to See Supervisor Logs:
+        You can access Supervisor logs directly within the container:
+            1. Application logs:
+
+                ```bash
+                docker exec -it <container_id> cat /var/log/supervisor/python_app.out.log
+                ```
+
+                <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_12.17.41_PM.webp" alt="" caption="" />2. Process status:
+
+                ```bash
+                docker exec -it <container_id> supervisorctl status
                 ```
-                
-            - Update other routes similarly to log information and errors:
-                
+
+                <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_12.19.32_PM.webp" alt="" caption="" />Using a process manager like Supervisor is particularly useful in environments requiring high reliability and more granular control over process execution within containers.
+2.  Implement custom logging libraries:
+    While Docker provides basic logging mechanisms, integrating custom logging libraries into your application code can give you more detailed and tailored process logging. By adding logging directly into your application, you gain several benefits: - Granular logging: Custom logging allows you to log specific events, variables, and process states that are important for your application. This can include detailed logs about internal operations, performance metrics, or application-specific errors. - [structured logging](https://signoz.io/blog/structured-logs/): Libraries like [Logrus](https://signoz.io/guides/golang-logrus/) (for Go) or Winston (for Node.js) allow you to create structured logs, which are easier to parse and analyze. Structured logs can include key-value pairs, timestamps, and contextual information that make troubleshooting much faster. - Enhanced log formats: With custom libraries, you can log in formats like JSON, making integrating with [log management tools](https://signoz.io/blog/open-source-log-management/) or dashboards easier. - Application-level insights: By embedding logging into your code, you can capture information unavailable through system-level logging. For example, you can track specific user actions, API calls, or business logic execution paths.
+        Sample:
+
+        Let's walk through an example of integrating a custom logging library to handle log management.
+
+        1. Clone the Sample Application Repository:
+        First, clone a sample Python application:
+
+            ```bash
+            git clone https://github.com/SigNoz/sample-flask-app
+            ```
+
+        2. Choose a Custom Logging Library:
+        For this example, we'll use `loguru`, a popular logging library that offers a more flexible and user-friendly setup than Python's built-in `logging` module.
+        3. Update Your Application Code:
+        Integrate the custom logging library into your application code. For this example, we will add it to our `app.py` file.
+            1. Install `loguru:`  Ensure `loguru` is installed via pip:
+
+                ```bash
+                pip install loguru
+                ```
+
+            2. Update Your `app.py`
+                - Add the following imports:
+
                 ```python
-                @app.route("/done")
-                def done():
-                    logger.info("Request to /done endpoint")
-                    try:
-                        # Your existing code...
-                    except Exception as e:
-                        logger.error(f"Error updating task: {e}")
+                from loguru import logger
                 ```
-                
-                Ensure the application start is logged:
-                
+
+                - Configure `loguru` at the top of your file:
+
                 ```python
-                if __name__ == "__main__":
-                    logger.info("Starting Flask application")
-                    app.run(host='0.0.0.0', port=5002, debug=True)
+                # Configure loguru
+                logger.add("logs/app.log", rotation="1 week", level="DEBUG", retention="1 month")
                 ```
-                
-    
-    4. Update `requirements.txt` :
-    
-    Ensure your `requirements.txt` includes `loguru`
-    
-    ```
-    flask
-    loguru # add this
-    opentelemetry-api
-    opentelemetry-sdk
-    opentelemetry-instrumentation-flask
-    ```
-    
-    1. Update Your Dockerfile: 
-    Modify your Dockerfile to include the custom logging library and update your application to use it.
-        
-        ```docker
-        # Install loguru library
-        RUN pip install loguru
-        ```
-        
-    2. Build and Run the Docker Container: 
-    Rebuild your Docker image and run the container:
-        
-        ```docker
-        docker build -t python-loguru-app .
-        docker run -d -p 5002:5002 python-loguru-app
+
+                Add logging statements to your existing routes and functions:
+
+                - Log request information and exceptions:
+
+                    ```python
+                    @app.route("/list")
+                    def lists():
+                        logger.info("Request to /list endpoint")
+                        try:
+                            # Your existing code...
+                        except requests.RequestException as e:
+                            logger.error(f"Request failed: {e}")
+                    ```
+
+                - Update other routes similarly to log information and errors:
+
+                    ```python
+                    @app.route("/done")
+                    def done():
+                        logger.info("Request to /done endpoint")
+                        try:
+                            # Your existing code...
+                        except Exception as e:
+                            logger.error(f"Error updating task: {e}")
+                    ```
+
+                    Ensure the application start is logged:
+
+                    ```python
+                    if __name__ == "__main__":
+                        logger.info("Starting Flask application")
+                        app.run(host='0.0.0.0', port=5002, debug=True)
+                    ```
+
+
+        4. Update `requirements.txt` :
+
+        Ensure your `requirements.txt` includes `loguru`
+
         ```
-        
-        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_1.14.41_PM.webp" alt="" caption="" />1. Accessing Logs: 
-    To view the logs generated by `loguru`, Access container logs: 
-        
-        ```bash
-        docker exec -it <container_id> cat /code/logs/app.log
+        flask
+        loguru # add this
+        opentelemetry-api
+        opentelemetry-sdk
+        opentelemetry-instrumentation-flask
         ```
-        
-        <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_1.23.26_PM.webp" alt="" caption="" />Integrating logging libraries into your applications is a good approach for teams that need precise control over their logs and want to capture application-specific data.
-    
-3. Leverage container orchestration
-Managing and logging processes manually in large-scale deployments with multiple containers can quickly become overwhelming. This is where container orchestration platforms like Kubernetes come into play. Kubernetes offers advanced features for managing and monitoring containerized environments, including robust logging capabilities.
-    
-    Key advantages of using Kubernetes for process logging include:
-    
-    - [Centralized logging](https://signoz.io/blog/centralized-logging/): Kubernetes can centralize the logs from all containers across your cluster, making monitoring and analysing logs from a single location easier. This is achieved through integrations with logging solutions like ELK Stack (Elasticsearch, Logstash, Kibana) or Fluentd.
-    - Advanced monitoring: Kubernetes works smoothly with monitoring tools such as Prometheus and Grafana, allowing you to gather, visualise, and analyse process information. You can configure alerts based on resource use, process failures, and other relevant data.
-    - Automatic log rotation: Kubernetes helps manage logs by automatically rotating them to prevent containers from running out of disk space. This ensures that logging doesn’t become a burden on container performance.
-    - Scalability: Kubernetes excels at managing containerized applications at scale. Its logging and monitoring features can scale as your deployment grows, ensuring consistent visibility across all your containers.
+
+        1. Update Your Dockerfile:
+        Modify your Dockerfile to include the custom logging library and update your application to use it.
+
+            ```docker
+            # Install loguru library
+            RUN pip install loguru
+            ```
+
+        2. Build and Run the Docker Container:
+        Rebuild your Docker image and run the container:
+
+            ```docker
+            docker build -t python-loguru-app .
+            docker run -d -p 5002:5002 python-loguru-app
+            ```
+
+            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_1.14.41_PM.webp" alt="" caption="" />1. Accessing Logs:
+        To view the logs generated by `loguru`, Access container logs:
+
+            ```bash
+            docker exec -it <container_id> cat /code/logs/app.log
+            ```
+
+            <Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-09-19_at_1.23.26_PM.webp" alt="" caption="" />Integrating logging libraries into your applications is a good approach for teams that need precise control over their logs and want to capture application-specific data.
+3.  Leverage container orchestration
+    Managing and logging processes manually in large-scale deployments with multiple containers can quickly become overwhelming. This is where container orchestration platforms like Kubernetes come into play. Kubernetes offers advanced features for managing and monitoring containerized environments, including robust logging capabilities.
+        Key advantages of using Kubernetes for process logging include:
+
+        - [Centralized logging](https://signoz.io/blog/centralized-logging/): Kubernetes can centralize the logs from all containers across your cluster, making monitoring and analysing logs from a single location easier. This is achieved through integrations with logging solutions like ELK Stack (Elasticsearch, Logstash, Kibana) or Fluentd.
+        - Advanced monitoring: Kubernetes works smoothly with monitoring tools such as Prometheus and Grafana, allowing you to gather, visualise, and analyse process information. You can configure alerts based on resource use, process failures, and other relevant data.
+        - Automatic log rotation: Kubernetes helps manage logs by automatically rotating them to prevent containers from running out of disk space. This ensures that logging doesn’t become a burden on container performance.
+        - Scalability: Kubernetes excels at managing containerized applications at scale. Its logging and monitoring features can scale as your deployment grows, ensuring consistent visibility across all your containers.
 
 ## Monitoring Docker Container Processes with SigNoz
 
@@ -489,9 +459,13 @@ git clone https://github.com/dockersamples/example-voting-app
 cd example-voting-app
 ```
 
-<Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-07-09_at_9.47.11_PM.webp" alt="Git commands to clone the repo" caption="Git commands to clone the repo" />
+<Figure
+  src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-07-09_at_9.47.11_PM.webp"
+  alt="Git commands to clone the repo"
+  caption="Git commands to clone the repo"
+/>
 
-*Git commands to clone the repo*
+_Git commands to clone the repo_
 
 Note: Skip this step if you have your own running Docker containers and Docker Compose configuration.
 
@@ -515,7 +489,11 @@ Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with
 
 To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. The ingestion key and region are under the “Ingestion Settings” tab.
 
-<Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-08-28_at_9.04.01_AM.webp" alt="SigNoz Ingestion Settings" caption="SigNoz Ingestion Settings" />
+<Figure
+  src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-08-28_at_9.04.01_AM.webp"
+  alt="SigNoz Ingestion Settings"
+  caption="SigNoz Ingestion Settings"
+/>
 
 1. Set Up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)Config
 
@@ -526,7 +504,7 @@ In the root of your project folder, create a file `otel-collector-config.yaml` a
 ```yaml
 receivers:
   tcplog/docker:
-    listen_address: "0.0.0.0:2255"
+    listen_address: '0.0.0.0:2255'
     operators:
       - type: regex_parser
         regex: '^<([0-9]+)>[0-9]+ (?P<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?) (?P<container_id>\\S+) (?P<container_name>\\S+) [0-9]+ - -( (?P<body>.*))?'
@@ -554,7 +532,7 @@ exporters:
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": ${env:SIGNOZ_INGESTION_KEY}
+      'signoz-ingestion-key': ${env:SIGNOZ_INGESTION_KEY}
 
 service:
   pipelines:
@@ -601,102 +579,103 @@ In your existing Docker Compose file, add the below configuration:
     command: syslog+tcp://otel-collector:2255
     depends_on:
       - otel-collector
-    restart: on-failure 
+    restart: on-failure
 ```
 
 The above Docker Compose configuration sets up two services:
 
 - `otel-collector`:
-    - Uses the Signoz [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) image.
-    - Mounts the `otel-collector-config.yaml` file into the container.
-    - Uses environment variables from the `.env` file for configuration.
-    - Exposes ports `4317` (OTLP gRPC receiver) and `4318` (OTLP HTTP receiver).
+  - Uses the Signoz [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) image.
+  - Mounts the `otel-collector-config.yaml` file into the container.
+  - Uses environment variables from the `.env` file for configuration.
+  - Exposes ports `4317` (OTLP gRPC receiver) and `4318` (OTLP HTTP receiver).
 - `logspout`:
-    - Uses the `gliderlabs/logspout` image to collect logs from other Docker containers.
-    - Forwards logs to the `otel-collector` service on port `2255`.
-    - Depends on the `otel-collector` service, ensuring it starts first so it can forward the logs to it.
+  - Uses the `gliderlabs/logspout` image to collect logs from other Docker containers.
+  - Forwards logs to the `otel-collector` service on port `2255`.
+  - Depends on the `otel-collector` service, ensuring it starts first so it can forward the logs to it.
+
 1. Start the Docker Compose file
 
 Run the below command in your terminal to start the containers:
 
 ```docker
-docker compose up -d 
+docker compose up -d
 ```
 
 If it runs without any error, navigate to your SigNoz Cloud. Under the “Logs” tab, you should see the incoming logs.
 
-<Figure src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-07-09_at_11.05.54_PM.webp" alt="SigNoz cloud dashboard to view logs" caption="SigNoz cloud dashboard to view logs" />
+<Figure
+  src="/img/guides/2024/09/how-to-log-all-the-processes-running-inside-a-docker-container-Screenshot_2024-07-09_at_11.05.54_PM.webp"
+  alt="SigNoz cloud dashboard to view logs"
+  caption="SigNoz cloud dashboard to view logs"
+/>
 
 ## Best Practices for Docker Container Process Logging
 
 Effective process logging in Docker containers is key to ensuring your applications run smoothly and securely. However, to get the most out of your logging setup, following certain best practices is essential. These guidelines will help you balance the need for detailed information with maintaining performance and security.
 
-- Balance Detail and Performance: 
-When logging processes in Docker containers, capturing all relevant information is crucial without compromising system performance. Logging too much detail can generate excessive noise and slow down your application, while too little detail may make it difficult to troubleshoot issues. A balanced approach ensures that logs are informative but do not overwhelm the system or complicate analysis. 
-Define clear logging levels (e.g., debug, info, error) and use them appropriately to control the verbosity of your logs based on your environment (e.g., development vs. production).
-- Implement log rotation: 
-Continuous logging can cause log files to grow significantly over time, which may result in excessive disk usage or even out-of-space errors. Log rotation helps mitigate this by regularly archiving or deleting older log files.
-Configure log rotation policies in Docker using the `max-size` and `max-file` options for `json-file` logging driver or use external logging solutions like `syslog`
+- Balance Detail and Performance:
+  When logging processes in Docker containers, capturing all relevant information is crucial without compromising system performance. Logging too much detail can generate excessive noise and slow down your application, while too little detail may make it difficult to troubleshoot issues. A balanced approach ensures that logs are informative but do not overwhelm the system or complicate analysis.
+  Define clear logging levels (e.g., debug, info, error) and use them appropriately to control the verbosity of your logs based on your environment (e.g., development vs. production).
+- Implement log rotation:
+  Continuous logging can cause log files to grow significantly over time, which may result in excessive disk usage or even out-of-space errors. Log rotation helps mitigate this by regularly archiving or deleting older log files.
+  Configure log rotation policies in Docker using the `max-size` and `max-file` options for `json-file` logging driver or use external logging solutions like `syslog`
 - Secure sensitive data
-Logs can unintentionally expose sensitive information such as credentials, tokens, or personal data. Ensure that your logging strategy is designed to avoid logging sensitive information or sanitize logs before they are stored or transmitted.
-Use environment variables and secrets management tools (e.g., Docker secrets, AWS Secrets Manager) to ensure that sensitive data is not logged, and enforce redaction rules if necessary.
+  Logs can unintentionally expose sensitive information such as credentials, tokens, or personal data. Ensure that your logging strategy is designed to avoid logging sensitive information or sanitize logs before they are stored or transmitted.
+  Use environment variables and secrets management tools (e.g., Docker secrets, AWS Secrets Manager) to ensure that sensitive data is not logged, and enforce redaction rules if necessary.
 - Standardize logging
-Consistent logging across all containers makes it easier to aggregate and analyze logs. Establish a standardized format that includes timestamps, severity levels, service identifiers, and other relevant metadata. This consistency ensures seamless integration with [monitoring and alerting tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/). 
-Adopt structured logging formats such as JSON, which enables more sophisticated querying and log management across distributed systems.
-- Centralized Log Management: 
-In multi-container environments, having each container manage its own logs can become chaotic. Implement a [centralized log management solution](https://signoz.io/blog/centralized-logging/#what-is-centralized-logging) like [SigNoz](http://signoz.io) to collect logs from all containers in a single location, making it easier to monitor, analyze, and troubleshoot system-wide events.
+  Consistent logging across all containers makes it easier to aggregate and analyze logs. Establish a standardized format that includes timestamps, severity levels, service identifiers, and other relevant metadata. This consistency ensures seamless integration with [monitoring and alerting tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/).
+  Adopt structured logging formats such as JSON, which enables more sophisticated querying and log management across distributed systems.
+- Centralized Log Management:
+  In multi-container environments, having each container manage its own logs can become chaotic. Implement a [centralized log management solution](https://signoz.io/blog/centralized-logging/#what-is-centralized-logging) like [SigNoz](http://signoz.io) to collect logs from all containers in a single location, making it easier to monitor, analyze, and troubleshoot system-wide events.
 - Monitor and Alert on Logs:
-Logging should not be passive; actively monitor logs for errors, warnings, or other significant events. Set up automated alerts to notify you of critical issues in real time. Use log monitoring tools to create alerts based on patterns or specific events, ensuring that you can respond quickly to operational issues or security incidents.
+  Logging should not be passive; actively monitor logs for errors, warnings, or other significant events. Set up automated alerts to notify you of critical issues in real time. Use log monitoring tools to create alerts based on patterns or specific events, ensuring that you can respond quickly to operational issues or security incidents.
 
 ## Troubleshooting Common Issues
 
 While implementing process logging in Docker containers is essential for monitoring and troubleshooting, several common issues can arise. Understanding these challenges and knowing how to resolve them ensures that your logging setup remains reliable, efficient, and secure.
 
 - High log volume
-One of the most common problems in Docker container logging is the generation of large log volumes. This can occur due to excessive logging of minor events, high traffic, or long-running processes. Large log files can overwhelm your storage and degrade system performance if not properly managed.
-    
-    How to Manage High Log Volume:
-    
-    - Log Rotation: As mentioned earlier, implementing log rotation prevents individual log files from growing too large. Docker provides built-in options for rotating logs based on size and number of files. Configuring these options ensures that your logs remain manageable:
-        
-        ```docker
-        docker run --log-opt max-size=10m --log-opt max-file=5 <my-container> 
-        ```
-        
-        This command limits each log file to 10 MB and retains a maximum of 5 log files per container, automatically archiving older logs. Reducing log volume ensures that logging remains sustainable and doesn’t affect your system’s performance.
-        
-    - Log Compression: Compressing older log files can significantly reduce the amount of storage used by archived logs. Many log rotation tools offer compression options, where old log files are compressed into formats like `.gz` to save space.
-    - Filter Logs: Another approach to reducing log volume is to filter out non-essential log entries. You can achieve this by setting appropriate logging levels (e.g., ERROR, WARNING, INFO) and filtering out DEBUG or INFO-level logs in production environments, where they might not be necessary.
+  One of the most common problems in Docker container logging is the generation of large log volumes. This can occur due to excessive logging of minor events, high traffic, or long-running processes. Large log files can overwhelm your storage and degrade system performance if not properly managed.
+      How to Manage High Log Volume:
+
+      - Log Rotation: As mentioned earlier, implementing log rotation prevents individual log files from growing too large. Docker provides built-in options for rotating logs based on size and number of files. Configuring these options ensures that your logs remain manageable:
+
+          ```docker
+          docker run --log-opt max-size=10m --log-opt max-file=5 <my-container>
+          ```
+
+          This command limits each log file to 10 MB and retains a maximum of 5 log files per container, automatically archiving older logs. Reducing log volume ensures that logging remains sustainable and doesn’t affect your system’s performance.
+
+      - Log Compression: Compressing older log files can significantly reduce the amount of storage used by archived logs. Many log rotation tools offer compression options, where old log files are compressed into formats like `.gz` to save space.
+      - Filter Logs: Another approach to reducing log volume is to filter out non-essential log entries. You can achieve this by setting appropriate logging levels (e.g., ERROR, WARNING, INFO) and filtering out DEBUG or INFO-level logs in production environments, where they might not be necessary.
 
 Reducing log volume ensures that logging remains sustainable and doesn’t affect your system’s performance.
 
-- Permission issues: 
-In some cases, logging processes within a container might encounter permission issues. These issues typically arise when the container’s logging process or the user running the container does not have the required permissions to write to specific directories or log files.
-How to Resolve Permission Issues:
-    - Container User Permissions: Make sure the process responsible for writing logs inside the container has the correct user permissions. By default, many containers run as the `root` user, but for security reasons, you may want to run processes as non-root users. Ensure that the user or process inside the container has write permissions for the designated logging directory.
-        
-        You can adjust user permissions with the `USER` directive in your Dockerfile:
-        
-        ```docker
-        USER myuser
-        ```
-        
-    - Bind Mount Permissions: If you’re using bind mounts to store logs on the host machine, ensure that the directory on the host system has the correct permissions. The container may not be able to write logs if the directory is read-only or if the container’s user lacks the necessary access rights. You can adjust the permissions by modifying the file system’s permissions on the host or using the correct `chmod` command.
-- Resource constraints: 
-Logging, while valuable, consumes resources such as CPU, memory, and disk I/O. If the logging process is too resource-intensive, it can negatively impact the performance of your containerized application. This is especially concerning in resource-constrained environments or when running multiple containers on the same host.
-    
-    How to Address Resource Constraints:
-    
-    - Monitor Resource Usage: Use monitoring tools like Docker’s built-in stats (`docker stats`) or external monitoring solutions to track how much CPU, memory, and disk I/O the logging process is consuming. This can help you identify bottlenecks and determine whether the logging process is impacting your container’s performance.
-    - Optimize Log Frequency and Detail: Adjust the level of logging detail and the frequency of logs to minimize resource usage. For example, reduce the log verbosity (e.g., avoid DEBUG-level logs in production), or log only significant events rather than every small operation.
-    - Limit CPU and Memory: You can restrict the CPU and memory usage of your container by setting resource limits in the Docker run command or in your container orchestration tool (like Kubernetes). This ensures that even if the logging process consumes resources, it won’t affect the overall performance of the application.
-        
-        ```bash
-        docker run --memory=256m --cpus="1.0" <my-container>
-        ```
-        
-        This limits the container to 256 MB of memory and one CPU core, preventing it from using excessive resources for logging or other tasks.
-        
+- Permission issues:
+  In some cases, logging processes within a container might encounter permission issues. These issues typically arise when the container’s logging process or the user running the container does not have the required permissions to write to specific directories or log files.
+  How to Resolve Permission Issues: - Container User Permissions: Make sure the process responsible for writing logs inside the container has the correct user permissions. By default, many containers run as the `root` user, but for security reasons, you may want to run processes as non-root users. Ensure that the user or process inside the container has write permissions for the designated logging directory.
+          You can adjust user permissions with the `USER` directive in your Dockerfile:
+
+          ```docker
+          USER myuser
+          ```
+
+      - Bind Mount Permissions: If you’re using bind mounts to store logs on the host machine, ensure that the directory on the host system has the correct permissions. The container may not be able to write logs if the directory is read-only or if the container’s user lacks the necessary access rights. You can adjust the permissions by modifying the file system’s permissions on the host or using the correct `chmod` command.
+- Resource constraints:
+  Logging, while valuable, consumes resources such as CPU, memory, and disk I/O. If the logging process is too resource-intensive, it can negatively impact the performance of your containerized application. This is especially concerning in resource-constrained environments or when running multiple containers on the same host.
+      How to Address Resource Constraints:
+
+      - Monitor Resource Usage: Use monitoring tools like Docker’s built-in stats (`docker stats`) or external monitoring solutions to track how much CPU, memory, and disk I/O the logging process is consuming. This can help you identify bottlenecks and determine whether the logging process is impacting your container’s performance.
+      - Optimize Log Frequency and Detail: Adjust the level of logging detail and the frequency of logs to minimize resource usage. For example, reduce the log verbosity (e.g., avoid DEBUG-level logs in production), or log only significant events rather than every small operation.
+      - Limit CPU and Memory: You can restrict the CPU and memory usage of your container by setting resource limits in the Docker run command or in your container orchestration tool (like Kubernetes). This ensures that even if the logging process consumes resources, it won’t affect the overall performance of the application.
+
+          ```bash
+          docker run --memory=256m --cpus="1.0" <my-container>
+          ```
+
+          This limits the container to 256 MB of memory and one CPU core, preventing it from using excessive resources for logging or other tasks.
+
 
 By following these best practices and troubleshooting recommendations, you can keep your Docker containers' process logging system running smoothly.
 
@@ -723,4 +702,4 @@ You can automate process logging in Docker containers using several methods:
 3. Container Orchestration: Leverage platforms such as Kubernetes to centralize and automate logging for all containers in your environment, providing more advanced logging options and seamless integration with monitoring tools.
 4. Monitoring Tools: Utilize logging and monitoring solutions like SigNoz or the ELK Stack to automate [log collection and analysis](https://signoz.io/comparisons/log-analysis-tools/#splunk), reducing manual effort and increasing the depth of insights you can gather.
 
-Automating process logging ensures consistent, real-time visibility into your container’s performance and behavior, enhancing your ability to troubleshoot and optimize your containerized applications.
\ No newline at end of file
+Automating process logging ensures consistent, real-time visibility into your container’s performance and behavior, enhancing your ability to troubleshoot and optimize your containerized applications.
diff --git a/data/guides/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource.mdx b/data/guides/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource.mdx
index 7935bafed..412ef8934 100644
--- a/data/guides/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource.mdx
+++ b/data/guides/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Create Dynamic Grafana Templates with Chained Variables
-slug: how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource
 date: 2024-11-14
 tags: [grafana, faq]
 authors: [simran_kumari]
 description: Learn how to create dynamic Grafana dashboards using chained template variables with Prometheus. Step-by-step guide with practical examples and performance tips.
-keywords: [grafana templates, grafana variables, prometheus monitoring, grafana chained variables, grafana dashboard, grafana templating, grafana query variables]
-
+keywords:
+  [
+    grafana templates,
+    grafana variables,
+    prometheus monitoring,
+    grafana chained variables,
+    grafana dashboard,
+    grafana templating,
+    grafana query variables,
+  ]
 ---
 
 Dynamic dashboards are essential for teams who rely on scalable monitoring solutions, especially when working with vast datasets. By leveraging chained variables in Grafana, you can make your dashboards adaptable, enabling them to respond to changes in data sources without manual updates. This article walks you through creating powerful Grafana templates with interconnected (chained) variables, specifically using Prometheus as a data source.
@@ -21,29 +27,28 @@ Template variables in Grafana allow users to switch between different data views
 Grafana supports several types of variables, each serving specific needs:
 
 1. Query Variables
-    
-    Query variables pull dynamic data directly from a data source, such as Prometheus, to populate options in a dropdown.
-    
-    Example: A query like `label_values(http_requests_total, job)` will list all the available jobs in Prometheus and let users select from them.
-    
+
+   Query variables pull dynamic data directly from a data source, such as Prometheus, to populate options in a dropdown.
+
+   Example: A query like `label_values(http_requests_total, job)` will list all the available jobs in Prometheus and let users select from them.
+
 2. Custom Variables
-    
-    Custom variables allow you to define static options manually, which are useful when you have a fixed set of choices.
-    
-    Example: A custom variable with values like `production`, `staging`, `development` can be used to filter a dashboard based on the selected environment.
-    
+
+   Custom variables allow you to define static options manually, which are useful when you have a fixed set of choices.
+
+   Example: A custom variable with values like `production`, `staging`, `development` can be used to filter a dashboard based on the selected environment.
+
 3. Constant Variables
-    
-    Constant variables hold a fixed value that remains the same across the entire dashboard, ideal for reusable static information.
-    
-    Example: A constant variable like `cluster_name: "production-cluster"` can be used throughout the dashboard to reference a specific cluster.
-    
+
+   Constant variables hold a fixed value that remains the same across the entire dashboard, ideal for reusable static information.
+
+   Example: A constant variable like `cluster_name: "production-cluster"` can be used throughout the dashboard to reference a specific cluster.
+
 4. Datasource Variables
-    
-    Datasource variables allow you to switch between different data sources dynamically, useful when working with multiple data sources.
-    
-    Example: A datasource variable can switch between Prometheus and InfluxDB, depending on which source you want to query for the dashboard.
-    
+
+   Datasource variables allow you to switch between different data sources dynamically, useful when working with multiple data sources.
+
+   Example: A datasource variable can switch between Prometheus and InfluxDB, depending on which source you want to query for the dashboard.
 
 ### How Variable Chaining Works
 
@@ -67,30 +72,46 @@ In Grafana, variable chaining allows one variable to reference another’s value
 Let’s create a basic setup with Prometheus to see how chained variables work.
 
 1. Set Up the Primary Variable
-    - Go to Dashboard Settings > Variables and click Add variable.
-        
-        <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image.webp" alt="Adding Variables in dashboards" caption="Adding Variables in dashboards" />
-        
-    - Select Query as the variable type and choose Prometheus as the data source.
-        
-        <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%201.webp" alt="Defining variable parameters" caption="Defining variable parameters" />
-        
-    - In the Query field, use a query like `label_values(job)` to retrieve all available jobs.
-        
-        <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%202.webp" alt="Writing query to populate values in the variable" caption="Writing query to populate values in the variable" />
-        
-    - Give the variable a name, e.g., `job`, and click on the Apply button.
-        
-        <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%203.webp" alt="Saving the variable" caption="Saving the variable" />
-        
+   - Go to Dashboard Settings > Variables and click Add variable.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image.webp"
+       alt="Adding Variables in dashboards"
+       caption="Adding Variables in dashboards"
+     />
+   - Select Query as the variable type and choose Prometheus as the data source.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%201.webp"
+       alt="Defining variable parameters"
+       caption="Defining variable parameters"
+     />
+   - In the Query field, use a query like `label_values(job)` to retrieve all available jobs.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%202.webp"
+       alt="Writing query to populate values in the variable"
+       caption="Writing query to populate values in the variable"
+     />
+   - Give the variable a name, e.g., `job`, and click on the Apply button.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%203.webp"
+       alt="Saving the variable"
+       caption="Saving the variable"
+     />
 2. Configure the Dependent Variable
-    - Add a new variable and select Query as the type.
-    - Set Prometheus as the data source.
-    - In the Query field, use `label_values({job="$job"}, instance)` to populate instances based on the selected `job` value. This example uses `$job` as a reference to the primary variable.
-    - Name the variable `instance` and save it.
-    
-    <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%204.webp" alt="Creating Dependent Variable" caption="Creating Dependent Variable" />
-    
+
+   - Add a new variable and select Query as the type.
+   - Set Prometheus as the data source.
+   - In the Query field, use `label_values({job="$job"}, instance)` to populate instances based on the selected `job` value. This example uses `$job` as a reference to the primary variable.
+   - Name the variable `instance` and save it.
+
+   <Figure
+     src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%204.webp"
+     alt="Creating Dependent Variable"
+     caption="Creating Dependent Variable"
+   />
 
 ### Understanding Variable Syntax
 
@@ -108,23 +129,24 @@ Best practices for naming and organizing variables
 Once you've set up basic variables, you can explore more advanced reference patterns to create more dynamic and context-sensitive queries in Grafana. Here's how to handle both simple and more complex references:
 
 1. Basic and Complex Patterns
-    - Single Variable Reference:
-        - This is a straightforward way to reference a single variable in your query. For example, `label_values(job)` fetches all available job labels.
-        - To filter a second variable based on the first (e.g., `instance` values associated with a selected `job`), you can use `label_values(instance, {job="$job"})`. This ensures that the `instance` variable only shows values for the chosen `job`, allowing you to narrow down your data selection step-by-step.
-    - Multiple Dependencies:
-        - As dashboards become more complex, you may need to reference more than one variable in a single query. This allows for deeper filtering of data based on multiple criteria.
-        - For example, `label_values(metric_name{job="$job", instance="$instance"})` references both `job` and `instance` variables. This query would fetch metric values filtered by both the selected `job` and `instance` values, making the data highly specific to your selections.
+   - Single Variable Reference:
+     - This is a straightforward way to reference a single variable in your query. For example, `label_values(job)` fetches all available job labels.
+     - To filter a second variable based on the first (e.g., `instance` values associated with a selected `job`), you can use `label_values(instance, {job="$job"})`. This ensures that the `instance` variable only shows values for the chosen `job`, allowing you to narrow down your data selection step-by-step.
+   - Multiple Dependencies:
+     - As dashboards become more complex, you may need to reference more than one variable in a single query. This allows for deeper filtering of data based on multiple criteria.
+     - For example, `label_values(metric_name{job="$job", instance="$instance"})` references both `job` and `instance` variables. This query would fetch metric values filtered by both the selected `job` and `instance` values, making the data highly specific to your selections.
 2. Using Regex Filters
-    
-    You can filter values based on patterns with regex:
-    
-    - For example, using `label_values({job=~"$job_pattern"}, instance)` allows dynamic instance selection based on `job_pattern`.
+
+   You can filter values based on patterns with regex:
+
+   - For example, using `label_values({job=~"$job_pattern"}, instance)` allows dynamic instance selection based on `job_pattern`.
+
 3. Error Handling and Validation
-    
-    Sometimes, chained variables can lead to errors if a referenced variable isn’t set or returns no results. To manage this:
-    
-    - Ensure primary variables have default values.
-    - Wrap queries in error-safe PromQL expressions if possible.
+
+   Sometimes, chained variables can lead to errors if a referenced variable isn’t set or returns no results. To manage this:
+
+   - Ensure primary variables have default values.
+   - Wrap queries in error-safe PromQL expressions if possible.
 
 ## Advanced Variable Chaining Techniques
 
@@ -150,26 +172,29 @@ This functionality allows for more precise filtering and more efficient data exp
 Steps to set up cascading dropdowns:
 
 1. Define the Parent Variable (e.g., `job`)
-    
-    Create a variable for `job` that lists all available jobs. This will be the parent dropdown.
-    
+
+   Create a variable for `job` that lists all available jobs. This will be the parent dropdown.
+
 2. Define the Dependent Variable (e.g., `instance`)
-    
-    Create a second variable for `instance` with a query that uses the selected `job` value. For example, use `$job` in the query to filter instances based on the chosen job.
-    
+
+   Create a second variable for `instance` with a query that uses the selected `job` value. For example, use `$job` in the query to filter instances based on the chosen job.
+
 3. Save Both Variables
-    
-    After setting up both variables, save the dashboard.
-    
+
+   After setting up both variables, save the dashboard.
+
 4. Test the Cascade
-    
-    Go to the dashboard view, where you’ll see two dropdowns: one for `job` and one for `instance`.
-    
-    - Select a `job` in the first dropdown.
-    - The `instance` dropdown will automatically update to display only instances associated with the selected job, letting you refine data selections efficiently.
-    
-    <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%205.webp" alt="Cascading Dropdowns" caption="Cascading Dropdowns" />
-    
+
+   Go to the dashboard view, where you’ll see two dropdowns: one for `job` and one for `instance`.
+
+   - Select a `job` in the first dropdown.
+   - The `instance` dropdown will automatically update to display only instances associated with the selected job, letting you refine data selections efficiently.
+
+   <Figure
+     src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%205.webp"
+     alt="Cascading Dropdowns"
+     caption="Cascading Dropdowns"
+   />
 
 To make use of these variables in a panel, you might use a query like:
 
@@ -179,7 +204,11 @@ up{job="$job", instance="$instance"}
 
 This query will filter based on both the selected job and instance, displaying data specific to the chosen cascading options.
 
-<Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%206.webp" alt="Displaying data specific to the chosen cascading options." caption="Displaying data specific to the chosen cascading options." />
+<Figure
+  src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%206.webp"
+  alt="Displaying data specific to the chosen cascading options."
+  caption="Displaying data specific to the chosen cascading options."
+/>
 
 ### Create Dynamic Query Variables
 
@@ -187,36 +216,40 @@ Grafana’s `query` variable type allows you to define a Prometheus query direct
 
 Use Prometheus functions like `label_values(<label>)` and `label_values(<metric>, <label>)` to create dynamic lists based on live metrics. Example: label_values(job) populates based on available labels in Prometheus.
 
-<Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%207.webp" alt="Dynamic Query Variables" caption="Dynamic Query Variables" />
+<Figure
+  src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%207.webp"
+  alt="Dynamic Query Variables"
+  caption="Dynamic Query Variables"
+/>
 
 ### Multi-Value Selections
 
 Enable multi-value selection for variables, allowing users to select multiple jobs or instances. This is particularly useful when you want to aggregate or compare data across multiple systems.
 
-<Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%208.webp" alt="Enabling multi-value selections" caption="Enabling multi-value selections" />
+<Figure
+  src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%208.webp"
+  alt="Enabling multi-value selections"
+  caption="Enabling multi-value selections"
+/>
 
-<Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%209.webp" alt="Using multi-value selections" caption="Using multi-value selections" />
+<Figure
+  src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%209.webp"
+  alt="Using multi-value selections"
+  caption="Using multi-value selections"
+/>
 
 ### Optimizing Variable Performance in Grafana
 
 Optimizing variable performance is essential for creating responsive and efficient dashboards, especially in large-scale or complex environments. Here are strategies to ensure better performance for Grafana variables:
 
 - Enable variable caching in Grafana settings
-    
-    Enabling caching for variables in Grafana settings helps reduce repeated queries. Cached variables store their results temporarily, which cuts down on the need to re-fetch data every time a dashboard loads, improving speed and responsiveness.
-    
+  Enabling caching for variables in Grafana settings helps reduce repeated queries. Cached variables store their results temporarily, which cuts down on the need to re-fetch data every time a dashboard loads, improving speed and responsiveness.
 - Use the `regex` parameter to filter results
-    
-    Use the `regex` parameter to retrieve only the data you need, filtering out unnecessary results. By applying regex filters like `/^prod-/`, you can limit variables to production-specific data, which lightens the load and makes queries more efficient.
-    
+  Use the `regex` parameter to retrieve only the data you need, filtering out unnecessary results. By applying regex filters like `/^prod-/`, you can limit variables to production-specific data, which lightens the load and makes queries more efficient.
 - Limit the number of values in multi-value selections
-    
-    Multi-value variables are helpful but can slow dashboards when large numbers of selections are made. Restricting the number of selections with a cap or default values prevents excessive data from being queried at once, keeping performance steady.
-    
+  Multi-value variables are helpful but can slow dashboards when large numbers of selections are made. Restricting the number of selections with a cap or default values prevents excessive data from being queried at once, keeping performance steady.
 - Use specific metrics instead of high-cardinality ones
-    
-    High-cardinality metrics (those with many unique label combinations) are resource-intensive. To optimize, use metrics with lower cardinality whenever possible, especially for variables. [Aggregated metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/), for instance, can provide valuable insights without the overhead of querying every unique label combination.
-    
+  High-cardinality metrics (those with many unique label combinations) are resource-intensive. To optimize, use metrics with lower cardinality whenever possible, especially for variables. [Aggregated metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/), for instance, can provide valuable insights without the overhead of querying every unique label combination.
 
 ## Monitoring Variable Performance with SigNoz
 
@@ -231,13 +264,19 @@ While Grafana excels at data visualization, it lacks dedicated tools for monitor
 Here’s how SigNoz enhances monitoring:
 
 - [Unified Observability](https://signoz.io/unified-observability/): SigNoz integrates metrics, traces, and logs, providing a comprehensive view of application health that simplifies troubleshooting.
-    
-    <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%2010.webp" alt="Unified Observability" caption="Unified Observability" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%2010.webp"
+    alt="Unified Observability"
+    caption="Unified Observability"
+  />
 - Real-time Performance Monitoring: Unlike Grafana, which focuses on historical data, SigNoz enables real-time analysis of application performance, helping identify bottlenecks and issues as they occur.
-    
-    <Figure src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%2011.webp" alt="Real-time Performance Monitoring" caption="Real-time Performance Monitoring" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-make-grafana-template-variable-reference-another-variable-prometheus-datasource-image%2011.webp"
+    alt="Real-time Performance Monitoring"
+    caption="Real-time Performance Monitoring"
+  />
 - Cost-Effective and Simplified Setup: As an open-source solution, SigNoz offers a cost-effective alternative to paid services. Its built-in support for [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) simplifies the setup process, allowing developers to start monitoring quickly without extensive configuration.
 
 SigNoz enables proactive dashboard optimization, ensuring a responsive and efficient observability stack.
@@ -267,4 +306,4 @@ If overused, chained variables can impact Grafana’s performance by increasing
 
 ### How do I implement cascading dropdowns in Grafana?
 
-Create sequential variables where each depends on the previous selection. Use the `label_values` function with filters based on parent variables.
\ No newline at end of file
+Create sequential variables where each depends on the previous selection. Use the `label_values` function with filters based on parent variables.
diff --git a/data/guides/how-to-merge-zero-values-vector-0-with-metric-values-in-promql.mdx b/data/guides/how-to-merge-zero-values-vector-0-with-metric-values-in-promql.mdx
index 96f5ab274..6a962879a 100644
--- a/data/guides/how-to-merge-zero-values-vector-0-with-metric-values-in-promql.mdx
+++ b/data/guides/how-to-merge-zero-values-vector-0-with-metric-values-in-promql.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How to Merge Zero Values with Metrics in PromQL - A Guide
-slug: how-to-merge-zero-values-vector-0-with-metric-values-in-promql
 date: 2024-10-22
 tags: [faq, prometheus]
 authors: [simran_kumari]
 description: Learn how to effectively merge zero values with existing metrics in PromQL queries. Improve data visualization and analysis with this comprehensive guide.
 keywords: [PromQL, zero values, vector(0), metrics, data analysis, Prometheus, monitoring, SigNoz]
-
 ---
 
 PromQL, the query language for Prometheus, is a powerful tool for analyzing time-series data. However, you may encounter challenges when dealing with incomplete datasets or gaps in your time series. These issues can significantly impact your visualizations and analysis. This guide will show you how to merge zero values with existing metrics in PromQL, ensuring more accurate and comprehensive data representation.
@@ -21,9 +18,12 @@ However, when analyzing data, you may often encounter missing data points. These
 Missing data can result in:
 
 - Visualizations that don't reflect the full picture: A brief network outage could leave gaps in your CPU usage graph, making it seem like the system was underutilized.
-    
-    <Figure src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image.webp" alt="Gaps in Data visualization" caption="Gaps in Data visualization" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image.webp"
+    alt="Gaps in Data visualization"
+    caption="Gaps in Data visualization"
+  />
 - Aggregations that skew your analysis: Missing intervals in request rate data could lower the average, misleading you into thinking traffic was lighter than it was.
 - Alerts that trigger incorrectly: If data collection fails, Prometheus might interpret it as zero usage, triggering false alarms.
 
@@ -61,21 +61,24 @@ While the `vector(0)` function is helpful for filling gaps, it doesn’t automat
 To merge zero values with your existing metrics, you'll primarily use the `or` operator in combination with `vector(0)`. Here's a step-by-step guide:
 
 1. Start with your metric query:
-    
-    ```
-    http_requests_total
-    ```
-    
+
+   ```
+   http_requests_total
+   ```
+
 2. Add the `or` operator and `vector(0)`:
-    
-    ```
-    http_requests_total or vector(0)
-    ```
-    
+
+   ```
+   http_requests_total or vector(0)
+   ```
 
 This query returns the `http_requests_total` metric where it exists and 0 where it doesn't.
 
-<Figure src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image%201.webp" alt="Handling missing data with vector(0)" caption="Handling missing data with vector(0)" />
+<Figure
+  src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image%201.webp"
+  alt="Handling missing data with vector(0)"
+  caption="Handling missing data with vector(0)"
+/>
 
 Handling Label Matching When Merging Zero Values
 
@@ -83,13 +86,10 @@ When merging zero values with metrics, label matching is crucial. Prometheus mat
 
 - No Labels on `vector(0)`: By default, `vector(0)` doesn’t carry any labels. This can cause mismatches when comparing it with a metric that has labels.
 - Using `label_replace()`: To ensure correct label matching, you can use the `label_replace()` function to align the labels of `vector(0)` with your metrics:
-    
-    ```
-    http_requests_total or label_replace(vector(0), "job", "my_service", "", "")
-    ```
-    
-    In this example, `label_replace()` assigns a `"job"` label to `vector(0)`, allowing it to match the `http_requests_total` metric's labels. This way, zero values are merged correctly, even when labels are involved.
-    
+  ```
+  http_requests_total or label_replace(vector(0), "job", "my_service", "", "")
+  ```
+  In this example, `label_replace()` assigns a `"job"` label to `vector(0)`, allowing it to match the `http_requests_total` metric's labels. This way, zero values are merged correctly, even when labels are involved.
 
 Best practices for merging zero values:
 
@@ -115,7 +115,11 @@ An example query:
 system_resource_usage * on(instance, exported_instance) group_left error_rate or vector(0)
 ```
 
-<Figure src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image%202.webp" alt="Using combination of grouping and vector(0)" caption="Using combination of grouping and vector(0)" />
+<Figure
+  src="/img/guides/2024/10/how-to-merge-zero-values-vector-0-with-metric-values-in-promql-image%202.webp"
+  alt="Using combination of grouping and vector(0)"
+  caption="Using combination of grouping and vector(0)"
+/>
 
 Query Explanation
 
@@ -135,20 +139,20 @@ metric_name or (vector(0) unless metric_name[24h])
 Merging zero values with metrics has several practical applications:
 
 1. Web Application Performance Monitoring
-    - Use Case: A retail website may show no sales on low-traffic days.
-    - Application: Using `sales_total or vector(0)` fills gaps, allowing accurate daily performance analysis.
+   - Use Case: A retail website may show no sales on low-traffic days.
+   - Application: Using `sales_total or vector(0)` fills gaps, allowing accurate daily performance analysis.
 2. API Health Monitoring
-    - Use Case: An API service experiences inactivity during maintenance.
-    - Application: Merging `api_requests_total or vector(0)` provides accurate visualizations of usage patterns, including periods of inactivity.
+   - Use Case: An API service experiences inactivity during maintenance.
+   - Application: Merging `api_requests_total or vector(0)` provides accurate visualizations of usage patterns, including periods of inactivity.
 3. Infrastructure Resource Management
-    - Use Case: Cloud applications can have idle instances with no reported metrics.
-    - Application: Applying `cpu_usage or vector(0)` shows zero usage during downtime, aiding resource allocation decisions.
+   - Use Case: Cloud applications can have idle instances with no reported metrics.
+   - Application: Applying `cpu_usage or vector(0)` shows zero usage during downtime, aiding resource allocation decisions.
 4. CI/CD Monitoring
-    - Use Case: A CI/CD pipeline may not report metrics during non-deployment periods.
-    - Application: Using `deployment_count or vector(0)` maintains consistent deployment activity tracking.
+   - Use Case: A CI/CD pipeline may not report metrics during non-deployment periods.
+   - Application: Using `deployment_count or vector(0)` maintains consistent deployment activity tracking.
 5. Network Traffic Analysis
-    - Use Case: A network may experience periods of inactivity.
-    - Application: Using `packet_drops or vector(0)` visualizes times with zero drops, improving network health monitoring.
+   - Use Case: A network may experience periods of inactivity.
+   - Application: Using `packet_drops or vector(0)` visualizes times with zero drops, improving network health monitoring.
 
 ## Optimizing Performance When Merging Zero Values
 
@@ -208,4 +212,4 @@ While `vector(0)` is the most common method, you can also use:
 2. `absent()` function to detect missing time series
 3. Custom recording rules to pre-process data and fill gaps
 
-Choose the method that best fits your specific use case and performance requirements.
\ No newline at end of file
+Choose the method that best fits your specific use case and performance requirements.
diff --git a/data/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus.mdx b/data/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus.mdx
index 0ddee6b2e..c898482ae 100644
--- a/data/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus.mdx
+++ b/data/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus.mdx
@@ -1,158 +1,173 @@
 ---
-
 title: How to Monitor Custom Kubernetes Pod Metrics with Prometheus
-slug: how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus
 date: 2024-07-25
 tags: [prometheus, faq]
 authors: [ankit_anand]
 description: Learn how to effectively monitor custom Kubernetes pod metrics using Prometheus. A comprehensive guide for developers and DevOps engineers.
-keywords: [Kubernetes, Prometheus, custom metrics, pod monitoring, metrics collection, Kubernetes monitoring, Prometheus setup, PromQL]
-
+keywords:
+  [
+    Kubernetes,
+    Prometheus,
+    custom metrics,
+    pod monitoring,
+    metrics collection,
+    Kubernetes monitoring,
+    Prometheus setup,
+    PromQL,
+  ]
 ---
 
 <head>
   <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "How to Monitor Custom Kubernetes Pod Metrics with Prometheus",
-  "alternativeHeadline": "Effectively Monitor Custom Kubernetes Pod Metrics Using Prometheus",
-  "author": {
-    "@type": "Person",
-    "name": "Ankit Anand"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-25T00:00:00Z",
-  "dateModified": "2024-07-25T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus/"
-  },
-  "description": "Learn how to effectively monitor custom Kubernetes pod metrics using Prometheus. A comprehensive guide for developers and DevOps engineers.",
-  "keywords": "Kubernetes, Prometheus, custom metrics, pod monitoring, metrics collection, Kubernetes monitoring, Prometheus setup, PromQL",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Kubernetes",
-      "description": "An open-source container orchestration platform for automating deployment, scaling, and management of containerized applications."
-    },
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-    },
-    {
-      "@type": "Thing",
-      "name": "Custom Metrics",
-      "description": "User-defined measurements that provide specific insights into an application's behavior and performance."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Prometheus",
-      "applicationCategory": "Monitoring Tool"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What are custom Kubernetes pod metrics?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Custom Kubernetes pod metrics are user-defined measurements that provide specific insights into your application's behavior and performance. Unlike core metrics (CPU and memory usage), custom metrics offer tailored information relevant to your application's unique characteristics."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do you set up Prometheus for Kubernetes?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To set up Prometheus in your Kubernetes cluster, create a namespace for Prometheus, apply the necessary RBAC rules, create a ConfigMap for Prometheus configuration, and deploy Prometheus using the provided configurations."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do you implement custom pod metrics in Kubernetes?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To implement custom metrics, instrument your application code using a Prometheus client library, create an HTTP endpoint to expose the metrics, and add Prometheus annotations to your pod specification."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are some best practices for custom metric monitoring?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Best practices include following the USE method (monitor Utilization, Saturation, and Errors), keeping metric names consistent and descriptive, using labels for better filtering and aggregation, and setting up alerting rules for critical custom metrics."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "Monitoring Custom Kubernetes Pod Metrics",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Create a Kubernetes namespace for Prometheus",
-        "text": "kubectl create namespace monitoring"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Apply RBAC rules",
-        "text": "Apply necessary RBAC rules to ensure Prometheus has access to Kubernetes resources."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create ConfigMap for Prometheus configuration",
-        "text": "Create a ConfigMap containing Prometheus' configuration details."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Deploy Prometheus",
-        "text": "Deploy Prometheus using the provided configuration files."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Instrument application code",
-        "text": "Use a Prometheus client library to instrument your application code and expose custom metrics."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Add Prometheus annotations",
-        "text": "Add necessary Prometheus annotations to your pod specification to enable metric scraping."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Query and visualize custom metrics",
-        "text": "Use PromQL to query custom metrics and integrate with Grafana for visualization."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Monitor Custom Kubernetes Pod Metrics with Prometheus',
+        alternativeHeadline: 'Effectively Monitor Custom Kubernetes Pod Metrics Using Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-monitor-custom-kubernetes-pod-metrics-using-prometheus/',
+        },
+        description:
+          'Learn how to effectively monitor custom Kubernetes pod metrics using Prometheus. A comprehensive guide for developers and DevOps engineers.',
+        keywords:
+          'Kubernetes, Prometheus, custom metrics, pod monitoring, metrics collection, Kubernetes monitoring, Prometheus setup, PromQL',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes',
+            description:
+              'An open-source container orchestration platform for automating deployment, scaling, and management of containerized applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Custom Metrics',
+            description:
+              "User-defined measurements that provide specific insights into an application's behavior and performance.",
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are custom Kubernetes pod metrics?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Custom Kubernetes pod metrics are user-defined measurements that provide specific insights into your application's behavior and performance. Unlike core metrics (CPU and memory usage), custom metrics offer tailored information relevant to your application's unique characteristics.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do you set up Prometheus for Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To set up Prometheus in your Kubernetes cluster, create a namespace for Prometheus, apply the necessary RBAC rules, create a ConfigMap for Prometheus configuration, and deploy Prometheus using the provided configurations.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do you implement custom pod metrics in Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To implement custom metrics, instrument your application code using a Prometheus client library, create an HTTP endpoint to expose the metrics, and add Prometheus annotations to your pod specification.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some best practices for custom metric monitoring?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Best practices include following the USE method (monitor Utilization, Saturation, and Errors), keeping metric names consistent and descriptive, using labels for better filtering and aggregation, and setting up alerting rules for critical custom metrics.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Monitoring Custom Kubernetes Pod Metrics',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Kubernetes namespace for Prometheus',
+              text: 'kubectl create namespace monitoring',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Apply RBAC rules',
+              text: 'Apply necessary RBAC rules to ensure Prometheus has access to Kubernetes resources.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create ConfigMap for Prometheus configuration',
+              text: "Create a ConfigMap containing Prometheus' configuration details.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Deploy Prometheus',
+              text: 'Deploy Prometheus using the provided configuration files.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Instrument application code',
+              text: 'Use a Prometheus client library to instrument your application code and expose custom metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Prometheus annotations',
+              text: 'Add necessary Prometheus annotations to your pod specification to enable metric scraping.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Query and visualize custom metrics',
+              text: 'Use PromQL to query custom metrics and integrate with Grafana for visualization.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
@@ -205,13 +220,13 @@ kind: ClusterRole
 metadata:
   name: prometheus
 rules:
-- apiGroups: [""]
-  resources:
-  - nodes
-  - services
-  - endpoints
-  - pods
-  verbs: ["get", "list", "watch"]
+  - apiGroups: ['']
+    resources:
+      - nodes
+      - services
+      - endpoints
+      - pods
+    verbs: ['get', 'list', 'watch']
 ---
 apiVersion: v1
 kind: ServiceAccount
@@ -228,10 +243,9 @@ roleRef:
   kind: ClusterRole
   name: prometheus
 subjects:
-- kind: ServiceAccount
-  name: prometheus
-  namespace: monitoring
-
+  - kind: ServiceAccount
+    name: prometheus
+    namespace: monitoring
 ```
 
 1. Create a ConfigMap for Prometheus configuration:
@@ -265,7 +279,6 @@ data:
           target_label: __address__
         - action: labelmap
           regex: __meta_kubernetes_pod_label_(.+)
-
 ```
 
 1. Deploy Prometheus:
@@ -288,19 +301,19 @@ spec:
     spec:
       serviceAccountName: prometheus
       containers:
-      - name: prometheus
-        image: prom/prometheus:v2.37.0
-        args:
-        - "--config.file=/etc/prometheus/prometheus.yml"
-        ports:
-        - containerPort: 9090
-        volumeMounts:
-        - name: config
-          mountPath: /etc/prometheus
+        - name: prometheus
+          image: prom/prometheus:v2.37.0
+          args:
+            - '--config.file=/etc/prometheus/prometheus.yml'
+          ports:
+            - containerPort: 9090
+          volumeMounts:
+            - name: config
+              mountPath: /etc/prometheus
       volumes:
-      - name: config
-        configMap:
-          name: prometheus-config
+        - name: config
+          configMap:
+            name: prometheus-config
 ---
 apiVersion: v1
 kind: Service
@@ -311,9 +324,8 @@ spec:
   selector:
     app: prometheus
   ports:
-  - port: 9090
-    targetPort: 9090
-
+    - port: 9090
+      targetPort: 9090
 ```
 
 Apply these configurations to your cluster using `kubectl apply -f`.
@@ -329,10 +341,9 @@ To expose custom metrics from your Kubernetes pods:
 ```yaml
 metadata:
   annotations:
-    prometheus.io/scrape: "true"
-    prometheus.io/port: "8080"
-    prometheus.io/path: "/metrics"
-
+    prometheus.io/scrape: 'true'
+    prometheus.io/port: '8080'
+    prometheus.io/path: '/metrics'
 ```
 
 Here's an example of a custom metric in Python using the `prometheus_client` library:
@@ -390,4 +401,4 @@ SigNoz offers several advantages over a standalone Prometheus setup:
 
 By using [SigNoz](https://signoz.io/docs/introduction/), you can streamline your monitoring workflow and gain deeper insights into your Kubernetes applications' performance.
 
-Monitoring custom Kubernetes pod metrics is essential for maintaining healthy, performant applications. By leveraging tools like Prometheus and SigNoz, you can gain valuable insights into your application's behavior and make data-driven decisions to improve its performance and reliability.
\ No newline at end of file
+Monitoring custom Kubernetes pod metrics is essential for maintaining healthy, performant applications. By leveraging tools like Prometheus and SigNoz, you can gain valuable insights into your application's behavior and make data-driven decisions to improve its performance and reliability.
diff --git a/data/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes.mdx b/data/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes.mdx
index c48506931..e6413b0f5 100644
--- a/data/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes.mdx
+++ b/data/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes.mdx
@@ -1,143 +1,156 @@
 ---
-
 title: How to Monitor Disk Usage in Kubernetes Persistent Volumes
-slug: how-to-monitor-disk-usage-of-kubernetes-persistent-volumes
 date: 2024-07-25
 tags: [prometheus, faq]
 authors: [yuvraj]
 description: Learn effective methods to monitor disk usage of Kubernetes persistent volumes. Discover tools and best practices for optimal storage management.
 keywords: [Kubernetes, persistent volumes, disk usage, monitoring, storage management, PV, PVC]
-
 ---
 
 <head>
- <script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "How to Monitor Disk Usage in Kubernetes Persistent Volumes",
-  "alternativeHeadline": "Effective Methods to Monitor Disk Usage of Kubernetes Persistent Volumes",
-  "author": {
-    "@type": "Person",
-    "name": "Ankit Anand"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-25",
-  "dateModified": "2024-07-25",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes/"
-  },
-  "description": "Learn effective methods to monitor disk usage of Kubernetes persistent volumes. Discover tools and best practices for optimal storage management.",
-  "keywords": ["Kubernetes", "persistent volumes", "disk usage", "monitoring", "storage management", "PV", "PVC"],
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Kubernetes",
-      "description": "An open-source container orchestration platform for automating deployment, scaling, and management of containerized applications."
-    },
-    {
-      "@type": "Thing",
-      "name": "Persistent Volumes",
-      "description": "Storage resources in Kubernetes that exist independently of pods and provide data persistence."
-    },
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Prometheus",
-      "applicationCategory": "Monitoring Tool"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "How often should I check disk usage in Kubernetes PVs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Check disk usage at least daily for critical applications. For less critical systems, weekly checks may suffice. Automated monitoring solutions can provide real-time insights."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Can I automate PV disk usage monitoring in Kubernetes?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, automation is possible and recommended. Use tools like Prometheus with Alertmanager or custom scripts integrated with your monitoring stack for automated checks and alerts."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the signs of a PV nearing capacity in Kubernetes?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Signs include high percentage of used space (e.g., >80%), increased I/O wait times, application performance degradation, and failed writes due to insufficient space."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I expand a PV when it's running out of space?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To expand a PV, ensure your storage class supports volume expansion, edit the PVC to request more storage, apply the changes using kubectl apply -f pvc.yaml, and verify the expansion with kubectl get pv. Note that not all storage providers support online expansion, and some may require downtime."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "Monitoring Disk Usage of Kubernetes Persistent Volumes",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Using kubectl Commands",
-        "text": "Use kubectl exec to run the df command in pods, kubectl describe to get detailed PV and PVC information, and kubectl top for an overview of resource usage."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Leveraging Prometheus Metrics",
-        "text": "Set up Prometheus in your Kubernetes cluster, configure it to scrape kubelet_volume_stats metrics, create custom dashboards using Grafana, and set up alerts based on PV usage thresholds."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Implementing Custom Monitoring Solutions",
-        "text": "Create debugging pods to access and report PV data, develop scripts that regularly check disk usage, and integrate your own metrics with existing monitoring stacks."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Best Practices for PV Disk Usage Monitoring",
-        "text": "Establish baselines, implement automated alerts, regularly audit PVs and PVCs, and maintain clear procedures for monitoring and responding to disk usage issues."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Monitor Disk Usage in Kubernetes Persistent Volumes',
+        alternativeHeadline:
+          'Effective Methods to Monitor Disk Usage of Kubernetes Persistent Volumes',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-25',
+        dateModified: '2024-07-25',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-monitor-disk-usage-of-kubernetes-persistent-volumes/',
+        },
+        description:
+          'Learn effective methods to monitor disk usage of Kubernetes persistent volumes. Discover tools and best practices for optimal storage management.',
+        keywords: [
+          'Kubernetes',
+          'persistent volumes',
+          'disk usage',
+          'monitoring',
+          'storage management',
+          'PV',
+          'PVC',
+        ],
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes',
+            description:
+              'An open-source container orchestration platform for automating deployment, scaling, and management of containerized applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Persistent Volumes',
+            description:
+              'Storage resources in Kubernetes that exist independently of pods and provide data persistence.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'How often should I check disk usage in Kubernetes PVs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Check disk usage at least daily for critical applications. For less critical systems, weekly checks may suffice. Automated monitoring solutions can provide real-time insights.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I automate PV disk usage monitoring in Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, automation is possible and recommended. Use tools like Prometheus with Alertmanager or custom scripts integrated with your monitoring stack for automated checks and alerts.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the signs of a PV nearing capacity in Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Signs include high percentage of used space (e.g., >80%), increased I/O wait times, application performance degradation, and failed writes due to insufficient space.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How do I expand a PV when it's running out of space?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To expand a PV, ensure your storage class supports volume expansion, edit the PVC to request more storage, apply the changes using kubectl apply -f pvc.yaml, and verify the expansion with kubectl get pv. Note that not all storage providers support online expansion, and some may require downtime.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Monitoring Disk Usage of Kubernetes Persistent Volumes',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Using kubectl Commands',
+              text: 'Use kubectl exec to run the df command in pods, kubectl describe to get detailed PV and PVC information, and kubectl top for an overview of resource usage.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Leveraging Prometheus Metrics',
+              text: 'Set up Prometheus in your Kubernetes cluster, configure it to scrape kubelet_volume_stats metrics, create custom dashboards using Grafana, and set up alerts based on PV usage thresholds.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implementing Custom Monitoring Solutions',
+              text: 'Create debugging pods to access and report PV data, develop scripts that regularly check disk usage, and integrate your own metrics with existing monitoring stacks.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Best Practices for PV Disk Usage Monitoring',
+              text: 'Establish baselines, implement automated alerts, regularly audit PVs and PVCs, and maintain clear procedures for monitoring and responding to disk usage issues.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
@@ -161,27 +174,26 @@ Common challenges in tracking PV storage utilization include dynamic provisionin
 The `kubectl` command-line tool provides several ways to check PV usage:
 
 1. **df command in pods**: Execute the `df` command in pods using PVCs to get disk usage information.
-    
-    ```bash
-    kubectl exec -it <pod-name> -- df -h /path/to/mount
-    
-    ```
-    
+
+   ```bash
+   kubectl exec -it <pod-name> -- df -h /path/to/mount
+
+   ```
+
 2. **kubectl describe**: Use this command to get detailed information about PVs and PVCs.
-    
-    ```bash
-    kubectl describe pv <pv-name>
-    kubectl describe pvc <pvc-name>
-    
-    ```
-    
+
+   ```bash
+   kubectl describe pv <pv-name>
+   kubectl describe pvc <pvc-name>
+
+   ```
+
 3. **[kubectl top](https://signoz.io/blog/kubectl-top/#tracking-pod-resource-consumption-with-kubectl-top-pod)**: While primarily for CPU and memory, it can provide an overview of resource usage.
-    
-    ```bash
-    kubectl top pods
-    
-    ```
-    
+
+   ```bash
+   kubectl top pods
+
+   ```
 
 **Best practice**: Use these commands judiciously in production environments to avoid performance impact.
 
@@ -282,4 +294,4 @@ To set up SigNoz for monitoring your Kubernetes PVs:
 
 <GetStartedSigNoz />
 
-By leveraging [SigNoz](https://signoz.io/docs/introduction/), you can gain deeper insights into your PV usage patterns and their impact on overall application performance, enabling more proactive management of your Kubernetes storage resources.
\ No newline at end of file
+By leveraging [SigNoz](https://signoz.io/docs/introduction/), you can gain deeper insights into your PV usage patterns and their impact on overall application performance, enabling more proactive management of your Kubernetes storage resources.
diff --git a/data/guides/how-to-monitor-docker-containers-with-prometheus-and-grafana.mdx b/data/guides/how-to-monitor-docker-containers-with-prometheus-and-grafana.mdx
index 0e80ccc70..678f360fd 100644
--- a/data/guides/how-to-monitor-docker-containers-with-prometheus-and-grafana.mdx
+++ b/data/guides/how-to-monitor-docker-containers-with-prometheus-and-grafana.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Docker Monitoring - Prometheus and Grafana Setup Guide
-slug: how-to-monitor-docker-containers-with-prometheus-and-grafana
 date: 2024-08-01
 tags: [prometheus]
 authors: [daniel]
 description: Learn how to monitor Docker containers using Prometheus and Grafana. This comprehensive guide covers setup, configuration, and best practices for effective container monitoring.
-keywords: [Docker monitoring, Prometheus, Grafana, container metrics, cAdvisor, Loki, Docker Compose]
-
+keywords:
+  [Docker monitoring, Prometheus, Grafana, container metrics, cAdvisor, Loki, Docker Compose]
 ---
 
 Docker containers have revolutionized application deployment, but they've also introduced new challenges in monitoring and performance management. This guide will walk you through the process of setting up Prometheus and Grafana to monitor your Docker containers, offering insights into performance metrics and helping you maintain a healthy containerized environment.
@@ -41,7 +39,6 @@ scrape_configs:
   - job_name: 'docker'
     static_configs:
       - targets: ['172.17.0.1:9323']
-
 ```
 
 1. Run Prometheus in a Docker container:
@@ -84,7 +81,6 @@ scrape_configs:
   - job_name: 'cadvisor'
     static_configs:
       - targets: ['172.17.0.1:8080']
-
 ```
 
 Restart Prometheus to apply the changes. Now, Prometheus will collect detailed metrics from your Docker containers via cAdvisor.
@@ -104,14 +100,14 @@ docker run -d --name grafana \\
 
 1. Access Grafana at [http://localhost:3000](http://localhost:3000/) (default credentials: admin/admin).
 2. Add Prometheus as a data source:
-    - Go to Configuration > Data Sources
-    - Click "Add data source" and select Prometheus
-    - Set the URL to [http://172.17.0.1:9090](http://172.17.0.1:9090/) (Docker host IP)
-    - Click "Save & Test"
+   - Go to Configuration > Data Sources
+   - Click "Add data source" and select Prometheus
+   - Set the URL to [http://172.17.0.1:9090](http://172.17.0.1:9090/) (Docker host IP)
+   - Click "Save & Test"
 3. Create a new dashboard:
-    - Click the "+" icon in the sidebar and select "Dashboard"
-    - Add a new panel
-    - In the query editor, you can now use PromQL to visualize Docker metrics
+   - Click the "+" icon in the sidebar and select "Dashboard"
+   - Add a new panel
+   - In the query editor, you can now use PromQL to visualize Docker metrics
 
 Here's a simple PromQL query to get you started:
 
@@ -127,15 +123,15 @@ This query shows CPU usage for all containers.
 To create more dynamic and useful dashboards:
 
 1. Use variables for flexibility:
-    - Create a variable for container names
-    - Use this variable in your queries to easily switch between containers
+   - Create a variable for container names
+   - Use this variable in your queries to easily switch between containers
 2. Set up alerting:
-    - Define thresholds for important metrics
-    - Configure Grafana to send notifications when these thresholds are breached
+   - Define thresholds for important metrics
+   - Configure Grafana to send notifications when these thresholds are breached
 3. Organize your dashboards:
-    - Group related panels together
-    - Use consistent naming conventions
-    - Share dashboards with your team for collaborative monitoring
+   - Group related panels together
+   - Use consistent naming conventions
+   - Share dashboards with your team for collaborative monitoring
 
 ## Monitoring Docker Container Logs with Loki
 
@@ -151,8 +147,8 @@ docker run -d --name loki \\
 ```
 
 1. Configure Docker to send logs to Loki:
-    - Update your [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration to use the Loki logging driver
-    - Restart the Docker daemon to apply changes
+   - Update your [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration to use the Loki logging driver
+   - Restart the Docker daemon to apply changes
 2. In Grafana, add Loki as a data source and create log visualization panels alongside your metric panels for comprehensive monitoring.
 
 ## Automating the Setup Process
@@ -167,12 +163,12 @@ services:
     volumes:
       - ./prometheus.yml:/etc/prometheus/prometheus.yml
     ports:
-      - "9090:9090"
+      - '9090:9090'
 
   grafana:
     image: grafana/grafana
     ports:
-      - "3000:3000"
+      - '3000:3000'
 
   cadvisor:
     image: google/cadvisor
@@ -183,13 +179,12 @@ services:
       - /var/lib/docker/:/var/lib/docker:ro
       - /dev/disk/:/dev/disk:ro
     ports:
-      - "8080:8080"
+      - '8080:8080'
 
   loki:
     image: grafana/loki
     ports:
-      - "3100:3100"
-
+      - '3100:3100'
 ```
 
 Run the entire stack with:
@@ -236,4 +231,4 @@ To get started with SigNoz:
 
 SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level. It also provides advanced querying capabilities and custom dashboard creation, similar to Grafana.
 
-Whether you choose Grafana or SigNoz, visualizing your [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) is a crucial step in understanding and optimizing your systems' performance. Start exploring your metrics today and unlock the power of data-driven decision making.
\ No newline at end of file
+Whether you choose Grafana or SigNoz, visualizing your [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) is a crucial step in understanding and optimizing your systems' performance. Start exploring your metrics today and unlock the power of data-driven decision making.
diff --git a/data/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container.mdx b/data/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container.mdx
index 5a78352d7..87b4ebdf4 100644
--- a/data/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container.mdx
+++ b/data/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container.mdx
@@ -1,164 +1,170 @@
 ---
-
 title: Docker - How to Persist Prometheus Data for Reliable Monitoring
-slug: how-to-persist-data-in-prometheus-running-in-a-docker-container
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Learn how to persist Prometheus data in Docker containers for continuous monitoring. Step-by-step guide, best practices, and troubleshooting tips included.
 keywords: [Prometheus, Docker, data persistence, monitoring, container, volume, Docker Compose]
-
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Docker - How to Persist Prometheus Data for Reliable Monitoring",
-    "alternativeHeadline": "Ensuring Prometheus Data Persistence in Docker Containers",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2023-06-09T00:00:00Z",
-    "dateModified": "2023-06-09T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container/"
-    },
-    "description": "Learn how to persist Prometheus data in Docker containers for continuous monitoring. Step-by-step guide, best practices, and troubleshooting tips included.",
-    "keywords": "Prometheus, Docker, data persistence, monitoring, container, volume, Docker Compose",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Docker",
-        "description": "A platform for developing, shipping, and running applications in containers."
-      },
-      {
-        "@type": "Thing",
-        "name": "Data Persistence",
-        "description": "The process of storing data in a way that ensures it remains available across restarts and crashes."
-      },
-      {
-        "@type": "Thing",
-        "name": "Volume",
-        "description": "Docker volumes are storage areas that can be mounted to containers to persist data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Docker Compose",
-        "description": "A tool for defining and running multi-container Docker applications."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Docker",
-        "applicationCategory": "Containerization Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "How does persisting Prometheus data affect performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Persisting data has minimal impact on performance. The slight overhead is outweighed by the benefits of data retention and reliability."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Docker - How to Persist Prometheus Data for Reliable Monitoring',
+        alternativeHeadline: 'Ensuring Prometheus Data Persistence in Docker Containers',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "Can I migrate persisted Prometheus data between different Docker environments?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, you can migrate data by copying the contents of the Docker volume. Ensure version compatibility between environments."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What are the storage requirements for persisting Prometheus data long-term?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Storage needs vary based on metrics volume and retention period. Monitor your data growth and adjust storage accordingly."
-          }
+        datePublished: '2023-06-09T00:00:00Z',
+        dateModified: '2023-06-09T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-persist-data-in-prometheus-running-in-a-docker-container/',
         },
-        {
-          "@type": "Question",
-          "name": "How often should I back up my persisted Prometheus data?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Backup frequency depends on your data criticality. Daily backups are common for important metrics."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Persisting Prometheus Data in Docker",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Create a Docker Volume",
-          "text": "Create a Docker volume to store Prometheus data: docker volume create prometheus-data"
+        description:
+          'Learn how to persist Prometheus data in Docker containers for continuous monitoring. Step-by-step guide, best practices, and troubleshooting tips included.',
+        keywords:
+          'Prometheus, Docker, data persistence, monitoring, container, volume, Docker Compose',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Modify Docker Compose File",
-          "text": "Update your Docker Compose file to mount the volume to Prometheus: version: '3' services: prometheus: image: prom/prometheus:v2.37.0 volumes: - prometheus-data:/prometheus command: - '--config.file=/etc/prometheus/prometheus.yml' - '--storage.tsdb.path=/prometheus' - '--web.console.libraries=/usr/share/prometheus/console_libraries' - '--web.console.templates=/usr/share/prometheus/consoles' ports: - 9090:9090 volumes: prometheus-data: external: true"
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Docker',
+            description:
+              'A platform for developing, shipping, and running applications in containers.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Data Persistence',
+            description:
+              'The process of storing data in a way that ensures it remains available across restarts and crashes.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Volume',
+            description:
+              'Docker volumes are storage areas that can be mounted to containers to persist data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Docker Compose',
+            description: 'A tool for defining and running multi-container Docker applications.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Docker',
+            applicationCategory: 'Containerization Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'How does persisting Prometheus data affect performance?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Persisting data has minimal impact on performance. The slight overhead is outweighed by the benefits of data retention and reliability.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I migrate persisted Prometheus data between different Docker environments?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, you can migrate data by copying the contents of the Docker volume. Ensure version compatibility between environments.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the storage requirements for persisting Prometheus data long-term?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Storage needs vary based on metrics volume and retention period. Monitor your data growth and adjust storage accordingly.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How often should I back up my persisted Prometheus data?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Backup frequency depends on your data criticality. Daily backups are common for important metrics.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Correct Permissions",
-          "text": "Set the correct permissions for the mounted volume: docker run --rm -v prometheus-data:/prometheus prom/prometheus:v2.37.0 chown -R nobody:nobody /prometheus"
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Persisting Prometheus Data in Docker',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Docker Volume',
+              text: 'Create a Docker volume to store Prometheus data: docker volume create prometheus-data',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Modify Docker Compose File',
+              text: "Update your Docker Compose file to mount the volume to Prometheus: version: '3' services: prometheus: image: prom/prometheus:v2.37.0 volumes: - prometheus-data:/prometheus command: - '--config.file=/etc/prometheus/prometheus.yml' - '--storage.tsdb.path=/prometheus' - '--web.console.libraries=/usr/share/prometheus/console_libraries' - '--web.console.templates=/usr/share/prometheus/consoles' ports: - 9090:9090 volumes: prometheus-data: external: true",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Correct Permissions',
+              text: 'Set the correct permissions for the mounted volume: docker run --rm -v prometheus-data:/prometheus prom/prometheus:v2.37.0 chown -R nobody:nobody /prometheus',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Start Prometheus Container',
+              text: 'Start your Prometheus container with the updated configuration: docker-compose up -d',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Verify Data Persistence',
+              text: 'Verify data persistence by stopping and restarting the container, then checking if your metrics are still available in the Prometheus UI.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus Container",
-          "text": "Start your Prometheus container with the updated configuration: docker-compose up -d"
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Verify Data Persistence",
-          "text": "Verify data persistence by stopping and restarting the container, then checking if your metrics are still available in the Prometheus UI."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus is a powerful monitoring tool, but running it in a Docker container can lead to data loss when the container stops or restarts. This guide shows you how to persist Prometheus data in a Docker container, ensuring your metrics remain intact and accessible for long-term analysis.
@@ -209,7 +215,6 @@ services:
 volumes:
   prometheus-data:
     external: true
-
 ```
 
 1. Set correct permissions:
@@ -227,8 +232,8 @@ docker-compose up -d
 ```
 
 1. Verify data persistence:
-    - Stop and restart the container
-    - Check if your metrics are still available in the Prometheus UI
+   - Stop and restart the container
+   - Check if your metrics are still available in the Prometheus UI
 
 ## Best Practices for Prometheus Data Persistence
 
@@ -293,4 +298,4 @@ Storage needs vary based on metrics volume and retention period. Monitor your da
 
 ### How often should I back up my persisted Prometheus data?
 
-Backup frequency depends on your data criticality. Daily backups are common for important metrics.
\ No newline at end of file
+Backup frequency depends on your data criticality. Daily backups are common for important metrics.
diff --git a/data/guides/how-to-reduce-datadog-costs.mdx b/data/guides/how-to-reduce-datadog-costs.mdx
index 377977cef..59ecbec9c 100644
--- a/data/guides/how-to-reduce-datadog-costs.mdx
+++ b/data/guides/how-to-reduce-datadog-costs.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Reduce Datadog Costs Without Sacrificing Observability
-slug: how-to-reduce-datadog-costs
 date: 2025-05-27
 tags: [Observability]
 authors: [yuvraj]
 description: Learn proven strategies to reduce Datadog costs by 30-70% without sacrificing observability. Include tips for controlling custom metrics, optimizing logs, managing hosts, and avoiding common pricing pitfalls.
-keywords: [datadog pricing, observability costs, monitoring expenses, APM pricing, log management costs]
-
+keywords:
+  [datadog pricing, observability costs, monitoring expenses, APM pricing, log management costs]
 ---
 
 Datadog bills can spiral out of control quickly. We've previously covered [how Datadog pricing works](https://signoz.io/blog/datadog-pricing/) and the common pricing pitfalls teams face. This guide dives into proven strategies to slash your Datadog costs by 30-70% while maintaining the observability your team needs.
@@ -34,7 +32,6 @@ Beyond free allotments (100 per host on Pro), each unique metric timeseries cost
 
 Each feature (traces, RUM, synthetics) has separate pricing units. Enabling integrations can flood your account with hundreds of default metrics.
 
-
 ## Strategies to Reduce Datadog Costs
 
 Many datadog exploding bills surprises come from:
@@ -44,14 +41,13 @@ Many datadog exploding bills surprises come from:
 - Verbose logging in production.
 - High-cardinality metrics from dynamic tags.
 
-Datadog’s **costs scale with your usage of hosts, metrics, logs, traces, etc.** - uncontrolled growth in any of these will translate to a higher bill. 
+Datadog’s **costs scale with your usage of hosts, metrics, logs, traces, etc.** - uncontrolled growth in any of these will translate to a higher bill.
 
 The following sections outline strategies to keep these costs under control without sacrificing observability.
 
-
 ### 1. Control Custom Metrics and Cardinality
 
-Custom metrics are useful for application-specific monitoring, but they can become a *silent budget killer* if not managed.
+Custom metrics are useful for application-specific monitoring, but they can become a _silent budget killer_ if not managed.
 
 Each unique metric name + tag combination counts as a separate timeseries.
 
@@ -83,14 +79,18 @@ Be careful: with this feature, you might pay for two volumes – ingested vs ind
 
 **Pre-Aggregate When Possible:**
 
-If you only need high-level trends and not granular details, consider aggregating metrics *before* sending to Datadog.
+If you only need high-level trends and not granular details, consider aggregating metrics _before_ sending to Datadog.
 
 - Example: For example, instead of sending a custom metric with `{user_id}` tag for every user’s action (and incurring one series per user), aggregate counts or sums by minute and send a metric like `app.feature.usage_count` with no user tag.
 
 **Monitor Metric Usage:**
 Use Datadog's **Metrics Summary** page to identify top metrics by cardinality. Set up alerts when metric counts spike unexpectedly.
 
-<Figure src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%201.webp" alt="Metrics Summary page showing highest cardinality metrics. (Source: Datadog docs)" caption="Metrics Summary page showing highest cardinality metrics. (Source: Datadog docs)" />
+<Figure
+  src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%201.webp"
+  alt="Metrics Summary page showing highest cardinality metrics. (Source: Datadog docs)"
+  caption="Metrics Summary page showing highest cardinality metrics. (Source: Datadog docs)"
+/>
 
 ### 2. Optimize Log Collection, Indexing, and Retention
 
@@ -108,26 +108,25 @@ logs:
     log_processing_rules:
       - type: exclude_at_match
         name: exclude_healthchecks
-        pattern: "healthcheck"
+        pattern: 'healthcheck'
       - type: exclude_at_match
         name: exclude_debug
-        pattern: " DEBUG "
-
+        pattern: ' DEBUG '
 ```
 
 The above configuration will **drop any log line containing "healthcheck" or " DEBUG "** (note the spaces to target log level in context). The `exclude_at_match` rule ensures matching logs are not sent to Datadog. By doing this, you stop paying for logs that provide little value.
 
-**Why filter before sending?** Once data reaches Datadog, you’re incurring ingestion costs. Dropping data *after* ingestion (via exclusion filters) saves on indexing but not on ingestion costs. So it’s often best to do initial filtering in your logging agent or pipeline on your infrastructure.
+**Why filter before sending?** Once data reaches Datadog, you’re incurring ingestion costs. Dropping data _after_ ingestion (via exclusion filters) saves on indexing but not on ingestion costs. So it’s often best to do initial filtering in your logging agent or pipeline on your infrastructure.
 
 **Reminder:** When filtering, ensure you’re not [dropping logs](https://signoz.io/docs/logs-management/guides/drop-logs/) that you’ll regret losing during an incident. A good approach is to involve developers in deciding which logs are mission-critical.
 
 **Use Exclusion Filters for Indexing:**
 
-Even after filtering at source, you’ll have logs that you **do** send to Datadog for archive or metrics, but perhaps you don’t need all of them indexed (searchable) in real-time. 
+Even after filtering at source, you’ll have logs that you **do** send to Datadog for archive or metrics, but perhaps you don’t need all of them indexed (searchable) in real-time.
 
-Datadog lets you define **Log Exclusion Filters** on indexes – rules that say “ingest the log (for archive or live tail) but don’t index it for search”. 
+Datadog lets you define **Log Exclusion Filters** on indexes – rules that say “ingest the log (for archive or live tail) but don’t index it for search”.
 
-For example, you might keep ERROR and WARN logs indexed, but exclude INFO logs from indexing to save on storage costs. 
+For example, you might keep ERROR and WARN logs indexed, but exclude INFO logs from indexing to save on storage costs.
 
 **Shorten Retention Periods:**
 
@@ -148,7 +147,11 @@ Smaller log events = fewer GB ingested = lower cost. Datadog suggests using an 
 
 Hard caps prevent runaway costs. Set quotas slightly above normal peak usage—when exceeded, additional logs are dropped from indexing.
 
-<Figure src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%202.webp" alt="Log index configuration showing daily quotas. (source: Datadog docs)" caption="Log index configuration showing daily quotas. (source: Datadog docs)" />
+<Figure
+  src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%202.webp"
+  alt="Log index configuration showing daily quotas. (source: Datadog docs)"
+  caption="Log index configuration showing daily quotas. (source: Datadog docs)"
+/>
 
 ### 3. Clean Up Unused Metrics, Dashboards, and Pipelines
 
@@ -166,19 +169,23 @@ Over time, it’s common for organizations to accumulate cruft in their monitori
 2. Bulk delete dashboards not accessed in 3+ months
 3. Use Datadog's 30-day recycle bin as safety net
 
-<Figure src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%203.webp" alt="Recently deleted dashboards can be recovered using the recycle bin. (source: Datadog docs)" caption="Recently deleted dashboards can be recovered using the recycle bin. (source: Datadog docs)" />
+<Figure
+  src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%203.webp"
+  alt="Recently deleted dashboards can be recovered using the recycle bin. (source: Datadog docs)"
+  caption="Recently deleted dashboards can be recovered using the recycle bin. (source: Datadog docs)"
+/>
 
-While dashboards themselves don’t incur direct cost, they often pull in metrics (and people might keep metrics because “it’s on some dashboard”). 
+While dashboards themselves don’t incur direct cost, they often pull in metrics (and people might keep metrics because “it’s on some dashboard”).
 
 **Remove Unused Log Pipelines:**
 
-An unused pipeline might not incur a cost directly, but it adds processing overhead and complexity. More importantly, some pipelines extract custom attributes or generate metrics from logs which *do* cost money.
+An unused pipeline might not incur a cost directly, but it adds processing overhead and complexity. More importantly, some pipelines extract custom attributes or generate metrics from logs which _do_ cost money.
 
 Delete pipelines for retired services or those generating unused metrics from logs.
 
 ### 4. Set Up Proactive Billing Alerts and Usage Caps
 
-Just as you monitor CPU or error rates, you can monitor your Datadog spend. Datadog’s Cloud Cost Management features let you create **cost monitors** that trigger alerts based on usage or cost thresholds. 
+Just as you monitor CPU or error rates, you can monitor your Datadog spend. Datadog’s Cloud Cost Management features let you create **cost monitors** that trigger alerts based on usage or cost thresholds.
 
 **Cost Monitors:**
 
@@ -194,47 +201,40 @@ Allocate costs by team using tags. Set budgets and alert when teams exceed alloc
 
 **Treat your observability usage as a monitored system**. Set thresholds, get alerted on abnormal usage, and react quickly – either by optimizing usage or contacting Datadog to adjust the plan if truly needed.
 
-<Figure src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%204.webp" alt="Datadog cost monitor dashboard." caption="Datadog cost monitor dashboard." />
+<Figure
+  src="/img/guides/2025/05/how-to-reduce-datadog-costs-image%204.webp"
+  alt="Datadog cost monitor dashboard."
+  caption="Datadog cost monitor dashboard."
+/>
 
 ## Use SigNoz for Simple Usage-based Predictable Observability Costs
 
-
 Even with all the cost optimisations, the stories of exploding Datadog bills are quite common.
 
 In 2021, Coinbase famously faced a \$65 million annual Datadog bill before stepping back to renegotiate and explore alternatives.
 
-{/* > *"I used to work at Coinbase actually. At Coinbase, there was a huge effort internally to minimize the Datadog bill. I think we were spending tens of millions of dollars on Datadog at Coinbase."*
-— Shiv Ansal, Co-founder & CTO, Bands (Read [full case study](https://signoz.io/case-study/bands/)) */}
-
-
+{/_ > _"I used to work at Coinbase actually. At Coinbase, there was a huge effort internally to minimize the Datadog bill. I think we were spending tens of millions of dollars on Datadog at Coinbase."_
+— Shiv Ansal, Co-founder & CTO, Bands (Read [full case study](https://signoz.io/case-study/bands/)) _/}
 
 SigNoz takes a simpler approach:
 
 - **No Per-Metric Fees**
-    
-    Unlike Datadog’s $0.05/series model, SigNoz charges only for raw data volume:
-    
-    - **Metrics:** \$0.10 per million samples/month (all series included)
-    - **Logs & Traces:** \$0.30 per GB ingested/month (regardless of field count or cardinality)
-        
-        This means you can emit high-cardinality metrics (e.g. per-user counters) without per-series penalties, cost scales purely with event volume.
-        
+  Unlike Datadog’s $0.05/series model, SigNoz charges only for raw data volume:
+  - **Metrics:** \$0.10 per million samples/month (all series included)
+  - **Logs & Traces:** \$0.30 per GB ingested/month (regardless of field count or cardinality)
+    This means you can emit high-cardinality metrics (e.g. per-user counters) without per-series penalties, cost scales purely with event volume.
 - **Transparent Data Flow**
-    
-    SigNoz uses a columnar database under the hood, so you know exactly how bytes translate into cost. There’s no hidden “indexed vs. ingested” split for metrics, it’s a single volume-based pool.
-    
+  SigNoz uses a columnar database under the hood, so you know exactly how bytes translate into cost. There’s no hidden “indexed vs. ingested” split for metrics, it’s a single volume-based pool.
 - **Self-Hosting Option**
-    
-    Run the full stack (ClickHouse + [OpenTelemetry collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) + frontend) on your own infrastructure for zero licensing costs—only pay your cloud/VM bills.
-    
+  Run the full stack (ClickHouse + [OpenTelemetry collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) + frontend) on your own infrastructure for zero licensing costs—only pay your cloud/VM bills.
 - **Core Observability Features**
-    - **Metrics:** Prebuilt dashboards for system and application metrics, plus custom queries via PromQL.
-    - **Logs:** Query your logs quickly with our powerful logs [query builder](https://signoz.io/blog/query-builder-v5/) with cost-effective long-term storage of logs.
-    - **Traces:** Native [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) support with distributed-trace flame graphs and span-level querying.
-    - **Alerts:** Threshold and anomaly detectors driven by real-time data.
+  - **Metrics:** Prebuilt dashboards for system and application metrics, plus custom queries via PromQL.
+  - **Logs:** Query your logs quickly with our powerful logs [query builder](https://signoz.io/blog/query-builder-v5/) with cost-effective long-term storage of logs.
+  - **Traces:** Native [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) support with distributed-trace flame graphs and span-level querying.
+  - **Alerts:** Threshold and anomaly detectors driven by real-time data.
 - **Technical Advantages**
-    - **Unified Storage:** All telemetry (metrics, logs, traces) lives in one ClickHouse cluster—cross-correlation queries are just SQL joins.
-    - **Resource Efficiency:** ClickHouse’s columnar storage delivers high throughput at low cost per GB.
+  - **Unified Storage:** All telemetry (metrics, logs, traces) lives in one ClickHouse cluster—cross-correlation queries are just SQL joins.
+  - **Resource Efficiency:** ClickHouse’s columnar storage delivers high throughput at low cost per GB.
 
 <Figure
   src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp"
@@ -292,4 +292,4 @@ Explore a [feature-by-feature comparison of SigNoz vs. Datadog](https://signoz.i
 5. **Consider alternatives:** For high-volume workloads, tools like [SigNoz](https://signoz.io/docs/introduction/) can offer 90%+ savings.
 6. **Optimize incrementally:** Start with biggest cost drivers (usually custom metrics and logs).
 
-Most teams can reduce Datadog costs by 30-70% through these optimizations while maintaining essential observability. The key is treating cost as a first-class metric to monitor and optimize continuously.
\ No newline at end of file
+Most teams can reduce Datadog costs by 30-70% through these optimizations while maintaining essential observability. The key is treating cost as a first-class metric to monitor and optimize continuously.
diff --git a/data/guides/how-to-see-prometheus-metrics-in-grafana.mdx b/data/guides/how-to-see-prometheus-metrics-in-grafana.mdx
index 97b6f67c5..ac398126b 100644
--- a/data/guides/how-to-see-prometheus-metrics-in-grafana.mdx
+++ b/data/guides/how-to-see-prometheus-metrics-in-grafana.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: Visualizing Prometheus Metrics in Grafana - A Beginner's Guide
-slug: how-to-see-prometheus-metrics-in-grafana
 date: 2024-08-01
 tags: [prometheus]
 authors: [daniel]
 description: Learn how to visualize Prometheus metrics in Grafana with this comprehensive guide for beginners. Discover setup, querying, and best practices.
 keywords: [Prometheus, Grafana, metrics visualization, monitoring, PromQL, dashboards]
-
 ---
 
 If you're wondering how to see Prometheus metrics in Grafana, you're in the right place. This guide walks you through the process, from understanding these tools to creating insightful dashboards.
@@ -130,4 +127,4 @@ To get started with SigNoz:
 
 SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level. It also provides advanced querying capabilities and custom dashboard creation, similar to Grafana.
 
-Whether you choose Grafana or SigNoz, visualizing your Prometheus metrics is a crucial step in understanding and optimizing your systems' performance. Start exploring your metrics today and unlock the power of data-driven decision making.
\ No newline at end of file
+Whether you choose Grafana or SigNoz, visualizing your Prometheus metrics is a crucial step in understanding and optimizing your systems' performance. Start exploring your metrics today and unlock the power of data-driven decision making.
diff --git a/data/guides/how-to-set-dashboards-on-grafana-home-page.mdx b/data/guides/how-to-set-dashboards-on-grafana-home-page.mdx
index 38869e15e..8879bed3b 100644
--- a/data/guides/how-to-set-dashboards-on-grafana-home-page.mdx
+++ b/data/guides/how-to-set-dashboards-on-grafana-home-page.mdx
@@ -1,16 +1,21 @@
 ---
-
 title: How to Set Up a Custom Dashboard on Grafana's Home Page
-slug: how-to-set-dashboards-on-grafana-home-page
 date: 2024-10-30
 tags: [Grafana]
 authors: [simran_kumari]
 description: Learn how to customize Grafana's home page with a tailored dashboard. This guide covers setup, troubleshooting, and best practices for optimal data visualization.
-keywords: [Grafana dashboard, home page customization, data visualization, monitoring, Grafana setup, dashboard design]
-
+keywords:
+  [
+    Grafana dashboard,
+    home page customization,
+    data visualization,
+    monitoring,
+    Grafana setup,
+    dashboard design,
+  ]
 ---
 
-Grafana stands as a powerful open-source platform for monitoring and observability, offering robust data visualization capabilities. One of its most valuable features is the ability to customize dashboards to suit your needs.  For users who frequently revisit Grafana, having a custom dashboard set as the home page can streamline workflows and improve efficiency. This guide will walk you through the process of setting up a custom home dashboard in Grafana, from basic steps to advanced customization, along with tips for creating effective dashboards and leveraging SigNoz for enhanced monitoring.
+Grafana stands as a powerful open-source platform for monitoring and observability, offering robust data visualization capabilities. One of its most valuable features is the ability to customize dashboards to suit your needs. For users who frequently revisit Grafana, having a custom dashboard set as the home page can streamline workflows and improve efficiency. This guide will walk you through the process of setting up a custom home dashboard in Grafana, from basic steps to advanced customization, along with tips for creating effective dashboards and leveraging SigNoz for enhanced monitoring.
 
 ## Understanding Grafana's Home Dashboard
 
@@ -40,29 +45,50 @@ Follow these steps to set a custom dashboard as your Grafana home page:
 
 1. Log in to Grafana: Begin by logging into Grafana with credentials that have the necessary permissions (Admin or Editor role).
 2. Navigate to the desired dashboard: Locate the dashboard you want to set as your home page.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image.webp" alt="Navigate to the desired dashboard" caption="Navigate to the desired dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image.webp"
+     alt="Navigate to the desired dashboard"
+     caption="Navigate to the desired dashboard"
+   />
+
 3. Star the dashboard: To ensure the dashboard is marked as important, click the star icon located in the top-right corner of the dashboard. Starring a dashboard will make it appear in your list of favorites, and it’s also a best practice when managing multiple dashboards.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%201.webp" alt="Star the dashboard" caption="Star the dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%201.webp"
+     alt="Star the dashboard"
+     caption="Star the dashboard"
+   />
+
 4. Access Default preferences:
-    - Click on the Administration(gear) icon in the left sidebar.
-    - Select "Default Preferences" under the "General" section.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%202.webp" alt="Access Default preferences" caption="Access Default preferences" />
-    
+
+   - Click on the Administration(gear) icon in the left sidebar.
+   - Select "Default Preferences" under the "General" section.
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%202.webp"
+     alt="Access Default preferences"
+     caption="Access Default preferences"
+   />
+
 5. Set the new home dashboard:
-    - In the "Home Dashboard" dropdown, select your starred dashboard.
-    - Click "Save" to apply the changes.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%203.webp" alt="Set the new home dashboard" caption="Set the new home dashboard" />
-    
+
+   - In the "Home Dashboard" dropdown, select your starred dashboard.
+   - Click "Save" to apply the changes.
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%203.webp"
+     alt="Set the new home dashboard"
+     caption="Set the new home dashboard"
+   />
 
 Your selected dashboard will now appear as the home page when you access Grafana.
 
-<Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%204.webp" alt="New Grafana Home Page" caption="New Grafana Home Page" />
+<Figure
+  src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%204.webp"
+  alt="New Grafana Home Page"
+  caption="New Grafana Home Page"
+/>
 
 ### Troubleshooting Common Issues
 
@@ -79,13 +105,21 @@ To further enhance your Grafana experience, consider these advanced customizatio
 
 1. Create a custom welcome dashboard: Design a dashboard specifically for new users or team members, including links to important resources and key metrics.
 2. Incorporate multiple data sources: Grafana supports multiple data sources in one dashboard. By integrating data from Prometheus, Elasticsearch, or InfluxDB, you can create a comprehensive home dashboard that offers a holistic view of your system’s performance.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%205.webp" alt="Creating panels using multiple data sources" caption="Creating panels using multiple data sources" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%205.webp"
+     alt="Creating panels using multiple data sources"
+     caption="Creating panels using multiple data sources"
+   />
+
 3. Use variables and templating: Implement dynamic content that adapts based on user selections or time ranges.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%206.webp" alt="Using Variables" caption="Using Variables" /> 
-    
+
+   <Figure
+     src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%206.webp"
+     alt="Using Variables"
+     caption="Using Variables"
+   />{' '}
+
 4. Implement role-based home dashboards: Set different home dashboards for various user groups based on their roles and responsibilities.
 
 ## Best Practices for Designing an Effective Home Dashboard
@@ -112,14 +146,20 @@ Here are some common reasons you may consider SigNoz over Grafana:
 
 - [Unified Observability](https://signoz.io/unified-observability/): SigNoz provides a one-stop solution for logs, metrics, and traces, whereas Grafana typically focuses on metrics and visualizations. With SigNoz, you don’t need multiple tools to monitor different aspects of your application.
 - Distributed Tracing: One of SigNoz’s key strengths is its built-in support for distributed tracing. This makes it easier to track the performance of microservices and pinpoint issues within your system, an area where Grafana relies on external tools like Jaeger.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%207.webp" alt="Distributed Tracing in SigNoz" caption="Distributed Tracing in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%207.webp"
+    alt="Distributed Tracing in SigNoz"
+    caption="Distributed Tracing in SigNoz"
+  />
 - Simple Setup: SigNoz is easy to set up with built-in capabilities for observability, whereas Grafana often requires additional tools or services like Loki for logs and Tempo for tracing.
 - Integrated Dashboards: With SigNoz, you get an integrated dashboard that handles metrics, logs, and traces together, avoiding the need for configuring multiple data sources and integrations.
-    
-    <Figure src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%208.webp" alt="Integrated Dashboards in SigNoz" caption="Integrated Dashboards in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/how-to-set-dashboards-on-grafana-home-page-image%208.webp"
+    alt="Integrated Dashboards in SigNoz"
+    caption="Integrated Dashboards in SigNoz"
+  />
 
 <GetStartedSigNoz />
 
@@ -150,4 +190,4 @@ Yes, you can revert to the default home dashboard by selecting "Default" in the
 
 ### Can I use a dashboard from a different Grafana organization as my home dashboard?
 
-No, you can only set a dashboard from the current organization as your home dashboard. If you need a dashboard from another organization, consider copying it to your current organization first.
\ No newline at end of file
+No, you can only set a dashboard from the current organization as your home dashboard. If you need a dashboard from another organization, consider copying it to your current organization first.
diff --git a/data/guides/how-to-set-logging-level-from-command-line.mdx b/data/guides/how-to-set-logging-level-from-command-line.mdx
index 8b6fe5b68..01dece5cf 100644
--- a/data/guides/how-to-set-logging-level-from-command-line.mdx
+++ b/data/guides/how-to-set-logging-level-from-command-line.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Set Logging Levels via Command Line in Python - A Quick Guide
-slug: how-to-set-logging-level-from-command-line
 date: 2024-09-04
 tags: [faq]
 authors: [sushant_gaurav]
 description: Learn how to set logging levels from the command line in Python. This guide covers basic to advanced techniques for flexible logging control.
-keywords: [python logging, command line logging, set log level, argparse, debugging, application monitoring]
-
+keywords:
+  [python logging, command line logging, set log level, argparse, debugging, application monitoring]
 ---
 
 Logging is a very important tool in software development as it helps you to gather critical insights related to an application's behaviour and also helps in efficient debugging. The `logging` module of Python provides a lot of robust features, you can also adjust the logging levels dynamically i.e. during runtime. This article will help to learn about how to set logging levels directly from the command line in Python and will help you in making your debugging and monitoring processes more efficient and flexible.
@@ -68,7 +66,11 @@ If you run the script with the DEBUG level:
 python your_script.py --log=DEBUG
 ```
 
-<Figure src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image.webp" alt="Sample Terminal Output with command" caption="Sample Terminal Output with command" />
+<Figure
+  src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image.webp"
+  alt="Sample Terminal Output with command"
+  caption="Sample Terminal Output with command"
+/>
 
 You'll see the following output:
 
@@ -116,7 +118,11 @@ If you're running the script in Google Colab, you can execute it like this (on y
 
 Sample Output:
 
-<Figure src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image%201.webp" alt="Sample Output with code on Google Collab" caption="Sample Output with code on Google Collab" />
+<Figure
+  src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image%201.webp"
+  alt="Sample Output with code on Google Collab"
+  caption="Sample Output with code on Google Collab"
+/>
 
 ### Common Logging Level Arguments
 
@@ -128,7 +134,7 @@ When you are configuring logging levels from the command line then you can use s
 
 These arguments help you to gain flexible control over the logging output. You can utilize them according to the needs during the execution of your Python script.
 
-Example 
+Example
 
 ```python
 import argparse
@@ -180,58 +186,48 @@ if __name__ == "__main__":
 Running the Script
 
 1. Default Behavior (No Arguments)
-    - Command: `python file_name.py`
-    - Output:
-        
-        ```
-        WARNING: This is a warning message
-        ERROR: This is an error message
-        CRITICAL: This is a critical message
-        ```
-        
+   - Command: `python file_name.py`
+   - Output:
+     ```
+     WARNING: This is a warning message
+     ERROR: This is an error message
+     CRITICAL: This is a critical message
+     ```
 2. Using `-log=DEBUG` or `l DEBUG`
-    - Command: `python file_name.py --log=DEBUG`
-    - Output:
-        
-        ```
-        DEBUG: This is a debug message
-        INFO: This is an info message
-        WARNING: This is a warning message
-        ERROR: This is an error message
-        CRITICAL: This is a critical message
-        ```
-        
+   - Command: `python file_name.py --log=DEBUG`
+   - Output:
+     ```
+     DEBUG: This is a debug message
+     INFO: This is an info message
+     WARNING: This is a warning message
+     ERROR: This is an error message
+     CRITICAL: This is a critical message
+     ```
 3. Using `-verbose` or `v`
-    - Command: `python file_name.py --verbose`
-    - Output:
-        
-        ```
-        INFO: This is an info message
-        WARNING: This is a warning message
-        ERROR: This is an error message
-        CRITICAL: This is a critical message
-        ```
-        
-    - Command: `python logging_example.py -vv` (Using `v` twice)
-    - Output:
-        
-        ```
-        DEBUG: This is a debug message
-        INFO: This is an info message
-        WARNING: This is a warning message
-        ERROR: This is an error message
-        CRITICAL: This is a critical message
-        ```
-        
+   - Command: `python file_name.py --verbose`
+   - Output:
+     ```
+     INFO: This is an info message
+     WARNING: This is a warning message
+     ERROR: This is an error message
+     CRITICAL: This is a critical message
+     ```
+   - Command: `python logging_example.py -vv` (Using `v` twice)
+   - Output:
+     ```
+     DEBUG: This is a debug message
+     INFO: This is an info message
+     WARNING: This is a warning message
+     ERROR: This is an error message
+     CRITICAL: This is a critical message
+     ```
 4. Using `-quiet` or `q`
-    - Command: `python logging_example.py --quiet`
-    - Output:
-        
-        ```
-        ERROR: This is an error message
-        CRITICAL: This is a critical message
-        ```
-        
+   - Command: `python logging_example.py --quiet`
+   - Output:
+     ```
+     ERROR: This is an error message
+     CRITICAL: This is a critical message
+     ```
 
 Explanation:
 
@@ -386,18 +382,16 @@ Explanation:
 
 ### Example Usage:
 
-- Increase Verbosity:  In command-line applications, verbosity refers to the amount of information the script outputs during execution. By default, scripts may only show warnings and errors, but you can increase the amount of information (i.e., increase verbosity) by using the `-v` option. When you use the `-v` flag with your command, it typically increases the level of detail in the logs. The more times you use `-v`, the more verbose the output becomes, moving from less detailed logs (e.g., only showing warnings) to more detailed logs (e.g., including debug information).
+- Increase Verbosity: In command-line applications, verbosity refers to the amount of information the script outputs during execution. By default, scripts may only show warnings and errors, but you can increase the amount of information (i.e., increase verbosity) by using the `-v` option. When you use the `-v` flag with your command, it typically increases the level of detail in the logs. The more times you use `-v`, the more verbose the output becomes, moving from less detailed logs (e.g., only showing warnings) to more detailed logs (e.g., including debug information).
 
 ```bash
 python your_script.py -v -v
 ```
 
 - Suppress Output: If you want to suppress all output except errors, you can do so with the help of the `q` flag:
-    
-    ```bash
-    python your_script.py -q
-    ```
-    
+  ```bash
+  python your_script.py -q
+  ```
 
 ## Advanced Techniques for Flexible Logging Control
 
@@ -495,7 +489,12 @@ SigNoz provides a holistic view of your application's performance by correlating
 
 <GetStartedSigNoz />
 
-<Figure src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image%202.webp" alt="" caption="" />### Benefits of Using SigNoz with Dynamic Log Levels
+<Figure
+  src="/img/guides/2024/09/how-to-set-logging-level-from-command-line-image%202.webp"
+  alt=""
+  caption=""
+/>
+### Benefits of Using SigNoz with Dynamic Log Levels
 
 Let’s look at the several benefits of integrating SigNoz with your Python application:
 
@@ -574,6 +573,12 @@ In this example, `module1` will log messages at the `INFO` level and above, whil
 
 ## Resources
 
-- <a href="https://docs.python.org/3/library/logging.html" rel="noopener noreferrer nofollow" target="_blank">Python Official Logging Documentation</a>
+- <a
+    href="https://docs.python.org/3/library/logging.html"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    Python Official Logging Documentation
+  </a>
 - [Python Logging - From Setup to Monitoring with Best Practices](https://signoz.io/guides/logging-in-python/)
-- [SigNoz Python Application Monitoring Guide](https://signoz.io/blog/python-application-monitoring/)
\ No newline at end of file
+- [SigNoz Python Application Monitoring Guide](https://signoz.io/blog/python-application-monitoring/)
diff --git a/data/guides/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards.mdx b/data/guides/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards.mdx
index 096a3bc6f..8c4e544ff 100644
--- a/data/guides/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards.mdx
+++ b/data/guides/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: Grafana - How to Enable Password-Free Dashboard Viewing
-slug: how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards
 date: 2024-09-18
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Learn how to configure Grafana for password-free dashboard viewing. Enhance accessibility while maintaining security for your monitoring dashboards.
-keywords: [Grafana, password-free dashboards, anonymous access, dashboard security, monitoring, observability]
-
+keywords:
+  [
+    Grafana,
+    password-free dashboards,
+    anonymous access,
+    dashboard security,
+    monitoring,
+    observability,
+  ]
 ---
 
 As a system administrator or DevOps professional, you may want to simplify access to your Grafana dashboards. Password-free viewing can be useful for internal teams, public-facing dashboards, or when you need to display metrics on a big screen without the hassle of logging in every time. But before jumping in, it's essential to know how to set this up securely and avoid exposing your sensitive data.
@@ -46,32 +51,40 @@ Grafana offers multiple approaches to enable password-free viewing. Let's explor
 Anonymous access allows anyone to view dashboards without authentication. Here's how to set it up:
 
 1. Locate your configuration file.
-    
-    <aside>
-    💡
-    
-    Configuration file location
-    
-    - The default settings for a Grafana instance are stored in the `$WORKING_DIR/conf/defaults.ini` file. *Do not* change this file.
-    - Depending on your OS, your custom configuration file is either the `$WORKING_DIR/conf/custom.ini` file or the `/usr/local/etc/grafana/grafana.ini` file.
-    - On Windows, the `sample.ini` file is located in the same directory as `defaults.ini` file. It contains all the settings commented out. Copy `sample.ini` and name it `custom.ini`.
-    </aside>
-    
+
+   <aside>
+💡
+
+   Configuration file location
+
+   - The default settings for a Grafana instance are stored in the `$WORKING_DIR/conf/defaults.ini` file. *Do not* change this file.
+   - Depending on your OS, your custom configuration file is either the `$WORKING_DIR/conf/custom.ini` file or the `/usr/local/etc/grafana/grafana.ini` file.
+   - On Windows, the `sample.ini` file is located in the same directory as `defaults.ini` file. It contains all the settings commented out. Copy `sample.ini` and name it `custom.ini`.
+     </aside>
+
 2. Find the `[auth.anonymous]` section in your configuration file(or add it if it doesn't exist).
-    
-    <Figure src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image.webp" alt="Configure authorization in Grafana Configuration file" caption="Configure authorization in Grafana Configuration file" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image.webp"
+     alt="Configure authorization in Grafana Configuration file"
+     caption="Configure authorization in Grafana Configuration file"
+   />
+
 3. Set the following options:
-    
-    ```
-    [auth.anonymous]
-    enabled = true
-    org_name = Main Org.
-    org_role = Viewer
-    ```
-    
-    <Figure src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%201.webp" alt="Enabling Anonymous access for Grafana Dashboard" caption="Enabling Anonymous access for Grafana Dashboard" />
-    
+
+   ```
+   [auth.anonymous]
+   enabled = true
+   org_name = Main Org.
+   org_role = Viewer
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%201.webp"
+     alt="Enabling Anonymous access for Grafana Dashboard"
+     caption="Enabling Anonymous access for Grafana Dashboard"
+   />
+
 4. Save the file and restart the Grafana service.
 
 This configuration grants viewer access to all dashboards in the specified organization to any visitor.
@@ -81,32 +94,44 @@ This configuration grants viewer access to all dashboards in the specified organ
 For more granular control, you can create a dedicated organization for public access:
 
 1. Log in to Grafana as an admin. Visit Administration → General → Organizations → `New org`
-    
-    <Figure src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%202.webp" alt="Creating new organization in Grafana" caption="Creating new organization in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%202.webp"
+     alt="Creating new organization in Grafana"
+     caption="Creating new organization in Grafana"
+   />
+
 2. Create a new organization (e.g., "Public Dashboards").
-    
-    <Figure src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%203.webp" alt="Naming Organization in Grafana" caption="Naming Organization in Grafana" /> 
-    
+
+   <Figure
+     src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%203.webp"
+     alt="Naming Organization in Grafana"
+     caption="Naming Organization in Grafana"
+   />{' '}
+
 - To switch to the new organization, click on your admin user account icon, then select Profile. Scroll down to Organizations and choose the desired organization. Usually, a newly created organization is automatically set as the current one.
-    
-    <Figure src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%204.webp" alt="Switching Profile in Grafana" caption="Switching Profile in Grafana" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/how-to-set-up-grafana-so-that-no-password-is-necessary-to-view-dashboards-image%204.webp"
+    alt="Switching Profile in Grafana"
+    caption="Switching Profile in Grafana"
+  />
+
 1. Set Up Dashboards
-    
-    Add the dashboards you want to expose publicly to this organization. These dashboards will be available to anonymous users if the configuration allows.
-    
+
+   Add the dashboards you want to expose publicly to this organization. These dashboards will be available to anonymous users if the configuration allows.
+
 2. Configure Anonymous Access
-    
-    Modify the Grafana configuration file to enable anonymous access specifically for this new organization:
-    
-    ```
-    [auth.anonymous]
-    enabled = true
-    org_name = <org_name>
-    org_role = Viewer
-    ```
-    
+
+   Modify the Grafana configuration file to enable anonymous access specifically for this new organization:
+
+   ```
+   [auth.anonymous]
+   enabled = true
+   org_name = <org_name>
+   org_role = Viewer
+   ```
+
 3. Restart Grafana: Once you've configured the settings, restart the Grafana service to apply the changes.
 
 ### IP Address Whitelisting
@@ -114,16 +139,16 @@ For more granular control, you can create a dedicated organization for public ac
 For internal use cases, you can restrict access based on IP addresses:
 
 1. In your Grafana configuration file, add:
-    
-    ```
-    [auth.proxy]
-    enabled = true
-    header_name = X-WEBAUTH-USER
-    header_property = username
-    auto_sign_up = true
-    whitelist = 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16
-    ```
-    
+
+   ```
+   [auth.proxy]
+   enabled = true
+   header_name = X-WEBAUTH-USER
+   header_property = username
+   auto_sign_up = true
+   whitelist = 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16
+   ```
+
 2. Configure your reverse proxy to set the `X-WEBAUTH-USER` header for whitelisted IPs.
 
 This method ensures that only devices on specified networks can access dashboards without authentication.
@@ -133,7 +158,7 @@ This method ensures that only devices on specified networks can access dashboard
 While enabling password-free viewing can enhance accessibility, it's crucial to maintain security:
 
 - Implement IP restrictions: Limit access to trusted networks when possible.
-- Use a reverse proxy:  By doing this, you can implement additional authentication steps or even SSL certificates to secure your Grafana instance, even if you’re allowing password-free viewing.
+- Use a reverse proxy: By doing this, you can implement additional authentication steps or even SSL certificates to secure your Grafana instance, even if you’re allowing password-free viewing.
 - Regularly audit access logs: Keep an eye on your access logs to ensure that no unauthorized users are gaining access to your dashboards. Regular audits can help you catch any potential security issues early.
 - Limit functionality for anonymous users: Restrict edit capabilities and sensitive data access.
 
@@ -190,4 +215,4 @@ Anonymous access typically has minimal impact on Grafana's performance. However,
 
 ### What are the limitations of using password-free dashboard viewing?
 
-Password-free viewing usually limits users to read-only access. Features like editing dashboards, accessing data sources, or changing settings remain restricted to authenticated users. Additionally, you may lose the ability to track individual user actions when using anonymous access.
\ No newline at end of file
+Password-free viewing usually limits users to read-only access. Features like editing dashboards, accessing data sources, or changing settings remain restricted to authenticated users. Additionally, you may lose the ability to track individual user actions when using anonymous access.
diff --git a/data/guides/how-to-specify-custom-http-headers-in-prometheus.mdx b/data/guides/how-to-specify-custom-http-headers-in-prometheus.mdx
index fc76ae6da..5d7e25e71 100644
--- a/data/guides/how-to-specify-custom-http-headers-in-prometheus.mdx
+++ b/data/guides/how-to-specify-custom-http-headers-in-prometheus.mdx
@@ -1,159 +1,172 @@
 ---
-
 title: How to Add Custom HTTP Headers in Prometheus - A Guide
-slug: how-to-specify-custom-http-headers-in-prometheus
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [daniel]
 description: Learn how to add custom HTTP headers in Prometheus for enhanced security and access to protected metrics. Explore methods like reverse proxies and custom exporters.
-keywords: [Prometheus, custom HTTP headers, metrics collection, authentication, reverse proxy, custom exporter, Grafana integration]
-
+keywords:
+  [
+    Prometheus,
+    custom HTTP headers,
+    metrics collection,
+    authentication,
+    reverse proxy,
+    custom exporter,
+    Grafana integration,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Add Custom HTTP Headers in Prometheus: A Guide",
-    "alternativeHeadline": "Implementing Custom HTTP Headers in Prometheus for Enhanced Security and Access",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-25T00:00:00Z",
-    "dateModified": "2024-07-25T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-specify-custom-http-headers-in-prometheus/"
-    },
-    "description": "Learn how to add custom HTTP headers in Prometheus for enhanced security and access to protected metrics. Explore methods like reverse proxies and custom exporters.",
-    "keywords": "Prometheus, custom HTTP headers, metrics collection, authentication, reverse proxy, custom exporter, Grafana integration",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metrics Collection",
-        "description": "The process of gathering and storing performance data for analysis."
-      },
-      {
-        "@type": "Thing",
-        "name": "Authentication",
-        "description": "The process of verifying the identity of a user or process."
-      },
-      {
-        "@type": "Thing",
-        "name": "Reverse Proxy",
-        "description": "A server that forwards client requests to other servers."
-      },
-      {
-        "@type": "Thing",
-        "name": "Custom Exporter",
-        "description": "A custom-built application to export metrics with additional functionality."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Can Prometheus natively support custom HTTP headers?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "No, Prometheus does not natively support custom HTTP headers. You need to use external methods like reverse proxies or custom exporters to add this functionality."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Add Custom HTTP Headers in Prometheus: A Guide',
+        alternativeHeadline:
+          'Implementing Custom HTTP Headers in Prometheus for Enhanced Security and Access',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How do custom headers affect Prometheus' performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The impact is generally minimal, but it depends on the implementation method. Reverse proxies may add a slight latency, while custom exporters could increase resource usage."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Are there security risks associated with using custom HTTP headers?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, improper handling of custom headers can lead to security vulnerabilities. Always follow best practices, such as using encryption for sensitive data and regularly rotating credentials."
-          }
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/how-to-specify-custom-http-headers-in-prometheus/',
         },
-        {
-          "@type": "Question",
-          "name": "Can I use custom headers with other Prometheus integrations?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, custom headers can be used with various Prometheus integrations, but the implementation method may vary depending on the specific integration and your infrastructure setup."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Adding Custom HTTP Headers in Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Using a Reverse Proxy",
-          "text": "Install Nginx, create a new configuration file to set up a reverse proxy with custom headers, and update Prometheus configuration to scrape from the proxy."
+        description:
+          'Learn how to add custom HTTP headers in Prometheus for enhanced security and access to protected metrics. Explore methods like reverse proxies and custom exporters.',
+        keywords:
+          'Prometheus, custom HTTP headers, metrics collection, authentication, reverse proxy, custom exporter, Grafana integration',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Creating a Custom Exporter",
-          "text": "Develop a custom exporter in Python or another language to add headers programmatically and fetch metrics from the endpoint."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metrics Collection',
+            description: 'The process of gathering and storing performance data for analysis.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Authentication',
+            description: 'The process of verifying the identity of a user or process.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Reverse Proxy',
+            description: 'A server that forwards client requests to other servers.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Custom Exporter',
+            description:
+              'A custom-built application to export metrics with additional functionality.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Can Prometheus natively support custom HTTP headers?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'No, Prometheus does not natively support custom HTTP headers. You need to use external methods like reverse proxies or custom exporters to add this functionality.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How do custom headers affect Prometheus' performance?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The impact is generally minimal, but it depends on the implementation method. Reverse proxies may add a slight latency, while custom exporters could increase resource usage.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Are there security risks associated with using custom HTTP headers?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, improper handling of custom headers can lead to security vulnerabilities. Always follow best practices, such as using encryption for sensitive data and regularly rotating credentials.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use custom headers with other Prometheus integrations?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, custom headers can be used with various Prometheus integrations, but the implementation method may vary depending on the specific integration and your infrastructure setup.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configuring Grafana",
-          "text": "Add Prometheus as a data source in Grafana and configure custom HTTP headers for secure access."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Adding Custom HTTP Headers in Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Using a Reverse Proxy',
+              text: 'Install Nginx, create a new configuration file to set up a reverse proxy with custom headers, and update Prometheus configuration to scrape from the proxy.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Creating a Custom Exporter',
+              text: 'Develop a custom exporter in Python or another language to add headers programmatically and fetch metrics from the endpoint.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configuring Grafana',
+              text: 'Add Prometheus as a data source in Grafana and configure custom HTTP headers for secure access.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Using SigNoz for Simplified Monitoring',
+              text: 'Set up SigNoz for an integrated monitoring solution with built-in support for custom headers and enhanced security features.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Using SigNoz for Simplified Monitoring",
-          "text": "Set up SigNoz for an integrated monitoring solution with built-in support for custom headers and enhanced security features."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus, a powerful open-source monitoring system, doesn't natively support custom HTTP headers. This limitation can be a roadblock when you need to access protected metrics endpoints or implement authentication mechanisms. But don't worry — you can still add custom HTTP headers to Prometheus with a few clever techniques.
@@ -316,4 +329,4 @@ Yes, improper handling of custom headers can lead to security vulnerabilities. A
 
 ### **Can I use custom headers with other Prometheus integrations?**
 
-Yes, custom headers can be used with various Prometheus integrations, but the implementation method may vary depending on the specific integration and your infrastructure setup.
\ No newline at end of file
+Yes, custom headers can be used with various Prometheus integrations, but the implementation method may vary depending on the specific integration and your infrastructure setup.
diff --git a/data/guides/how-to-use-selected-period-of-time-in-query.mdx b/data/guides/how-to-use-selected-period-of-time-in-query.mdx
index 740fdafe9..842ed9d78 100644
--- a/data/guides/how-to-use-selected-period-of-time-in-query.mdx
+++ b/data/guides/how-to-use-selected-period-of-time-in-query.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Query Data by Time Period - A Step-by-Step Guide
-slug: how-to-use-selected-period-of-time-in-query
 date: 2024-11-20
 tags: [prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to query data by time period with practical examples. Master time-based queries for effective data analysis and monitoring.
-keywords: [time period query, time series data, database querying, time-based analysis, data monitoring, timestamp queries, time range filters]
-
+keywords:
+  [
+    time period query,
+    time series data,
+    database querying,
+    time-based analysis,
+    data monitoring,
+    timestamp queries,
+    time range filters,
+  ]
 ---
 
 Time-based querying is a powerful approach to monitoring and analyzing data trends over time, especially in real-time data platforms like Grafana. This guide will walk you through essential steps, from understanding time-based queries to building advanced time-based visualizations for insights in Grafana.
@@ -27,13 +33,20 @@ With Grafana and Prometheus, you can dynamically query time-series data from you
 In Grafana, you can define time periods in your queries using two main types:
 
 1. Absolute Time Periods: Absolute periods specify exact start and end times, such as `"2023-01-01T00:00:00"` to `"2023-12-31T23:59:59"`. Absolute periods allow you to analyze a fixed timeframe, ideal for detailed reports or historical data snapshots.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image.webp" alt="Absolute Time Periods" caption="Absolute Time Periods" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image.webp"
+     alt="Absolute Time Periods"
+     caption="Absolute Time Periods"
+   />
+
 2. Relative Time Periods: Relative periods use expressions like “last week,” `now-24h` (last 24 hours) or `now-7d` (last seven days), based on the current time. Relative periods are great for dashboards, as they automatically update to reflect the latest data without manual adjustment.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%201.webp" alt="Relative Time Periods" caption="Relative Time Periods" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%201.webp"
+     alt="Relative Time Periods"
+     caption="Relative Time Periods"
+   />
 
 Grafana makes it easy to switch between these periods using its built-in time selector, allowing you to customize your view with just a few clicks.
 
@@ -76,9 +89,9 @@ When using Prometheus in Grafana, you’ll typically see time-selection patterns
 Selecting the right time range format is essential for effective time-based querying in Grafana with Prometheus. Here’s a breakdown of commonly used formats:
 
 1. Relative Time Expressions: Grafana’s relative time options allow for dynamically changing time ranges based on the current time. For example:
-    - `last 24h`: Shows the last 24 hours from the current time.
-    - `past week`: Displays data from the last seven days.
-    - `now-1h` to `now`: Custom expressions like `now-1h` to `now` are also available, letting you fine-tune time ranges based on specific requirements.
+   - `last 24h`: Shows the last 24 hours from the current time.
+   - `past week`: Displays data from the last seven days.
+   - `now-1h` to `now`: Custom expressions like `now-1h` to `now` are also available, letting you fine-tune time ranges based on specific requirements.
 2. Custom Date-Time Patterns: In Grafana, you can specify custom date ranges in the dashboard’s time range selector, allowing for non-standard intervals that aren’t covered by the default options. For instance, if you need to look at data from `"2023-05-15 09:00"` to `"2023-05-15 17:00"`, you can set these manually.
 3. Time Zone Considerations: Grafana allows you to set a time zone per dashboard, ensuring consistent data display for users across different regions. When using Prometheus with Grafana, it’s crucial to confirm that your time zones align to avoid discrepancies, especially if the data originates from geographically dispersed sources.
 
@@ -86,65 +99,73 @@ Selecting the right time range format is essential for effective time-based quer
 
 Constructing time-based queries in Grafana with Prometheus involves setting up filters, applying functions, and using operators to retrieve data effectively. Here’s how to do it step-by-step:
 
-### 1.  Building Basic Time Range Filters
+### 1. Building Basic Time Range Filters
 
-In Grafana, you select the time range for your data from the dashboard’s time picker. Prometheus handles the selected range automatically, filtering results to only include data within that time frame. 
+In Grafana, you select the time range for your data from the dashboard’s time picker. Prometheus handles the selected range automatically, filtering results to only include data within that time frame.
 
 Example:
 
 If you select “Last 1 hour” in Grafana, Prometheus applies this range to the data it queries, so metrics will only display values from the last hour.
 
-<Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%202.webp" alt="Basic Time Range Filters" caption="Basic Time Range Filters" />
+<Figure
+  src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%202.webp"
+  alt="Basic Time Range Filters"
+  caption="Basic Time Range Filters"
+/>
 
 ### 2. Time Functions
 
 Prometheus’s PromQL provides several time functions and operators that allow for precise control over time ranges and metrics:
 
 - rate(): The `rate()` function calculates the average per-second rate of increase over a specified time interval. Ideal for metrics like network requests or CPU usage.
-    
-    ```sql
-    rate(prometheus_http_requests_total[5m])
-    ```
-    
-    This query returns the rate of HTTP requests per second over the last five minutes.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%203.webp" alt="rate() function" caption="rate() function" />
-    
+  ```sql
+  rate(prometheus_http_requests_total[5m])
+  ```
+  This query returns the rate of HTTP requests per second over the last five minutes.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%203.webp"
+    alt="rate() function"
+    caption="rate() function"
+  />
 - increase(): Calculates the cumulative increase over a given period, useful for counters.
-    
-    ```sql
-    increase(http_requests_total[1h])
-    ```
-    
-    Here, `increase()` shows the total increase in HTTP requests in the last hour.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%204.webp" alt="increase() function" caption="increase() function" />
-    
+  ```sql
+  increase(http_requests_total[1h])
+  ```
+  Here, `increase()` shows the total increase in HTTP requests in the last hour.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%204.webp"
+    alt="increase() function"
+    caption="increase() function"
+  />
 
 ### 3. Time Aggregations
 
 Aggregating data over specific time intervals is essential for meaningful summaries. In PromQL, you can use functions like `avg_over_time` and `sum_over_time` for this purpose.
 
 - sum_over_time(): Returns the total value over a specified interval, which is useful for aggregating metrics like total bytes transferred.
-    
-    ```
-    sum_over_time(prometheus_http_requests_total[1h])
-    ```
-    
-    This query aggregates HTTP requests in the last hour.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%205.webp" alt="sum_over_time() - Time aggregation" caption="sum_over_time() - Time aggregation" />
-    
+  ```
+  sum_over_time(prometheus_http_requests_total[1h])
+  ```
+  This query aggregates HTTP requests in the last hour.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%205.webp"
+    alt="sum_over_time() - Time aggregation"
+    caption="sum_over_time() - Time aggregation"
+  />
 - avg_over_time(): Calculates the average value over a given interval. For instance:
-    
-    ```
-    avg_over_time(prometheus_http_requests_total[1h])
-    ```
-    
-    This query computes the average HTTP requests received over the last 1 hour.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%206.webp" alt="avg_over_time() - Time aggregation" caption="avg_over_time() - Time aggregation" />
-    
+  ```
+  avg_over_time(prometheus_http_requests_total[1h])
+  ```
+  This query computes the average HTTP requests received over the last 1 hour.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%206.webp"
+    alt="avg_over_time() - Time aggregation"
+    caption="avg_over_time() - Time aggregation"
+  />
 - max_over_time() and min_over_time(): These return the maximum or minimum values within a specified range, ideal for identifying peaks or minimum usage patterns.
 
 ## Advanced Time Query Techniques
@@ -162,7 +183,11 @@ For a high-level correlation, you might create two queries for metrics like `cpu
 
 These can be placed on the same graph or separate panels in Grafana to visually compare trends over time.
 
-<Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%207.webp" alt="Time-Based Joins and Correlations" caption="Time-Based Joins and Correlations" />
+<Figure
+  src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%207.webp"
+  alt="Time-Based Joins and Correlations"
+  caption="Time-Based Joins and Correlations"
+/>
 
 ### Handling Missing Time Intervals
 
@@ -174,7 +199,7 @@ In Prometheus, you can sometimes manage missing data using expressions that defa
 rate(http_requests_total[5m]) or 0
 ```
 
-This expression returns zero if there’s no data for `http_requests_total` over the last five minutes. 
+This expression returns zero if there’s no data for `http_requests_total` over the last five minutes.
 
 ### Performance Optimization Tips
 
@@ -189,17 +214,26 @@ Here are some performance optimization tips for working with time-based queries
 [SigNoz](https://signoz.io) provides powerful capabilities for monitoring and analyzing time series data, making it a compelling alternative to traditional tools like Grafana, especially when integrated with observability standards like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/). Here's how SigNoz stands out:
 
 - Real-Time Querying Capabilities: SigNoz allows for fast, real-time querying of time series data, enabling you to track and troubleshoot issues as they arise. SigNoz streamlines the process with its intuitive interface and seamless integration with [observability pipelines](https://signoz.io/guides/observability-pipeline/).
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%208.webp" alt="Real-time querying capabilities" caption="Real-time querying capabilities" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%208.webp"
+    alt="Real-time querying capabilities"
+    caption="Real-time querying capabilities"
+  />
 - Built-In Time Range Selectors: With SigNoz, users can easily adjust time ranges within dashboards to pinpoint the exact moment events occurred. This built-in functionality eliminates the need for manual configurations, offering a more streamlined experience.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-b7c63af8-2a57-4089-a31b-2f04539bc53e.webp" alt="Built-in time range selectors in SigNoz" caption="Built-in time range selectors in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-b7c63af8-2a57-4089-a31b-2f04539bc53e.webp"
+    alt="Built-in time range selectors in SigNoz"
+    caption="Built-in time range selectors in SigNoz"
+  />
 - Custom Dashboard Creation: SigNoz simplifies the creation of customized dashboards tailored to your unique monitoring needs. While Grafana provides extensive customization options, SigNoz focuses on reducing complexity and offering a user-friendly design that integrates out-of-the-box observability features. This makes it a great option for teams looking to quickly set up and scale their monitoring systems.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%209.webp" alt="Custom dashboard creation" caption="Custom dashboard creation" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%209.webp"
+    alt="Custom dashboard creation"
+    caption="Custom dashboard creation"
+  />
 
 <GetStartedSigNoz />
 
@@ -208,42 +242,47 @@ Here are some performance optimization tips for working with time-based queries
 In Grafana, time series data is often analyzed using queries tailored to various time-based patterns. Here are common time query patterns that you can use in Grafana for better insights into your data:
 
 - Daily Aggregation Queries: Aggregate the `http_requests_total` metric by day to track daily traffic.
-    
-    Example:
-    
-    ```
-    avg_over_time(prometheus_http_requests_total[1d])
-    ```
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2010.webp" alt="Daily aggregation queries" caption="Daily aggregation queries" />
-    
+  Example:
+  ```
+  avg_over_time(prometheus_http_requests_total[1d])
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2010.webp"
+    alt="Daily aggregation queries"
+    caption="Daily aggregation queries"
+  />
 - Business Hours Filtering: Filter `http_requests_total` for data during business hours (9 AM - 5 PM).
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2011.webp" alt="Business hours filtering" caption="Business hours filtering" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2011.webp"
+    alt="Business hours filtering"
+    caption="Business hours filtering"
+  />
 - Time-Based Comparisons: Compare `http_requests_total` from different time periods, such as this week vs. last week.
-    
-    Example:
-    
-    ```
-    rate(prometheus_http_requests_total[1w] offset 1w) #last week
-    rate(prometheus_http_requests_total[1w] #current week
-    ```
-    
-    The `offset` modifier takes a time duration as an argument, such as `1w` (1 week), `1d` (1 day), `5h` (5 hours), etc. This allows you to look at data as it was at a specific time in the past.
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2012.webp" alt="Time-based comparisons" caption="Time-based comparisons" />
-    
+  Example:
+  ```
+  rate(prometheus_http_requests_total[1w] offset 1w) #last week
+  rate(prometheus_http_requests_total[1w] #current week
+  ```
+  The `offset` modifier takes a time duration as an argument, such as `1w` (1 week), `1d` (1 day), `5h` (5 hours), etc. This allows you to look at data as it was at a specific time in the past.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2012.webp"
+    alt="Time-based comparisons"
+    caption="Time-based comparisons"
+  />
 - Seasonal Analysis Queries: Analyze seasonal trends in `http_requests_total`, like yearly or monthly totals.
-    
-    Example:
-    
-    ```
-    avg_over_time(prometheus_http_requests_total[1y])
-    ```
-    
-    <Figure src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2013.webp" alt="Seasonal analysis queries" caption="Seasonal analysis queries" />
-    
+  Example:
+  ```
+  avg_over_time(prometheus_http_requests_total[1y])
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/how-to-use-selected-period-of-time-in-query-image%2013.webp"
+    alt="Seasonal analysis queries"
+    caption="Seasonal analysis queries"
+  />
 
 ## Key Takeaways
 
@@ -268,4 +307,4 @@ Use the `offset` modifier in Prometheus, like `http_requests_total[1w] offset 1w
 
 ### What are the performance considerations for time-based queries?
 
-Time-based queries can be slower with longer durations or high-cardinality metrics. Limit your query range, avoid complex aggregations, and optimize sampling rates to improve performance.
\ No newline at end of file
+Time-based queries can be slower with longer durations or high-cardinality metrics. Limit your query range, avoid complex aggregations, and optimize sampling rates to improve performance.
diff --git a/data/guides/how-to-view-docker-compose-healthcheck-logs.mdx b/data/guides/how-to-view-docker-compose-healthcheck-logs.mdx
index 9d6ddaf4e..30c7a8697 100644
--- a/data/guides/how-to-view-docker-compose-healthcheck-logs.mdx
+++ b/data/guides/how-to-view-docker-compose-healthcheck-logs.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: How to View Docker-Compose Healthcheck Logs - A Quick Guide
-slug: how-to-view-docker-compose-healthcheck-logs
 date: 2024-08-28
 tags: [faq, docker]
 authors: [nitin_gouda]
 description: Learn how to view and analyze Docker-Compose healthcheck logs with this comprehensive guide. Troubleshoot, optimize, and monitor your containerized applications effectively.
-keywords: [docker-compose healthcheck logs, container monitoring, docker inspect, docker logs, healthcheck troubleshooting]
-
+keywords:
+  [
+    docker-compose healthcheck logs,
+    container monitoring,
+    docker inspect,
+    docker logs,
+    healthcheck troubleshooting,
+  ]
 ---
 
 Docker-Compose healthchecks play a crucial role in maintaining the reliability and performance of containerized applications. As a developer or system administrator, you need to know how to view and interpret these logs to ensure your containers are running smoothly. This guide will walk you through the process of accessing Docker-Compose healthcheck logs, provide advanced techniques for log analysis, and offer best practices for implementing effective healthchecks.
@@ -27,81 +31,79 @@ Docker-Compose healthchecks are an essential tool for maintaining the operationa
 
 To effectively monitor and troubleshoot your Docker-Compose services, it's important to know how to access and interpret healthcheck logs. Here’s a step-by-step guide:
 
-1. Use the `docker inspect` command: This command allows you to retrieve detailed information about a container, including its health status.
-    
+1.  Use the `docker inspect` command: This command allows you to retrieve detailed information about a container, including its health status.
+
     ```docker
     docker inspect --format='{{json .State.Health}}' <container_name> | jq
     ```
-    
-    > *Replace `<container_name>` with the container-id or container-name.*
-    
+
+    > _Replace `<container_name>` with the container-id or container-name._
+
     The command returns a JSON object that includes the current health status of the container and the results of recent healthchecks. This is useful for quickly checking the health of your container and seeing a history of its healthcheck results. If you have raw JSON output, `jq` can format it in a more readable way.
-    
-    <Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.32.49_PM.webp" alt="docker inspect logs" caption="docker inspect logs" />
-    
-2. Check the `Health` section in the inspect output: 
-The `docker inspect` output contains a `Health` section where you can find the current status of the container’s healthcheck. 
-    
-    <Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.35.01_PM.webp" alt="docker inspect - health status" caption="docker inspect - health status" />
-    
-    - `Status`: Indicates whether the container is "starting", "healthy", or "unhealthy".
-    - `Log`: Contains entries of recent healthchecks, including the output of the check command and its exit status.
-    
-    This section helps you understand the current health state of your container and identify any recent failures or successes in the healthcheck process.
-    
-3. Use the `docker logs` command for detailed logs:
-While `docker inspect` gives a summary of the health status, `docker logs` provides a more detailed view by showing the container’s standard output (stdout) and standard error (stderr), where healthcheck results may be logged.
-    
-    ```docker
-    docker logs <container_name>
-    ```
-    
-    This command shows the container's stdout and stderr, which often include healthcheck results.
-    
-    <Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.37.21_PM.webp" alt="docker logs" caption="docker logs" />
-    
-4. Interpret healthcheck status and results:
+
+    <Figure
+      src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.32.49_PM.webp"
+      alt="docker inspect logs"
+      caption="docker inspect logs"
+    />
+
+2.  Check the `Health` section in the inspect output:
+    The `docker inspect` output contains a `Health` section where you can find the current status of the container’s healthcheck.
+        <Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.35.01_PM.webp" alt="docker inspect - health status" caption="docker inspect - health status" />
+
+        - `Status`: Indicates whether the container is "starting", "healthy", or "unhealthy".
+        - `Log`: Contains entries of recent healthchecks, including the output of the check command and its exit status.
+
+        This section helps you understand the current health state of your container and identify any recent failures or successes in the healthcheck process.
+3.  Use the `docker logs` command for detailed logs:
+    While `docker inspect` gives a summary of the health status, `docker logs` provides a more detailed view by showing the container’s standard output (stdout) and standard error (stderr), where healthcheck results may be logged.
+        ```docker
+        docker logs <container_name>
+        ```
+
+        This command shows the container's stdout and stderr, which often include healthcheck results.
+
+        <Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-27_at_11.37.21_PM.webp" alt="docker logs" caption="docker logs" />
+4.  Interpret healthcheck status and results:
+
     - "starting": Indicates that the container is still within its startup period, and healthchecks are not yet determining the overall health status.
     - "healthy": The container has passed its most recent healthcheck, indicating it is functioning as expected.
     - "unhealthy": The container has failed its healthcheck, signaling a potential problem that may require attention.
-    
+
     Understanding these statuses helps you quickly assess whether a container is operating normally or if there are issues that need to be addressed.
-    
 
 ## Advanced Techniques for Healthcheck Log Analysis
 
 For more comprehensive Docker-Compose healthcheck logs, you can leverage several advanced techniques. These methods can help you gain deeper insights into the health and performance of your containers, manage log data efficiently, and monitor service health more effectively.
 
-1. Utilize `docker service ps` for swarm mode services: 
-In Docker Swarm mode, `docker service ps` provides an overview of the tasks (containers) associated with a service, including their health status.
-    
-    ```docker
-    docker service ps --format "{{.Name}}: {{.CurrentState}}" service_name
-    ```
-    
+1.  Utilize `docker service ps` for swarm mode services:
+    In Docker Swarm mode, `docker service ps` provides an overview of the tasks (containers) associated with a service, including their health status.
+        ```docker
+        docker service ps --format "{{.Name}}: {{.CurrentState}}" service_name
+        ```
+
 - `-format "{{.Name}}: {{.CurrentState}}"`: Customizes the output to show the name of each task and its current state.
 - `service_name`: Replace with the name of your service.
 
 This command shows the current state of all tasks in a service, including healthcheck status.
 
-1. Implement custom logging drivers: 
-Custom logging drivers can centralize and manage healthcheck logs more effectively. You can configure a logging driver like Fluentd or Logstash to collect and centralize healthcheck logs.
-2. Use third-party monitoring tools:
-Tools like Prometheus with Grafana can provide visual insights into your healthcheck statuses over time. Third-party monitoring tools can offer advanced features for visualizing and analyzing healthcheck data.
-3. Set up log rotation: 
-Docker provides built-in options for configuring log rotation for containers using the `json-file` logging driver. Log rotation helps manage log file sizes and retention periods, preventing disk space issues. Here’s how you can set it up in your `docker-compose.yml` file:
-    
-    ```yaml
-    services:
-      my_service:
-        image: <image>
-        logging:
-          driver: "json-file"
-          options:
-            max-size: "10m"
-            max-file: "3"
-    ```
-    
+1.  Implement custom logging drivers:
+    Custom logging drivers can centralize and manage healthcheck logs more effectively. You can configure a logging driver like Fluentd or Logstash to collect and centralize healthcheck logs.
+2.  Use third-party monitoring tools:
+    Tools like Prometheus with Grafana can provide visual insights into your healthcheck statuses over time. Third-party monitoring tools can offer advanced features for visualizing and analyzing healthcheck data.
+3.  Set up log rotation:
+    Docker provides built-in options for configuring log rotation for containers using the `json-file` logging driver. Log rotation helps manage log file sizes and retention periods, preventing disk space issues. Here’s how you can set it up in your `docker-compose.yml` file:
+        ```yaml
+        services:
+          my_service:
+            image: <image>
+            logging:
+              driver: "json-file"
+              options:
+                max-size: "10m"
+                max-file: "3"
+        ```
+
 - `driver`: Specifies the logging driver to use. For log rotation, the `json-file` driver is commonly used.
 - `max-size`: Defines the maximum size of each log file before it gets rotated. For example, `"10m"` limits log files to 10 megabytes. Once this size is reached, the log file will be rotated.
 - `max-file`: Specifies the number of rotated log files to keep. For instance, `"3"` keeps the latest three log files. Older files are deleted after reaching this limit.
@@ -110,83 +112,76 @@ Docker provides built-in options for configuring log rotation for containers usi
 
 When dealing with healthcheck failures, consider these troubleshooting steps:
 
-1. Identify failed healthchecks:
-Use the `docker events` command to observe healthcheck events as they occur. This command helps you track changes in container health status, enabling you to quickly pinpoint when and where issues arise.
-    
-    ```docker
-    docker events --filter 'event=health_status'
-    ```
-    
-    This command filters Docker events to display only those related to health status changes. You'll see real-time updates whenever a container's health status transitions, such as from "healthy" to "unhealthy." 
-    
-2. Debug timing-related problems:
-Timing-related issues are common in Docker healthchecks, especially when the services inside your containers require more time to start up or respond than the healthcheck parameters allow. Misconfigured timing can lead to unnecessary healthcheck failures, causing containers to be marked as unhealthy or even restarted prematurely.
-    
-    ```yaml
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost/health"]
-      interval: 1m30s  
-      timeout: 10s
-      retries: 3 
-      start_period: 40s 
-    ```
-    
-    - Adjust the `interval` Parameter:
-    The `interval` parameter defines how often the healthcheck is run. If your service takes longer to stabilize after startup or under heavy load, a short interval might cause the healthcheck to fail frequently.
-    - Evaluate `retries` Count:
-    The `retries` parameter determines how many consecutive failures Docker should tolerate before marking the container as unhealthy. If your service has intermittent issues, increasing the `retries` count can prevent it from being prematurely flagged as unhealthy.
-    - Use the `start_period` Parameter:
-    The `start_period` parameter defines a grace period after the container starts, during which Docker ignores failed healthchecks. This is particularly useful for services that require a long startup time before they can respond to healthcheck requests.
-3. Handle network-related failures: 
-Network-related failures in Docker healthchecks can occur due to various factors like network latency, temporary outages, or unstable network connections. If not properly managed, these issues can cause your containers to be marked as unhealthy, even when the service itself is functioning correctly.
-    1. Design Healthchecks to Be Resilient to Network Fluctuations:
-    Ensure that your healthcheck commands can handle brief network interruptions or latency. For example, if your healthcheck involves making an HTTP request, use tools that can retry the request or include built-in timeout handling.
-    2. Use Graceful Failures in Healthcheck Commands:
-    Implement error handling in your healthcheck scripts or commands to deal with network-related issues. For example, you could script a healthcheck that returns a temporary "warning" state instead of an immediate failure if a network call fails.
-        
-        ```bash
-        #!/bin/sh
-        if curl -f http://localhost/health; then
-          exit 0
-        else
-          # Log the failure for further analysis
-          echo "Healthcheck warning: Network issue detected" >> /var/log/healthcheck.log
-          exit 1
-        fi
+1.  Identify failed healthchecks:
+    Use the `docker events` command to observe healthcheck events as they occur. This command helps you track changes in container health status, enabling you to quickly pinpoint when and where issues arise.
+        ```docker
+        docker events --filter 'event=health_status'
         ```
-        
-    3. Monitor and Adjust Based on Network Conditions:
-    Regularly monitor the performance of your healthchecks in relation to network conditions. If you notice frequent network-related failures, consider further adjustments to the `interval`, `timeout`, or even the nature of the healthcheck itself.
-        
+
+        This command filters Docker events to display only those related to health status changes. You'll see real-time updates whenever a container's health status transitions, such as from "healthy" to "unhealthy."
+2.  Debug timing-related problems:
+    Timing-related issues are common in Docker healthchecks, especially when the services inside your containers require more time to start up or respond than the healthcheck parameters allow. Misconfigured timing can lead to unnecessary healthcheck failures, causing containers to be marked as unhealthy or even restarted prematurely.
         ```yaml
-        healthcheck:  
-        	test: ["CMD", "curl", "-f", "http://localhost/health"]  
-        	interval: 1m30s  
-        	timeout: 30s  
-        	retries: 5  
-        	start_period: 1m
+        healthcheck:
+          test: ["CMD", "curl", "-f", "http://localhost/health"]
+          interval: 1m30s
+          timeout: 10s
+          retries: 3
+          start_period: 40s
         ```
-        
-4. Optimize healthcheck performance:
-Optimizing the performance of healthchecks is crucial to ensuring that they accurately monitor the health of your Docker containers without introducing unnecessary overhead or consuming excessive resources. Poorly designed healthchecks can lead to performance bottlenecks, increased resource usage, and even false positives, where healthy containers are marked as unhealthy.
-    
-    ```yaml
-    healthcheck:  
-    	test: ["CMD", "curl", "-f", "http://localhost/health"]  
-    	interval: 30s  
-    	timeout: 5s  
-    	retries: 3  
-    	start_period: 10s
-    ```
-    
-    - Use Lightweight Commands:
-    The commands used in healthchecks should be as lightweight as possible. Avoid complex scripts or commands that require significant CPU, memory, or I/O operations, as these can degrade the overall performance of the container. eg. CMD, curl etc.
-    - Reduce Healthcheck Frequency:
-    Set the healthcheck `interval` to a reasonable value that balances responsiveness with performance. Too frequent checks can overwhelm the container and host system, especially if the check itself is resource-intensive.
-    - Adjust Timeout and Retry Settings:
-    Fine-tune the `timeout` and `retries` settings to prevent the healthcheck from running too long or retrying excessively. If the healthcheck takes too long, it can consume resources that could otherwise be used by the application itself.
-    - Limit the Scope of Healthchecks:
-    Focus your healthchecks on critical aspects of the service rather than testing every possible condition. For instance, checking if a web server is responding may be sufficient, without needing to check every endpoint or perform extensive database queries.
+
+        - Adjust the `interval` Parameter:
+        The `interval` parameter defines how often the healthcheck is run. If your service takes longer to stabilize after startup or under heavy load, a short interval might cause the healthcheck to fail frequently.
+        - Evaluate `retries` Count:
+        The `retries` parameter determines how many consecutive failures Docker should tolerate before marking the container as unhealthy. If your service has intermittent issues, increasing the `retries` count can prevent it from being prematurely flagged as unhealthy.
+        - Use the `start_period` Parameter:
+        The `start_period` parameter defines a grace period after the container starts, during which Docker ignores failed healthchecks. This is particularly useful for services that require a long startup time before they can respond to healthcheck requests.
+3.  Handle network-related failures:
+    Network-related failures in Docker healthchecks can occur due to various factors like network latency, temporary outages, or unstable network connections. If not properly managed, these issues can cause your containers to be marked as unhealthy, even when the service itself is functioning correctly. 1. Design Healthchecks to Be Resilient to Network Fluctuations:
+    Ensure that your healthcheck commands can handle brief network interruptions or latency. For example, if your healthcheck involves making an HTTP request, use tools that can retry the request or include built-in timeout handling. 2. Use Graceful Failures in Healthcheck Commands:
+    Implement error handling in your healthcheck scripts or commands to deal with network-related issues. For example, you could script a healthcheck that returns a temporary "warning" state instead of an immediate failure if a network call fails.
+            ```bash
+            #!/bin/sh
+            if curl -f http://localhost/health; then
+              exit 0
+            else
+              # Log the failure for further analysis
+              echo "Healthcheck warning: Network issue detected" >> /var/log/healthcheck.log
+              exit 1
+            fi
+            ```
+
+        3. Monitor and Adjust Based on Network Conditions:
+        Regularly monitor the performance of your healthchecks in relation to network conditions. If you notice frequent network-related failures, consider further adjustments to the `interval`, `timeout`, or even the nature of the healthcheck itself.
+
+            ```yaml
+            healthcheck:
+            	test: ["CMD", "curl", "-f", "http://localhost/health"]
+            	interval: 1m30s
+            	timeout: 30s
+            	retries: 5
+            	start_period: 1m
+            ```
+
+4.  Optimize healthcheck performance:
+    Optimizing the performance of healthchecks is crucial to ensuring that they accurately monitor the health of your Docker containers without introducing unnecessary overhead or consuming excessive resources. Poorly designed healthchecks can lead to performance bottlenecks, increased resource usage, and even false positives, where healthy containers are marked as unhealthy.
+        ```yaml
+        healthcheck:
+        	test: ["CMD", "curl", "-f", "http://localhost/health"]
+        	interval: 30s
+        	timeout: 5s
+        	retries: 3
+        	start_period: 10s
+        ```
+
+        - Use Lightweight Commands:
+        The commands used in healthchecks should be as lightweight as possible. Avoid complex scripts or commands that require significant CPU, memory, or I/O operations, as these can degrade the overall performance of the container. eg. CMD, curl etc.
+        - Reduce Healthcheck Frequency:
+        Set the healthcheck `interval` to a reasonable value that balances responsiveness with performance. Too frequent checks can overwhelm the container and host system, especially if the check itself is resource-intensive.
+        - Adjust Timeout and Retry Settings:
+        Fine-tune the `timeout` and `retries` settings to prevent the healthcheck from running too long or retrying excessively. If the healthcheck takes too long, it can consume resources that could otherwise be used by the application itself.
+        - Limit the Scope of Healthchecks:
+        Focus your healthchecks on critical aspects of the service rather than testing every possible condition. For instance, checking if a web server is responding may be sufficient, without needing to check every endpoint or perform extensive database queries.
 
 ## Customizing Healthchecks in Docker-Compose
 
@@ -197,12 +192,11 @@ services:
   web:
     image: nginx
     healthcheck:
-      test: ["CMD", "curl", "-f", "<http://localhost>"]
+      test: ['CMD', 'curl', '-f', '<http://localhost>']
       interval: 1m30s
       timeout: 10s
       retries: 3
       start_period: 40s
-
 ```
 
 - `test`: The `test` parameter defines the command that Docker will execute inside the container to check its health. This command should return a zero exit code if the container is healthy. In this example, `curl -f http://localhost` checks if the Nginx server is responding to requests. The `-f` option ensures that `curl` will return an error code if the HTTP response code is 400 or greater, indicating that the web server is not functioning correctly.
@@ -219,12 +213,12 @@ Follow these best practices to maximize the effectiveness of your healthchecks:
 2. Keep checks lightweight: Healthchecks should be lightweight and fast. Heavy or resource-intensive checks can negatively impact the performance of your container, especially if they are run frequently. Use basic commands like `curl` or simple scripts that complete quickly to ensure minimal disruption to the container's operation.
 3. Set appropriate intervals: The interval between healthchecks should be set based on the criticality of the service. For high-availability services, a shorter interval may be necessary to detect and respond to issues quickly. However, running checks too frequently can strain system resources, especially in environments with many containers. Typically, an interval of 30 seconds to 2 minutes is sufficient for most services..
 4. Use environment variables: To enhance flexibility and adaptability, use environment variables in your healthcheck commands. This allows you to modify healthcheck behavior without changing the code. For example:
-    
-    ```yaml
-    healthcheck:  
-    	test: ["CMD", "curl", "-f", "http://${HOST:-localhost}:${PORT:-80}/health"]
-    ```
-    
+
+   ```yaml
+   healthcheck:
+   	test: ["CMD", "curl", "-f", "http://${HOST:-localhost}:${PORT:-80}/health"]
+   ```
+
 5. Implement graceful shutdowns: Ensure that your application can handle `SIGTERM` signals, which are sent by Docker when stopping a container. Properly handling these signals allows your application to clean up resources and shut down gracefully.
 
 ## Monitoring Docker-Compose Healthchecks with SigNoz
@@ -253,7 +247,11 @@ Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with
 
 To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab or if not present you can create for yourself by clicking on “New Ingestion key”.
 
-<Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-28_at_9.04.01_AM.webp" alt="SigNoz Ingestion Settings" caption="SigNoz Ingestion Settings" />
+<Figure
+  src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-08-28_at_9.04.01_AM.webp"
+  alt="SigNoz Ingestion Settings"
+  caption="SigNoz Ingestion Settings"
+/>
 
 1. Set Up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)Config
 
@@ -264,7 +262,7 @@ In the root of your project folder, create a file `otel-collector-config.yaml` a
 ```yaml
 receivers:
   tcplog/docker:
-    listen_address: "0.0.0.0:2255"
+    listen_address: '0.0.0.0:2255'
     operators:
       - type: regex_parser
         regex: '^<([0-9]+)>[0-9]+ (?P<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?([zZ]|([\\+-])([01]\\d|2[0-3]):?([0-5]\\d)?)?) (?P<container_id>\\S+) (?P<container_name>\\S+) [0-9]+ - -( (?P<body>.*))?'
@@ -292,7 +290,7 @@ exporters:
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": ${env:SIGNOZ_INGESTION_KEY}
+      'signoz-ingestion-key': ${env:SIGNOZ_INGESTION_KEY}
 
 service:
   pipelines:
@@ -339,31 +337,36 @@ In your Docker Compose file, add the below configuration:
     command: syslog+tcp://otel-collector:2255
     depends_on:
       - otel-collector
-    restart: on-failure 
+    restart: on-failure
 ```
 
 The above Docker Compose configuration sets up two services:
 
 - `otel-collector`:
-    - Uses the Signoz [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) image.
-    - Mounts the `otel-collector-config.yaml` file into the container.
-    - Uses environment variables from the `.env` file for configuration.
-    - Exposes ports `4317` (OTLP gRPC receiver) and `4318` (OTLP HTTP receiver).
+  - Uses the Signoz [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/) image.
+  - Mounts the `otel-collector-config.yaml` file into the container.
+  - Uses environment variables from the `.env` file for configuration.
+  - Exposes ports `4317` (OTLP gRPC receiver) and `4318` (OTLP HTTP receiver).
 - `logspout`:
-    - Uses the `gliderlabs/logspout` image to collect logs from other Docker containers.
-    - Forwards logs to the `otel-collector` service on port `2255`.
-    - Depends on the `otel-collector` service, ensuring it starts first so it can forward the logs to it.
+  - Uses the `gliderlabs/logspout` image to collect logs from other Docker containers.
+  - Forwards logs to the `otel-collector` service on port `2255`.
+  - Depends on the `otel-collector` service, ensuring it starts first so it can forward the logs to it.
+
 1.  Start the Docker Compose file
 
 Run the below command in your terminal to start the containers:
 
 ```docker
-docker compose up -d 
+docker compose up -d
 ```
 
 If it runs without any error, navigate to your SigNoz Cloud. Under the “Logs” tab, you should see the incoming logs.
 
-<Figure src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-07-17_at_4.08.17_PM.webp" alt="Docker logs sent to SigNoz" caption="Docker logs sent to SigNoz" />
+<Figure
+  src="/img/guides/2024/08/how-to-view-docker-compose-healthcheck-logs-Screenshot_2024-07-17_at_4.08.17_PM.webp"
+  alt="Docker logs sent to SigNoz"
+  caption="Docker logs sent to SigNoz"
+/>
 
 ## Key Takeaways
 
@@ -391,40 +394,40 @@ The `HEALTHCHECK` instruction in a Dockerfile and the `healthcheck` configuratio
 
 Implementing multi-stage healthchecks is an effective strategy for ensuring that complex applications are thoroughly monitored.
 
-1. Using a script: You can create a script that runs multiple checks in sequence, with each check focusing on a different part of the application. 
-    
-    ```bash
-    #!/bin/sh
-    if curl -f http://localhost/health/db; then
-      if curl -f http://localhost/health/cache; then
-        exit 0
-      fi
-    fi
-    exit 1
-    ```
-    
-    This script first checks the database health, then the cache. If both are healthy, the script exits with a status code 0 (indicating success). If any check fails, it exits with a non-zero code (indicating failure).
-    
+1. Using a script: You can create a script that runs multiple checks in sequence, with each check focusing on a different part of the application.
+
+   ```bash
+   #!/bin/sh
+   if curl -f http://localhost/health/db; then
+     if curl -f http://localhost/health/cache; then
+       exit 0
+     fi
+   fi
+   exit 1
+   ```
+
+   This script first checks the database health, then the cache. If both are healthy, the script exits with a status code 0 (indicating success). If any check fails, it exits with a non-zero code (indicating failure).
+
 2. Implementing different healthcheck commands: In Docker-Compose, you can define individual healthchecks for different services or components of your application.
-    
-    ```docker
-    services:
-      web:
-        image: myapp
-        healthcheck:
-          test: ["CMD", "curl", "-f", "http://localhost/health/web"]
-          interval: 1m
-          timeout: 10s
-          retries: 3
-      db:
-        image: mydb
-        healthcheck:
-          test: ["CMD", "pg_isready"]
-          interval: 30s
-          timeout: 5s
-          retries: 3
-    ```
-    
-    In this example, the `web` service is monitored by checking its web interface, while the `db` service uses a database-specific healthcheck. Each service is monitored according to its specific needs.
-    
-3. Utilizing external health checking services: External checks can often be integrated with [monitoring and alerting tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/), such as SigNoz or Prometheus, allowing you to track healthcheck results over time, generate alerts on failures, and correlate healthcheck data with other application metrics.
\ No newline at end of file
+
+   ```docker
+   services:
+     web:
+       image: myapp
+       healthcheck:
+         test: ["CMD", "curl", "-f", "http://localhost/health/web"]
+         interval: 1m
+         timeout: 10s
+         retries: 3
+     db:
+       image: mydb
+       healthcheck:
+         test: ["CMD", "pg_isready"]
+         interval: 30s
+         timeout: 5s
+         retries: 3
+   ```
+
+   In this example, the `web` service is monitored by checking its web interface, while the `db` service uses a database-specific healthcheck. Each service is monitored according to its specific needs.
+
+3. Utilizing external health checking services: External checks can often be integrated with [monitoring and alerting tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/), such as SigNoz or Prometheus, allowing you to track healthcheck results over time, generate alerts on failures, and correlate healthcheck data with other application metrics.
diff --git a/data/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label.mdx b/data/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label.mdx
index cad6b32d8..b49fbf4ee 100644
--- a/data/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label.mdx
+++ b/data/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label.mdx
@@ -1,154 +1,166 @@
 ---
-
 title: How to Write Prometheus Queries to Return Label Values
-slug: how-to-write-a-prometheus-query-that-returns-the-value-of-the-label
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Learn how to write Prometheus queries that return label values. Master PromQL, advanced techniques, and best practices for efficient metric analysis.
-keywords: [Prometheus queries, label values, PromQL, metric analysis, Grafana visualization, monitoring systems]
-
+keywords:
+  [
+    Prometheus queries,
+    label values,
+    PromQL,
+    metric analysis,
+    Grafana visualization,
+    monitoring systems,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "How to Write Prometheus Queries to Return Label Values",
-    "alternativeHeadline": "Mastering PromQL: Writing Queries to Return Label Values",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-25T00:00:00Z",
-    "dateModified": "2024-07-25T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label/"
-    },
-    "description": "Learn how to write Prometheus queries that return label values. Master PromQL, advanced techniques, and best practices for efficient metric analysis.",
-    "keywords": "Prometheus queries, label values, PromQL, metric analysis, Grafana visualization, monitoring systems",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "Label Values",
-        "description": "Key-value pairs in Prometheus metrics that provide additional context and allow for fine-grained filtering and aggregation."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What's the difference between a metric name and a label in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "A metric name identifies the measurement being collected, while labels provide additional context or dimensions for that metric. For example, `http_requests_total` is a metric name, and `method=\"GET\"` is a label."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How can I query for the absence of a label?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use the `!=` matcher with an empty string: `http_requests_total{method!=\"\"}`. This selects all `http_requests_total` metrics where the `method` label is present."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Write Prometheus Queries to Return Label Values',
+        alternativeHeadline: 'Mastering PromQL: Writing Queries to Return Label Values',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "Is it possible to perform mathematical operations on label values?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "PromQL doesn't support direct mathematical operations on label values. However, you can use functions like `label_replace()` to manipulate label values based on regular expressions."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I use label queries in Prometheus alerting rules?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, you can use label queries in alerting rules. This allows you to create specific alerts based on label values, enhancing your monitoring capabilities."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Writing Prometheus Queries to Return Label Values",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Select Metrics with Specific Labels",
-          "text": "Use the basic syntax `metric_name{label_name=\"label_value\"}` to select metrics with specific labels."
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/how-to-write-a-prometheus-query-that-returns-the-value-of-the-label/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use Label Matchers",
-          "text": "Apply label matchers like `=`, `!=`, `=~`, and `!~` for exact matches, inequality, regex matches, and regex not matches respectively."
+        description:
+          'Learn how to write Prometheus queries that return label values. Master PromQL, advanced techniques, and best practices for efficient metric analysis.',
+        keywords:
+          'Prometheus queries, label values, PromQL, metric analysis, Grafana visualization, monitoring systems',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Extract Label Values",
-          "text": "Use the `label()` function to extract label values from metrics, for example, `label(metric_name, \"label_name\")`."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Label Values',
+            description:
+              'Key-value pairs in Prometheus metrics that provide additional context and allow for fine-grained filtering and aggregation.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "What's the difference between a metric name and a label in Prometheus?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'A metric name identifies the measurement being collected, while labels provide additional context or dimensions for that metric. For example, `http_requests_total` is a metric name, and `method="GET"` is a label.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I query for the absence of a label?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use the `!=` matcher with an empty string: `http_requests_total{method!=""}`. This selects all `http_requests_total` metrics where the `method` label is present.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is it possible to perform mathematical operations on label values?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "PromQL doesn't support direct mathematical operations on label values. However, you can use functions like `label_replace()` to manipulate label values based on regular expressions.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use label queries in Prometheus alerting rules?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, you can use label queries in alerting rules. This allows you to create specific alerts based on label values, enhancing your monitoring capabilities.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Combine Label Conditions",
-          "text": "Combine multiple label conditions for more refined queries, such as `http_requests_total{method=\"GET\", status=\"200\"}`."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Writing Prometheus Queries to Return Label Values',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Select Metrics with Specific Labels',
+              text: 'Use the basic syntax `metric_name{label_name="label_value"}` to select metrics with specific labels.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use Label Matchers',
+              text: 'Apply label matchers like `=`, `!=`, `=~`, and `!~` for exact matches, inequality, regex matches, and regex not matches respectively.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Extract Label Values',
+              text: 'Use the `label()` function to extract label values from metrics, for example, `label(metric_name, "label_name")`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Combine Label Conditions',
+              text: 'Combine multiple label conditions for more refined queries, such as `http_requests_total{method="GET", status="200"}`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Apply Grouping and Aggregation',
+              text: 'Use the `group()` function to group by label values and apply aggregation functions like `sum()`, e.g., `sum(http_requests_total) by (method)`.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Apply Grouping and Aggregation",
-          "text": "Use the `group()` function to group by label values and apply aggregation functions like `sum()`, e.g., `sum(http_requests_total) by (method)`."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus queries that return label values are essential for effective metric analysis in monitoring systems. This guide will show you how to write these queries, from basic syntax to advanced techniques.
@@ -227,7 +239,7 @@ This calculates the ratio of total requests to successful requests for each meth
 To get all label names:
 
 ```jsx
-GET /api/v1/labels
+GET / api / v1 / labels
 ```
 
 To get all values for a specific label:
@@ -332,4 +344,4 @@ PromQL doesn't support direct mathematical operations on label values. However,
 
 ### Can I use label queries in Prometheus alerting rules?
 
-Yes, you can use label queries in alerting rules. This allows you to create specific alerts based on label values, enhancing your monitoring capabilities.
\ No newline at end of file
+Yes, you can use label queries in alerting rules. This allows you to create specific alerts based on label values, enhancing your monitoring capabilities.
diff --git a/data/guides/how-to-write-to-a-file-using-the-logging-python-module.mdx b/data/guides/how-to-write-to-a-file-using-the-logging-python-module.mdx
index 8012b63d0..bfacc741e 100644
--- a/data/guides/how-to-write-to-a-file-using-the-logging-python-module.mdx
+++ b/data/guides/how-to-write-to-a-file-using-the-logging-python-module.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Write to a File Using the Logging Python Module - A Step-by-Step Guide
-slug: how-to-write-to-a-file-using-the-logging-python-module
 date: 2024-08-28
 tags: [faq, logging]
 authors: [sushant_gaurav]
 description: Learn how to effectively write logs to files using Python's logging module. This guide covers basic setup, advanced techniques, and best practices for file-based logging.
-keywords: [Python logging, file logging, logging module, log files, Python debugging, log rotation, logging best practices]
-
+keywords:
+  [
+    Python logging,
+    file logging,
+    logging module,
+    log files,
+    Python debugging,
+    log rotation,
+    logging best practices,
+  ]
 ---
 
 Python's `logging` module is an important tool for event recording, problem debugging, and application debugging. Unlike basic `print` instructions, the logging module provides a reliable and flexible method for capturing and storing log data. In this article, you'll learn how to configure file-based logging, apply advanced approaches, and improve your logging procedures. Whether you're new to Python or an experienced developer, this guide will help you improve your logging approach in Python applications.
@@ -27,7 +33,11 @@ The logging module comprises four main components that work together to facilita
 - Formatters: Formatters control the layout and content of log messages. They govern how timestamps, log levels, and messages are shown in the logs.
 - Levels: Logging levels (such as `DEBUG`, `INFO`, `WARNING`, `ERROR`, and `CRITICAL`) help you to manage the logs in a better way. Setting a specified log level allows you to filter out less important messages and focus on what matters.
 
-<Figure src="/img/guides/2024/08/how-to-write-to-a-file-using-the-logging-python-module-image.webp" alt="four main components of logging module" caption="four main components of logging module" />
+<Figure
+  src="/img/guides/2024/08/how-to-write-to-a-file-using-the-logging-python-module-image.webp"
+  alt="four main components of logging module"
+  caption="four main components of logging module"
+/>
 
 To learn about logging in Python, different levels of logging, formatters, etc. in more detail, you can refer to this article [Python Logging - From Setup to Monitoring with Best Practices](https://signoz.io/guides/logging-in-python/). You can also check out [Python Logging Best Practices - Expert Tips with Practical Examples](https://signoz.io/guides/python-logging-best-practices/).
 
@@ -53,9 +63,9 @@ This simple Python script performs the following actions:
 
 1. Imports the logging module: Provides access to the logging functions.
 2. Configures the logger using `basicConfig()`:
-    - `filename='app.log'`: Specifies that logs should be written to the file `app.log`.
-    - `level=logging.INFO`: Sets the logging level to `INFO`, meaning all messages with a severity of `INFO` or higher will be logged.
-    - `format='%(asctime)s - %(levelname)s - %(message)s'`: Defines the log message format to include the timestamp, log level, and message content.
+   - `filename='app.log'`: Specifies that logs should be written to the file `app.log`.
+   - `level=logging.INFO`: Sets the logging level to `INFO`, meaning all messages with a severity of `INFO` or higher will be logged.
+   - `format='%(asctime)s - %(levelname)s - %(message)s'`: Defines the log message format to include the timestamp, log level, and message content.
 3. Writes a log message: The `logging.info()` function generates an informational log entry.
 
 After running this script, you'll find a file named `app.log` in your current working directory containing a log entry similar to this:
@@ -259,47 +269,48 @@ Sample Output:
 While logging is necessary for monitoring and debugging, it can impact your application's performance if handled incorrectly. So, here are some strategies to improve log performance:
 
 1. Use Appropriate Log Levels:
-    - Use `DEBUG` for detailed development logs, which can be turned off in production to reduce overhead. To disable `DEBUG` logging in production while keeping it enabled in development, you can configure the logging level dynamically based on the environment (can be managed through configuration settings).
-    - Reserve `INFO` for general tracking and `ERROR` for critical issues that require immediate attention.
+   - Use `DEBUG` for detailed development logs, which can be turned off in production to reduce overhead. To disable `DEBUG` logging in production while keeping it enabled in development, you can configure the logging level dynamically based on the environment (can be managed through configuration settings).
+   - Reserve `INFO` for general tracking and `ERROR` for critical issues that require immediate attention.
 2. Implement Lazy Logging:
-    - Lazy  logging is a technique which can be used to delay the creation and formatting of log messages until it is certain that the message will be logged. This approach is particularly useful for optimizing performance when logging messages involve expensive computations or operations that might not always be necessary.
-    - Lazu logging helps you to reduce the overhead associated with logging by avoiding unnecessary computations for log messages. This is crucial in high-performance applications where even minor delays can accumulate.
-    - Expensive operations such as database queries or complex calculations are only executed if the corresponding log level is enabled. This prevents wasting resources on operations that might be irrelevant if the log level is set higher (e.g., `INFO` or `WARNING` instead of `DEBUG`).
-    Example:
-    
-    ```python
-    # Example of lazy logging to avoid unnecessary computation
-    if logger.isEnabledFor(logging.DEBUG):
-        logger.debug(f"Complex calculation result: {expensive_function()}")
-    ```
-    
-    - Explanation: The `isEnabledFor(logging.DEBUG)` check ensures that `expensive_function()` is only called if `DEBUG` logging is enabled. This prevents unnecessary computation when `DEBUG` logs are not required.
+
+   - Lazy logging is a technique which can be used to delay the creation and formatting of log messages until it is certain that the message will be logged. This approach is particularly useful for optimizing performance when logging messages involve expensive computations or operations that might not always be necessary.
+   - Lazu logging helps you to reduce the overhead associated with logging by avoiding unnecessary computations for log messages. This is crucial in high-performance applications where even minor delays can accumulate.
+   - Expensive operations such as database queries or complex calculations are only executed if the corresponding log level is enabled. This prevents wasting resources on operations that might be irrelevant if the log level is set higher (e.g., `INFO` or `WARNING` instead of `DEBUG`).
+     Example:
+
+   ```python
+   # Example of lazy logging to avoid unnecessary computation
+   if logger.isEnabledFor(logging.DEBUG):
+       logger.debug(f"Complex calculation result: {expensive_function()}")
+   ```
+
+   - Explanation: The `isEnabledFor(logging.DEBUG)` check ensures that `expensive_function()` is only called if `DEBUG` logging is enabled. This prevents unnecessary computation when `DEBUG` logs are not required.
+
 3. Consider Asynchronous Logging:
+
 - Asynchronous logging can help yout to reduce the performance impact of logging by handling log messages in a separate thread or process. This approach minimizes the delay caused by I/O operations which ensures that logging does not interfere with the primary application flow.
 - It allows the main application to continue running smoothly by passing on the log processing to a background thread or process. So by offloading logging tasks, your application can handle more operations per second, which is crucial for high-performance or high-throughput systems.
 - You can use libraries such as `concurrent-log-handler` to implement asynchronous logging. You can install the `concurrent-log-handler` using the command: `pip install concurrent-log-handler` .
-Example:
-    
-    ```python
-    import logging
-    from concurrent_log_handler import ConcurrentRotatingFileHandler
-    
-    # Create a logger
-    logger = logging.getLogger('my_logger')
-    logger.setLevel(logging.DEBUG)
-    
-    # Set up an asynchronous file handler
-    handler = ConcurrentRotatingFileHandler('app.log', maxBytes=10485760, backupCount=5)
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
-    
-    # Add the handler to the logger
-    logger.addHandler(handler)
-    
-    # Example log entry
-    logger.info('This is an informational message')
-    ```
-    
+  Example:
+      ```python
+      import logging
+      from concurrent_log_handler import ConcurrentRotatingFileHandler
+
+      # Create a logger
+      logger = logging.getLogger('my_logger')
+      logger.setLevel(logging.DEBUG)
+
+      # Set up an asynchronous file handler
+      handler = ConcurrentRotatingFileHandler('app.log', maxBytes=10485760, backupCount=5)
+      formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+      handler.setFormatter(formatter)
+
+      # Add the handler to the logger
+      logger.addHandler(handler)
+
+      # Example log entry
+      logger.info('This is an informational message')
+      ```
 
 ## Enhancing Observability with SigNoz
 
@@ -319,7 +330,11 @@ Here's how SigNoz can support your logging strategy:
 2. Trace Correlation: SigNoz allows you to connect logs and dispersed traces. This means you can track a given request as it moves through several services and correlate those traces with logs to get a complete picture of the request's lifecycle.
 3. Performance Metrics: In addition to logs, SigNoz gathers performance measures (such as CPU utilization and response times). By tracking these metrics alongside your logs, you can gain a more complete picture of your application's health and performance.
 
-<Figure src="/img/guides/2024/08/how-to-write-to-a-file-using-the-logging-python-module-image%201.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/guides/2024/08/how-to-write-to-a-file-using-the-logging-python-module-image%201.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 ## Best Practices for File-Based Logging in Python
 
@@ -327,25 +342,21 @@ You should adhere to certain best practices to guarantee that your file-based lo
 
 1. Use appropriate log levels based on message severity (e.g., `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`). Properly categorizing log messages prevents you from missing key issues or becoming overwhelmed by less essential ones.
 2. Log messages with consistent structure are easier to read, search, and analyze. Including essential information in your log messages, such as user IDs, IP addresses, or transaction IDs, can significantly boost their utility.
-    - Example:
-        
-        ```python
-        logger.info("User %s logged in from IP %s", user_id, ip_address)
-        ```
-        
-    - You can use `%s` in log messages to pass variables as arguments here.
+   - Example:
+     ```python
+     logger.info("User %s logged in from IP %s", user_id, ip_address)
+     ```
+   - You can use `%s` in log messages to pass variables as arguments here.
 3. Large log files can consume disk space and become difficult to manage. Log rotation will automatically archive old log files and produce new ones, which helps to manage your log directory and prevents disk space difficulties.
 4. Logs frequently contain sensitive information, such as user data, authentication tokens, and system configurations. It is critical to encrypt your log files to prevent unauthorized access and to avoid logging sensitive information entirely.
-    - You can use proper file permissions to restrict log file access.
-    - Do not log sensitive data, such as passwords or personally identifiable information (PII). If necessary, disguise or encrypt this information before logging.
-    - Example:
-        
-        ```python
-        # Example of masking sensitive data
-        masked_email = re.sub(r'(\\w{2})\\w+(@\\w+)', r'\\1***\\2', user_email)
-        logger.info("User email: %s", masked_email)
-        ```
-        
+   - You can use proper file permissions to restrict log file access.
+   - Do not log sensitive data, such as passwords or personally identifiable information (PII). If necessary, disguise or encrypt this information before logging.
+   - Example:
+     ```python
+     # Example of masking sensitive data
+     masked_email = re.sub(r'(\\w{2})\\w+(@\\w+)', r'\\1***\\2', user_email)
+     logger.info("User email: %s", masked_email)
+     ```
 
 ## Key Takeaways
 
@@ -455,4 +466,4 @@ try:
     result = 10 / 0
 except Exception as e:
     logger.error("An error occurred", exc_info=True)
-```
\ No newline at end of file
+```
diff --git a/data/guides/hybrid-cloud-monitoring.mdx b/data/guides/hybrid-cloud-monitoring.mdx
index 63a8c6ed5..1350fe5f3 100644
--- a/data/guides/hybrid-cloud-monitoring.mdx
+++ b/data/guides/hybrid-cloud-monitoring.mdx
@@ -1,54 +1,64 @@
 ---
-
 title: Mastering Hybrid Cloud Monitoring - Key Strategies
-slug: hybrid-cloud-monitoring
 date: 2024-09-18
 tags: [monitoring]
 authors: [manjunath_irukulla]
 description: Learn essential strategies for effective hybrid cloud monitoring. Discover key metrics, best practices, and tools to optimize your hybrid infrastructure.
-keywords: [hybrid cloud monitoring, cloud infrastructure, performance optimization, IT management, DevOps, observability, SigNoz]
-
+keywords:
+  [
+    hybrid cloud monitoring,
+    cloud infrastructure,
+    performance optimization,
+    IT management,
+    DevOps,
+    observability,
+    SigNoz,
+  ]
 ---
 
-Hybrid cloud environments have become the backbone of modern IT infrastructures. As organizations blend on-premises and cloud resources, effective monitoring is crucial to maintaining system visibility, performance, and cost-efficiency. Hybrid cloud monitoring helps ensure that your infrastructure runs smoothly by providing real-time insights and control over all components. 
+Hybrid cloud environments have become the backbone of modern IT infrastructures. As organizations blend on-premises and cloud resources, effective monitoring is crucial to maintaining system visibility, performance, and cost-efficiency. Hybrid cloud monitoring helps ensure that your infrastructure runs smoothly by providing real-time insights and control over all components.
 
 This article explores essential strategies for mastering hybrid cloud monitoring, ensuring your systems remain reliable and optimized for success.
 
 ## What is Hybrid Cloud Monitoring and Why is it Critical?
 
-<Figure src="/img/guides/2024/09/hybrid-cloud-monitoring-7d7b49c9-9c9b-44de-8f3c-41da18e470c8.webp" alt="Key Aspects of Hybrid Cloud Monitoring" caption="Key Aspects of Hybrid Cloud Monitoring" />
+<Figure
+  src="/img/guides/2024/09/hybrid-cloud-monitoring-7d7b49c9-9c9b-44de-8f3c-41da18e470c8.webp"
+  alt="Key Aspects of Hybrid Cloud Monitoring"
+  caption="Key Aspects of Hybrid Cloud Monitoring"
+/>
 
-Hybrid cloud monitoring is the practice of tracking, analyzing, and managing the performance, availability, and resource utilization of IT systems spread across on-premises data centres and cloud platforms. As more organizations adopt hybrid cloud strategies, monitoring these environments becomes critical for several reasons: 
+Hybrid cloud monitoring is the practice of tracking, analyzing, and managing the performance, availability, and resource utilization of IT systems spread across on-premises data centres and cloud platforms. As more organizations adopt hybrid cloud strategies, monitoring these environments becomes critical for several reasons:
 
-1. Managing Complexity: Hybrid environments combine diverse technologies, including legacy systems and modern cloud platforms, making maintaining a unified view of your infrastructure challenging. Hybrid cloud monitoring provides a single pane of glass to track and manage these disparate components, ensuring smooth operation and preventing performance issues from slipping through the cracks. 
-2. Performance optimization: [Continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) in hybrid environments allows for real-time identification of performance bottlenecks. IT teams can optimize workloads by analyzing resource usage across both on-premises and cloud systems, ensuring the right resources are allocated at the right time to maintain optimal system performance. 
-3. Cost control: The risk within a hybrid setup is that resources can become over-provisioned or underutilised, which essentially wastes money. Hybrid cloud monitoring gives insight into resource consumption, enabling IT to fine-tune allocations and find cost-saving opportunities across both environments on-premises and in the cloud. 
-4. Security and compliance: Ensuring consistent security policies and compliance can be challenging with workloads spread across multiple environments. Hybrid cloud monitoring servers as the key to identifying vulnerabilities, knowing where security threats are coming from, and maintaining compliance with respective industry regulation requirements. It ensures data security and satisfies all legal obligations, irrespective of the location on which the workloads run. 
+1. Managing Complexity: Hybrid environments combine diverse technologies, including legacy systems and modern cloud platforms, making maintaining a unified view of your infrastructure challenging. Hybrid cloud monitoring provides a single pane of glass to track and manage these disparate components, ensuring smooth operation and preventing performance issues from slipping through the cracks.
+2. Performance optimization: [Continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) in hybrid environments allows for real-time identification of performance bottlenecks. IT teams can optimize workloads by analyzing resource usage across both on-premises and cloud systems, ensuring the right resources are allocated at the right time to maintain optimal system performance.
+3. Cost control: The risk within a hybrid setup is that resources can become over-provisioned or underutilised, which essentially wastes money. Hybrid cloud monitoring gives insight into resource consumption, enabling IT to fine-tune allocations and find cost-saving opportunities across both environments on-premises and in the cloud.
+4. Security and compliance: Ensuring consistent security policies and compliance can be challenging with workloads spread across multiple environments. Hybrid cloud monitoring servers as the key to identifying vulnerabilities, knowing where security threats are coming from, and maintaining compliance with respective industry regulation requirements. It ensures data security and satisfies all legal obligations, irrespective of the location on which the workloads run.
 
 ## Essential Components of a Robust Hybrid Cloud Monitoring Strategy
 
 To effectively monitor your hybrid cloud environment, you need a comprehensive strategy that includes:
 
 - Unified visibility: Deploy a centralised monitoring platform that consolidates data from both on-premises and cloud environments into a single view. To achieve this, you can start by selecting a monitoring solution that supports hybrid environment tools like Prometheus, Datadog, or Grafana.
-    - Once the platform is chosen, integrate cloud-native services like AWS CloudWatch or Azure Monitor alongside on-premises systems through agent-based or agentless methods.
-    - These agents gather and stream metrics, logs, and event data from all parts of your infrastructure. You can further enhance the setup by standardizing monitoring metrics and implementing custom dashboards to visualize the data in real-time.
-    - This unified approach provides comprehensive visibility, and easier management, and enables prompt detection and resolution of issues before they impact performance.
+  - Once the platform is chosen, integrate cloud-native services like AWS CloudWatch or Azure Monitor alongside on-premises systems through agent-based or agentless methods.
+  - These agents gather and stream metrics, logs, and event data from all parts of your infrastructure. You can further enhance the setup by standardizing monitoring metrics and implementing custom dashboards to visualize the data in real-time.
+  - This unified approach provides comprehensive visibility, and easier management, and enables prompt detection and resolution of issues before they impact performance.
 - Real-time performance tracking: It is essential to proactively manage your hybrid cloud infrastructure. Start by setting up continuous monitoring using tools like Prometheus, Zabbix or Datadog, which offer real-time metrics collection.
-    - Define and configure Key Performance Indicators (KPIs) relevant to your systems, such as CPU usage, memory utilization, network latency, and application response times.
-    - Enable real-time alerting through integrations with communication tools like Slack, Microsoft Teams, or PagerDuty to ensure that your team receives instant notifications when performance thresholds are breached.
-    - To eliminate downtime, implement automated remediation workflows that trigger predefined corrective actions as soon as an issue is detected, ensuring that performance remains optimal and issues are resolved quickly without manual intervention.
+  - Define and configure Key Performance Indicators (KPIs) relevant to your systems, such as CPU usage, memory utilization, network latency, and application response times.
+  - Enable real-time alerting through integrations with communication tools like Slack, Microsoft Teams, or PagerDuty to ensure that your team receives instant notifications when performance thresholds are breached.
+  - To eliminate downtime, implement automated remediation workflows that trigger predefined corrective actions as soon as an issue is detected, ensuring that performance remains optimal and issues are resolved quickly without manual intervention.
 - Automated discovery and mapping: Automated discovery and mapping is the key to maintaining visibility in complex hybrid environments. Use tools like Solarwinds, ServiceNow, or Dynatrace, which can automatically scan your hybrid infrastructure to discover assets across both on-premises and cloud environments.
-    - These tools will generate dynamic topology maps that visually represent component dependencies, including servers, applications, databases, and network resources.
-    - By identifying and mapping out these dependencies, your team gains a deeper understanding of how different components interact, making it easier to troubleshoot complex issues.
-    - Additionally, ensure the mapping process is continuously updated as the environment evolves. So, you always have an accurate and real-time view of your infrastructure. This helps in isolating problem areas and mitigating potential risks effectively.
+  - These tools will generate dynamic topology maps that visually represent component dependencies, including servers, applications, databases, and network resources.
+  - By identifying and mapping out these dependencies, your team gains a deeper understanding of how different components interact, making it easier to troubleshoot complex issues.
+  - Additionally, ensure the mapping process is continuously updated as the environment evolves. So, you always have an accurate and real-time view of your infrastructure. This helps in isolating problem areas and mitigating potential risks effectively.
 - Scalability: Scalable monitoring solutions are crucial for the evolving nature of hybrid cloud environments. Choose tools like Prometheus, Datadog, or SigNoz which are designed to scale seamlessly as your infrastructure grows.
-    - These platforms can handle increased data volumes and provide dynamic resource tracking, ensuring that as you add new components, the monitoring system automatically adapts to expanded workloads and changing performance metrics.
-    - Additionally, ensure your solutions support auto-scaling features to accommodate fluctuations in cloud resource utilization, preventing performance bottlenecks or gaps in monitoring coverage.
-    - This way, your monitoring stays aligned with your infrastructure’s evolving demands without sacrificing efficiency or visibility.
+  - These platforms can handle increased data volumes and provide dynamic resource tracking, ensuring that as you add new components, the monitoring system automatically adapts to expanded workloads and changing performance metrics.
+  - Additionally, ensure your solutions support auto-scaling features to accommodate fluctuations in cloud resource utilization, preventing performance bottlenecks or gaps in monitoring coverage.
+  - This way, your monitoring stays aligned with your infrastructure’s evolving demands without sacrificing efficiency or visibility.
 
 ### Key Metrics to Monitor in Hybrid Cloud Environments
 
-To maintain optimal performance and efficiency in your hybrid cloud setup, focus on monitoring the following critical metrics: 
+To maintain optimal performance and efficiency in your hybrid cloud setup, focus on monitoring the following critical metrics:
 
 - Resource utilization: Monitor CPU, memory, and storage utilization for on-premises to the cloud. Tracking these metrics prevents overprovisioning, ensures resources are well allocated, and prevents constraint issues that would impact performance.
 - Network performance: Track latency, throughput, and packet loss. These metrics relate to the reliable and efficient communication of the on-premise and cloud resources over the network, determining the performance of the overall system.
@@ -57,23 +67,25 @@ To maintain optimal performance and efficiency in your hybrid cloud setup, focus
 
 ## How to Implement Effective Hybrid Cloud Monitoring
 
-<Figure src="/img/guides/2024/09/hybrid-cloud-monitoring-2d8307ee-60f3-4597-a567-a3411f1f36ef.webp" alt="Steps to Implement Effective Hybrid Cloud Monitoring" caption="Steps to Implement Effective Hybrid Cloud Monitoring" />
+<Figure
+  src="/img/guides/2024/09/hybrid-cloud-monitoring-2d8307ee-60f3-4597-a567-a3411f1f36ef.webp"
+  alt="Steps to Implement Effective Hybrid Cloud Monitoring"
+  caption="Steps to Implement Effective Hybrid Cloud Monitoring"
+/>
 
 Follow these steps to set up a robust monitoring system for your hybrid cloud:
 
 - Select the right tools: Choose monitoring platforms that offer comprehensive support for both on-premises and cloud environments. Look for features such as auto-discovery of assets, customizable dashboards, and advanced analytics capabilities. Ensure that the tools can provide unified visibility across your entire infrastructure and handle the complexity of hybrid setups.
 - Establish consistent practices: Define standardized monitoring processes and metrics that apply uniformly across all your environments. Consistency in monitoring processes and metrics is crucial for obtaining accurate and comparable data, which helps in deriving meaningful insights and maintaining operational efficiency.
-    
-    ### Example of Standard Monitoring Practices:
-    
-    - Unified Metrics Framework: Define a common set of performance metrics (such as CPU utilization, Memory usage, and latency) that apply uniformly to all environments whether on-premises or in the cloud.
-    - Standardized Monitoring Tools: Use tools that support both cloud and on-premises environments equally. For example, a tool like Prometheus can be deployed across different infrastructures, ensuring the same monitoring processes are applied to cloud-native microservices and traditional systems alike.
+  ### Example of Standard Monitoring Practices:
+  - Unified Metrics Framework: Define a common set of performance metrics (such as CPU utilization, Memory usage, and latency) that apply uniformly to all environments whether on-premises or in the cloud.
+  - Standardized Monitoring Tools: Use tools that support both cloud and on-premises environments equally. For example, a tool like Prometheus can be deployed across different infrastructures, ensuring the same monitoring processes are applied to cloud-native microservices and traditional systems alike.
 - Implement monitoring-as-code: Leverage Infrastructure and Code to automate deployment and configuration of monitoring agents or tools, which helps ensure that monitoring setups can be repeatable, scalable, and paralleled with infrastructural changes for minimal overhead and less likelihood of configuration errors.
 - Integrate with existing processes: Ensure your monitoring solution integrates with DevOps workflows, ITSM tools, and incident management systems. Integration allows for the smoothing of incident response, teams can collaborate more effectively, and monitoring data forms part of an overall IT operation strategy.
 
 ## Best Practices for Optimizing Hybrid Cloud Performance
 
-To maximize the effectiveness of your hybrid cloud monitoring and ensure peak performance: 
+To maximize the effectiveness of your hybrid cloud monitoring and ensure peak performance:
 
 - Implement [proactive monitoring](https://signoz.io/guides/proactive-monitoring/): Utilize predictive analytics to foresee and address potential issues before they affect your systems. Proactive monitoring helps mitigate risks and ensure uninterrupted service by addressing problems at an early stage.
 - Leverage AI and machine learning: Integrate advanced anomaly detection and pattern recognition algorithms. AI and machine learning can help rapidly pinpoint unusual behaviour and potential threats but-most importantly provide deeper insights that enable more rapid responses to emerging issues.
@@ -85,60 +97,44 @@ To maximize the effectiveness of your hybrid cloud monitoring and ensure peak pe
 Address these common challenges is crucial for effective hybrid cloud monitoring:
 
 - Data silos: Data silos is one of the biggest challenges that organizations face in hybrid cloud environments. It occurs when information is isolated within specific departments or teams, limiting access and reducing the ability to gain comprehensive insights across the infrastructure. This isolation not only hampers collaboration but also leads to inefficiencies and incomplete decision-making.
-    
-    Key Challenges of Data Silos: 
-    
-    - Lack of Visibility: Without unified access to data across the hybrid cloud, teams miss out on crucial insights that could improve performance or prevent issues.
-    - Duplicate Efforts: When data is siloed, teams may unknowingly duplicate work, leading to a waste of time and resources.
-    - Reduced Collaboration: Silos prevent effective communication and cooperation between teams, reducing operational efficiency and making it difficult to optimize the hybrid environment.
-    
-    Solutions: 
-    
-    - Team Collaboration and Data Sharing: Promote a collaborative culture where data is shared across teams to ensure everyone has access to the information they need for informed decision-making.
-    - Integrate Monitoring Tools: Centralizing monitoring tools and data streams across your hybrid cloud environment can eliminate silos, providing a unified view of operations. This makes it easier to identify trends, manage resources, and maintain a consistent security posture.
+  Key Challenges of Data Silos:
+  - Lack of Visibility: Without unified access to data across the hybrid cloud, teams miss out on crucial insights that could improve performance or prevent issues.
+  - Duplicate Efforts: When data is siloed, teams may unknowingly duplicate work, leading to a waste of time and resources.
+  - Reduced Collaboration: Silos prevent effective communication and cooperation between teams, reducing operational efficiency and making it difficult to optimize the hybrid environment.
+  Solutions:
+  - Team Collaboration and Data Sharing: Promote a collaborative culture where data is shared across teams to ensure everyone has access to the information they need for informed decision-making.
+  - Integrate Monitoring Tools: Centralizing monitoring tools and data streams across your hybrid cloud environment can eliminate silos, providing a unified view of operations. This makes it easier to identify trends, manage resources, and maintain a consistent security posture.
 - Security and compliance: Security and compliance are critical concerns when managing hybrid cloud infrastructures. The complexity of monitoring across on-premises and cloud environments often exposes vulnerabilities and regulatory risks if not properly handled.
-    
-    Key Challenges of Security and Compliance:
-    
-    - Data Vulnerabilities: Monitoring systems may expose sensitive data if not secured with proper encryption and access controls.
-    - Regulatory Risks: Failing to meet industry-specific complaint standards (such as GDPR or HIPPA) can result in fines or operational restrictions.
-    - Multiple Security Frameworks: Hybrid environments require organisations to manage security across diverse systems, each with its requirements.
-    
-    Solutions: 
-    
-    - End-to-End Encryption: Implement encryption for both data at rest and in transit to ensure sensitive information is protected throughout the monitoring process.
-    - Role-Based Access Control (RBAC): Limit access to monitoring tools and data based on user roles, ensuring that only authorized personnel can view or manage critical information.
-    - Regular Audits: Conduct frequent security and compliance audits to ensure all hybrid environments meet the necessary regulatory standards and maintain consistent security policies.
+  Key Challenges of Security and Compliance:
+  - Data Vulnerabilities: Monitoring systems may expose sensitive data if not secured with proper encryption and access controls.
+  - Regulatory Risks: Failing to meet industry-specific complaint standards (such as GDPR or HIPPA) can result in fines or operational restrictions.
+  - Multiple Security Frameworks: Hybrid environments require organisations to manage security across diverse systems, each with its requirements.
+  Solutions:
+  - End-to-End Encryption: Implement encryption for both data at rest and in transit to ensure sensitive information is protected throughout the monitoring process.
+  - Role-Based Access Control (RBAC): Limit access to monitoring tools and data based on user roles, ensuring that only authorized personnel can view or manage critical information.
+  - Regular Audits: Conduct frequent security and compliance audits to ensure all hybrid environments meet the necessary regulatory standards and maintain consistent security policies.
 - Tool sprawl: It refers to the overwhelming number of monitoring tools and platforms that organizations use to manage hybrid environments. This fragmentation creates complexity, increases costs, and makes it difficult to maintain visibility across systems.
-    
-    Key Challenges of Tool Sprawl: 
-    
-    - Fragmented Data: Multiple tools create disconnected streams of data, making it hard to get a comprehensive view of infrastructure.
-    - Increased Management Overhead: Managing a wide range of tools requires more resources and personnel, increasing operational complexity.
-    - Lack of Integration: Many tools cannot work together seamlessly, limiting efficiency and centralization of insights.
-    
-    Solutions: 
-    
-    - Consolidate Monitoring Tools: Where possible, reduce the number of tools in use by selecting platforms that offer multiple functionalities, such as [unified observability](https://signoz.io/unified-observability/), analytics, and automation.
-    - Choose Integrated Solutions: Opt for monitoring tools that integrate easily with existing infrastructure and cloud providers, allowing for centralized data collection and analysis.
-    - Automate Monitoring Processes: Utilize platforms that provide automation capabilities to reduce manual tasks and streamline monitoring workflows.
+  Key Challenges of Tool Sprawl:
+  - Fragmented Data: Multiple tools create disconnected streams of data, making it hard to get a comprehensive view of infrastructure.
+  - Increased Management Overhead: Managing a wide range of tools requires more resources and personnel, increasing operational complexity.
+  - Lack of Integration: Many tools cannot work together seamlessly, limiting efficiency and centralization of insights.
+  Solutions:
+  - Consolidate Monitoring Tools: Where possible, reduce the number of tools in use by selecting platforms that offer multiple functionalities, such as [unified observability](https://signoz.io/unified-observability/), analytics, and automation.
+  - Choose Integrated Solutions: Opt for monitoring tools that integrate easily with existing infrastructure and cloud providers, allowing for centralized data collection and analysis.
+  - Automate Monitoring Processes: Utilize platforms that provide automation capabilities to reduce manual tasks and streamline monitoring workflows.
 - Legacy system integration: It poses a unique challenge in hybrid cloud monitoring. Older, on-premises systems often lack the modern APIs and interfaces needed to integrate with cloud-based solutions, creating gaps in visibility and performance tracking.
-    
-    Key Challenges of Legacy System Integration: 
-    
-    - Incompatibility: Legacy systems may not be compatible with cloud-native tools, making it difficult to monitor them effectively within the hybrid environment.
-    - Limited Data Access: Older systems may not generate the same level of detailed metrics or data points needed for modern monitoring.
-    - Costly Upgrades: Upgrading or replacing legacy systems to ensure integration with hybrid cloud solutions can be expensive and disruptive to operations.
-    
-    Solutions:
-    
-    - Utilize APIs and Custom Integrations: Develop custom APIs or use middleware to bridge the gap between legacy systems and modern monitoring platforms, ensuring data flows seamlessly across the hybrid cloud.
-    - Leverage Edge Computing: Use edge computing solutions to manage and process data from legacy systems before sending it to the cloud, enabling real-time monitoring and insights.
-    - Progressive Modernization: Gradually upgrade legacy systems by implementing hybrid-compatible components while maintaining essential operations, ensuring a smoother transition without major disruptions.
+  Key Challenges of Legacy System Integration:
+  - Incompatibility: Legacy systems may not be compatible with cloud-native tools, making it difficult to monitor them effectively within the hybrid environment.
+  - Limited Data Access: Older systems may not generate the same level of detailed metrics or data points needed for modern monitoring.
+  - Costly Upgrades: Upgrading or replacing legacy systems to ensure integration with hybrid cloud solutions can be expensive and disruptive to operations.
+  Solutions:
+  - Utilize APIs and Custom Integrations: Develop custom APIs or use middleware to bridge the gap between legacy systems and modern monitoring platforms, ensuring data flows seamlessly across the hybrid cloud.
+  - Leverage Edge Computing: Use edge computing solutions to manage and process data from legacy systems before sending it to the cloud, enabling real-time monitoring and insights.
+  - Progressive Modernization: Gradually upgrade legacy systems by implementing hybrid-compatible components while maintaining essential operations, ensuring a smoother transition without major disruptions.
 
 ## Enhancing Hybrid Cloud Monitoring with SigNoz
 
-[SigNoz](https://signoz.io/docs/introduction/) is designed to elevate your hybrid cloud monitoring capabilities with a range of powerful features: 
+[SigNoz](https://signoz.io/docs/introduction/) is designed to elevate your hybrid cloud monitoring capabilities with a range of powerful features:
 
 <GetStartedSigNoz />
 
@@ -149,7 +145,7 @@ Address these common challenges is crucial for effective hybrid cloud monitoring
 
 ## Future Trends in Hybrid Cloud Monitoring
 
-As hybrid cloud environments grow in complexity, it’s essential to stay ahead of emerging trends in monitoring technologies; 
+As hybrid cloud environments grow in complexity, it’s essential to stay ahead of emerging trends in monitoring technologies;
 
 - AI-driven autonomous operations: The integration of AIOps will become more prevalent, enabling systems to automatically respond to incidents and perform self-healing actions. By reducing manual intervention, these AI-powered tools will help organizations minimize downtime, quickly address issues, and improve overall system efficiency.
 - Edge computing integration: With the growth of edge computing, the scope of monitoring solutions will expand not only to include central cloud and on-premises environments but also distributed edge devices. Those solutions shall give insight into the performance and health of remote resources in seamless operations at the edge and better synchronization between on-premises data centres, cloud platforms, and edge devices.
@@ -168,39 +164,39 @@ As hybrid cloud environments grow in complexity, it’s essential to stay ahead
 
 ### What are the main differences between monitoring hybrid cloud vs. traditional on-premises environments?
 
-| Aspect | Hybrid Cloud | Traditional On-Premises |
-| --- | --- | --- |
-| Infrastructure | Combines on-premises and cloud resources | Relies solely on local, on-premises hardware |
-| Scalability | Highly scalable with access to cloud resources | Limited by physical hardware capacity  |
-| Cost Model | Pay-as-you-go for cloud, upfront investment for on-prem | Requires significant upfront investment |
-| Flexibility | Offers visibility in workload placement (cloud or local) | Less flexible, all workflows run local infrastructure  |
-| Security | Security managed across both local and cloud environments.  | Security entirely managed within local systems |
-| Maintenance | Shared responsibility (cloud provider and in-house) | Fully managed by in-house IT teams |
+| Aspect         | Hybrid Cloud                                               | Traditional On-Premises                               |
+| -------------- | ---------------------------------------------------------- | ----------------------------------------------------- |
+| Infrastructure | Combines on-premises and cloud resources                   | Relies solely on local, on-premises hardware          |
+| Scalability    | Highly scalable with access to cloud resources             | Limited by physical hardware capacity                 |
+| Cost Model     | Pay-as-you-go for cloud, upfront investment for on-prem    | Requires significant upfront investment               |
+| Flexibility    | Offers visibility in workload placement (cloud or local)   | Less flexible, all workflows run local infrastructure |
+| Security       | Security managed across both local and cloud environments. | Security entirely managed within local systems        |
+| Maintenance    | Shared responsibility (cloud provider and in-house)        | Fully managed by in-house IT teams                    |
 
 ### How can organizations ensure data security while monitoring hybrid cloud infrastructures?
 
-To ensure data security in hybrid cloud monitoring: 
+To ensure data security in hybrid cloud monitoring:
 
-1. Encrypt data in transit and at rest to protect against unauthorized access. 
-2. Use role-based access control (RBAC) to limit access to monitoring data. 
-3. Regularly audit security policies to address new risks across environments. 
-4. Ensure secure communication with VPNs or dedicated connections between on-premises and cloud systems. 
-5. Maintain compliance with relevant regulations to protect sensitive data. 
+1. Encrypt data in transit and at rest to protect against unauthorized access.
+2. Use role-based access control (RBAC) to limit access to monitoring data.
+3. Regularly audit security policies to address new risks across environments.
+4. Ensure secure communication with VPNs or dedicated connections between on-premises and cloud systems.
+5. Maintain compliance with relevant regulations to protect sensitive data.
 
 ### What role does AIOps play in hybrid cloud monitoring?
 
 AIOps (Artificial Intelligence for IT Operations) enhances hybrid cloud monitoring by:
 
 1. Automating routine tasks like alert triage and incident management, reducing manual intervention.
-2. Predictive analysis to forecast potential issues, enabling proactive response before problems escalate. 
-3. Intelligently anomaly detection for rapid identification of unusual and derivations in performance. 
-4. Advanced root cause analysis, correlating events across different environments to pinpoint and resolve issues faster. 
+2. Predictive analysis to forecast potential issues, enabling proactive response before problems escalate.
+3. Intelligently anomaly detection for rapid identification of unusual and derivations in performance.
+4. Advanced root cause analysis, correlating events across different environments to pinpoint and resolve issues faster.
 
 ### How often should hybrid cloud monitoring strategies be reviewed and updated?
 
 Review and update your hybrid cloud monitoring strategy regularly—at least quarterly. However, also conduct reviews:
 
-1. After significant infrastructure changes or cloud migrations to ensure compatibility and visibility in the updated environment. 
-2. When introducing new applications or services integrate them into your monitoring processes. 
-3. Following major incidents or performance issues to address root causes and improve system resilience. 
-4. When new monitoring technologies or best practices emerge to stay up to date with the latest advancements.
\ No newline at end of file
+1. After significant infrastructure changes or cloud migrations to ensure compatibility and visibility in the updated environment.
+2. When introducing new applications or services integrate them into your monitoring processes.
+3. Following major incidents or performance issues to address root causes and improve system resilience.
+4. When new monitoring technologies or best practices emerge to stay up to date with the latest advancements.
diff --git a/data/guides/incident-management-metrics.mdx b/data/guides/incident-management-metrics.mdx
index 4ded30dd4..5d6d3ac59 100644
--- a/data/guides/incident-management-metrics.mdx
+++ b/data/guides/incident-management-metrics.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: 10 Essential Incident Management Metrics to Track
-slug: incident-management-metrics
 date: 2024-12-19
 tags: [monitoring, incident management]
 authors: [soumya_gupta]
 description: Discover 10 crucial incident management metrics to improve your IT operations. Learn how to track, analyze, and optimize your incident response process.
-keywords: [incident management metrics, MTTR, MTTA, SLA compliance, incident response, IT operations]
-
+keywords:
+  [incident management metrics, MTTR, MTTA, SLA compliance, incident response, IT operations]
 ---
 
 Effective incident management is crucial for maintaining system reliability and customer satisfaction in today's fast-paced IT landscape. But how do you measure the success of your incident response efforts? The answer lies in tracking the right incident management metrics. These key performance indicators (KPIs) provide valuable insights into your team's efficiency, response times, and overall incident handling effectiveness.
@@ -16,16 +14,20 @@ Effective incident management is crucial for maintaining system reliability and
 
 Incident management metrics are quantifiable measures used to evaluate the performance and efficiency of an organization's incident response processes. These metrics help IT teams and managers assess various aspects of incident handling — from detection and response times to resolution rates and customer satisfaction.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image.webp" alt="Proactive and Reactive Metric" caption="Proactive and Reactive Metric" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image.webp"
+  alt="Proactive and Reactive Metric"
+  caption="Proactive and Reactive Metric"
+/>
 
 Incident management metrics fall into two main categories:
 
-| Factors | Reactive Metric | Proactive Metric |
-| --- | --- | --- |
-| Description | Reactive incident response is all about tackling incidents after they’ve already happened, working quickly to get things back to normal and limit any damage. | Proactive incident response is more about staying ahead of the game—anticipating problems and taking steps to stop them before they even start |
-| Need | Vital for addressing the immediate consequences of a security breach or system failure. | Crucial for identifying potential risks and implementing measures to prevent security breaches or system failures from happening in the first place. |
-| Challenges | Reactive strategies can cause longer downtimes, higher long-term costs, and damage to a company’s reputation, leading to customer churn. Without preparation, teams may struggle to handle incidents efficiently, slowing recovery. | Proactive strategies involve higher upfront costs for tools, skilled personnel, and system monitoring, and can be complex to implement in large IT environments. They may also generate false positives, leading to wasted efforts, and require continuous oversight, which can strain resources. |
-| Example | Mean Time to Resolution (MTTR) and First Touch Resolution Rate are examples of reactive metric. | Mean Time Between Failures (MTBF) is a prime example of a proactive metric. |
+| Factors     | Reactive Metric                                                                                                                                                                                                                     | Proactive Metric                                                                                                                                                                                                                                                                                  |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Description | Reactive incident response is all about tackling incidents after they’ve already happened, working quickly to get things back to normal and limit any damage.                                                                       | Proactive incident response is more about staying ahead of the game—anticipating problems and taking steps to stop them before they even start                                                                                                                                                    |
+| Need        | Vital for addressing the immediate consequences of a security breach or system failure.                                                                                                                                             | Crucial for identifying potential risks and implementing measures to prevent security breaches or system failures from happening in the first place.                                                                                                                                              |
+| Challenges  | Reactive strategies can cause longer downtimes, higher long-term costs, and damage to a company’s reputation, leading to customer churn. Without preparation, teams may struggle to handle incidents efficiently, slowing recovery. | Proactive strategies involve higher upfront costs for tools, skilled personnel, and system monitoring, and can be complex to implement in large IT environments. They may also generate false positives, leading to wasted efforts, and require continuous oversight, which can strain resources. |
+| Example     | Mean Time to Resolution (MTTR) and First Touch Resolution Rate are examples of reactive metric.                                                                                                                                     | Mean Time Between Failures (MTBF) is a prime example of a proactive metric.                                                                                                                                                                                                                       |
 
 By tracking a balanced set of both reactive and proactive metrics, you gain a comprehensive view of your incident management performance.
 
@@ -44,7 +46,11 @@ Monitoring incident management metrics offers several benefits:
 
 In today’s always-on world, outages and technical incidents have a significant impact, leading to missed deadlines, late payments, and project delays. That’s why it’s crucial for companies to track and measure metrics related to uptime, downtime, and how quickly and effectively teams resolve issues.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%201.webp" alt="Incident Metrics Visual" caption="Incident Metrics Visual" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%201.webp"
+  alt="Incident Metrics Visual"
+  caption="Incident Metrics Visual"
+/>
 
 ### 1. Mean Time to Detect (MTTD)
 
@@ -86,7 +92,11 @@ To reduce MTTA:
 
 ### 3. Mean Time to Respond/Resolve/Repair/Recover (MTTR)
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%202.webp" alt="Mean Time To: X" caption="Mean Time To: X" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%202.webp"
+  alt="Mean Time To: X"
+  caption="Mean Time To: X"
+/>
 
 MTTR represents four different measurements—repair, recovery, respond, or resolve. While these metrics overlap, each has its own distinct meaning. So, when discussing MTTR, it's important to clarify which one you're referring to and ensure everyone on the team is aligned on the definition before tracking successes and failures
 | Factors | Repair | Respond | Resolve | Recover |
@@ -97,7 +107,7 @@ MTTR represents four different measurements—repair, recovery, respond, or reso
 | Examples | With 8 outages and 40 hours spent on repairs in a month, we convert 40 hours to 2400 minutes. Dividing 2400 by 8 gives a mean time to repair of 300 minutes. | If there were four incidents in a 40-hour workweek with a total response time of 1 hour, dividing 60 minutes by 4 results in an MTTR of 15 minutes for the week. | Assume that your systems were down for two hours, and the team spent another two hours preventing future outages, the total resolution time would be four hours, resulting in an MTTR of four hours. | Say our systems were down for 30 minutes across two incidents in a 24-hour period, dividing 30 by 2 gives an MTTR of 15 minutes. |
 | Criteria | Support and maintenance teams rely on this to ensure repairs stay on schedule. | Utilized in cybersecurity to evaluate a team's effectiveness in countering system attacks. | Used to refer to unplanned incidents, as opposed to service requests, which are usually planned. | Used for evaluating the efficiency of your overall recovery process. |
 
-To improve MTTR: 
+To improve MTTR:
 
 - Develop and maintain comprehensive incident response playbooks
 - Implement post-incident reviews to identify areas for improvement
@@ -113,20 +123,20 @@ To analyze incident volume:
 - Identify peak incident periods and potential correlations with system changes or external factors
 - Use trend analysis to predict future incident volumes and plan accordingly
 
-Example: Consider the following mock data for an organization whose incident volume over a 4-week period looks like the following: 
+Example: Consider the following mock data for an organization whose incident volume over a 4-week period looks like the following:
 
-| Week | Incident Type | Severity | Affected System | Number of Incidents |
-| --- | --- | --- | --- | --- |
-| Week 1 | System Crash | High | Database | 5 |
-| Week 1 | Service Outage | Medium | API Gateway | 3 |
-| Week 2 | System Crash | High | Database | 7 |
-| Week 2 | Service Outage | Low | Web Server | 2 |
-| Week 3 | Security Breach | High | Database | 4 |
-| Week 3 | Service Outage | Medium | API Gateway | 6 |
-| Week 4 | System Crash | Low | Web Server | 1 |
-| Week 4 | Service Outage | Medium | API Gateway | 5 |
+| Week   | Incident Type   | Severity | Affected System | Number of Incidents |
+| ------ | --------------- | -------- | --------------- | ------------------- |
+| Week 1 | System Crash    | High     | Database        | 5                   |
+| Week 1 | Service Outage  | Medium   | API Gateway     | 3                   |
+| Week 2 | System Crash    | High     | Database        | 7                   |
+| Week 2 | Service Outage  | Low      | Web Server      | 2                   |
+| Week 3 | Security Breach | High     | Database        | 4                   |
+| Week 3 | Service Outage  | Medium   | API Gateway     | 6                   |
+| Week 4 | System Crash    | Low      | Web Server      | 1                   |
+| Week 4 | Service Outage  | Medium   | API Gateway     | 5                   |
 
-To analyze incident volume, we track incidents by type, severity, and affected systems. For instance, in Week 1, 5 high-severity database incidents suggest a recurring issue, while Week 3 saw an increase in medium-severity incidents with the API Gateway, pointing to potential performance issues. Peak periods are identified, like Week 2, which had 7 system crashes and 2 service outages, likely linked to a system update. 
+To analyze incident volume, we track incidents by type, severity, and affected systems. For instance, in Week 1, 5 high-severity database incidents suggest a recurring issue, while Week 3 saw an increase in medium-severity incidents with the API Gateway, pointing to potential performance issues. Peak periods are identified, like Week 2, which had 7 system crashes and 2 service outages, likely linked to a system update.
 
 Trend analysis reveals a consistent pattern of high-severity database incidents, which allows us to predict around 6 similar incidents in Week 5, along with medium and low-severity incidents involving the API Gateway and web server. By applying techniques such as linear regression or moving averages, we can fine-tune these predictions to improve resource planning and take proactive measures.
 
@@ -232,13 +242,17 @@ To successfully implement these metrics in your organization:
 
 ### Set up custom alerts based on your defined thresholds
 
-By setting up custom alerts and defining thresholds for a particular metric, we can proactively monitor system performance and receive timely notifications when metrics exceed or fall below defined limits. 
+By setting up custom alerts and defining thresholds for a particular metric, we can proactively monitor system performance and receive timely notifications when metrics exceed or fall below defined limits.
 
 Step 1: Set up an alert channel in SigNoz
 
 To set up an alert channel in SigNoz, go to SigNoz → Settings → Alerts → Create New Alert Channel. Provide a name for the alert channel, choose the type (e.g., email), add your email address, and click save.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%203.webp" alt="Alert Notification Channel in SigNoz" caption="Alert Notification Channel in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%203.webp"
+  alt="Alert Notification Channel in SigNoz"
+  caption="Alert Notification Channel in SigNoz"
+/>
 
 Step 2: Create an alert trigger
 
@@ -246,13 +260,21 @@ Next, we create an alert trigger that defines the conditions under which the ale
 
 Go to Alerts → Select [Trace-based alert](https://signoz.io/docs/alerts-management/trace-based-alerts/) (ideal for monitoring external APIs) → Configure the metrics to monitor, such as status codes (e.g., 503) → Click Stage to run the query.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%204.webp" alt="Alert Configuration in SigNoz" caption="Alert Configuration in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%204.webp"
+  alt="Alert Configuration in SigNoz"
+  caption="Alert Configuration in SigNoz"
+/>
 
 Step 3: Define metrics and alert conditions
 
 Set up the conditions for when the alert should be triggered, give your alert a name, define the threshold, and click save. Your alert system is now fully set up and ready to notify you when the specified conditions are met.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%205.webp" alt="Alert conditions setup" caption="Alert conditions setup" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%205.webp"
+  alt="Alert conditions setup"
+  caption="Alert conditions setup"
+/>
 
 ### 2. Automatically collect and visualize key incident management metrics
 
@@ -304,7 +326,7 @@ def toggle_downtime():
 def process_request():
     with tracer.start_as_current_span("process_request"):
     # Random latency between 100ms and 2000ms
-        latency = random.uniform(0.1, 2.0)  
+        latency = random.uniform(0.1, 2.0)
         time.sleep(latency)
         return jsonify({"message": "Processed", "latency": latency}), 200
 
@@ -312,13 +334,13 @@ if __name__ == "__main__":
     app.run(host="0.0.0.0", port=5000)
 ```
 
-Now let’s run `app.py` the above code using: 
+Now let’s run `app.py` the above code using:
 
 ```
 opentelemetry-instrument python3 app.py
 ```
 
-The below code in `test.py` is designed to test various endpoints of an [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) application. It offers a simple command-line interface (CLI) to interact with the system, allowing you to check the health, toggle downtime, send a process request, or simulate load by sending multiple requests with a delay. Each option triggers the corresponding API call and shows the status and response from the server. It’s a straightforward way to test and interact with your application’s endpoints. 
+The below code in `test.py` is designed to test various endpoints of an [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) application. It offers a simple command-line interface (CLI) to interact with the system, allowing you to check the health, toggle downtime, send a process request, or simulate load by sending multiple requests with a delay. Each option triggers the corresponding API call and shows the status and response from the server. It’s a straightforward way to test and interact with your application’s endpoints.
 
 Here's how it works:
 
@@ -389,7 +411,7 @@ if __name__ == "__main__":
     main()
 ```
 
-Output: 
+Output:
 
 ```
 Starting CLI Tester for OpenTelemetry Application
@@ -426,21 +448,33 @@ Testing /process endpoint...
 Status: 200, Response: {'latency': 1.8969696724059972, 'message': 'Processed'}
 ```
 
-Note: Learn how to instrument your application to SigNoz Server in-depth [here](https://signoz.io/docs/instrumentation/). 
+Note: Learn how to instrument your application to SigNoz Server in-depth [here](https://signoz.io/docs/instrumentation/).
 
-### 3.  Correlate metrics with logs and traces for faster root cause analysis
+### 3. Correlate metrics with logs and traces for faster root cause analysis
 
 When dealing with incidents, correlating metrics with logs and traces can make all the difference in quickly finding the root cause. By bringing these pieces of data together, teams can get a clearer picture of what went wrong, trace it back to the source, and fix the issue faster.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%206.webp" alt="Threshold crossed for this incident metric" caption="Threshold crossed for this incident metric" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%206.webp"
+  alt="Threshold crossed for this incident metric"
+  caption="Threshold crossed for this incident metric"
+/>
 
-As you can see above, the moment threshold is crossed the status is then changed to `Firing` under triggered alerts tab on SigNoz dashboard. 
+As you can see above, the moment threshold is crossed the status is then changed to `Firing` under triggered alerts tab on SigNoz dashboard.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%207.webp" alt="Triggered Alert for crossed threshold" caption="Triggered Alert for crossed threshold" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%207.webp"
+  alt="Triggered Alert for crossed threshold"
+  caption="Triggered Alert for crossed threshold"
+/>
 
-When an incident metric that we defined earlier crosses the set threshold, an email is sent in the following manner: 
+When an incident metric that we defined earlier crosses the set threshold, an email is sent in the following manner:
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%208.webp" alt="Email received from SigNoz" caption="Email received from SigNoz" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%208.webp"
+  alt="Email received from SigNoz"
+  caption="Email received from SigNoz"
+/>
 
 [Get started with SigNoz](https://signoz.io/) to streamline your incident management process and gain deeper insights into your system's performance.
 
@@ -448,7 +482,11 @@ When an incident metric that we defined earlier crosses the set threshold, an em
 
 Implementing an effective incident management process demands the right tools to streamline identification, assessment, response, and resolution, reducing the impact of IT issues.
 
-<Figure src="/img/guides/2024/12/incident-management-metrics-image%209.webp" alt="Incident Management Tools" caption="Incident Management Tools" />
+<Figure
+  src="/img/guides/2024/12/incident-management-metrics-image%209.webp"
+  alt="Incident Management Tools"
+  caption="Incident Management Tools"
+/>
 
 Here are key tools shaping modern incident management:
 
@@ -465,58 +503,34 @@ These tools collectively enhance efficiency, collaboration, and preparedness in
 ## Challenges of Incident Metrics: Beyond KPIs
 
 - Dependence on Limited Data
-    
-    Metrics like KPIs offer an overview but often fail to highlight the "why" or "how" behind team performance, leaving critical insights unexplored.
-    
+  Metrics like KPIs offer an overview but often fail to highlight the "why" or "how" behind team performance, leaving critical insights unexplored.
 - Lack of Incident-Specific Context
-    
-    KPIs can’t explain why some incidents take longer to resolve or why response times might vary unexpectedly. The nuances of each case often remain hidden.
-    
+  KPIs can’t explain why some incidents take longer to resolve or why response times might vary unexpectedly. The nuances of each case often remain hidden.
 - Misleading Comparisons
-    
-    Grouping fundamentally different incidents under the same metric can lead to inaccurate comparisons and misguided conclusions.
-    
+  Grouping fundamentally different incidents under the same metric can lead to inaccurate comparisons and misguided conclusions.
 - Overlooking Team Dynamics
-    
-    Metrics don’t reflect how teams navigate unexpected challenges, handle risks, or manage the intricacies of incident resolution.
-    
+  Metrics don’t reflect how teams navigate unexpected challenges, handle risks, or manage the intricacies of incident resolution.
 - False Sense of Progress
-    
-    KPIs may give a perception of success even when critical problem areas remain unaddressed, especially if metrics fail to improve.
-    
+  KPIs may give a perception of success even when critical problem areas remain unaddressed, especially if metrics fail to improve.
 - Complexity of Unique Incidents
-    
-    Incidents aren’t standardized processes. Two incidents of equal duration may differ greatly in risks, complexity, and the uncertainty they create.
-    
+  Incidents aren’t standardized processes. Two incidents of equal duration may differ greatly in risks, complexity, and the uncertainty they create.
 - KPIs as a Beginning, Not an End
-    
-    While KPIs provide valuable initial insights, true progress demands going beyond surface metrics to uncover deeper trends and root causes.
-    
+  While KPIs provide valuable initial insights, true progress demands going beyond surface metrics to uncover deeper trends and root causes.
 
 ## Best Practices for Continuous Improvement
 
 To drive ongoing enhancement of your incident management process:
 
 - Review Metrics Regularly
-    
-    Evaluate your incident metrics every quarter to ensure they remain relevant and effective. Analyze incidents to uncover root causes and identify preventive measures. Take steps to avoid recurring issues, complete all documentation, and provide necessary training on liability and compliance.
-    
+  Evaluate your incident metrics every quarter to ensure they remain relevant and effective. Analyze incidents to uncover root causes and identify preventive measures. Take steps to avoid recurring issues, complete all documentation, and provide necessary training on liability and compliance.
 - Promote a Culture of Improvement
-    
-    Empower teams to suggest and implement process enhancements based on insights from incident metrics. Encourage open feedback to drive meaningful changes.
-    
+  Empower teams to suggest and implement process enhancements based on insights from incident metrics. Encourage open feedback to drive meaningful changes.
 - Engage All Stakeholders
-    
-    Incorporate perspectives from support teams, developers, and management when analyzing metrics and setting goals, ensuring a well-rounded approach.
-    
+  Incorporate perspectives from support teams, developers, and management when analyzing metrics and setting goals, ensuring a well-rounded approach.
 - Stay Flexible with Metrics
-    
-    As your organization grows and evolves, update your metrics and targets to align with changing priorities and goals.
-    
+  As your organization grows and evolves, update your metrics and targets to align with changing priorities and goals.
 - Optimize Alerts and On-Call Strategies
-    
-    Prevent [alert fatigue](https://signoz.io/blog/alert-fatigue/) by categorizing events thoughtfully and setting up relevant alerts based on service level indicators (SLIs). Prioritize tasks like root cause analysis over superficial symptoms. Establish clear on-call schedules that consider individual workloads and incident volumes to ensure the right expertise is available when needed.
-    
+  Prevent [alert fatigue](https://signoz.io/blog/alert-fatigue/) by categorizing events thoughtfully and setting up relevant alerts based on service level indicators (SLIs). Prioritize tasks like root cause analysis over superficial symptoms. Establish clear on-call schedules that consider individual workloads and incident volumes to ensure the right expertise is available when needed.
 
 ## Key Takeaways
 
@@ -550,4 +564,4 @@ Balancing speed and quality in incident resolution requires a multi-faceted appr
 3. Conduct post-incident reviews to ensure that quick fixes don't lead to recurring issues.
 4. Use automation and AI to speed up routine tasks while allowing human expertise to focus on complex problems.
 
-By monitoring a balanced set of metrics and continuously refining your processes, you can achieve both rapid response times and high-quality incident resolutions.
\ No newline at end of file
+By monitoring a balanced set of metrics and continuously refining your processes, you can achieve both rapid response times and high-quality incident resolutions.
diff --git a/data/guides/incident-response-cycle.mdx b/data/guides/incident-response-cycle.mdx
index c8a46ce4f..5f79dd7f2 100644
--- a/data/guides/incident-response-cycle.mdx
+++ b/data/guides/incident-response-cycle.mdx
@@ -1,18 +1,28 @@
 ---
-
 title: The 5 Phases of Incident Response - A Complete Guide
-slug: incident-response-cycle
 date: 2024-12-19
 tags: [cybersecurity, incident response, NIST framework, threat detection, data breach]
 authors: [niyati_thakkar]
 description: Master the incident response cycle with our comprehensive guide. Learn the 5 phases to effectively handle cybersecurity threats and protect your organization.
-keywords: [incident response cycle, cybersecurity, NIST framework, threat detection, data breach, incident management, security operations]
-
+keywords:
+  [
+    incident response cycle,
+    cybersecurity,
+    NIST framework,
+    threat detection,
+    data breach,
+    incident management,
+    security operations,
+  ]
 ---
 
 Cybersecurity incidents are inevitable, making a robust incident response strategy essential for organizations. The incident response cycle, as outlined by the National Institute of Standards and Technology (NIST), provides a structured framework to effectively detect, manage, and resolve these incidents. A well-structured incident response cycle is your best defense against these threats. This guide breaks down the five crucial phases of incident response, providing you with the knowledge and tools to protect your digital assets effectively.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-CleanShot_2024-12-19_at_16.19.452x.webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-CleanShot_2024-12-19_at_16.19.452x.webp"
+  alt=""
+  caption=""
+/>
 
 ## What is the Incident Response Cycle?
 
@@ -31,28 +41,32 @@ A structured incident response process is essential for organizations to:
 
 The NIST lifecycle divides incident response into five interconnected phases as follows:
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-Untitled_design_(5).webp" alt="NIST lifecycle Phases" caption="NIST lifecycle Phases" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-Untitled_design_(5).webp"
+  alt="NIST lifecycle Phases"
+  caption="NIST lifecycle Phases"
+/>
 
 NIST lifecycle Phases
 
 1. Preparation – Building readiness through planning and training.
-    
-    Preparation ensures the team is ready to handle incidents. The organization conducts regular cybersecurity training and has incident response playbooks. Backup systems are configured for data protection. For example, endpoint detection tools flagged unusual activity during the attack.
-    
+
+   Preparation ensures the team is ready to handle incidents. The organization conducts regular cybersecurity training and has incident response playbooks. Backup systems are configured for data protection. For example, endpoint detection tools flagged unusual activity during the attack.
+
 2. Detection and Analysis – Identifying incidents and understanding their scope.
-    
-    This phase involves detecting and analyzing the threat. Security alerts reveal suspicious activity, and analysts confirm it’s ransomware. For instance, network logs showed the malware was triggered by an employee clicking a malicious email link.
-    
+
+   This phase involves detecting and analyzing the threat. Security alerts reveal suspicious activity, and analysts confirm it’s ransomware. For instance, network logs showed the malware was triggered by an employee clicking a malicious email link.
+
 3. Containment – Limiting the spread and impact of threats.
-    
-    Containment focuses on stopping the threat from spreading. Affected systems are isolated, and firewalls block attacker communication. For example, firewalls were reconfigured to prevent further spread of the ransomware.
-    
+
+   Containment focuses on stopping the threat from spreading. Affected systems are isolated, and firewalls block attacker communication. For example, firewalls were reconfigured to prevent further spread of the ransomware.
+
 4. Eradication and Recovery – Eliminating threats and restoring normalcy.
-The threat is removed, and systems are restored. Infected devices are wiped, backups are restored, and vulnerabilities are patched. For example, encrypted data was recovered from offline backups.
+   The threat is removed, and systems are restored. Infected devices are wiped, backups are restored, and vulnerabilities are patched. For example, encrypted data was recovered from offline backups.
 5. Post-Incident Activity – Learning from incidents to strengthen defenses.
-Post-incident reviews focus on improving future responses. Security measures, like multi-factor authentication, are added, and employees receive additional training. For example, email security systems were upgraded to prevent similar attacks.
+   Post-incident reviews focus on improving future responses. Security measures, like multi-factor authentication, are added, and employees receive additional training. For example, email security systems were upgraded to prevent similar attacks.
 
-Together, these phases form a robust strategy to tackle cybersecurity incidents efficiently and effectively. Let's dive into each phase to understand how they work together to create a robust incident response strategy. 
+Together, these phases form a robust strategy to tackle cybersecurity incidents efficiently and effectively. Let's dive into each phase to understand how they work together to create a robust incident response strategy.
 
 ## Phase 1: Preparation - Building Your Incident Response Foundation
 
@@ -61,21 +75,21 @@ Preparation is the first and most critical phase of the incident response cycle.
 ### Key Actions in the Preparation Phase
 
 1. Developing a Comprehensive Incident Response Plan
-    - Outline clear policies and procedures for managing incidents.
-    - Define the scope of incidents covered, from minor breaches to major attacks.
-    - A ransomware incident policy should include containment and restoration steps from secure backups.
+   - Outline clear policies and procedures for managing incidents.
+   - Define the scope of incidents covered, from minor breaches to major attacks.
+   - A ransomware incident policy should include containment and restoration steps from secure backups.
 2. Assembling and Training an Incident Response Team
-    - Form a dedicated team with clearly assigned roles, such as incident commander, forensic analyst, and communications officer.
-    - Provide regular training, including hands-on simulations and threat-specific exercises.
-    - Assign team members based on expertise, such as IT security for technical analysis and PR for external communications.
+   - Form a dedicated team with clearly assigned roles, such as incident commander, forensic analyst, and communications officer.
+   - Provide regular training, including hands-on simulations and threat-specific exercises.
+   - Assign team members based on expertise, such as IT security for technical analysis and PR for external communications.
 3. Establishing Communication Protocols and Escalation Procedures
-    - Set up clear communication channels for reporting and handling incidents.
-    - Define an escalation matrix to involve the right stakeholders at the appropriate time.
-    - Use a secure chat group and automated alerts for quick response during breaches.
+   - Set up clear communication channels for reporting and handling incidents.
+   - Define an escalation matrix to involve the right stakeholders at the appropriate time.
+   - Use a secure chat group and automated alerts for quick response during breaches.
 4. Implementing Necessary Tools and Technologies
-    - Deploy monitoring and alerting systems like SIEM tools for real-time detection.
-    - Ensure the availability of forensic tools, secure backups, and access controls.
-    - Use SIEM tools like Splunk for real-time alerts and off-site backups for data recovery.
+   - Deploy monitoring and alerting systems like SIEM tools for real-time detection.
+   - Ensure the availability of forensic tools, secure backups, and access controls.
+   - Use SIEM tools like Splunk for real-time alerts and off-site backups for data recovery.
 
 ### Key Components of an Effective Incident Response Plan
 
@@ -86,7 +100,11 @@ Your incident response plan should include:
 3. Documentation and reporting templates: Prepare standardized forms to ensure consistent and thorough incident documentation.
 4. Regular testing and updating: Conduct periodic reviews and simulations to keep your plan current and effective.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-NoteGPT_MindMap_1733589315416-transformed.webp" alt="Key components of an effective incident response plan" caption="Key components of an effective incident response plan" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-NoteGPT_MindMap_1733589315416-transformed.webp"
+  alt="Key components of an effective incident response plan"
+  caption="Key components of an effective incident response plan"
+/>
 
 SigNoz can help with tracking application performance and monitoring metrics, ensuring your systems are ready for potential incidents. Additionally, tools like Splunk and Tanium can assist with log management and endpoint visibility to enhance preparation.
 
@@ -104,17 +122,17 @@ Quick and accurate threat detection is crucial for minimizing damage. This phase
 ### Common Challenges in Detection and Analysis
 
 1. False Positives and [Alert Fatigue](https://signoz.io/blog/alert-fatigue/)
-    - Problem: Overwhelmed teams waste resources on benign alerts.
-    - Solution: Use adaptive machine learning to refine detection accuracy and prioritize high-risk alerts.
+   - Problem: Overwhelmed teams waste resources on benign alerts.
+   - Solution: Use adaptive machine learning to refine detection accuracy and prioritize high-risk alerts.
 2. Identifying Sophisticated or Zero-Day Attacks
-    - Problem: These threats evade traditional detection methods.
-    - Solution: Employ advanced behavior-based detection tools to spot unusual activity patterns.
+   - Problem: These threats evade traditional detection methods.
+   - Solution: Employ advanced behavior-based detection tools to spot unusual activity patterns.
 3. Correlating Data from Multiple Sources
-    - Problem: Disparate systems generate fragmented data, complicating analysis.
-    - Solution: Utilize SIEM platforms to aggregate and correlate data, enabling a unified view of incidents.
+   - Problem: Disparate systems generate fragmented data, complicating analysis.
+   - Solution: Utilize SIEM platforms to aggregate and correlate data, enabling a unified view of incidents.
 4. Balancing Speed and Thoroughness
-    - Problem: Rushing to contain incidents may overlook critical details.
-    - Solution: Implement a tiered approach—conduct rapid triage followed by detailed investigation for significant incidents.
+   - Problem: Rushing to contain incidents may overlook critical details.
+   - Solution: Implement a tiered approach—conduct rapid triage followed by detailed investigation for significant incidents.
 
 SigNoz can help you detect application performance issues in real-time. Pairing it with tools like Elasticsearch for log analysis, Prometheus for [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), and CrowdStrike for endpoint threat detection will ensure a comprehensive detection and analysis process.
 
@@ -130,21 +148,21 @@ Once an incident is detected, swift action is needed to prevent further spread.
 ### Containment Strategies for Different Types of Incidents
 
 1. Malware outbreaks:
-    - Isolate infected systems from the network
-    - Block known malicious IP addresses and domains
-    - Deploy updated antivirus signatures across the organization
+   - Isolate infected systems from the network
+   - Block known malicious IP addresses and domains
+   - Deploy updated antivirus signatures across the organization
 2. Data breaches:
-    - Revoke compromised credentials
-    - Implement additional authentication measures
-    - Monitor for unusual data access or exfiltration attempts
+   - Revoke compromised credentials
+   - Implement additional authentication measures
+   - Monitor for unusual data access or exfiltration attempts
 3. Denial of Service (DoS) attacks:
-    - Work with ISPs to filter malicious traffic
-    - Employ load balancers to distribute traffic
-    - Use Content Delivery Networks (CDNs) to absorb attack volume
+   - Work with ISPs to filter malicious traffic
+   - Employ load balancers to distribute traffic
+   - Use Content Delivery Networks (CDNs) to absorb attack volume
 4. Insider threats:
-    - Revoke access privileges for suspected individuals
-    - Monitor and log all user activities
-    - Implement data loss prevention (DLP) tools
+   - Revoke access privileges for suspected individuals
+   - Monitor and log all user activities
+   - Implement data loss prevention (DLP) tools
 
 During containment, [SigNoz](https://signoz.io/docs/architecture/) can provide continuous monitoring to track the impact of incident isolation. For securing the network, Palo Alto Networks and Fortinet are ideal for firewall management, while Apex One offers endpoint protection to prevent further damage.
 
@@ -160,18 +178,18 @@ With the incident contained, it's time to eliminate the threat and return to nor
 ### Best Practices for Secure Recovery
 
 1. Verify backup integrity: Before restoration, ensure your backups are clean and uncorrupted.
-    - Use hash values to confirm backup integrity
-    - Test backups in an isolated environment before full restoration
+   - Use hash values to confirm backup integrity
+   - Test backups in an isolated environment before full restoration
 2. Implement additional security measures: Use the recovery process as an opportunity to enhance your defenses.
-    - Deploy multi-factor authentication across all systems
-    - Update and patch all software to the latest versions
-    - Implement network segmentation to limit potential damage from future incidents
+   - Deploy multi-factor authentication across all systems
+   - Update and patch all software to the latest versions
+   - Implement network segmentation to limit potential damage from future incidents
 3. Conduct thorough testing: Before returning systems to production, verify their security and functionality.
-    - Perform vulnerability scans on restored systems
-    - Conduct penetration testing to identify any remaining weaknesses
+   - Perform vulnerability scans on restored systems
+   - Conduct penetration testing to identify any remaining weaknesses
 4. Monitor for reinfection: Stay vigilant for signs that the threat may still be present.
-    - Implement enhanced logging and monitoring on recovered systems
-    - Use file integrity monitoring tools to detect unauthorized changes
+   - Implement enhanced logging and monitoring on recovered systems
+   - Use file integrity monitoring tools to detect unauthorized changes
 
 SigNoz continues to monitor the system’s recovery process. Tools like Carbon Black are great for eradicating malware, while Veeam ensures secure backup and recovery, and Puppet can automate patching and configuration to strengthen defenses during recovery.
 
@@ -217,22 +235,38 @@ SigNoz provides a real-time monitoring [dashboard](https://signoz.io/docs/usergu
 
 For example, if your application is experiencing high latency, the SigNoz dashboard might show a sudden spike in response time.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-image.webp" alt="Anomaly Detection in SigNoz" caption="Anomaly Detection in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-image.webp"
+  alt="Anomaly Detection in SigNoz"
+  caption="Anomaly Detection in SigNoz"
+/>
 
 Step 2: Analyze the Root Cause with Distributed Tracing
 Navigate to the [distributed tracing](https://signoz.io/docs/introduction/#distributed-tracing) view to investigate the root cause. Traces reveal that one microservice takes significantly longer to respond due to a database query issue.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-distributed-tracing-cover.webp" alt="Distributed tracing in SigNoz" caption="Distributed tracing in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-distributed-tracing-cover.webp"
+  alt="Distributed tracing in SigNoz"
+  caption="Distributed tracing in SigNoz"
+/>
 
 Step 3: Correlate Performance Metrics with Logs
 Using SigNoz's [integrated logging and correlation features](https://signoz.io/docs/logs-pipelines/introduction/), filter logs related to the problematic service during the incident timeframe. The logs indicate a slow SQL query causing the delay.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-visualize-logs.webp" alt="logs and performance metrics" caption="logs and performance metrics" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-visualize-logs.webp"
+  alt="logs and performance metrics"
+  caption="logs and performance metrics"
+/>
 
 Step 4: Set Up Alerts to Prevent Future Incidents
 Create an [alert](https://signoz.io/docs/userguide/alerts-management/) in SigNoz to monitor response time thresholds for the affected service. This ensures your team is notified immediately if latency issues arise again.
 
-<Figure src="/img/guides/2024/12/incident-response-cycle-alerts-management-signoz.webp" alt="setting alerts" caption="setting alerts" />
+<Figure
+  src="/img/guides/2024/12/incident-response-cycle-alerts-management-signoz.webp"
+  alt="setting alerts"
+  caption="setting alerts"
+/>
 
 ### Benefits of the Workflow
 
@@ -269,4 +303,4 @@ Organizations often fail to communicate effectively, rush to address threats wit
 
 ### How can small businesses implement an effective incident response process with limited resources?
 
-Small businesses can prioritize key risks, use cloud-based tools, outsource to managed service providers, collaborate with peers, and rely on free or open-source tools to build a cost-effective incident response process.
\ No newline at end of file
+Small businesses can prioritize key risks, use cloud-based tools, outsource to managed service providers, collaborate with peers, and rely on free or open-source tools to build a cost-effective incident response process.
diff --git a/data/guides/incident-tracking.mdx b/data/guides/incident-tracking.mdx
index 0d5166a63..c4bc4bba0 100644
--- a/data/guides/incident-tracking.mdx
+++ b/data/guides/incident-tracking.mdx
@@ -1,26 +1,36 @@
 ---
-
 title: Incident Tracking - Essential Guide for Effective Management
-slug: incident-tracking
 date: 2024-12-05
 tags: [monitoring]
 authors: [manjunath_irukulla]
 description: Master incident tracking with our comprehensive guide. Learn best practices, choose the right tools, and improve your organization's incident management process.
-keywords: [incident tracking, incident management, IT operations, risk management, incident response, SigNoz, observability]
-
+keywords:
+  [
+    incident tracking,
+    incident management,
+    IT operations,
+    risk management,
+    incident response,
+    SigNoz,
+    observability,
+  ]
 ---
 
-In today’s fast-paced digital world, managing incidents effectively is key to maintaining operational efficiency and deliverying a seamless customer experience. This blog serves as your go-to-guide for understanding incident tracking, offering practical strategies to swiftly identify, respond to, and resolve disruptions while minimizing their impact on your organization. 
+In today’s fast-paced digital world, managing incidents effectively is key to maintaining operational efficiency and deliverying a seamless customer experience. This blog serves as your go-to-guide for understanding incident tracking, offering practical strategies to swiftly identify, respond to, and resolve disruptions while minimizing their impact on your organization.
 
 ## What is Incident Tracking and Why is it Important?
 
-Incident tracking is the systematic process of documenting, monitoring, and managing unexpected events or disruptions that impact normal business operations or IT services. These incidents, whether small technical issues or major organizational crises, require swift attention to minimize negative effects and ensure continuity. 
+Incident tracking is the systematic process of documenting, monitoring, and managing unexpected events or disruptions that impact normal business operations or IT services. These incidents, whether small technical issues or major organizational crises, require swift attention to minimize negative effects and ensure continuity.
 
 ### Types of Incidents
 
 Incidents can vary widely depending on the industry or business environment. Common categories include:
 
-<Figure src="/img/guides/2024/12/incident-tracking-29b7f6f2-fafe-4d31-8666-4728af8ebc5a.webp" alt="Types of Incidents that can occur" caption="Types of Incidents that can occur" />
+<Figure
+  src="/img/guides/2024/12/incident-tracking-29b7f6f2-fafe-4d31-8666-4728af8ebc5a.webp"
+  alt="Types of Incidents that can occur"
+  caption="Types of Incidents that can occur"
+/>
 
 - Security Incidents: Unauthorized access, phishing attempts, malware infections, or data breaches that threaten sensitive information or system integrity.
 - Operational Incidents: System outages, application crashes, network failures, or other disruptions that hinder productivity and service delivery.
@@ -28,7 +38,7 @@ Incidents can vary widely depending on the industry or business environment. Com
 
 ### The Importance of Incident Tracking
 
-Incident tracking is a cornerstone of effective risk management and operational efficiency. It provides a structured approach to identifying, addressing, and learning from incidents, ultimately strengthening the organization. Here’s why it is indispensable: 
+Incident tracking is a cornerstone of effective risk management and operational efficiency. It provides a structured approach to identifying, addressing, and learning from incidents, ultimately strengthening the organization. Here’s why it is indispensable:
 
 - Reduced Resolution Time: A well-designed tracking system helps quickly identify incidents and guide teams through standardized resolution workflows, preventing delays and escalation.
 - Improved Team Collaboration: Incident tracking fosters seamless communication and coordination across departments, ensuring everyone involved has the context and clarity to respond effectively.
@@ -40,28 +50,32 @@ A single unresolved incident can have a cascading effect disrupting operations,
 
 ## How Does Incident Tracking Work?
 
-Incident tracking operates through a structured lifecycle that ensures every incident is effectively logged, managed, and resolved. This systematic approach enables organizations to address issues promptly while uncovering insights for continuous improvement.  
+Incident tracking operates through a structured lifecycle that ensures every incident is effectively logged, managed, and resolved. This systematic approach enables organizations to address issues promptly while uncovering insights for continuous improvement.
 
 ### Key Components of an Incident Tracking System
 
-<Figure src="/img/guides/2024/12/incident-tracking-2400484c-7122-41bb-82a8-d3853cf6b13a.webp" alt="Key Components of an Incident Tracking System" caption="Key Components of an Incident Tracking System" />
+<Figure
+  src="/img/guides/2024/12/incident-tracking-2400484c-7122-41bb-82a8-d3853cf6b13a.webp"
+  alt="Key Components of an Incident Tracking System"
+  caption="Key Components of an Incident Tracking System"
+/>
 
 - Centralized Incident Database: A unified repository is the backbone of any incident tracking system.
-    - It stores all incident-related information, including logs, resolution steps, and outcomes, ensuring easy access for teams and enabling historical analysis.
+  - It stores all incident-related information, including logs, resolution steps, and outcomes, ensuring easy access for teams and enabling historical analysis.
 - Incident Logging Mechanism: A standardized method for reporting incidents ensures consistency and accuracy.
-    - Whether through automated monitoring tools or manual input, incident should capture key details like time of occurrence, description, and affected systems or users.
+  - Whether through automated monitoring tools or manual input, incident should capture key details like time of occurrence, description, and affected systems or users.
 - Prioritization and Categorization System: Not all incidents are created equal. A robust system for classifying incidents by severity, impact, and urgency helps allocate resources effectively.
-    - Categories may include critical, major, or minor incidents, and guiding response prioritization.
+  - Categories may include critical, major, or minor incidents, and guiding response prioritization.
 - Assignment and Escalation Workflows: Clear processes for assigning incidents to the right teams or individuals ensure swift action.
-    - Escalation workflows allow unresolved issues to be moved to higher authority levels or specialized teams for expected handling.
+  - Escalation workflows allow unresolved issues to be moved to higher authority levels or specialized teams for expected handling.
 - Communication Tools: Transparent and timely communication is essential for informing all stakeholders
-    - Tools like real-time notifications, email updates, or integrated chat systems facilitate collaboration and ensure everyone is aligned on incident status.
+  - Tools like real-time notifications, email updates, or integrated chat systems facilitate collaboration and ensure everyone is aligned on incident status.
 - Reporting and Analytics Capabilities: Beyond resolution, the ability to generate detailed reports and analyze incident trends is critical for long-term improvement.
-    - Insights drawn from data help identify recurring issues, assess team performance, and refine operational processes.
+  - Insights drawn from data help identify recurring issues, assess team performance, and refine operational processes.
 
 ### Roles and Responsibilities
 
-Clear delineation of roles and responsibilities is essential for effective incident tracking. This ensures accountability and streamlines the incident management process: 
+Clear delineation of roles and responsibilities is essential for effective incident tracking. This ensures accountability and streamlines the incident management process:
 
 - Incident Reporter: The Incident Reporter role is accountable for designing someone who promptly identifies and logs incidents with accurate details, enabling efficient tracking and resolution.
 - Incident Manager: Overseas the entire lifecycle of the incident, from detection to closure. The manager ensures proper coordination among teams, tracks progress, and enforces adherence to timelines and protocols.
@@ -71,42 +85,42 @@ Clear delineation of roles and responsibilities is essential for effective incid
 
 ### Stages of the Incident Tracking Lifecycle
 
-Incident tracking is a structured process divided into distinct stages, each ensuring a systematic and thorough approach to managing incidents. 
+Incident tracking is a structured process divided into distinct stages, each ensuring a systematic and thorough approach to managing incidents.
 
 1. Incident Detection and Reporting
-    - Key Activities:
-        - Detect incidents through monitoring tools, user feedback, or audit logs.
-        - Log the incident in the tracking system, capturing essential details such as time, description, and affected areas.
-    - Purpose:
-        - Create a reliable record that initiates the incident management process.
+   - Key Activities:
+     - Detect incidents through monitoring tools, user feedback, or audit logs.
+     - Log the incident in the tracking system, capturing essential details such as time, description, and affected areas.
+   - Purpose:
+     - Create a reliable record that initiates the incident management process.
 2. Triage and Prioritization
-    - Key Activities:
-        - Evaluate the severity and potential business impact of the incident.
-        - Assign a priority level (e.g., critical, high, medium, low) based on predefined criteria.
-    - Purpose:
-        - Allocate resources effectively and address high-impact issues promptly.
+   - Key Activities:
+     - Evaluate the severity and potential business impact of the incident.
+     - Assign a priority level (e.g., critical, high, medium, low) based on predefined criteria.
+   - Purpose:
+     - Allocate resources effectively and address high-impact issues promptly.
 3. Assignment and Escalation
-    - Key Activities:
-        - Route the incident to the appropriate team or specialist for resolution.
-        - Escalate unresolved issues to higher-level support or specialized experts as needed.
-    - Purpose:
-        - Ensure incidents are addressed by the right personnel with the required expertise.
+   - Key Activities:
+     - Route the incident to the appropriate team or specialist for resolution.
+     - Escalate unresolved issues to higher-level support or specialized experts as needed.
+   - Purpose:
+     - Ensure incidents are addressed by the right personnel with the required expertise.
 4. Resolution and Closure
-    - Key Activities:
-        - Diagnose the root cause, implement a solution, and test for successful resolution.
-        - Document the steps taken and close the incident in the system.
-    - Purpose:
-        - Restore normal operations and provide a comprehensive record for future reference.
+   - Key Activities:
+     - Diagnose the root cause, implement a solution, and test for successful resolution.
+     - Document the steps taken and close the incident in the system.
+   - Purpose:
+     - Restore normal operations and provide a comprehensive record for future reference.
 5. Post-Incident Review and Analysis
-    - Key Activities:
-        - Conduct a post-mortem analysis to identify root causes and areas for improvement.
-        - Develop actionable recommendations to prevent recurrence and enhance processes.
-    - Purpose:
-        - Drive continuous improvement by learning from past incidents.
+   - Key Activities:
+     - Conduct a post-mortem analysis to identify root causes and areas for improvement.
+     - Develop actionable recommendations to prevent recurrence and enhance processes.
+   - Purpose:
+     - Drive continuous improvement by learning from past incidents.
 
 ## Essential Features of Incident Tracking Software
 
-To effectively manage and resolve incidents, choosing software that streamlines processes and enhances team collaboration is important. Here are the essential features to prioritize: 
+To effectively manage and resolve incidents, choosing software that streamlines processes and enhances team collaboration is important. Here are the essential features to prioritize:
 
 - Centralized incident database: Provides a single source of truth for all incident-related data, ensuring consistency and easy retrieval for audits or reviews.
 - Real-time notifications and alerts: Keeps teams informed about status changes or escalations instantly, enabling faster responses to critical incidents.
@@ -117,7 +131,7 @@ To effectively manage and resolve incidents, choosing software that streamlines
 
 ### Choosing the Right Incident Tracking Tool
 
-Selecting the most suitable incident tracking software requires careful evaluation of organizational needs and the tool’s capabilities. Here are the key factors to consider: 
+Selecting the most suitable incident tracking software requires careful evaluation of organizational needs and the tool’s capabilities. Here are the key factors to consider:
 
 - Scalability: Ensure the software can grow with your organization, accommodating increasing users, incidents, and complexity.
 - Integration capabilities: Check if the tool integrates well with your existing technology stack, including monitoring systems, email platforms, and collaboration tools like Slack or Teams.
@@ -126,120 +140,120 @@ Selecting the most suitable incident tracking software requires careful evaluati
 
 ### Cloud-Based vs. On-Premises Solutions
 
-When evaluating incident tracking tools, it’s crucial to decide between cloud-based and on-premises solutions, depending on your organizational needs. 
+When evaluating incident tracking tools, it’s crucial to decide between cloud-based and on-premises solutions, depending on your organizational needs.
 
-| Solution Type | Pros | Cons |
-| --- | --- | --- |
-| Cloud-based Solutions | Quick and easy setup | May pose security concerns for sensitive data |
-|  | Automatic updates with minimal maintenance | Limited customization options |
-|  | Cost-effective with upfront costs |  |
-| On-premises Solutions | Full control over data, ensuring better compliance with regulations.  | Higher maintenance demands and infrastructure costs.  |
-|  | Highly customizable to meet unique operational needs | Longer implementation timelines |
+| Solution Type         | Pros                                                                 | Cons                                                 |
+| --------------------- | -------------------------------------------------------------------- | ---------------------------------------------------- |
+| Cloud-based Solutions | Quick and easy setup                                                 | May pose security concerns for sensitive data        |
+|                       | Automatic updates with minimal maintenance                           | Limited customization options                        |
+|                       | Cost-effective with upfront costs                                    |                                                      |
+| On-premises Solutions | Full control over data, ensuring better compliance with regulations. | Higher maintenance demands and infrastructure costs. |
+|                       | Highly customizable to meet unique operational needs                 | Longer implementation timelines                      |
 
 ## Best Practices for Effective Incident Tracking
 
 Maximizing the effectiveness of your incident tracking system requires thoughtful implementation and an ongoing commitment to improvement. Here are the best practices for ensuring your process is efficient and reliable.
 
 - Establish clear incident classification and severity levels
-    - Why: Proper classification ensures that incidents are prioritized and addressed appropriately.
-    - How:
-        - Develop specific criteria to categorize incidents (e.g., security breaches, operational disruptions, or customer complaints).
-        - Create a standardized severity scale (e.g., Low, Medium, High, Critical) to communicate urgency and impact clearly across teams.
+  - Why: Proper classification ensures that incidents are prioritized and addressed appropriately.
+  - How:
+    - Develop specific criteria to categorize incidents (e.g., security breaches, operational disruptions, or customer complaints).
+    - Create a standardized severity scale (e.g., Low, Medium, High, Critical) to communicate urgency and impact clearly across teams.
 - Implement standardized incident reporting procedures
-    - Why: Consistent reporting provides a uniform understanding of incidents and ensures no critical details are missed.
-    - How:
-        - Develop incident report templates with required fields like time of occurrence, description, impact assessment, and initial response.
-        - Train employees on recognizing and reporting incidents using these templates to maintain accuracy.
+  - Why: Consistent reporting provides a uniform understanding of incidents and ensures no critical details are missed.
+  - How:
+    - Develop incident report templates with required fields like time of occurrence, description, impact assessment, and initial response.
+    - Train employees on recognizing and reporting incidents using these templates to maintain accuracy.
 - Encourage a culture of transparency and continuous learning
-    - Why: Open communication fosters collaboration and improvement while reducing blame-focused responses.
-    - How:
-        - Conduct blameless post-mortems to analyze incidents without attributing fault, focusing instead on root cause analysis and solutions.
-        - Reward teams for sharing insights and lessons learned to prevent similar incidents.
+  - Why: Open communication fosters collaboration and improvement while reducing blame-focused responses.
+  - How:
+    - Conduct blameless post-mortems to analyze incidents without attributing fault, focusing instead on root cause analysis and solutions.
+    - Reward teams for sharing insights and lessons learned to prevent similar incidents.
 - Regularly review and update incident tracking processes
-    - Why: Static processes may become outdated as organizational needs and technologies evolve.
-    - How:
-        - Schedule regular reviews of your incident tracking process and tools.
-        - Solicit feedback from team members to identify pain points and areas for enhancement.
-        - Integrate modern tools and automation where possible to streamline workflows.
+  - Why: Static processes may become outdated as organizational needs and technologies evolve.
+  - How:
+    - Schedule regular reviews of your incident tracking process and tools.
+    - Solicit feedback from team members to identify pain points and areas for enhancement.
+    - Integrate modern tools and automation where possible to streamline workflows.
 
 ### Common Pitfalls to Avoid
 
 Even with best practices in place, certain missteps can undermine the effectiveness of your incident tracking system. Here are the common pitfalls and how to avoid them:
 
 - Overlooking Minor Incidents:
-    - Problem: Small incidents often go unnoticed but can escalate into larger issues if ignored.
-    - Solution: Treat minor incidents as early warning signs, documenting and addressing them promptly.
+  - Problem: Small incidents often go unnoticed but can escalate into larger issues if ignored.
+  - Solution: Treat minor incidents as early warning signs, documenting and addressing them promptly.
 - Failing to Document Lessons Learned:
-    - Problem: Missing opportunities to improve systems and processes for future incidents.
-    - Solution: Ensure every resolution includes a post-incident review with actionable takeaways documented and shared.
+  - Problem: Missing opportunities to improve systems and processes for future incidents.
+  - Solution: Ensure every resolution includes a post-incident review with actionable takeaways documented and shared.
 - Neglecting to Involve All Relevant Stakeholders:
-    - Problem: Excluding key personnel can lead to communication gaps and delayed resolution.
-    - Solution: Establish a clear process for involving all affected teams and decision-makers in the incident response.
+  - Problem: Excluding key personnel can lead to communication gaps and delayed resolution.
+  - Solution: Establish a clear process for involving all affected teams and decision-makers in the incident response.
 - Relying Too Heavily on Manual Processes
-    - Problem: Manual tracking increases the likelihood of human error and slows down the response time.
-    - Solution: Leverage automation tools for ticket creation, routing, and reporting to minimize delays and inaccuracies.
+  - Problem: Manual tracking increases the likelihood of human error and slows down the response time.
+  - Solution: Leverage automation tools for ticket creation, routing, and reporting to minimize delays and inaccuracies.
 
 ## Leveraging Incident Tracking Data for Continuous Improvement
 
 Effective incident tracking is more than just addressing immediate problems; it unlocks valuable insights that can strengthen your organization's operations over time. Here's how you can harness incident tracking data for continuous improvement:
 
 - Identify recurring issues and root causes
-    - Addressing systematic problems prevents repetitive incidents, saving time and resources.
-    - How to Do It:
-        - Analyze historical incident data to pinpoint recurring patterns and anomalies.
-        - Use root cause analysis techniques, such as the “5 Whys”, to systematically drill down into the underlying issues.
-        - Example: If frequent server outages occur during peak hours, the analysis might reveal insufficient server capacity as the root cause, prompting upgrades or optimizing.
+  - Addressing systematic problems prevents repetitive incidents, saving time and resources.
+  - How to Do It:
+    - Analyze historical incident data to pinpoint recurring patterns and anomalies.
+    - Use root cause analysis techniques, such as the “5 Whys”, to systematically drill down into the underlying issues.
+    - Example: If frequent server outages occur during peak hours, the analysis might reveal insufficient server capacity as the root cause, prompting upgrades or optimizing.
 - Measure and improve key performance indicators (KPIs)
-    - Tracking performance metrics ensures accountability and helps identify improvement areas.
-    - Key KPIs to Monitor:
-        - Mean Time to Resolve (MTTR): Average time taken to resolve incidents.
-        - First Contact Resolution Rate (FCR): Percentage of incidents without requiring escalation.
-        - Incident Recurrence Rate: Frequency of similar incidents over a defined period.
-    - How to Improve:
-        - Set measurable goals for each KPI. For instance, aim to reduce MTTR by 20% within six months.
-        - Regularly review progress and adjust strategies as needed.
+  - Tracking performance metrics ensures accountability and helps identify improvement areas.
+  - Key KPIs to Monitor:
+    - Mean Time to Resolve (MTTR): Average time taken to resolve incidents.
+    - First Contact Resolution Rate (FCR): Percentage of incidents without requiring escalation.
+    - Incident Recurrence Rate: Frequency of similar incidents over a defined period.
+  - How to Improve:
+    - Set measurable goals for each KPI. For instance, aim to reduce MTTR by 20% within six months.
+    - Regularly review progress and adjust strategies as needed.
 - Use incident data to inform proactive measures
-    - Leveraging past trends can prevent future disruptions and reduce downtime, and operational risks.
-    - How to Do It:
-        - Analyze incident frequency by type and time to predict high-risk periods or scenarios.
-        - Implement preventive measures like system upgrades, redundancy plans, or patch updates to address identified risks.
-        - Develop runbooks (step-by-step guides- for frequently occurring incidents to expedite response and resolution.
+  - Leveraging past trends can prevent future disruptions and reduce downtime, and operational risks.
+  - How to Do It:
+    - Analyze incident frequency by type and time to predict high-risk periods or scenarios.
+    - Implement preventive measures like system upgrades, redundancy plans, or patch updates to address identified risks.
+    - Develop runbooks (step-by-step guides- for frequently occurring incidents to expedite response and resolution.
 - Enhance team training and resource allocation
-    - Strengthening team capabilities and aligning resources ensure faster, more effective responses.
-    - How to Do It:
-        - Use incident resolution data to identify skill gaps within teams. For instance, if database related incidents take significantly longer to resolve, it may indicate the need for specialized database training.
-        - Reallocate resources to areas where data reveals higher risks or frequent issues.
-        - Example: Increase staffing during historically high-incident times, such as product launches or system migrations.
+  - Strengthening team capabilities and aligning resources ensure faster, more effective responses.
+  - How to Do It:
+    - Use incident resolution data to identify skill gaps within teams. For instance, if database related incidents take significantly longer to resolve, it may indicate the need for specialized database training.
+    - Reallocate resources to areas where data reveals higher risks or frequent issues.
+    - Example: Increase staffing during historically high-incident times, such as product launches or system migrations.
 
 ## Enhancing Incident Tracking with SigNoz
 
-A strong incident tracking process is foundational to effective incident management. However, pairing it with a comprehensive observability platform like SigNoz can elevate your operations to new levels of efficiency and insight. Here’s how SigNoz can complement and enhance your incident-tracking efforts: 
+A strong incident tracking process is foundational to effective incident management. However, pairing it with a comprehensive observability platform like SigNoz can elevate your operations to new levels of efficiency and insight. Here’s how SigNoz can complement and enhance your incident-tracking efforts:
 
 ### Key Features of SigNoz for Incident Tracking:
 
 - Real-time Monitoring and Alerting
-    - [SigNoz](https://signoz.io/docs/introduction/) provides instant notifications about system anomalies, helping you detect potential incidents before they affect end users.
-    - Example: Receive alerts for unusual traffic spikes or memory usage trends, enabling preemptive action.
+  - [SigNoz](https://signoz.io/docs/introduction/) provides instant notifications about system anomalies, helping you detect potential incidents before they affect end users.
+  - Example: Receive alerts for unusual traffic spikes or memory usage trends, enabling preemptive action.
 - [Distributed Tracing](https://signoz.io/blog/distributed-tracing/):
-    - Trace requests as they flow through distributed systems to pinpoint the root cause of performance bottlenecks.
-    - Ideal for modern microservices architectures where issues can span multiple components.
+  - Trace requests as they flow through distributed systems to pinpoint the root cause of performance bottlenecks.
+  - Ideal for modern microservices architectures where issues can span multiple components.
 - Log Management:
-    - Consolidate logs from across your stack into a centralized system for quick analysis.
-    - Streamline troubleshooting by correlating logs with specific incidents.
+  - Consolidate logs from across your stack into a centralized system for quick analysis.
+  - Streamline troubleshooting by correlating logs with specific incidents.
 - Custom Dashboards
-    - Create intuitive, tailored dashboards to visualize critical metrics, trends, and incident history at a glance.
-    - Example: A dashboard showing incident frequency by service, user impact metrics, and resolution times.
+  - Create intuitive, tailored dashboards to visualize critical metrics, trends, and incident history at a glance.
+  - Example: A dashboard showing incident frequency by service, user impact metrics, and resolution times.
 
 <GetStartedSigNoz />
 
 ### Benefits of Integrating SigNoz with Your Incident Tracking System
 
 - Faster Detection with MTTD Reduction
-    - Identify issues early with [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and intelligent alerting mechanisms.
+  - Identify issues early with [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and intelligent alerting mechanisms.
 - Improved Resolution Efficiency
-    - Leverage performance data, traces, and logs to diagnose and resolve issues more effectively.
+  - Leverage performance data, traces, and logs to diagnose and resolve issues more effectively.
 - Enhanced Post-Incident Insights
-    - Use detailed system analytics to conduct in-depth post-incident reviews and identify opportunities to prevent similar incidents in the future.
+  - Use detailed system analytics to conduct in-depth post-incident reviews and identify opportunities to prevent similar incidents in the future.
 
 ## Key Takeaways
 
@@ -251,7 +265,7 @@ Implementing an effective incident tracking system is crucial for maintaining op
 - Standardize procedures, foster a learning culture, and use incident data to refine processes.
 - Leverage tools like SigNoz for real-time insights and improved incident response efficiency.
 
-By implementing these principles, your organization will be better positioned to manage incidents effectively and continuously improve. 
+By implementing these principles, your organization will be better positioned to manage incidents effectively and continuously improve.
 
 ## FAQs
 
@@ -266,7 +280,7 @@ By implementing these principles, your organization will be better positioned to
 
 ### Can incident tracking help with regulatory compliance?
 
-Yes, it provides audit trails and documentation required for detecting, responding, and reporting incidents per regulations. 
+Yes, it provides audit trails and documentation required for detecting, responding, and reporting incidents per regulations.
 
 ### What metrics should we track to measure the effectiveness of our incident tracking system?
 
@@ -278,4 +292,4 @@ Key metrics to monitor include:
 - Customer Satisfaction Scores: User feedback on incident handling.
 - Number of Recurring Incidents: Repeated issues due to unresolved root causes.
 - Incident Response Time: Time taken to respond after detection.
-- Escalation Rate: Incidents requiring higher-level intervention.
\ No newline at end of file
+- Escalation Rate: Incidents requiring higher-level intervention.
diff --git a/data/guides/infrastructure-monitoring.mdx b/data/guides/infrastructure-monitoring.mdx
index 455ec76ae..274e78db7 100644
--- a/data/guides/infrastructure-monitoring.mdx
+++ b/data/guides/infrastructure-monitoring.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: What is Infrastructure Monitoring
-slug: infrastructure-monitoring
 date: 2024-08-21
 tags: [monitoring]
 authors: [nitin_gouda]
 description: Discover the essentials of infrastructure monitoring, its importance in IT management, and best practices for implementation. Learn how to optimize your systems.
-keywords: [infrastructure monitoring, IT management, system performance, network monitoring, cloud infrastructure, DevOps, observability, SigNoz]
-
+keywords:
+  [
+    infrastructure monitoring,
+    IT management,
+    system performance,
+    network monitoring,
+    cloud infrastructure,
+    DevOps,
+    observability,
+    SigNoz,
+  ]
 ---
 
 Infrastructure monitoring forms the backbone of modern IT operations. It keeps your systems running smoothly, preventing costly downtime and ensuring optimal performance but what exactly does it entail, and why is it crucial for your organization? This article dives deep into the world of infrastructure monitoring, exploring its components, benefits, and best practices.
@@ -35,17 +42,17 @@ By keeping a watchful eye on these components, you can:
 To fully grasp infrastructure monitoring, you need to understand the components it covers:
 
 1. Physical components:
-    - Servers: These are the core machines that handle processing tasks, run applications, and manage data. They include both on-premises servers in your data center and any physical servers used in other locations.
-    - Network Devices: Routers, switches, and firewalls are essential for managing and directing data traffic across your network. They ensure that data flows efficiently and securely between different parts of your infrastructure.
-    - Storage Systems: This category encompasses various methods for storing data, ranging from traditional hard drives and network-attached storage (NAS) to modern solid-state drives (SSDs) and storage area networks (SANs). Effective storage management is crucial for data accessibility and performance.
+   - Servers: These are the core machines that handle processing tasks, run applications, and manage data. They include both on-premises servers in your data center and any physical servers used in other locations.
+   - Network Devices: Routers, switches, and firewalls are essential for managing and directing data traffic across your network. They ensure that data flows efficiently and securely between different parts of your infrastructure.
+   - Storage Systems: This category encompasses various methods for storing data, ranging from traditional hard drives and network-attached storage (NAS) to modern solid-state drives (SSDs) and storage area networks (SANs). Effective storage management is crucial for data accessibility and performance.
 2. Virtual components:
-    - Virtual Machines (VMs): These are software-based emulations of physical computers, allowing multiple virtual instances to run on a single physical server. VMs offer flexibility and scalability for resource management.
-    - Containers: Containers are lightweight, isolated environments that package applications and their dependencies, making them portable and efficient. They allow for faster deployment and scaling of applications.
-    - Cloud Services: These include various platforms and services hosted by third-party providers, such as Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS), and Software-as-a-Service (SaaS). Cloud services provide scalable resources and solutions without the need for on-premises infrastructure.
+   - Virtual Machines (VMs): These are software-based emulations of physical computers, allowing multiple virtual instances to run on a single physical server. VMs offer flexibility and scalability for resource management.
+   - Containers: Containers are lightweight, isolated environments that package applications and their dependencies, making them portable and efficient. They allow for faster deployment and scaling of applications.
+   - Cloud Services: These include various platforms and services hosted by third-party providers, such as Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS), and Software-as-a-Service (SaaS). Cloud services provide scalable resources and solutions without the need for on-premises infrastructure.
 3. Software components:
-    - Operating systems: Operating systems serve as the fundamental layer upon which all other components of your IT infrastructure are built. They manage hardware resources, enable software applications to run, and provide the essential environment for all IT operations, ensuring that your systems function seamlessly and efficiently.
-    - Middleware: This software acts as an intermediary between different applications and services, enabling them to communicate and interact effectively. Middleware can include database management systems, message brokers, and other integration tools.
-    - Applications: Applications are the critical tools that power your business activities. They handle everything from daily operational tasks to complex processes, ensuring that your business runs smoothly. Monitoring these applications is vital to maintaining performance, functionality, and user satisfaction, directly impacting your organization’s success.
+   - Operating systems: Operating systems serve as the fundamental layer upon which all other components of your IT infrastructure are built. They manage hardware resources, enable software applications to run, and provide the essential environment for all IT operations, ensuring that your systems function seamlessly and efficiently.
+   - Middleware: This software acts as an intermediary between different applications and services, enabling them to communicate and interact effectively. Middleware can include database management systems, message brokers, and other integration tools.
+   - Applications: Applications are the critical tools that power your business activities. They handle everything from daily operational tasks to complex processes, ensuring that your business runs smoothly. Monitoring these applications is vital to maintaining performance, functionality, and user satisfaction, directly impacting your organization’s success.
 
 Monitoring each of these components provides a holistic view of your infrastructure's health and performance.
 
@@ -55,17 +62,25 @@ Infrastructure monitoring relies on a combination of data collection, analysis,
 
 1. Data collection: The process starts with gathering information through agents, APIs, and integrations from various parts of your infrastructure—such as servers, network devices, and storage systems. You can view it as taking each component's 'pulse' to assess its performance. APIs help collect data from external cloud services and third-party apps, while integrations streamline data collection across different platforms.
 2. Metric analysis: Once the data is collected, the next crucial step is metric analysis, where the system processes the information to reveal what's truly happening within your infrastructure. This analysis focuses on three main types of metrics:
-    - Performance Metrics: Metrics such as CPU usage, memory utilization, and disk I/O provide insights into how hard your systems are working, helping you gauge their efficiency and workload.
-    - Availability Metrics: Metrics like uptime, response times, and error rates are essential for ensuring that your systems are accessible and operating as expected, helping you quickly identify any disruptions.
-    - Capacity Metrics: It monitors storage usage, network bandwidth, and resource allocation, giving you a clear understanding of whether your resources are being overused or underutilized. This information is vital for making smart decisions about scaling and managing resources efficiently, helping you avoid both the risks of running out of capacity and the costs of over-provisioning. With a clear view of your resource usage, you can better plan and adjust your infrastructure to meet current and future demands.
+   - Performance Metrics: Metrics such as CPU usage, memory utilization, and disk I/O provide insights into how hard your systems are working, helping you gauge their efficiency and workload.
+   - Availability Metrics: Metrics like uptime, response times, and error rates are essential for ensuring that your systems are accessible and operating as expected, helping you quickly identify any disruptions.
+   - Capacity Metrics: It monitors storage usage, network bandwidth, and resource allocation, giving you a clear understanding of whether your resources are being overused or underutilized. This information is vital for making smart decisions about scaling and managing resources efficiently, helping you avoid both the risks of running out of capacity and the costs of over-provisioning. With a clear view of your resource usage, you can better plan and adjust your infrastructure to meet current and future demands.
 3. Log analysis: Beyond analyzing metrics, monitoring tools also delve into log files, which serve as a detailed diary of your system, capturing every event, error, and anomaly that occurs. These logs provide a chronological record of your infrastructure’s activities, offering deeper insights that go beyond what raw metrics can show. By carefully analyzing these logs, you can identify patterns, trends, or issues that might not be immediately obvious through metrics alone.
-    
-    <Figure src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-09_at_10.48.34_PM.webp" alt="SigNoz Logs" caption="SigNoz Logs" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-09_at_10.48.34_PM.webp"
+     alt="SigNoz Logs"
+     caption="SigNoz Logs"
+   />
+
 4. Event correlation: This is where monitoring gets clever. Advanced systems can connect events happening across different parts of your infrastructure. For example, if your server’s CPU usage suddenly increases and your network slows down at the same time, the system recognizes that these events are related. This connection is crucial for troubleshooting because it helps you understand the bigger picture and identify the underlying cause of problems, rather than just dealing with separate issues one at a time.
 5. Real-time alerting: Finally, you need to know when something goes wrong, and you need to know right away. Monitoring systems set predefined thresholds for various metrics. If any of these thresholds are breached—like if your server's CPU usage suddenly spikes to 100%—the system sends an alert to the relevant team members. This way, you can take action before a minor issue becomes a major problem.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-Untitled.webp" alt="Alerting Workflow" caption="Alerting Workflow" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-Untitled.webp"
+  alt="Alerting Workflow"
+  caption="Alerting Workflow"
+/>
 
 ### Advanced Monitoring Techniques
 
@@ -75,11 +90,19 @@ Modern infrastructure monitoring goes beyond basic metrics. It employs sophistic
 2. Application Performance Monitoring (APM) integration: Application Performance Monitoring (APM) integration enhances your monitoring strategy by combining the monitoring of both the infrastructure and the applications running on it. While infrastructure monitoring focuses on the health and performance of physical and virtual components, APM zeroes in on how applications behave and perform within that environment. By integrating these two, you get a more complete and unified view of your system’s overall health. This allows you to not only track the underlying infrastructure but also understand how it directly impacts the applications your business relies on, enabling quicker identification and resolution of issues that span across both layers. To learn more about APM, check out our detailed guide [here](https://signoz.io/guides/what-is-apm/).
 3. Observability: Observability takes monitoring a step further by focusing on the ability to understand a system's internal state based on its external outputs, such as logs, metrics, and traces. Unlike traditional monitoring, which often tells you what is happening, observability helps you understand why it's happening by providing deeper insights into the complex relationships and behaviors within your system. This is particularly valuable in modern, distributed environments where systems can be intricate and interdependent. With observability, you can diagnose issues more effectively, uncover the root causes of problems, and gain a comprehensive understanding of how all parts of your system interact and perform.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-CleanShot_2024-08-08_at_15.25.292x.webp" alt="Venn Diagram of Logs, Metrics and Traces" caption="Venn Diagram of Logs, Metrics and Traces" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-CleanShot_2024-08-08_at_15.25.292x.webp"
+  alt="Venn Diagram of Logs, Metrics and Traces"
+  caption="Venn Diagram of Logs, Metrics and Traces"
+/>
 
 1. Visualization tools: Visualization tools are essential for translating the complex data collected from your infrastructure into something more accessible and actionable. These tools use advanced dashboards and graphs to present data in a visual format, making it easier to digest and understand. By providing clear, visual representations of key metrics and trends, visualization tools help you quickly identify patterns, monitor performance, and track the overall health of your systems. This way, instead of sifting through raw data, you can instantly see what’s happening in your infrastructure and make informed decisions to keep everything running smoothly.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-Untitled%201.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-Untitled%201.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
 ## Benefits of Implementing Infrastructure Monitoring
 
@@ -104,7 +127,7 @@ Despite its benefits, infrastructure monitoring comes with its own set of challe
 
 To maximize the benefits of infrastructure monitoring, follow these best practices:
 
-1. Align monitoring objectives with business goals:  Ensure your monitoring strategy directly supports your organization’s objectives, focusing on the metrics that matter most.
+1. Align monitoring objectives with business goals: Ensure your monitoring strategy directly supports your organization’s objectives, focusing on the metrics that matter most.
 2. Implement comprehensive coverage: Monitor all layers of your infrastructure, including physical, virtual, and cloud environments, to gain a complete understanding of your system’s health.
 3. Leverage automation: Utilize automated tools for routine monitoring tasks and alert management, allowing your team to focus on more complex issues.
 4. Continuously refine processes: Regularly review and update your monitoring approach to adapt to evolving infrastructure needs and technologies.
@@ -125,25 +148,41 @@ Here's how you can leverage SigNoz for Infrastructure Monitoring solutions:
 
 [SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
 
-1. Using SigNoz Infrastructure Monitoring: 
+1. Using SigNoz Infrastructure Monitoring:
 
-In the top left corner, click on `Get Started`. 
+In the top left corner, click on `Get Started`.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-07_at_2.39.26_PM.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
-You will be redirected to “Get Started Page”. Choose `Infrastructure Monitoring` 
+You will be redirected to “Get Started Page”. Choose `Infrastructure Monitoring`
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-10_at_10.00.41_PM.webp" alt="Infrastructure Monitoring" caption="Infrastructure Monitoring" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-10_at_10.00.41_PM.webp"
+  alt="Infrastructure Monitoring"
+  caption="Infrastructure Monitoring"
+/>
 
 1. Select Data Source:
 
 You need to select the Data Source. Since the metrics to be collected here are from the host system, select HostMetrics.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-97d0507f-e640-4317-8f6a-6823fb2e15af.webp" alt="SigNoz Host Metrics" caption="SigNoz Host Metrics" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-97d0507f-e640-4317-8f6a-6823fb2e15af.webp"
+  alt="SigNoz Host Metrics"
+  caption="SigNoz Host Metrics"
+/>
 
 Choose the environment of your host system. For this demo, I am using my laptop which is a Macbook M1.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-14_at_07.46.27.webp" alt="Host System Environment" caption="Host System Environment" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-Screenshot_2024-08-14_at_07.46.27.webp"
+  alt="Host System Environment"
+  caption="Host System Environment"
+/>
 
 1. Setup [OTel Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) as an agent
 
@@ -155,7 +194,11 @@ Note: Download the <a href="https://github.com/open-telemetry/opentelemetry-coll
 
 To send host metrics to SigNoz, refer to the [documentation](https://signoz.io/docs/userguide/hostmetrics) for detailed instructions.
 
-<Figure src="/img/guides/2024/08/infrastructure-monitoring-6f59e135-17f5-40e6-ae34-8946d48bb4ee.webp" alt="HostMetrics Dashboard" caption="HostMetrics Dashboard" />
+<Figure
+  src="/img/guides/2024/08/infrastructure-monitoring-6f59e135-17f5-40e6-ae34-8946d48bb4ee.webp"
+  alt="HostMetrics Dashboard"
+  caption="HostMetrics Dashboard"
+/>
 
 To explore more dashboard functionalities, check out the [Dashboard Section](https://signoz.io/docs/userguide/manage-dashboards-and-panels/).
 
@@ -186,4 +229,4 @@ Yes, infrastructure monitoring can help with cost optimization in cloud environm
 
 Common metrics to track include CPU usage, memory utilization, disk I/O, network throughput, error rates, and response times. The specific metrics you monitor will depend on your infrastructure and business requirements.
 
-##
\ No newline at end of file
+##
diff --git a/data/guides/iot-monitoring.mdx b/data/guides/iot-monitoring.mdx
index a8346f018..73e5e8a34 100644
--- a/data/guides/iot-monitoring.mdx
+++ b/data/guides/iot-monitoring.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Essential Guide to IoT Monitoring - Benefits and Best Practices
-slug: iot-monitoring
 date: 2024-11-29
 tags: [monitoring]
 authors: [vivek_goswami]
 description: Discover the essential benefits and best practices of IoT monitoring. Learn how to optimize your connected ecosystem for efficiency, security, and performance.
-keywords: [IoT monitoring, connected devices, real-time data, predictive maintenance, device security, IoT analytics, edge computing, SigNoz]
-
+keywords:
+  [
+    IoT monitoring,
+    connected devices,
+    real-time data,
+    predictive maintenance,
+    device security,
+    IoT analytics,
+    edge computing,
+    SigNoz,
+  ]
 ---
 
 In today's interconnected world, the Internet of Things (IoT) has become a cornerstone of modern business operations. As the number of connected devices grows exponentially, the need for effective IoT monitoring has never been more critical. IoT monitoring enables organizations to maintain visibility, control, and optimize their vast networks of smart devices. This comprehensive guide explores the ins and outs of IoT monitoring, its benefits, and best practices to help you harness the full potential of your connected ecosystem.
@@ -17,21 +24,23 @@ In today's interconnected world, the Internet of Things (IoT) has become a corne
 IoT monitoring involves tracking, analyzing, and managing the performance and health of devices within an Internet of Things (IoT) ecosystem. With billions of connected devices in various industries, monitoring ensures smooth operations, improves efficiency, and enhances security.
 
 - Key components of an IoT monitoring system
-    1. *Devices and Sensors*: These collect real-time data such as temperature, humidity, motion, or energy consumption. For instance, a smart thermostat collects room temperature data to adjust heating or cooling systems.
-    2. *Gateways*: Act as intermediaries between IoT devices and cloud platforms, aggregating data and enabling communication.
-    3. *Cloud Platforms*: These handle data storage, analysis, and visualization. Platforms like AWS IoT Core or Microsoft Azure IoT Hub are commonly used.
+  1. _Devices and Sensors_: These collect real-time data such as temperature, humidity, motion, or energy consumption. For instance, a smart thermostat collects room temperature data to adjust heating or cooling systems.
+  2. _Gateways_: Act as intermediaries between IoT devices and cloud platforms, aggregating data and enabling communication.
+  3. _Cloud Platforms_: These handle data storage, analysis, and visualization. Platforms like AWS IoT Core or Microsoft Azure IoT Hub are commonly used.
 - Types of data monitored in IoT environments
-    1. *Performance Metrics*: Monitoring bandwidth usage or latency in industrial IoT ensures optimal performance.
-    2. *Health Status*: Device uptime, battery life, and hardware diagnostics are critical to maintaining uninterrupted operations. For example, monitoring the battery levels of wearable health devices helps prevent outages.
-    3. *Security Data*: Logs of unauthorized access attempts or unusual data patterns are essential for detecting breaches.
+  1. _Performance Metrics_: Monitoring bandwidth usage or latency in industrial IoT ensures optimal performance.
+  2. _Health Status_: Device uptime, battery life, and hardware diagnostics are critical to maintaining uninterrupted operations. For example, monitoring the battery levels of wearable health devices helps prevent outages.
+  3. _Security Data_: Logs of unauthorized access attempts or unusual data patterns are essential for detecting breaches.
 - Challenges unique to IoT monitoring
-    1. *Scale*: Managing thousands to millions of devices across diverse locations is complex.
-    2. *Diversity of Devices*: IoT systems integrate devices from different manufacturers, often using incompatible protocols.
-    3. *Data Volume*: High-frequency data generation leads to storage and processing challenges. For example, autonomous vehicles generate terabytes of data daily, requiring efficient real-time processing.
+  1. _Scale_: Managing thousands to millions of devices across diverse locations is complex.
+  2. _Diversity of Devices_: IoT systems integrate devices from different manufacturers, often using incompatible protocols.
+  3. _Data Volume_: High-frequency data generation leads to storage and processing challenges. For example, autonomous vehicles generate terabytes of data daily, requiring efficient real-time processing.
 
 ## Why IoT Monitoring is Critical for Businesses
 
-<Figure src="/img/guides/2024/11/iot-monitoring-image.webp" alt="" caption="" />IoT monitoring plays a vital role in ensuring the seamless functioning of businesses by effectively managing connected devices. Its significance can be observed in the following key areas:
+<Figure src="/img/guides/2024/11/iot-monitoring-image.webp" alt="" caption="" />
+IoT monitoring plays a vital role in ensuring the seamless functioning of businesses by effectively
+managing connected devices. Its significance can be observed in the following key areas:
 
 ### Ensuring Operational Efficiency and Minimizing Downtime
 
@@ -52,129 +61,111 @@ Predictive maintenance relies on IoT monitoring to analyze equipment performance
 ### Key Benefits of IoT Monitoring
 
 - Real-time visibility into device performance
-    
-    IoT monitoring ensures constant tracking, allowing stakeholders to assess device health instantly. For instance, sensors in manufacturing monitor machine temperatures, generating alerts for abnormalities to prevent downtime.
-    
+  IoT monitoring ensures constant tracking, allowing stakeholders to assess device health instantly. For instance, sensors in manufacturing monitor machine temperatures, generating alerts for abnormalities to prevent downtime.
 - Proactive issue detection and faster resolution
-    
-    Monitoring systems identify potential issues early, reducing repair costs and disruptions. For example, factories use predictive maintenance to detect unusual machinery vibrations and address them proactively.
-    
+  Monitoring systems identify potential issues early, reducing repair costs and disruptions. For example, factories use predictive maintenance to detect unusual machinery vibrations and address them proactively.
 - Improved scalability and management of device fleets
-    
-    IoT monitoring simplifies large-scale device management. Logistics fleets equipped with trackers can be monitored for location, fuel consumption, and maintenance needs, ensuring efficient operations.
-    
+  IoT monitoring simplifies large-scale device management. Logistics fleets equipped with trackers can be monitored for location, fuel consumption, and maintenance needs, ensuring efficient operations.
 - Enhanced data analytics for optimization
-    
-    Data from IoT devices uncovers patterns for process improvements. Smart agriculture, for instance, uses soil moisture data to optimize irrigation, conserving resources and improving crop yield.
-    
+  Data from IoT devices uncovers patterns for process improvements. Smart agriculture, for instance, uses soil moisture data to optimize irrigation, conserving resources and improving crop yield.
 
 ### Cost Savings and ROI
 
 Implementing IoT monitoring results in significant cost efficiencies and improved ROI through:
 
 1. Reduced Maintenance Costs
-    
-    Predictive maintenance helps prevent failures, minimizing downtime and repair expenses. For instance, IoT sensors in factories monitor machine performance, scheduling maintenance only when needed.
-    
+
+   Predictive maintenance helps prevent failures, minimizing downtime and repair expenses. For instance, IoT sensors in factories monitor machine performance, scheduling maintenance only when needed.
+
 2. Improved Resource Allocation
-    
-    Usage pattern analysis enables better resource distribution. In logistics, fleet systems track routes and fuel usage, optimizing schedules and reducing idle time. Smart offices adjust lighting and HVAC systems based on occupancy, saving energy.
-    
+
+   Usage pattern analysis enables better resource distribution. In logistics, fleet systems track routes and fuel usage, optimizing schedules and reducing idle time. Smart offices adjust lighting and HVAC systems based on occupancy, saving energy.
+
 3. Energy Efficiency Optimization
-    
-    Smart environments reduce energy consumption using connected devices like thermostats, which adjust temperatures dynamically based on weather and occupancy.
-    
+
+   Smart environments reduce energy consumption using connected devices like thermostats, which adjust temperatures dynamically based on weather and occupancy.
+
 4. Extended Device Lifespan
-    
-    Proper device management, including automated updates and real-time diagnostics, extends operational life. For example, smart water meters alert users to leaks, ensuring timely fixes and device longevity.
-    
+
+   Proper device management, including automated updates and real-time diagnostics, extends operational life. For example, smart water meters alert users to leaks, ensuring timely fixes and device longevity.
 
 ## Best Practices for Effective IoT Monitoring
 
 Effective IoT monitoring ensures optimal performance, security, and reliability of connected devices. Adopting the following practices helps achieve comprehensive monitoring:
 
 1. Centralized Monitoring Platform
-    
-    Using a centralized platform provides unified visibility across all IoT devices and systems. This enables efficient tracking of device status, performance, and anomalies. For instance, integrating tools like AWS IoT Core or Azure IoT Hub can centralize monitoring while offering real-time analytics.
-    
+
+   Using a centralized platform provides unified visibility across all IoT devices and systems. This enables efficient tracking of device status, performance, and anomalies. For instance, integrating tools like AWS IoT Core or Azure IoT Hub can centralize monitoring while offering real-time analytics.
+
 2. Baseline Performance Metrics and Thresholds
-    
-    Establishing baselines helps identify normal operational patterns. By defining metrics such as latency, uptime, and resource usage, deviations can be flagged early. For example, monitoring a smart thermostat's temperature adjustment patterns can reveal anomalies in energy consumption or system behavior.
-    
+
+   Establishing baselines helps identify normal operational patterns. By defining metrics such as latency, uptime, and resource usage, deviations can be flagged early. For example, monitoring a smart thermostat's temperature adjustment patterns can reveal anomalies in energy consumption or system behavior.
+
 3. Automated Alerting and Incident Response
-    
-    Automated alerts ensure quick responses to issues like device malfunctions or network outages. Incorporating incident management tools, such as PagerDuty or ServiceNow, facilitates immediate escalation. For example, a sensor detecting water leakage in a pipeline can trigger alerts to maintenance teams, preventing major damage.
-    
+
+   Automated alerts ensure quick responses to issues like device malfunctions or network outages. Incorporating incident management tools, such as PagerDuty or ServiceNow, facilitates immediate escalation. For example, a sensor detecting water leakage in a pipeline can trigger alerts to maintenance teams, preventing major damage.
+
 4. Robust Security Measures
-    
-    Security plays a critical role in IoT monitoring. Employing encryption protects data in transit, access controls restrict unauthorized usage, and regular firmware updates patch vulnerabilities. For instance, securing a fleet of connected cameras with TLS encryption and unique access keys minimizes data interception risks.
-    
+
+   Security plays a critical role in IoT monitoring. Employing encryption protects data in transit, access controls restrict unauthorized usage, and regular firmware updates patch vulnerabilities. For instance, securing a fleet of connected cameras with TLS encryption and unique access keys minimizes data interception risks.
 
 ## Data Management and Analytics
 
 Data management and analytics are crucial for organizations aiming to optimize operations and derive actionable insights from collected information. The following strategies highlight modern approaches to achieving efficiency and effectiveness:
 
 1. Implementing Edge Computing for Real-Time Processing
-    
-    Edge computing reduces latency by processing data closer to the source. For example, a manufacturing company can deploy edge devices on factory floors to analyze sensor data locally. This minimizes delays and enables real-time decision-making, such as identifying machinery issues and taking immediate corrective action.
-    
+
+   Edge computing reduces latency by processing data closer to the source. For example, a manufacturing company can deploy edge devices on factory floors to analyze sensor data locally. This minimizes delays and enables real-time decision-making, such as identifying machinery issues and taking immediate corrective action.
+
 2. Utilizing Machine Learning for Anomaly Detection and Predictive Analytics
-    
-    Machine learning models can analyze large datasets to detect anomalies and predict future trends. A financial institution, for instance, might use machine learning to identify fraudulent transactions by detecting unusual spending patterns. Similarly, predictive analytics can forecast maintenance needs in industrial equipment, reducing downtime and operational costs.
-    
+
+   Machine learning models can analyze large datasets to detect anomalies and predict future trends. A financial institution, for instance, might use machine learning to identify fraudulent transactions by detecting unusual spending patterns. Similarly, predictive analytics can forecast maintenance needs in industrial equipment, reducing downtime and operational costs.
+
 3. Establishing Data Retention and Archiving Policies
-    
-    Effective data retention policies ensure compliance with regulations while optimizing storage. Organizations can classify data based on importance and retention period. For example, customer transaction records might be retained for seven years for audit purposes, while less critical data is archived or deleted after a shorter duration.
-    
+
+   Effective data retention policies ensure compliance with regulations while optimizing storage. Organizations can classify data based on importance and retention period. For example, customer transaction records might be retained for seven years for audit purposes, while less critical data is archived or deleted after a shorter duration.
+
 4. Integrating IoT Data with Business Systems for Holistic Insights
-    
-    Combining IoT data with existing business systems provides a comprehensive view of operations. In a smart city project, traffic sensor data can be integrated with public transportation systems to optimize routes and schedules. This improves efficiency and reduces congestion, benefiting the community as a whole.
-    
+
+   Combining IoT data with existing business systems provides a comprehensive view of operations. In a smart city project, traffic sensor data can be integrated with public transportation systems to optimize routes and schedules. This improves efficiency and reduces congestion, benefiting the community as a whole.
 
 ## Common Challenges in IoT Monitoring and How to Overcome Them
 
 The rapid expansion of IoT ecosystems has introduced significant challenges in monitoring and management. Overcoming these challenges requires strategic approaches and robust solutions.
 
 - Heterogeneous Device Ecosystems
-    
-    IoT devices vary widely in hardware, communication protocols, and software capabilities. Managing such diversity requires tools that offer cross-platform support and interoperability. Implementing standard communication protocols like MQTT or CoAP ensures devices from different manufacturers can work seamlessly. For instance, using an IoT platform like AWS IoT Core helps integrate heterogeneous devices under a unified management layer.
-    
+  IoT devices vary widely in hardware, communication protocols, and software capabilities. Managing such diversity requires tools that offer cross-platform support and interoperability. Implementing standard communication protocols like MQTT or CoAP ensures devices from different manufacturers can work seamlessly. For instance, using an IoT platform like AWS IoT Core helps integrate heterogeneous devices under a unified management layer.
 - Ensuring Reliable Connectivity
-    
-    IoT devices in remote or harsh environments often face unreliable network connections. Employing low-power wide-area networks (LPWAN) like LoRaWAN or NB-IoT can help maintain connectivity over long distances. For critical applications, such as monitoring pipelines in remote areas, redundancy with multiple network options ensures data transmission even during outages.
-    
+  IoT devices in remote or harsh environments often face unreliable network connections. Employing low-power wide-area networks (LPWAN) like LoRaWAN or NB-IoT can help maintain connectivity over long distances. For critical applications, such as monitoring pipelines in remote areas, redundancy with multiple network options ensures data transmission even during outages.
 - Massive Data Generation and Management
-    
-    IoT devices generate massive amounts of data, which can overwhelm storage and analytics systems. Edge computing offers a practical solution by processing data locally before transmitting only critical information to the cloud. A smart factory, for example, can use edge devices to analyze sensor data for immediate insights, reducing the volume of data sent to centralized systems.
-    
+  IoT devices generate massive amounts of data, which can overwhelm storage and analytics systems. Edge computing offers a practical solution by processing data locally before transmitting only critical information to the cloud. A smart factory, for example, can use edge devices to analyze sensor data for immediate insights, reducing the volume of data sent to centralized systems.
 - Privacy and Regulatory Compliance
-    
-    IoT monitoring systems often handle sensitive user and organizational data. Compliance with regulations like GDPR or HIPAA is crucial. Implementing data encryption, both in transit and at rest, protects against breaches. A healthcare organization deploying IoT-enabled patient monitors, for example, can ensure compliance by anonymizing patient data and restricting access to authorized personnel.
-    
+  IoT monitoring systems often handle sensitive user and organizational data. Compliance with regulations like GDPR or HIPAA is crucial. Implementing data encryption, both in transit and at rest, protects against breaches. A healthcare organization deploying IoT-enabled patient monitors, for example, can ensure compliance by anonymizing patient data and restricting access to authorized personnel.
 
 ## Choosing the Right IoT Monitoring Tools
 
 Selecting an IoT monitoring tool requires careful consideration of several factors to ensure efficient device management and performance optimization. Here are key aspects to evaluate when choosing a platform:
 
 1. Key Features to Look for
-    - Real-time device monitoring and diagnostics help identify and address issues proactively.
-    - Support for predictive maintenance through advanced analytics minimizes downtime.
-    - Security features like encrypted communication, device authentication, and threat detection safeguard IoT networks.
-    - Customizable dashboards provide actionable insights tailored to specific requirements.
-    - Automated alerts and notifications enable quick response to anomalies.
-    
-    For instance, a logistics company monitoring delivery vehicles may benefit from GPS integration and real-time fuel consumption tracking to optimize operations.
-    
+
+   - Real-time device monitoring and diagnostics help identify and address issues proactively.
+   - Support for predictive maintenance through advanced analytics minimizes downtime.
+   - Security features like encrypted communication, device authentication, and threat detection safeguard IoT networks.
+   - Customizable dashboards provide actionable insights tailored to specific requirements.
+   - Automated alerts and notifications enable quick response to anomalies.
+
+   For instance, a logistics company monitoring delivery vehicles may benefit from GPS integration and real-time fuel consumption tracking to optimize operations.
+
 2. Comparison of Cloud-Based vs. On-Premises Solutions
-    - Cloud-Based Solutions: These provide scalability and remote accessibility, making them ideal for organizations with distributed IoT deployments. Maintenance is managed by service providers, reducing operational overhead. For example, a smart home solution company might use a cloud-based platform for seamless user control.
-    - On-Premises Solutions: Suitable for industries requiring stringent data privacy or where connectivity is limited. These solutions allow full control but require dedicated IT resources. Manufacturing facilities with sensitive operational data may prefer this approach.
+   - Cloud-Based Solutions: These provide scalability and remote accessibility, making them ideal for organizations with distributed IoT deployments. Maintenance is managed by service providers, reducing operational overhead. For example, a smart home solution company might use a cloud-based platform for seamless user control.
+   - On-Premises Solutions: Suitable for industries requiring stringent data privacy or where connectivity is limited. These solutions allow full control but require dedicated IT resources. Manufacturing facilities with sensitive operational data may prefer this approach.
 3. Importance of Scalability and Flexibility
-    - IoT ecosystems grow with the addition of devices and new use cases. The chosen platform must support a growing number of devices and diverse protocols.
-    - Flexibility to integrate with evolving technologies ensures the solution remains future-proof. For instance, an agricultural IoT system initially monitoring irrigation might later expand to include drone-based crop analysis.
+   - IoT ecosystems grow with the addition of devices and new use cases. The chosen platform must support a growing number of devices and diverse protocols.
+   - Flexibility to integrate with evolving technologies ensures the solution remains future-proof. For instance, an agricultural IoT system initially monitoring irrigation might later expand to include drone-based crop analysis.
 4. Integration Capabilities with Existing IT Infrastructure
-    - Seamless integration with IT tools like analytics platforms, CRMs, or ERPs enhances operational efficiency.
-    - APIs and SDKs should enable smooth interoperability, reducing deployment complexity.
-    - A retail chain, for example, can integrate its IoT-powered inventory system with an ERP to automate stock management.
+   - Seamless integration with IT tools like analytics platforms, CRMs, or ERPs enhances operational efficiency.
+   - APIs and SDKs should enable smooth interoperability, reducing deployment complexity.
+   - A retail chain, for example, can integrate its IoT-powered inventory system with an ERP to automate stock management.
 
 ## Implementing IoT Monitoring with SigNoz
 
@@ -200,21 +191,20 @@ To get started with SigNoz for IoT monitoring:
 The Internet of Things (IoT) continues to evolve, with monitoring technologies playing a crucial role in ensuring efficient operation and security. Emerging trends in IoT monitoring highlight innovations that promise to revolutionize the way devices and networks are managed.
 
 1. AI and Machine Learning in Predictive Monitoring
-    
-    AI and machine learning are reshaping IoT monitoring by enabling predictive analytics. These technologies analyze vast amounts of IoT data to identify potential issues before they occur. For example, predictive maintenance in industrial IoT setups can detect unusual patterns in machine performance, reducing downtime and repair costs. AI-powered monitoring tools also enable anomaly detection, ensuring faster responses to unexpected events.
-    
+
+   AI and machine learning are reshaping IoT monitoring by enabling predictive analytics. These technologies analyze vast amounts of IoT data to identify potential issues before they occur. For example, predictive maintenance in industrial IoT setups can detect unusual patterns in machine performance, reducing downtime and repair costs. AI-powered monitoring tools also enable anomaly detection, ensuring faster responses to unexpected events.
+
 2. 5G Technology Integration
-    
-    The integration of 5G into IoT ecosystems facilitates faster data transfer and enhanced connectivity. With its low latency and high bandwidth, 5G enables real-time monitoring of devices. For instance, in smart cities, 5G allows real-time traffic updates from IoT sensors, improving traffic management and reducing congestion. Similarly, healthcare IoT devices benefit from 5G by enabling instantaneous transmission of patient data, ensuring timely interventions.
-    
+
+   The integration of 5G into IoT ecosystems facilitates faster data transfer and enhanced connectivity. With its low latency and high bandwidth, 5G enables real-time monitoring of devices. For instance, in smart cities, 5G allows real-time traffic updates from IoT sensors, improving traffic management and reducing congestion. Similarly, healthcare IoT devices benefit from 5G by enabling instantaneous transmission of patient data, ensuring timely interventions.
+
 3. Edge Computing for Real-Time Processing
-    
-    Edge computing is transforming IoT monitoring by bringing data processing closer to the devices generating the data. This reduces latency and bandwidth requirements. A practical example is in autonomous vehicles, where edge computing processes data from sensors locally to make real-time decisions, such as braking or avoiding obstacles. Industrial IoT systems also leverage edge computing to monitor and respond to machinery issues instantly.
-    
+
+   Edge computing is transforming IoT monitoring by bringing data processing closer to the devices generating the data. This reduces latency and bandwidth requirements. A practical example is in autonomous vehicles, where edge computing processes data from sensors locally to make real-time decisions, such as braking or avoiding obstacles. Industrial IoT systems also leverage edge computing to monitor and respond to machinery issues instantly.
+
 4. Blockchain for Security and Data Integrity
-    
-    Blockchain technology is being adopted to enhance the security and integrity of IoT data. By creating immutable and transparent records, blockchain ensures that IoT data is tamper-proof. For example, in supply chain monitoring, blockchain enables secure tracking of goods, ensuring that data about the location and condition of items is reliable. Smart contracts powered by blockchain also automate responses in IoT systems, reducing human intervention and the potential for errors.
-    
+
+   Blockchain technology is being adopted to enhance the security and integrity of IoT data. By creating immutable and transparent records, blockchain ensures that IoT data is tamper-proof. For example, in supply chain monitoring, blockchain enables secure tracking of goods, ensuring that data about the location and condition of items is reliable. Smart contracts powered by blockchain also automate responses in IoT systems, reducing human intervention and the potential for errors.
 
 ## Key Takeaways
 
@@ -240,4 +230,4 @@ Yes, IoT monitoring can significantly enhance device security by providing real-
 
 ### What types of businesses benefit most from IoT monitoring?
 
-While IoT monitoring can benefit organizations across various industries, it's particularly valuable for manufacturing, healthcare, smart cities, agriculture, and logistics sectors where large numbers of connected devices are deployed in critical operations.
\ No newline at end of file
+While IoT monitoring can benefit organizations across various industries, it's particularly valuable for manufacturing, healthcare, smart cities, agriculture, and logistics sectors where large numbers of connected devices are deployed in critical operations.
diff --git a/data/guides/is-it-possible-to-duplicate-a-dashboard-in-grafana.mdx b/data/guides/is-it-possible-to-duplicate-a-dashboard-in-grafana.mdx
index e5c527d0c..a2dadf8c8 100644
--- a/data/guides/is-it-possible-to-duplicate-a-dashboard-in-grafana.mdx
+++ b/data/guides/is-it-possible-to-duplicate-a-dashboard-in-grafana.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to Duplicate a Grafana Dashboard - Step-by-Step Guide
-slug: is-it-possible-to-duplicate-a-dashboard-in-grafana
 date: 2024-11-07
 tags: [faq, grafana]
 authors: [nitin_gouda]
 description: Learn how to duplicate Grafana dashboards with our comprehensive guide. Explore step-by-step instructions, best practices, and advanced techniques.
-keywords: [Grafana dashboard duplication, duplicate Grafana dashboard, Grafana Cloud, dashboard management, SigNoz, monitoring solution]
-
+keywords:
+  [
+    Grafana dashboard duplication,
+    duplicate Grafana dashboard,
+    Grafana Cloud,
+    dashboard management,
+    SigNoz,
+    monitoring solution,
+  ]
 ---
 
 Grafana dashboards are powerful tools for visualizing and analyzing data. As your monitoring needs grow, you might want to create variations of existing dashboards or use them as templates for new projects. This is where dashboard duplication comes in handy, but is it possible to duplicate a dashboard in Grafana? The answer is a resounding yes. Grafana provides built-in functionality to duplicate dashboards, saving you time and effort in recreating complex visualizations from scratch. In this article, we’ll walk through the steps to duplicate dashboards in Grafana and explore ways to customize them for different monitoring needs.
@@ -62,29 +67,49 @@ Duplicating a dashboard in Grafana is a simple yet powerful feature that allows
 
 Start by logging into your Grafana instance using your credentials. Whether you're using Grafana Cloud or a self-hosted version, enter the URL of your Grafana instance in your browser and sign in. After logging in, you’ll be taken to the Grafana homepage, where you can access all your dashboards.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.36.59_AM.webp" alt="Grafana login page" caption="Grafana login page" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.36.59_AM.webp"
+  alt="Grafana login page"
+  caption="Grafana login page"
+/>
 
 1. Navigate to the Dashboard You Want to Duplicate
 
 Once logged in, locate the dashboard you want to duplicate. You can either browse through your dashboard list or use the search function at the top of the page to find the specific dashboard. Click on the dashboard to open it.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.37.57_AM.webp" alt="Grafana dashboards page" caption="Grafana dashboards page" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.37.57_AM.webp"
+  alt="Grafana dashboards page"
+  caption="Grafana dashboards page"
+/>
 
 1. Locating the "Save As" or Duplication Option
 
 In the dashboard view, find the settings gear icon or dropdown menu typically located in the top-right corner. Click on it to reveal options, including the "Save As" feature, which initiates the duplication process.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.52.52_AM.webp" alt="Grafana Dashboard Settings Page" caption="Grafana Dashboard Settings Page" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.52.52_AM.webp"
+  alt="Grafana Dashboard Settings Page"
+  caption="Grafana Dashboard Settings Page"
+/>
 
-1. Choosing a New Name and Location for the Duplicated Dashboard 
+1. Choosing a New Name and Location for the Duplicated Dashboard
 
 After selecting "Save As," a prompt will appear, asking for a new name for the duplicated dashboard. Enter a descriptive name to distinguish it from the original. You can also select a folder for organization, helping you manage multiple dashboards effectively.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.44.59_AM.webp" alt="Grafana “Save As” window" caption="Grafana “Save As” window" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_1.44.59_AM.webp"
+  alt="Grafana “Save As” window"
+  caption="Grafana “Save As” window"
+/>
 
 You will see the duplicated dashboard in your dashboard list.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_2.26.45_AM.webp" alt="SigNoz Dashboard Copy" caption="SigNoz Dashboard Copy" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-22_at_2.26.45_AM.webp"
+  alt="SigNoz Dashboard Copy"
+  caption="SigNoz Dashboard Copy"
+/>
 
 ## Duplicating in Grafana Cloud
 
@@ -92,7 +117,7 @@ Duplicating dashboards in Grafana Cloud is an essential skill that enhances your
 
 ### Differences in the Duplication Process for Grafana Cloud
 
- The process of duplicating dashboards in Grafana Cloud shares similarities with on-premises Grafana installations, yet there are key differences that beginners should be aware of. 
+The process of duplicating dashboards in Grafana Cloud shares similarities with on-premises Grafana installations, yet there are key differences that beginners should be aware of.
 
 In Grafana Cloud, you may encounter specific user interface elements and features that are optimized for cloud functionality. For example, your dashboards are stored in a centralized cloud environment, which may affect how changes are saved and synced across users. Additionally, the cloud service often includes enhanced collaboration features, allowing teams to work together more seamlessly.
 
@@ -104,31 +129,51 @@ To duplicate a dashboard in Grafana Cloud, follow these steps:
 
 Log into your Grafana Cloud account and select the dashboard you wish to duplicate.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-f0f8594b-d092-46fc-9dc7-0be5c4fb7a6a.webp" alt="Grafana Cloud login page" caption="Grafana Cloud login page" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-f0f8594b-d092-46fc-9dc7-0be5c4fb7a6a.webp"
+  alt="Grafana Cloud login page"
+  caption="Grafana Cloud login page"
+/>
 
 1. Open Dashboard Settings
 
 Click on the `Settings` icon in the upper right corner of the dashboard to access the settings menu.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-2e245007-1edc-4bd0-aaa3-3ae000d34fd5.webp" alt="Click on Settings" caption="Click on Settings" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-2e245007-1edc-4bd0-aaa3-3ae000d34fd5.webp"
+  alt="Click on Settings"
+  caption="Click on Settings"
+/>
 
 1. Select 'Save As'
 
 From the dropdown menu, choose the “Save As” option. This action allows you to create a copy of the existing dashboard.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-4bfd2d5c-a2ce-4131-b984-115f0cd96b06.webp" alt="Click on Save As to copy the dashboard" caption="Click on Save As to copy the dashboard" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-4bfd2d5c-a2ce-4131-b984-115f0cd96b06.webp"
+  alt="Click on Save As to copy the dashboard"
+  caption="Click on Save As to copy the dashboard"
+/>
 
 1. Rename the Duplicate
 
 A dialog box will appear, prompting you to rename the new dashboard. Provide a meaningful name and adjust any other settings as necessary, then click “Save.”
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-8c85d0b1-e862-4fa9-9bc7-479cec5c6314.webp" alt="Rename the dashboard and description" caption="Rename the dashboard and description" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-8c85d0b1-e862-4fa9-9bc7-479cec5c6314.webp"
+  alt="Rename the dashboard and description"
+  caption="Rename the dashboard and description"
+/>
 
 1. Edit the Duplicate
 
 After saving, you can modify the content of the duplicated dashboard according to your needs.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_2.34.13_PM.webp" alt="Edit the panel names or add new panels" caption="Edit the panel names or add new panels" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_2.34.13_PM.webp"
+  alt="Edit the panel names or add new panels"
+  caption="Edit the panel names or add new panels"
+/>
 
 ### Potential Limitations or Considerations Specific to Cloud Environments
 
@@ -143,13 +188,13 @@ While duplicating dashboards is generally a smooth process, there are some limit
 Here are some helpful tips for organizing your duplicated Grafana dashboards:
 
 - Understanding Permissions
-Before duplicating a dashboard, check that you have the necessary permissions in your Grafana Cloud account. Without the right permissions, you won’t be able to access the duplication feature. This step ensures that you can manage your dashboards effectively.
+  Before duplicating a dashboard, check that you have the necessary permissions in your Grafana Cloud account. Without the right permissions, you won’t be able to access the duplication feature. This step ensures that you can manage your dashboards effectively.
 - Awareness of Storage Limitations
-Grafana Cloud plans may have storage limits that restrict the number of dashboards you can create. Keep this in mind to avoid exceeding your plan’s capacity. Monitoring your storage usage is essential for maintaining an organized workspace.
+  Grafana Cloud plans may have storage limits that restrict the number of dashboards you can create. Keep this in mind to avoid exceeding your plan’s capacity. Monitoring your storage usage is essential for maintaining an organized workspace.
 - Utilizing Folder Structures
-Grafana Cloud provides a folder structure that helps you organize your dashboards. When duplicating a dashboard, consider placing it in a relevant folder. This practice makes it easier to locate and manage your dashboards over time, especially when working on multiple projects.
+  Grafana Cloud provides a folder structure that helps you organize your dashboards. When duplicating a dashboard, consider placing it in a relevant folder. This practice makes it easier to locate and manage your dashboards over time, especially when working on multiple projects.
 - Naming and Descriptions
-When you create a duplicate dashboard, use meaningful names and descriptions. This helps you quickly identify each dashboard’s purpose and content. For example, instead of naming a duplicate "Dashboard Copy," consider naming it "Application Monitoring - Version 2." A clear naming convention enhances the usability of your Grafana environment.
+  When you create a duplicate dashboard, use meaningful names and descriptions. This helps you quickly identify each dashboard’s purpose and content. For example, instead of naming a duplicate "Dashboard Copy," consider naming it "Application Monitoring - Version 2." A clear naming convention enhances the usability of your Grafana environment.
 
 Always take a moment to reflect on how you organize your dashboards. A well-structured Grafana Cloud environment not only improves your efficiency but also makes it easier for team members to collaborate. By adopting these best practices, you can ensure that your Grafana Cloud workspace remains organized, functional, and conducive to effective monitoring.
 
@@ -161,9 +206,17 @@ After duplicating a dashboard in Grafana, it’s essential to customize it to be
 
 Start by clicking on the panel title and selecting "Edit." Change the title to accurately reflect the metrics being displayed. Adding descriptions can also provide context, helping collaborators understand the purpose of each panel.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-2a5a66bf-df6d-49f9-9634-b2e6a24a7807.webp" alt="Editing Panels" caption="Editing Panels" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-2a5a66bf-df6d-49f9-9634-b2e6a24a7807.webp"
+  alt="Editing Panels"
+  caption="Editing Panels"
+/>
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_2.58.12_PM.webp" alt="Updating Panel Title" caption="Updating Panel Title" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_2.58.12_PM.webp"
+  alt="Updating Panel Title"
+  caption="Updating Panel Title"
+/>
 
 1. Updating Data Sources
 
@@ -172,11 +225,23 @@ When you duplicate a dashboard, it retains the original data sources. If you're
 - Access Data Source Settings: In the panel editor, navigate to the "Query" section to select the appropriate data source for the new context.
 - Verify Connections: After updating, check that the data flows correctly, ensuring accuracy in the displayed metrics.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_3.00.12_PM.webp" alt="Selecting Grafana as DataSource" caption="Selecting Grafana as DataSource" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_3.00.12_PM.webp"
+  alt="Selecting Grafana as DataSource"
+  caption="Selecting Grafana as DataSource"
+/>
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-24bf7cb5-2cc1-4a06-aaf7-46e85195681d.webp" alt="Running the Query and changing the panel title" caption="Running the Query and changing the panel title" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-24bf7cb5-2cc1-4a06-aaf7-46e85195681d.webp"
+  alt="Running the Query and changing the panel title"
+  caption="Running the Query and changing the panel title"
+/>
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-9944bad3-9161-45d0-bc16-3f7ca2f1f5db.webp" alt="Final Dashboard" caption="Final Dashboard" /> 
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-9944bad3-9161-45d0-bc16-3f7ca2f1f5db.webp"
+  alt="Final Dashboard"
+  caption="Final Dashboard"
+/>{' '}
 
 1. Adjusting Time Ranges and Refresh Intervals
 
@@ -185,7 +250,11 @@ Customize time settings to focus on relevant data:
 - Set Time Ranges: Use the time range selector to customize the time frame for the entire dashboard or individual panels, based on your analysis needs.
 - Adjust Refresh Intervals: Determine how often data should refresh. For real-time monitoring, shorter intervals (e.g., every 5 seconds) may be appropriate, while historical analysis can use longer intervals.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-c52b84ff-ce88-47bb-9a26-2bacc99a1bd9.webp" alt="Changing the time range" caption="Changing the time range" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-c52b84ff-ce88-47bb-9a26-2bacc99a1bd9.webp"
+  alt="Changing the time range"
+  caption="Changing the time range"
+/>
 
 1. Adding or Removing Panels
 
@@ -194,7 +263,11 @@ Your monitoring needs may change, so review the panels included:
 - Add New Panels: If certain metrics are missing, click the “+” button and select “Add Panel” to create a new visualization based on available data sources.
 - Remove Unnecessary Panels: If specific panels are irrelevant, you can remove them by clicking the panel title and selecting "Remove." This keeps your dashboard focused and manageable.
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-15c65278-85af-4201-be33-2a2463fbe88c.webp" alt="Removing Older Panels" caption="Removing Older Panels" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-15c65278-85af-4201-be33-2a2463fbe88c.webp"
+  alt="Removing Older Panels"
+  caption="Removing Older Panels"
+/>
 
 ### Best Practices for Personalizing the Duplicated Dashboard
 
@@ -211,122 +284,117 @@ By following these steps, you can create a customized Grafana dashboard that eff
 
 For power users and organizations managing multiple dashboards, consider these advanced techniques:
 
-1. Use the Grafana API for Programmatic Dashboard Duplication
-The Grafana API allows you to automate the duplication of dashboards programmatically. Below is a Python example illustrating how to duplicate a dashboard using the API.
-    1. Create a Service Account and Generate a Token: 
-    Navigate to the Service Accounts section in Grafana. Click Add Service Account. Provide a descriptive name for your service account and assign it the necessary permissions for managing dashboards. Since we are are just doing a small example we will allow assign admin access. 
-        
-        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-561a3929-18c1-4932-94e8-fa06a4c8e345.webp" alt="Creating Service Account" caption="Creating Service Account" />
-        
-    2. Generate an API Token: 
-    Select the newly created service account from the list. Go to the Tokens tab and click Add Token. Enter a name for the token, Set an expiration date and click Create. Copy the generated token securely. You will use this token in your API requests.
-        
-        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-27ccd991-6d24-4e27-9dcd-c4f6b0a92f77.webp" alt="Generating API Token" caption="Generating API Token" />
-        
-        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-49beb0a6-7b36-4c68-a796-3066a97b70ff.webp" alt="Grafana’s Service Account Page" caption="Grafana’s Service Account Page" /> 
-        
-    3. Finding the Dashboard UID: 
-    Open the dashboard you want to duplicate. Look at the URL in your browser. The UID is the last part of the URL. For example, in `http://your-grafana-url/d/be2evm5oplddsf/dashboard-name`, the UID is `be2evm5oplddsf`.
-        
-        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_3.35.18_PM.webp" alt="Grafana’s Dashboard" caption="Grafana’s Dashboard" />
-        
-    4. Prepare the Python Script: 
-    Create a new Python file (e.g., `duplicate.py`) and copy the following code into it. Also Make sure you have the `requests` library installed. If you haven't installed it yet, you can do so using pip
-        
-        ```
-        pip install requests
-        ```
-        
-        Copy the following code and paste the below into the `duplicate.py` file
-        
-        ```python
-        import requests
-        
-        def duplicate_dashboard(service_account_token, dashboard_uid, new_title):
-            headers = {
-                "Authorization": f"Bearer {service_account_token}",
-                "Content-Type": "application/json"
-            }
-        
-            # Get original dashboard by UID
-            response = requests.get(f"http://127.0.0.1:62141/api/dashboards/uid/{dashboard_uid}", headers=headers)
-            
-            if response.status_code == 200:
-                dashboard = response.json().get("dashboard")
-                
-                if not dashboard:
-                    return {"error": "Dashboard not found in response"}
-        
-                # Modify dashboard title and clear IDs to make it a new dashboard
-                dashboard["title"] = new_title
-                dashboard["id"] = None  # Remove the original ID
-                dashboard.pop("uid", None)  # Remove the UID for new dashboard creation
-        
-                # Create the new dashboard
-                payload = {"dashboard": dashboard, "overwrite": False}
-                response = requests.post("http://127.0.0.1:62141/api/dashboards/db", headers=headers, json=payload)
-        
+1.  Use the Grafana API for Programmatic Dashboard Duplication
+    The Grafana API allows you to automate the duplication of dashboards programmatically. Below is a Python example illustrating how to duplicate a dashboard using the API. 1. Create a Service Account and Generate a Token:
+    Navigate to the Service Accounts section in Grafana. Click Add Service Account. Provide a descriptive name for your service account and assign it the necessary permissions for managing dashboards. Since we are are just doing a small example we will allow assign admin access.
+            <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-561a3929-18c1-4932-94e8-fa06a4c8e345.webp" alt="Creating Service Account" caption="Creating Service Account" />
+
+        2. Generate an API Token:
+        Select the newly created service account from the list. Go to the Tokens tab and click Add Token. Enter a name for the token, Set an expiration date and click Create. Copy the generated token securely. You will use this token in your API requests.
+
+            <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-27ccd991-6d24-4e27-9dcd-c4f6b0a92f77.webp" alt="Generating API Token" caption="Generating API Token" />
+
+            <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-49beb0a6-7b36-4c68-a796-3066a97b70ff.webp" alt="Grafana’s Service Account Page" caption="Grafana’s Service Account Page" />
+
+        3. Finding the Dashboard UID:
+        Open the dashboard you want to duplicate. Look at the URL in your browser. The UID is the last part of the URL. For example, in `http://your-grafana-url/d/be2evm5oplddsf/dashboard-name`, the UID is `be2evm5oplddsf`.
+
+            <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-30_at_3.35.18_PM.webp" alt="Grafana’s Dashboard" caption="Grafana’s Dashboard" />
+
+        4. Prepare the Python Script:
+        Create a new Python file (e.g., `duplicate.py`) and copy the following code into it. Also Make sure you have the `requests` library installed. If you haven't installed it yet, you can do so using pip
+
+            ```
+            pip install requests
+            ```
+
+            Copy the following code and paste the below into the `duplicate.py` file
+
+            ```python
+            import requests
+
+            def duplicate_dashboard(service_account_token, dashboard_uid, new_title):
+                headers = {
+                    "Authorization": f"Bearer {service_account_token}",
+                    "Content-Type": "application/json"
+                }
+
+                # Get original dashboard by UID
+                response = requests.get(f"http://127.0.0.1:62141/api/dashboards/uid/{dashboard_uid}", headers=headers)
+
                 if response.status_code == 200:
-                    return response.json()
+                    dashboard = response.json().get("dashboard")
+
+                    if not dashboard:
+                        return {"error": "Dashboard not found in response"}
+
+                    # Modify dashboard title and clear IDs to make it a new dashboard
+                    dashboard["title"] = new_title
+                    dashboard["id"] = None  # Remove the original ID
+                    dashboard.pop("uid", None)  # Remove the UID for new dashboard creation
+
+                    # Create the new dashboard
+                    payload = {"dashboard": dashboard, "overwrite": False}
+                    response = requests.post("http://127.0.0.1:62141/api/dashboards/db", headers=headers, json=payload)
+
+                    if response.status_code == 200:
+                        return response.json()
+                    else:
+                        return {"error": "Failed to create the new dashboard", "details": response.json()}
                 else:
-                    return {"error": "Failed to create the new dashboard", "details": response.json()}
-            else:
-                return {"error": "Failed to fetch the dashboard", "details": response.json()}
-        
-        # Replace the following values with your actual data
-        service_account_token = "<your-service-account-token>"
-        dashboard_uid = "<your-dashboard-uid>"
-        new_title = "Duplicated Dashboard Title"
-        
-        result = duplicate_dashboard(service_account_token, dashboard_uid, new_title)
-        print(result)
+                    return {"error": "Failed to fetch the dashboard", "details": response.json()}
+
+            # Replace the following values with your actual data
+            service_account_token = "<your-service-account-token>"
+            dashboard_uid = "<your-dashboard-uid>"
+            new_title = "Duplicated Dashboard Title"
+
+            result = duplicate_dashboard(service_account_token, dashboard_uid, new_title)
+            print(result)
+            ```
+
+            The above script duplicates an existing Grafana dashboard by fetching its data via API, modifying its title, and creating a new copy with the modified details without overwriting the original.
+
+            - Replace `YOUR_SERVICE_ACCOUNT_TOKEN` with the token you generated.
+            - Replace `YOUR_DASHBOARD_UID` with the UID of the dashboard you want to duplicate.
+            - Set the `new_title` to the desired name for the duplicated dashboard
+
+        e. Run the Script:
+
+        Once you have updated the script with your values, run it from your terminal:
+
+        ```
+        python duplicate.py
         ```
-        
-        The above script duplicates an existing Grafana dashboard by fetching its data via API, modifying its title, and creating a new copy with the modified details without overwriting the original.
-        
-        - Replace `YOUR_SERVICE_ACCOUNT_TOKEN` with the token you generated.
-        - Replace `YOUR_DASHBOARD_UID` with the UID of the dashboard you want to duplicate.
-        - Set the `new_title` to the desired name for the duplicated dashboard
-    
-    e. Run the Script: 
-    
-    Once you have updated the script with your values, run it from your terminal:
-    
-    ```
-    python duplicate.py
-    ```
-    
-    <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-23_at_11.23.38_PM.webp" alt="Running the code locally" caption="Running the code locally" />
-    
-    <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-23_at_11.24.36_PM.webp" alt="Dashboard duplicated with the desired dashboard name" caption="Dashboard duplicated with the desired dashboard name" />
-    
-2. Implement version control for dashboards using tools like Git: 
-Version control systems, such as Git, can be invaluable for managing dashboard configurations. By storing dashboard JSON files in a Git repository, teams can track changes, collaborate more effectively, and roll back to previous versions if necessary. This ensures that modifications are documented and reversible, fostering a more organized workflow.
-    
-    <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-1f1c53b2-9f8a-4e73-a220-5b2973061e3f.webp" alt="Downloading Dashboard" caption="Downloading Dashboard" />
-    
-    <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-6ae4be49-5d8b-49bd-9fff-5865509dde0a.webp" alt="Export dashboard as JSON" caption="Export dashboard as JSON" />
-    
-    You can download the dashboard file or you can paste it where its needed. If needed you can store it on git repositories too
-    
-3. Use Grafana's templating feature to create dynamic, reusable dashboards: 
-Grafana's templating feature enables the creation of dynamic dashboards that adapt to user input. By defining template variables, you can create reusable dashboards that allow users to filter data, switch between different data sources, and adjust visualization parameters seamlessly. This enhances flexibility and efficiency, making dashboards more interactive and tailored to specific needs.
-4. Develop a naming convention for duplicated dashboards to maintain consistency: 
-Establishing a clear naming convention for duplicated dashboards is essential for maintaining organization and clarity within your Grafana environment. Consistent naming helps team members easily identify and differentiate between various dashboard versions. 
-For example, you could include the original dashboard name, the date of duplication, and a version number in the title (e.g., "Sales Overview - Copy - 2024-10-21 - v1"). This practice minimizes confusion and streamlines navigation.
+
+        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-23_at_11.23.38_PM.webp" alt="Running the code locally" caption="Running the code locally" />
+
+        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-Screenshot_2024-10-23_at_11.24.36_PM.webp" alt="Dashboard duplicated with the desired dashboard name" caption="Dashboard duplicated with the desired dashboard name" />
+2.  Implement version control for dashboards using tools like Git:
+    Version control systems, such as Git, can be invaluable for managing dashboard configurations. By storing dashboard JSON files in a Git repository, teams can track changes, collaborate more effectively, and roll back to previous versions if necessary. This ensures that modifications are documented and reversible, fostering a more organized workflow.
+        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-1f1c53b2-9f8a-4e73-a220-5b2973061e3f.webp" alt="Downloading Dashboard" caption="Downloading Dashboard" />
+
+        <Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-6ae4be49-5d8b-49bd-9fff-5865509dde0a.webp" alt="Export dashboard as JSON" caption="Export dashboard as JSON" />
+
+        You can download the dashboard file or you can paste it where its needed. If needed you can store it on git repositories too
+3.  Use Grafana's templating feature to create dynamic, reusable dashboards:
+    Grafana's templating feature enables the creation of dynamic dashboards that adapt to user input. By defining template variables, you can create reusable dashboards that allow users to filter data, switch between different data sources, and adjust visualization parameters seamlessly. This enhances flexibility and efficiency, making dashboards more interactive and tailored to specific needs.
+4.  Develop a naming convention for duplicated dashboards to maintain consistency:
+    Establishing a clear naming convention for duplicated dashboards is essential for maintaining organization and clarity within your Grafana environment. Consistent naming helps team members easily identify and differentiate between various dashboard versions.
+    For example, you could include the original dashboard name, the date of duplication, and a version number in the title (e.g., "Sales Overview - Copy - 2024-10-21 - v1"). This practice minimizes confusion and streamlines navigation.
 
 ## Troubleshooting Common Duplication Issues
 
 Even with Grafana's user-friendly interface, you might encounter some issues when duplicating dashboards:
 
-- Permission errors: 
-One of the most common issues when attempting to duplicate a dashboard is a lack of permissions. In Grafana, users are often assigned roles with varying levels of access. If you encounter permission-related errors, ensure that your user account has the required rights to create and modify dashboards. You may need to contact an administrator to grant additional permissions if necessary.
-- Data source conflicts: 
-After duplicating a dashboard, you might notice that some panels aren’t displaying data correctly. This issue is often related to data source conflicts. When duplicating, Grafana retains the original dashboard’s data sources. However, if the duplicated dashboard is moved to another environment or project, these data sources might not be available or may have different configurations. Always verify that the data sources for the new dashboard are correctly set up and accessible.
-- Performance issues: 
-Large or complex dashboards, especially those with multiple panels, data sources, and queries, might take a longer time to duplicate. In some cases, you may notice slow performance during the duplication process. Be patient and wait for the duplication to complete, especially in cloud environments where network latency may also contribute to delays. For better performance, consider simplifying dashboards by removing unused panels or optimizing queries.
-- Plugin compatibility: 
-Grafana allows the use of plugins to extend dashboard functionalities, such as adding custom panels or data visualizations. When duplicating a dashboard, if certain plugins are missing from the new instance of Grafana, some parts of the dashboard may not function as expected. To avoid this issue, verify that all required plugins are installed and enabled in your Grafana instance. If the duplicated dashboard relies on specific plugins, ensure that they are compatible with your Grafana version.
+- Permission errors:
+  One of the most common issues when attempting to duplicate a dashboard is a lack of permissions. In Grafana, users are often assigned roles with varying levels of access. If you encounter permission-related errors, ensure that your user account has the required rights to create and modify dashboards. You may need to contact an administrator to grant additional permissions if necessary.
+- Data source conflicts:
+  After duplicating a dashboard, you might notice that some panels aren’t displaying data correctly. This issue is often related to data source conflicts. When duplicating, Grafana retains the original dashboard’s data sources. However, if the duplicated dashboard is moved to another environment or project, these data sources might not be available or may have different configurations. Always verify that the data sources for the new dashboard are correctly set up and accessible.
+- Performance issues:
+  Large or complex dashboards, especially those with multiple panels, data sources, and queries, might take a longer time to duplicate. In some cases, you may notice slow performance during the duplication process. Be patient and wait for the duplication to complete, especially in cloud environments where network latency may also contribute to delays. For better performance, consider simplifying dashboards by removing unused panels or optimizing queries.
+- Plugin compatibility:
+  Grafana allows the use of plugins to extend dashboard functionalities, such as adding custom panels or data visualizations. When duplicating a dashboard, if certain plugins are missing from the new instance of Grafana, some parts of the dashboard may not function as expected. To avoid this issue, verify that all required plugins are installed and enabled in your Grafana instance. If the duplicated dashboard relies on specific plugins, ensure that they are compatible with your Grafana version.
 
 ## Enhancing Dashboard Management with SigNoz
 
@@ -342,7 +410,11 @@ SigNoz offers several key advantages that go beyond basic dashboarding:
 
 SigNoz enhances dashboard management by integrating metrics, traces, and logs into a unified platform, simplifying workflows and improving collaboration through version control. This streamlined observability tool makes monitoring more efficient, helping teams gain deeper insights. To learn more, check out SigNoz’s [dashboard features](https://signoz.io/dashboards) and [metrics capabilities](https://signoz.io/metrics-and-dashboards/).
 
-<Figure src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-image.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+<Figure
+  src="/img/guides/2024/11/is-it-possible-to-duplicate-a-dashboard-in-grafana-image.webp"
+  alt="SigNoz Dashboard"
+  caption="SigNoz Dashboard"
+/>
 
 <GetStartedSigNoz />
 
@@ -385,4 +457,4 @@ Grafana doesn't impose strict limits on dashboard duplications. However, conside
 
 ### Can I schedule automatic dashboard duplications in Grafana?
 
-Grafana doesn't offer built-in scheduling for dashboard duplication. However, you can achieve this using the Grafana API and external scheduling tools like cron jobs or CI/CD pipelines.
\ No newline at end of file
+Grafana doesn't offer built-in scheduling for dashboard duplication. However, you can achieve this using the Grafana API and external scheduling tools like cron jobs or CI/CD pipelines.
diff --git a/data/guides/is-it-possible-to-use-grafana-without-prometheus.mdx b/data/guides/is-it-possible-to-use-grafana-without-prometheus.mdx
index a45ddf1ba..dab1ab94f 100644
--- a/data/guides/is-it-possible-to-use-grafana-without-prometheus.mdx
+++ b/data/guides/is-it-possible-to-use-grafana-without-prometheus.mdx
@@ -1,6 +1,5 @@
 ---
 title: Is It Possible to Use Grafana Without Prometheus? - Prometheus Monitoring
-slug: is-it-possible-to-use-grafana-without-prometheus
 date: 2024-07-02
 tags: [faq, prometheus]
 authors: [yuvraj]
@@ -17,101 +16,105 @@ keywords:
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Is It Possible to Use Grafana Without Prometheus? - Prometheus Monitoring",
-  "alternativeHeadline": "Exploring Grafana's versatility with various data sources like MySQL",
-  "author": {
-    "@type": "Person",
-    "name": "Yuvraj"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-02T00:00:00Z",
-  "dateModified": "2024-07-02T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/is-it-possible-to-use-grafana-without-prometheus/"
-  },
-  "description": "Discover how to use Grafana without Prometheus by exploring its versatility with various data sources like MySQL. Learn the benefits, setup process, and practical applications in this comprehensive guide.",
-  "keywords": "Grafana without Prometheus, Grafana MySQL setup, Grafana data sources, Grafana visualization, Grafana monitoring, MySQL Grafana integration",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Grafana",
-      "description": "An open-source platform for monitoring and observability"
-    },
-    {
-      "@type": "Thing",
-      "name": "MySQL",
-      "description": "An open-source relational database management system"
-    },
-    {
-      "@type": "Thing",
-      "name": "Data Visualization",
-      "description": "The graphical representation of information and data"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Prometheus",
-      "applicationCategory": "Monitoring system & time series database"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "InfluxDB",
-      "applicationCategory": "Time series database"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Elasticsearch",
-      "applicationCategory": "Search and analytics engine"
-    }
-  ],
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "Setting Up Grafana with MySQL",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install Grafana",
-        "text": "Download and install Grafana from the official website. Follow the installation instructions for your operating system."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Set Up MySQL and Create a Sample Database",
-        "text": "Install MySQL on your system if it's not already installed. Create a sample database and table for storing your data."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Grafana to Connect to MySQL",
-        "text": "Open Grafana in your browser, log in, navigate to Configuration > Data Sources, add MySQL as a data source, and enter the necessary connection details."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create a Simple Dashboard Using MySQL Data",
-        "text": "Navigate to Create > Dashboard, add a new panel, select your MySQL data source, write a simple SQL query to fetch data, and customize the visualization."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Is It Possible to Use Grafana Without Prometheus? - Prometheus Monitoring',
+        alternativeHeadline: "Exploring Grafana's versatility with various data sources like MySQL",
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-02T00:00:00Z',
+        dateModified: '2024-07-02T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/is-it-possible-to-use-grafana-without-prometheus/',
+        },
+        description:
+          'Discover how to use Grafana without Prometheus by exploring its versatility with various data sources like MySQL. Learn the benefits, setup process, and practical applications in this comprehensive guide.',
+        keywords:
+          'Grafana without Prometheus, Grafana MySQL setup, Grafana data sources, Grafana visualization, Grafana monitoring, MySQL Grafana integration',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Grafana',
+            description: 'An open-source platform for monitoring and observability',
+          },
+          {
+            '@type': 'Thing',
+            name: 'MySQL',
+            description: 'An open-source relational database management system',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Data Visualization',
+            description: 'The graphical representation of information and data',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring system & time series database',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'InfluxDB',
+            applicationCategory: 'Time series database',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Elasticsearch',
+            applicationCategory: 'Search and analytics engine',
+          },
+        ],
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Setting Up Grafana with MySQL',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Grafana',
+              text: 'Download and install Grafana from the official website. Follow the installation instructions for your operating system.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up MySQL and Create a Sample Database',
+              text: "Install MySQL on your system if it's not already installed. Create a sample database and table for storing your data.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Grafana to Connect to MySQL',
+              text: 'Open Grafana in your browser, log in, navigate to Configuration > Data Sources, add MySQL as a data source, and enter the necessary connection details.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Simple Dashboard Using MySQL Data',
+              text: 'Navigate to Create > Dashboard, add a new panel, select your MySQL data source, write a simple SQL query to fetch data, and customize the visualization.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
diff --git a/data/guides/is-opentelemetry-ready-for-production.mdx b/data/guides/is-opentelemetry-ready-for-production.mdx
index e222bb5c5..47154db46 100644
--- a/data/guides/is-opentelemetry-ready-for-production.mdx
+++ b/data/guides/is-opentelemetry-ready-for-production.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Is OpenTelemetry Production-Ready? A Practical Guide
-slug: is-opentelemetry-ready-for-production
 date: 2024-11-14
 tags: [opentelemetry, faq]
 authors: [niyati_thakkar]
 description: Discover if OpenTelemetry is production-ready with our comprehensive guide. Learn about its strengths, challenges, and best practices for implementation.
-keywords: [OpenTelemetry, observability, production readiness, telemetry data, cloud-native, monitoring, SigNoz]
-
+keywords:
+  [
+    OpenTelemetry,
+    observability,
+    production readiness,
+    telemetry data,
+    cloud-native,
+    monitoring,
+    SigNoz,
+  ]
 ---
 
 Observability is essential for monitoring and optimizing application performance. OpenTelemetry, an open-source framework for unified telemetry data collection, offers a standardized approach to gathering traces, metrics, and logs, making it a powerful tool for distributed systems. But the burning question remains: Is OpenTelemetry ready for production use? This comprehensive guide will help you navigate the current state of OpenTelemetry, assess its production readiness, and provide practical strategies for implementation.
@@ -41,7 +47,11 @@ As of 2023, many OpenTelemetry components have reached GA status, while others a
 
 OpenTelemetry is poised for further growth and innovation in 2024 and beyond. The project's focus on community-driven development, vendor-neutral standards, and a strong ecosystem of tools and integrations positions it as a leading solution for observability.
 
-<Figure src="/img/guides/2024/11/is-opentelemetry-ready-for-production-Ik1o6v_9Jp8D9jqNrmZjR.webp" alt="Opentelemetry Maturity Levels" caption="Opentelemetry Maturity Levels" />
+<Figure
+  src="/img/guides/2024/11/is-opentelemetry-ready-for-production-Ik1o6v_9Jp8D9jqNrmZjR.webp"
+  alt="Opentelemetry Maturity Levels"
+  caption="Opentelemetry Maturity Levels"
+/>
 
 ### Production-Ready Components
 
@@ -87,9 +97,7 @@ Security
 - Data Privacy: OpenTelemetry offers configurable scrubbing of personally identifiable information (PII) and sensitive data, making it suitable for industries with strict privacy requirements, such as healthcare.
 - Authentication: The OpenTelemetry Collector integrates with security protocols like TLS and mTLS, enabling secure data transmission across environments. This is particularly important in highly regulated environments.
 - Regular Security Audits: Regular security reviews are conducted as part of the Cloud Native Computing Foundation (CNCF)'s practices, which adds reliability and helps identify vulnerabilities early.
-    
-    Note: CNCF is a non-profit foundation dedicated to fostering the adoption and growth of cloud-native computing.
-    
+  Note: CNCF is a non-profit foundation dedicated to fostering the adoption and growth of cloud-native computing.
 
 Documentation and Community Support
 
@@ -111,16 +119,16 @@ These case studies demonstrate OpenTelemetry's viability in large-scale, product
 
 OpenTelemetry stands out for its open-source, vendor-neutral flexibility, making it ideal for custom and distributed environments. While still maturing in some areas, it reduces vendor lock-in compared to proprietary, full-stack alternatives like Datadog and New Relic, which are mature but more restrictive in customization.
 
-| Feature | OpenTelemetry | Datadog | New Relic | Prometheus |
-| --- | --- | --- | --- | --- |
-| Deployment Model | Open-source, vendor-neutral | Proprietary, SaaS | Proprietary, SaaS & hybrid | Open-source |
-| Cost | Free, community-supported | Paid subscription | Paid subscription | Free, community-supported |
-| Customization | Highly customizable | Limited (vendor-managed) | Limited (vendor-managed) | Moderate (requires setup) |
-| Component Maturity | Tracing (GA), Metrics (Beta), Logs (Alpha) | Fully mature | Fully mature | Primarily Metrics (GA) |
-| Community Support | Strong, CNCF and open-source contributors | Strong, vendor-based | Strong, vendor-based | Strong, CNCF and community-based |
-| Security | Flexible; custom data privacy controls | Built-in security features | Built-in security features | Flexible; customizable |
-| Use Cases | Distributed tracing, cloud-native apps | Full-stack observability | Application and infrastructure monitoring | Primarily metrics |
-| Vendor Lock-in | None | Yes | Yes | None |
+| Feature            | OpenTelemetry                              | Datadog                    | New Relic                                 | Prometheus                       |
+| ------------------ | ------------------------------------------ | -------------------------- | ----------------------------------------- | -------------------------------- |
+| Deployment Model   | Open-source, vendor-neutral                | Proprietary, SaaS          | Proprietary, SaaS & hybrid                | Open-source                      |
+| Cost               | Free, community-supported                  | Paid subscription          | Paid subscription                         | Free, community-supported        |
+| Customization      | Highly customizable                        | Limited (vendor-managed)   | Limited (vendor-managed)                  | Moderate (requires setup)        |
+| Component Maturity | Tracing (GA), Metrics (Beta), Logs (Alpha) | Fully mature               | Fully mature                              | Primarily Metrics (GA)           |
+| Community Support  | Strong, CNCF and open-source contributors  | Strong, vendor-based       | Strong, vendor-based                      | Strong, CNCF and community-based |
+| Security           | Flexible; custom data privacy controls     | Built-in security features | Built-in security features                | Flexible; customizable           |
+| Use Cases          | Distributed tracing, cloud-native apps     | Full-stack observability   | Application and infrastructure monitoring | Primarily metrics                |
+| Vendor Lock-in     | None                                       | Yes                        | Yes                                       | None                             |
 
 ### Strengths of OpenTelemetry for Production Use
 
@@ -142,7 +150,11 @@ Potential for Reduced Operational Costs and Improved Interoperability:
 
 As an open-source solution, OpenTelemetry eliminates licensing costs associated with proprietary monitoring tools. Additionally, its cross-platform compatibility reduces the effort required to maintain and integrate with different observability systems. This translates to fewer resources spent on agent maintenance and easier onboarding for new team members. By adopting a standardized approach to telemetry, organizations can streamline their operations and reduce the time and effort required to manage their [observability infrastructure](https://signoz.io/blog/observability-tools/).
 
-<Figure src="/img/guides/2024/11/is-opentelemetry-ready-for-production-image.webp" alt="Strengths of OpenTelemetry" caption="Strengths of OpenTelemetry" />
+<Figure
+  src="/img/guides/2024/11/is-opentelemetry-ready-for-production-image.webp"
+  alt="Strengths of OpenTelemetry"
+  caption="Strengths of OpenTelemetry"
+/>
 
 ### Challenges and Considerations
 
@@ -182,17 +194,11 @@ To successfully adopt OpenTelemetry in your production environment, follow these
 Choose the right instrumentation approach for your needs:
 
 - Auto-Instrumentation: This approach is ideal when you need rapid deployment with minimal effort, especially when working with widely used frameworks. For example, in a Spring Boot application, OpenTelemetry’s Java agent enables auto-instrumentation for HTTP clients, database queries, and Spring itself, instantly capturing metrics and traces.
-    
-    Teams launching new microservices often find auto-instrumentation valuable as it quickly generates a comprehensive view of service interactions and dependencies, without touching the application code.
-    
+  Teams launching new microservices often find auto-instrumentation valuable as it quickly generates a comprehensive view of service interactions and dependencies, without touching the application code.
 - Manual Instrumentation: For cases requiring deeper insights into custom logic or business-critical operations, manual instrumentation is essential. In an e-commerce app, for instance, auto-instrumentation may track standard HTTP requests, but manual instrumentation shines when capturing specific events, such as “Add to Cart” or “Payment Processing.” Here, developers add custom spans and metrics to measure performance and track issues precisely where it counts.
-    
-    This approach is beneficial when monitoring high-value workflows, as it reveals bottlenecks and success rates at each stage, providing insights into potential customer drop-off points.
-    
+  This approach is beneficial when monitoring high-value workflows, as it reveals bottlenecks and success rates at each stage, providing insights into potential customer drop-off points.
 - Hybrid Approach: Many teams opt for a hybrid approach, combining auto and manual instrumentation to get the best of both worlds. For example, in a financial services app, auto-instrumentation covers common infrastructure like HTTP requests and database calls, while manual instrumentation focuses on critical transactions like "Loan Approval" or "Fund Transfer." This balance offers the efficiency of auto-instrumentation across the stack and detailed tracking for sensitive operations.
-    
-    For teams managing complex, multi-service environments, the hybrid approach enables both broad observability and deep insight into specific processes that are essential to business performance.
-    
+  For teams managing complex, multi-service environments, the hybrid approach enables both broad observability and deep insight into specific processes that are essential to business performance.
 
 Manual Instrumentation Tips:
 
@@ -223,13 +229,14 @@ You’ll also find detailed guides on integrating OpenTelemetry instrumentation
 
 ### SigNoz Cloud vs. Open Source
 
-| Feature | SigNoz Cloud | SigNoz Open-Source |
-| --- | --- | --- |
-| Deployment & Maintenance | Hosted by SigNoz; no setup or maintenance needed | Self-hosted; requires setup and ongoing maintenance |
-| Cost Structure | Pay-as-you-go, scalable without upfront costs | Free; costs are infrastructure and maintenance only |
-| Data Privacy & Control | Data hosted on SigNoz servers; may have compliance implications | Full control over data; ideal for strict privacy requirements |
-| Scaling & Performance | Automatic scaling managed by SigNoz | Requires manual scaling based on available resources |
-| Feature Updates & Support | Immediate access to new features with priority support | Manual updates; community support available |
+| Feature                   | SigNoz Cloud                                                    | SigNoz Open-Source                                            |
+| ------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------- |
+| Deployment & Maintenance  | Hosted by SigNoz; no setup or maintenance needed                | Self-hosted; requires setup and ongoing maintenance           |
+| Cost Structure            | Pay-as-you-go, scalable without upfront costs                   | Free; costs are infrastructure and maintenance only           |
+| Data Privacy & Control    | Data hosted on SigNoz servers; may have compliance implications | Full control over data; ideal for strict privacy requirements |
+| Scaling & Performance     | Automatic scaling managed by SigNoz                             | Requires manual scaling based on available resources          |
+| Feature Updates & Support | Immediate access to new features with priority support          | Manual updates; community support available                   |
+
 - SigNoz Cloud: Ideal for fast setup, minimal maintenance, and scalable infrastructure.
 - SigNoz Open-Source: Best for teams needing full control, customizable setups, and willing to manage infrastructure.
 
@@ -281,4 +288,4 @@ You can contribute to OpenTelemetry by:
 3. Participating in community discussions
 4. Sharing your OpenTelemetry adoption story
 
-Visit the OpenTelemetry website for detailed contribution guidelines.
\ No newline at end of file
+Visit the OpenTelemetry website for detailed contribution guidelines.
diff --git a/data/guides/is-prometheus-a-visualization-tool.mdx b/data/guides/is-prometheus-a-visualization-tool.mdx
index d151871c9..a616a6a73 100644
--- a/data/guides/is-prometheus-a-visualization-tool.mdx
+++ b/data/guides/is-prometheus-a-visualization-tool.mdx
@@ -1,164 +1,167 @@
 ---
-
 title: Is Prometheus a Visualization Tool?
-slug: is-prometheus-a-visualization-tool
 date: 2024-07-24
 tags: [faq]
 authors: [daniel]
 description: Prometheus provides basic visualization via its expression browser, which allows for ad hoc queries and….
-keywords: [prometheus,metrics,monitoring,visualization]
-
+keywords: [prometheus, metrics, monitoring, visualization]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Is Prometheus a Visualization Tool?",
-    "alternativeHeadline": "Understanding the Role of Prometheus in Monitoring and Visualization",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-24T00:00:00Z",
-    "dateModified": "2024-07-24T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/is-prometheus-a-visualization-tool/"
-    },
-    "description": "Prometheus provides basic visualization via its expression browser, which allows for ad hoc queries and basic graphing. For more comprehensive dashboards, dedicated visualization tools like Grafana or SigNoz are recommended.",
-    "keywords": "prometheus, metrics, monitoring, visualization",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The process of observing and checking the behavior and outputs of a system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Visualization",
-        "description": "The representation of data or metrics in a visual format, such as graphs or charts, to make analysis easier."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Is Prometheus a visualization tool?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus itself is not a visualization tool; it is a powerful monitoring and alerting toolkit. However, it includes basic built-in visualization capabilities for ad-hoc exploration and troubleshooting."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus excels at collecting metrics from various sources, including applications and systems. It stores these metrics as time-series data, making it well-suited for tracking trends, identifying anomalies, and generating alerts."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What are the limitations of Prometheus's built-in visualization?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus's built-in visualization is primarily for ad-hoc exploration and debugging. It lacks advanced features for creating complex visualizations and comprehensive dashboards."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Is Prometheus a Visualization Tool?',
+        alternativeHeadline: 'Understanding the Role of Prometheus in Monitoring and Visualization',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "When should you use a dedicated visualization tool?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "You should use a dedicated visualization tool for creating complex dashboards, advanced visualization types, collaboration, long-term data analysis, and integrating with other data sources for unified visualization."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What is SigNoz?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "SigNoz is an open-source observability platform that provides a comprehensive solution for monitoring applications and infrastructure. It combines metrics monitoring, [distributed tracing](https://signoz.io/blog/distributed-tracing/), and log management into a single, unified platform."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Use Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Prometheus",
-          "text": "Download and install Prometheus from the official website."
+        datePublished: '2024-07-24T00:00:00Z',
+        dateModified: '2024-07-24T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/is-prometheus-a-visualization-tool/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus",
-          "text": "Set up the Prometheus configuration file to define scrape targets and rules."
+        description:
+          'Prometheus provides basic visualization via its expression browser, which allows for ad hoc queries and basic graphing. For more comprehensive dashboards, dedicated visualization tools like Grafana or SigNoz are recommended.',
+        keywords: 'prometheus, metrics, monitoring, visualization',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus",
-          "text": "Run the Prometheus server to start collecting metrics."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The process of observing and checking the behavior and outputs of a system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Visualization',
+            description:
+              'The representation of data or metrics in a visual format, such as graphs or charts, to make analysis easier.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Is Prometheus a visualization tool?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus itself is not a visualization tool; it is a powerful monitoring and alerting toolkit. However, it includes basic built-in visualization capabilities for ad-hoc exploration and troubleshooting.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus excels at collecting metrics from various sources, including applications and systems. It stores these metrics as time-series data, making it well-suited for tracking trends, identifying anomalies, and generating alerts.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What are the limitations of Prometheus's built-in visualization?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Prometheus's built-in visualization is primarily for ad-hoc exploration and debugging. It lacks advanced features for creating complex visualizations and comprehensive dashboards.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'When should you use a dedicated visualization tool?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'You should use a dedicated visualization tool for creating complex dashboards, advanced visualization types, collaboration, long-term data analysis, and integrating with other data sources for unified visualization.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is SigNoz?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'SigNoz is an open-source observability platform that provides a comprehensive solution for monitoring applications and infrastructure. It combines metrics monitoring, [distributed tracing](https://signoz.io/blog/distributed-tracing/), and log management into a single, unified platform.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Up Alerting",
-          "text": "Integrate Prometheus with Alertmanager to manage alerts."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Prometheus',
+              text: 'Download and install Prometheus from the official website.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus',
+              text: 'Set up the Prometheus configuration file to define scrape targets and rules.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Start Prometheus',
+              text: 'Run the Prometheus server to start collecting metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Alerting',
+              text: 'Integrate Prometheus with Alertmanager to manage alerts.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize Metrics',
+              text: 'Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize Metrics",
-          "text": "Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus itself is not a visualization tool; it is a powerful monitoring and alerting toolkit. However, it does include basic built-in visualization capabilities, which are intended for ad-hoc exploration and troubleshooting rather than for creating comprehensive dashboards. To create rich, interactive dashboards and gain deeper insights from your metrics, you will typically use a dedicated visualization tool.
 
 ## What is Prometheus?
 
-Prometheus excels at collecting metrics from various sources, including applications, and systems. It stores these metrics as time-series data, making it well-suited for tracking trends, identifying anomalies, and generating alerts. 
+Prometheus excels at collecting metrics from various sources, including applications, and systems. It stores these metrics as time-series data, making it well-suited for tracking trends, identifying anomalies, and generating alerts.
 
 ## Prometheus's Built-In Visualization Tool
 
diff --git a/data/guides/is-prometheus-free-or-paid.mdx b/data/guides/is-prometheus-free-or-paid.mdx
index 2c583238f..695cb69f9 100644
--- a/data/guides/is-prometheus-free-or-paid.mdx
+++ b/data/guides/is-prometheus-free-or-paid.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: Is Prometheus Free? Understanding Pricing and Options
-slug: is-prometheus-free-or-paid
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [daniel]
 description: Discover if Prometheus is free or paid, explore pricing options, and learn how to choose the best monitoring solution for your needs.
-keywords: [Prometheus, monitoring, open-source, pricing, cloud-native, time series database, observability]
-
+keywords:
+  [Prometheus, monitoring, open-source, pricing, cloud-native, time series database, observability]
 ---
 
 Prometheus has become a cornerstone of modern monitoring solutions, but many wonder: [is Prometheus free](https://signoz.io/guides/is-prometheus-free-or-paid/#is-prometheus-free-or-paid) or paid? The short answer is that Prometheus core is free and open-source. However, the full picture is more nuanced, involving considerations of deployment, management, and additional services. This article delves into the pricing models of Prometheus, helping you understand the costs and options available for this powerful monitoring tool.
@@ -93,17 +91,17 @@ This analysis will help you determine the most cost-effective solution for your
 Whether you choose free or paid options, optimizing your Prometheus deployment can significantly reduce costs:
 
 1. **Efficient metric collection**:
-    - Use service discovery to automatically update targets.
-    - Implement proper labeling to reduce cardinality.
+   - Use service discovery to automatically update targets.
+   - Implement proper labeling to reduce cardinality.
 2. **Storage optimization**:
-    - Adjust retention periods based on actual needs.
-    - Use recording rules to pre-aggregate frequently accessed metrics.
+   - Adjust retention periods based on actual needs.
+   - Use recording rules to pre-aggregate frequently accessed metrics.
 3. **Infrastructure efficiency**:
-    - Leverage cloud-native integrations for better resource utilization.
-    - Use auto-scaling for Prometheus servers based on load.
+   - Leverage cloud-native integrations for better resource utilization.
+   - Use auto-scaling for Prometheus servers based on load.
 4. **Query optimization**:
-    - Optimize PromQL queries to reduce resource consumption.
-    - Use caching mechanisms for frequently accessed dashboards.
+   - Optimize PromQL queries to reduce resource consumption.
+   - Use caching mechanisms for frequently accessed dashboards.
 
 By implementing these strategies, you can maintain a robust monitoring system while keeping costs under control—regardless of whether you're using the free or paid version of Prometheus.
 
@@ -159,4 +157,4 @@ Free Prometheus users can access support through:
 - GitHub issues for bug reports and feature requests
 - Third-party books and online resources
 
-While these options can be comprehensive, they may lack the immediacy and personalized attention of paid support services.
\ No newline at end of file
+While these options can be comprehensive, they may lack the immediacy and personalized attention of paid support services.
diff --git a/data/guides/is-prometheus-monitoring-push-or-pull.mdx b/data/guides/is-prometheus-monitoring-push-or-pull.mdx
index 32550ab9a..1c10c79ae 100644
--- a/data/guides/is-prometheus-monitoring-push-or-pull.mdx
+++ b/data/guides/is-prometheus-monitoring-push-or-pull.mdx
@@ -1,125 +1,128 @@
 ---
-
 title: Is Prometheus Monitoring Push or Pull?
-slug: is-prometheus-monitoring-push-or-pull
 date: 2024-07-12
 tags: [faq, prometheus]
 authors: [daniel]
 description: Prometheus utilizes a pull-based monitoring model, where it retrieves metrics from predefined targets by scraping data from their exposed endpoints.
-keywords: [prometheus,monitoring,metrics]
-
+keywords: [prometheus, monitoring, metrics]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Is Prometheus Monitoring Push or Pull?",
-  "alternativeHeadline": "Understanding Prometheus' pull-based monitoring model and its push-based alternative",
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-12T00:00:00Z",
-  "dateModified": "2024-07-12T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/"
-  },
-  "description": "Prometheus utilizes a pull-based monitoring model, where it retrieves metrics from predefined targets by scraping data from their exposed endpoints.",
-  "keywords": "prometheus, monitoring, metrics",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source systems monitoring and alerting toolkit"
-    },
-    {
-      "@type": "Thing",
-      "name": "Pull-based Monitoring",
-      "description": "A monitoring approach where the monitoring system retrieves metrics from targets"
-    },
-    {
-      "@type": "Thing",
-      "name": "Push-based Monitoring",
-      "description": "A monitoring approach where targets send metrics to the monitoring system"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Prometheus",
-      "applicationCategory": "Monitoring Tool"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Pushgateway",
-      "applicationCategory": "Monitoring Component"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "Is Prometheus monitoring push or pull?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Prometheus primarily uses a pull-based monitoring model, where it retrieves metrics from configured targets by scraping their exposed endpoints. However, it can also support push-based monitoring through the use of the Pushgateway component."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How does pull-based monitoring work in Prometheus?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "In Prometheus' pull-based model, the Prometheus server regularly sends HTTP requests to specified endpoints of configured targets to collect metrics. These metrics are then stored in Prometheus' time series database for querying and analysis."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Can Prometheus do push-based monitoring?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, Prometheus can support push-based monitoring using the Pushgateway component. The Pushgateway allows short-lived jobs to push their metrics to an intermediary job, which Prometheus can then scrape."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the pros of pull-based monitoring?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Pull-based monitoring offers simplicity in setup, easy integration with service discovery mechanisms, reliability in detecting down targets, and fine-grained control over scrape intervals and metrics collection."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the cons of push-based monitoring?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Push-based monitoring can potentially lead to metric loss if the target is unavailable when Prometheus attempts to scrape, and it introduces dependency on external systems like the Pushgateway, which could become a single point of failure."
-        }
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Is Prometheus Monitoring Push or Pull?',
+        alternativeHeadline:
+          "Understanding Prometheus' pull-based monitoring model and its push-based alternative",
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-12T00:00:00Z',
+        dateModified: '2024-07-12T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/',
+        },
+        description:
+          'Prometheus utilizes a pull-based monitoring model, where it retrieves metrics from predefined targets by scraping data from their exposed endpoints.',
+        keywords: 'prometheus, monitoring, metrics',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description: 'An open-source systems monitoring and alerting toolkit',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Pull-based Monitoring',
+            description:
+              'A monitoring approach where the monitoring system retrieves metrics from targets',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Push-based Monitoring',
+            description:
+              'A monitoring approach where targets send metrics to the monitoring system',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Pushgateway',
+            applicationCategory: 'Monitoring Component',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Is Prometheus monitoring push or pull?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus primarily uses a pull-based monitoring model, where it retrieves metrics from configured targets by scraping their exposed endpoints. However, it can also support push-based monitoring through the use of the Pushgateway component.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does pull-based monitoring work in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "In Prometheus' pull-based model, the Prometheus server regularly sends HTTP requests to specified endpoints of configured targets to collect metrics. These metrics are then stored in Prometheus' time series database for querying and analysis.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Prometheus do push-based monitoring?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Prometheus can support push-based monitoring using the Pushgateway component. The Pushgateway allows short-lived jobs to push their metrics to an intermediary job, which Prometheus can then scrape.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the pros of pull-based monitoring?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Pull-based monitoring offers simplicity in setup, easy integration with service discovery mechanisms, reliability in detecting down targets, and fine-grained control over scrape intervals and metrics collection.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the cons of push-based monitoring?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Push-based monitoring can potentially lead to metric loss if the target is unavailable when Prometheus attempts to scrape, and it introduces dependency on external systems like the Pushgateway, which could become a single point of failure.',
+              },
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
@@ -127,9 +130,13 @@ Prometheus uses a pull-based model for monitoring. In this model, the Prometheus
 
 ## How Pull-Based Monitoring Works in Prometheus
 
-<Figure src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled.webp" alt="Prometheus architecture" caption="Prometheus architecture" />
+<Figure
+  src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled.webp"
+  alt="Prometheus architecture"
+  caption="Prometheus architecture"
+/>
 
-From the above architecture diagram, Prometheus scrapes or pulls metrics from the targets configured for it. Targets are the applications or services that expose metrics endpoints. 
+From the above architecture diagram, Prometheus scrapes or pulls metrics from the targets configured for it. Targets are the applications or services that expose metrics endpoints.
 
 Metrics endpoints are specific URLs exposed by applications or services where Prometheus can access the metrics data. These endpoints provide a standardized format of metrics that Prometheus can scrape and store. The metrics offer detailed insights into the performance, resource usage, and operational health of the applications or services.
 
@@ -139,14 +146,14 @@ Example of target configuration:
 
 ```yaml
 scrape_configs:
-  - job_name: 'prometheus' 
-    static_configs: 
+  - job_name: 'prometheus'
+    static_configs:
       - targets: ['prometheus:9090']
-      
+
   - job_name: 'cadvisor'
     scrape_interval: 5s
     static_configs:
-    - targets: ['cadvisor:8080']
+      - targets: ['cadvisor:8080']
 
   - job_name: 'mysqld_exporter'
     scrape_interval: 5s
@@ -166,15 +173,21 @@ The above [Prometheus configuration](https://signoz.io/guides/what-is-prometheus
 - mysqld_exporter: This exporter provides metrics about a running MySQL database server. Prometheus is configured to scrape metrics from mysqld_exporter (`mysqld_exporter:9104`) every 5 seconds.
 - node_exporter: This exporter provides hardware and operating system metrics from the host machine. Prometheus is configured to scrape metrics from node_exporter (`node-exporter:9100`) every 5 seconds.
 
-<Figure src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%201.webp" alt="Exposed metrics endpoint" caption="Exposed metrics endpoint" />
+<Figure
+  src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%201.webp"
+  alt="Exposed metrics endpoint"
+  caption="Exposed metrics endpoint"
+/>
 
-
-The above image shows the `/metrics` endpoint of the cAdvisor container at`:8000/metrics` which exposes metrics about containers on a system. Prometheus server initiates HTTP requests to the `/metrics` endpoints exposed by the applications or services being monitored. 
+The above image shows the `/metrics` endpoint of the cAdvisor container at`:8000/metrics` which exposes metrics about containers on a system. Prometheus server initiates HTTP requests to the `/metrics` endpoints exposed by the applications or services being monitored.
 
 In the Prometheus targets UI, you can see the targets being monitored, their current status, and details about the last scrape. This interface provides an overview of all configured scrape targets, indicating whether they are up or down, the last scrape duration, and any errors encountered during scraping.
 
-<Figure src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%202.webp" alt="Prometheus targets" caption="Prometheus targets" />
-
+<Figure
+  src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%202.webp"
+  alt="Prometheus targets"
+  caption="Prometheus targets"
+/>
 
 Once Prometheus pulls the metrics from the endpoints, it stores them in its time series database which can be queried for visualization and monitoring using the Prometheus web UI or a monitoring tool.
 
@@ -182,8 +195,11 @@ Once Prometheus pulls the metrics from the endpoints, it stores them in its time
 
 Yes, Prometheus can also do push-based monitoring using the Pushgateway. The <a href="https://github.com/prometheus/pushgateway" rel="noopener noreferrer nofollow" target="_blank">Prometheus Pushgateway</a> allows you to push time series from <a href="https://prometheus.io/docs/practices/pushing/" rel="noopener noreferrer nofollow" target="_blank">short-lived service-level batch jobs</a> to an intermediary job which Prometheus can scrape. This is useful for monitoring components that cannot be scraped.
 
-<Figure src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%203.webp" alt="Push-based monitoring" caption="Push-based monitoring" />
-
+<Figure
+  src="/img/guides/2024/07/is-prometheus-monitoring-push-or-pull-Untitled%203.webp"
+  alt="Push-based monitoring"
+  caption="Push-based monitoring"
+/>
 
 Example of using Pushgateway:
 
@@ -268,7 +284,7 @@ Knowing when to use the pull-based and push-based monitoring approach in Prometh
 
 ## Conclusion
 
-This guide outlines how Prometheus does pull-based monitoring as well as push-based monitoring. It also covers the pros and cons of each monitoring approach as well their use cases. 
+This guide outlines how Prometheus does pull-based monitoring as well as push-based monitoring. It also covers the pros and cons of each monitoring approach as well their use cases.
 
 Some Key takeaways include:
 
@@ -276,4 +292,3 @@ Some Key takeaways include:
 - Prometheus can do push-based monitoring through the Pushgateway.
 - The Pushgateway has certain limitations and should be used for scenarios where the component to be monitored cannot be scraped.
 - The pull-based monitoring approach is ideal for dynamic environments and long-lived services, while the push-based approach is ideal for short-lived or ephemeral jobs.
-
diff --git a/data/guides/is-there-a-way-to-have-a-moving-average-in-grafana.mdx b/data/guides/is-there-a-way-to-have-a-moving-average-in-grafana.mdx
index e184ee19c..5f175be2c 100644
--- a/data/guides/is-there-a-way-to-have-a-moving-average-in-grafana.mdx
+++ b/data/guides/is-there-a-way-to-have-a-moving-average-in-grafana.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Implement Moving Averages in Grafana Dashboards
-slug: is-there-a-way-to-have-a-moving-average-in-grafana
 date: 2024-10-22
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Learn how to implement moving averages in Grafana dashboards. This guide covers built-in features, transformations, and advanced techniques for data analysis.
-keywords: [Grafana, moving averages, data visualization, dashboards, time series analysis, data smoothing, trend analysis]
-
+keywords:
+  [
+    Grafana,
+    moving averages,
+    data visualization,
+    dashboards,
+    time series analysis,
+    data smoothing,
+    trend analysis,
+  ]
 ---
 
 Grafana dashboards offer powerful visualization capabilities for time series data, but can you effectively implement moving averages to smooth out fluctuations and identify trends? The answer is a resounding yes. Grafana provides multiple methods to calculate and display moving averages, enhancing your ability to analyze data patterns and make informed decisions. This comprehensive guide will walk you through the process of implementing moving averages in Grafana, from basic concepts to advanced techniques.
@@ -35,7 +41,7 @@ Moving averages are a valuable tool in Grafana dashboards, helping to reveal mea
 
 ### Common Use Cases for Moving Averages in Data Visualization
 
-Here are some common use cases where moving averages can enhance data insights:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
+Here are some common use cases where moving averages can enhance data insights:
 
 - IT Operations: Monitoring server response times or resource utilization
 - Finance: Analyzing stock prices or trading volumes
@@ -47,27 +53,32 @@ Here are some common use cases where moving averages can enhance data insights:
 Grafana offers native support for moving averages through its query language and built-in functions. Here's how to implement a simple moving average:
 
 1. Open your Grafana dashboard and edit the panel where you want to add a moving average.
-    
-    <Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image.webp" alt="Editing panels in Grafana Dashboard" caption="Editing panels in Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image.webp"
+     alt="Editing panels in Grafana Dashboard"
+     caption="Editing panels in Grafana Dashboard"
+   />
+
 2. In the query editor, use the `moving_average()` function. The basic syntax is:
-    
-    ```
-    moving_average(metric, windowSize)
-    ```
-    
-    Replace `metric` with your data source and `windowSize` with the number of data points to include in the average.
-    
-    For example, to calculate a 7-day moving average of daily sales:
-    
-    ```
-    moving_average(sales_daily, 7)
-    ```
-    
-    Note: 
-    
-    - The above query holds true only with InfluxDB as the data source, you can find the details in further sections for moving averages in other data sources.
-    - The moving average function needs to be used with the InfluxDB query to get the desired output, above example is just a part of it.
+
+   ```
+   moving_average(metric, windowSize)
+   ```
+
+   Replace `metric` with your data source and `windowSize` with the number of data points to include in the average.
+
+   For example, to calculate a 7-day moving average of daily sales:
+
+   ```
+   moving_average(sales_daily, 7)
+   ```
+
+   Note:
+
+   - The above query holds true only with InfluxDB as the data source, you can find the details in further sections for moving averages in other data sources.
+   - The moving average function needs to be used with the InfluxDB query to get the desired output, above example is just a part of it.
+
 3. Adjust the time range and refresh rate of your panel to ensure you have enough data points for meaningful averages.
 
 ### Best Practices for Optimizing Moving Average Performance in Grafana
@@ -92,13 +103,17 @@ Here's how you can implement a moving average in Prometheus:
 
 The `avg_over_time()` function calculates the average value of a time series over a specified window of time.
 
-Example: 5-minute moving average for HTTP requests 
+Example: 5-minute moving average for HTTP requests
 
 ```
 avg_over_time(rate(app_requests_total[1m])[5m:])
 ```
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%201.webp" alt="Moving average with Prometheus as data source" caption="Moving average with Prometheus as data source" />
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%201.webp"
+  alt="Moving average with Prometheus as data source"
+  caption="Moving average with Prometheus as data source"
+/>
 
 Limitations
 
@@ -112,9 +127,9 @@ InfluxDB provides native functions like `moving_average()` and `exponential_movi
 Simple Moving Average (SMA) in InfluxDB
 
 ```sql
-SELECT moving_average(mean("co"), 5) 
-FROM "airSensors" 
-WHERE time > now() - 1h 
+SELECT moving_average(mean("co"), 5)
+FROM "airSensors"
+WHERE time > now() - 1h
 GROUP BY time(1m)
 ```
 
@@ -126,14 +141,18 @@ Query Explanation:
 
 This smooths out fluctuations in CO levels, providing a clearer trend over time.
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%202.webp" alt="Moving Averages with InfluxDB in Grafana" caption="Moving Averages with InfluxDB in Grafana" />
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%202.webp"
+  alt="Moving Averages with InfluxDB in Grafana"
+  caption="Moving Averages with InfluxDB in Grafana"
+/>
 
 Exponential Moving Average (EMA) in InfluxDB
 
 ```sql
-SELECT exponential_moving_average(mean("co"), 10) 
-FROM "airSensors" 
-WHERE time > now() - 1h 
+SELECT exponential_moving_average(mean("co"), 10)
+FROM "airSensors"
+WHERE time > now() - 1h
 GROUP BY time(1m)
 ```
 
@@ -146,7 +165,11 @@ Query Explanation:
 
 This query will provide a smoother trend that gives more weight to recent data points, making it more sensitive to recent changes.
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%203.webp" alt="Exponential Moving Average (EMA) with InfluxDB in Grafana dashboard" caption="Exponential Moving Average (EMA) with InfluxDB in Grafana dashboard" />
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%203.webp"
+  alt="Exponential Moving Average (EMA) with InfluxDB in Grafana dashboard"
+  caption="Exponential Moving Average (EMA) with InfluxDB in Grafana dashboard"
+/>
 
 Weighted Moving Average (WMA)
 
@@ -160,7 +183,7 @@ Simple Moving Average (SMA) in MySQL
 
 In MySQL, functions like `moving_average()` and `exponential_moving_average()` are not in-built. You need to write complex SQL Queries to calculate them.
 
-Example: To calculate a 5-point moving average of the mean CO levels from the airSensors table in SQL, assuming the table has columns such as _value (representing CO levels), _time (timestamp), and sensor_id for identifying sensors, you can use a window function to compute the moving average over a rolling window of 5 points.
+Example: To calculate a 5-point moving average of the mean CO levels from the airSensors table in SQL, assuming the table has columns such as \_value (representing CO levels), \_time (timestamp), and sensor_id for identifying sensors, you can use a window function to compute the moving average over a rolling window of 5 points.
 
 ```sql
 SELECT
@@ -178,15 +201,19 @@ ORDER BY
 Query Explanation:
 
 - SELECT Clause:
-    - `_time`: Displays timestamps of measurements.
-    - `_value`: Shows carbon monoxide levels.
-    - `AVG(_value) OVER (...) AS moving_avg_co`: Calculates a 5-point moving average of `_value`.
+  - `_time`: Displays timestamps of measurements.
+  - `_value`: Shows carbon monoxide levels.
+  - `AVG(_value) OVER (...) AS moving_avg_co`: Calculates a 5-point moving average of `_value`.
 - Window Function - `AVG(_value) OVER (ORDER BY _time ROWS BETWEEN 4 PRECEDING AND CURRENT ROW)`: Computes the average of the current value and the four preceding values.
 - `FROM airSensors`: The data source is the `airSensors` table.
 - `WHERE _field = 'co'`: Filters results to include only carbon monoxide readings.
 - `ORDER BY _time`: Results are sorted chronologically.
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%204.webp" alt="Moving Averages with MySQL" caption="Moving Averages with MySQL" />
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%204.webp"
+  alt="Moving Averages with MySQL"
+  caption="Moving Averages with MySQL"
+/>
 
 Exponential Moving Average (EMA) in MySQL
 
@@ -228,51 +255,50 @@ LIMIT 1;  -- Only insert the first row for initialization
 Step 4: Calculate the EMA for Subsequent Values
 
 1. Use a Cursor for Iteration
-    
-    First, we need to define a procedure that handles EMA calculation using a cursor. This is a more efficient way to process row-by-row without reopening the temporary table.
-    
-    ```sql
-    DELIMITER //
-    
-    CREATE PROCEDURE CalculateEMA()
-    BEGIN
-        DECLARE done INT DEFAULT FALSE;
-        DECLARE current_time DATETIME;
-        DECLARE current_value FLOAT;
-        DECLARE current_ema FLOAT DEFAULT NULL;
-    
-        DECLARE cur CURSOR FOR
-            SELECT _time, _value FROM airSensors WHERE _field = 'co' ORDER BY _time;
-    
-        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
-    
-        OPEN cur;
-    
-        read_loop: LOOP
-            FETCH cur INTO current_time, current_value;
-            IF done THEN
-                LEAVE read_loop;
-            END IF;
-    
-            -- Calculate EMA
-            SET current_ema = IF(current_ema IS NULL, current_value, (@alpha * current_value + (1 - @alpha) * current_ema));
-    
-            -- Insert into temporary table
-            INSERT INTO temp_ema (_time, _value, ema) VALUES (current_time, current_value, current_ema);
-        END LOOP;
-    
-        CLOSE cur;
-    END //
-    
-    DELIMITER ;
-    ```
-    
+
+   First, we need to define a procedure that handles EMA calculation using a cursor. This is a more efficient way to process row-by-row without reopening the temporary table.
+
+   ```sql
+   DELIMITER //
+
+   CREATE PROCEDURE CalculateEMA()
+   BEGIN
+       DECLARE done INT DEFAULT FALSE;
+       DECLARE current_time DATETIME;
+       DECLARE current_value FLOAT;
+       DECLARE current_ema FLOAT DEFAULT NULL;
+
+       DECLARE cur CURSOR FOR
+           SELECT _time, _value FROM airSensors WHERE _field = 'co' ORDER BY _time;
+
+       DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
+
+       OPEN cur;
+
+       read_loop: LOOP
+           FETCH cur INTO current_time, current_value;
+           IF done THEN
+               LEAVE read_loop;
+           END IF;
+
+           -- Calculate EMA
+           SET current_ema = IF(current_ema IS NULL, current_value, (@alpha * current_value + (1 - @alpha) * current_ema));
+
+           -- Insert into temporary table
+           INSERT INTO temp_ema (_time, _value, ema) VALUES (current_time, current_value, current_ema);
+       END LOOP;
+
+       CLOSE cur;
+   END //
+
+   DELIMITER ;
+   ```
+
 2. Call the Procedure to Calculate EMA
-    
-    ```sql
-    CALL CalculateEMA()
-    ```
-    
+
+   ```sql
+   CALL CalculateEMA()
+   ```
 
 Step 5: Retrieve the Results
 
@@ -280,7 +306,11 @@ Step 5: Retrieve the Results
 SELECT * FROM temp_ema ORDER BY _time;
 ```
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%205.webp" alt="Exponential Moving Average (EMA) in MySQL" caption="Exponential Moving Average (EMA) in MySQL" />
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%205.webp"
+  alt="Exponential Moving Average (EMA) in MySQL"
+  caption="Exponential Moving Average (EMA) in MySQL"
+/>
 
 Limitations
 
@@ -297,19 +327,19 @@ Limitations
 
 To make your moving average visualizations more effective:
 
-1. Select appropriate chart types: 
-    
-    Line charts work well for most moving averages, while area charts can highlight the difference between raw data and smoothed trends.
-    
+1. Select appropriate chart types:
+
+   Line charts work well for most moving averages, while area charts can highlight the difference between raw data and smoothed trends.
+
 2. Adjust color schemes and line styles:
-    - Use contrasting colors for raw data and moving averages
-    - Make moving average lines thicker or dashed for easy differentiation
+   - Use contrasting colors for raw data and moving averages
+   - Make moving average lines thicker or dashed for easy differentiation
 3. Add annotations and alerts:
-    - Set up alerts when moving averages cross certain thresholds
-    - Use annotations to mark significant events that may impact trends
+   - Set up alerts when moving averages cross certain thresholds
+   - Use annotations to mark significant events that may impact trends
 4. Combine moving averages with other metrics:
-    - Display multiple moving averages with different time windows on the same graph
-    - Show volume or other related metrics below price charts for comprehensive analysis
+   - Display multiple moving averages with different time windows on the same graph
+   - Show volume or other related metrics below price charts for comprehensive analysis
 
 ## Enhancing Observability with SigNoz and Moving Averages
 
@@ -334,33 +364,37 @@ SigNoz provides built-in support for moving averages in its dashboards, allowing
 To take your moving average analysis to the next level:
 
 1. Implement dynamic time windows:
-    
-    Use variables in Grafana to allow users to adjust the moving average window size on the fly:
-    
-    ```
-    moving_average(metric, $window_size)
-    ```
-    
-    Note: The above query works only with InfluxDB as the data source. 
-    
+
+   Use variables in Grafana to allow users to adjust the moving average window size on the fly:
+
+   ```
+   moving_average(metric, $window_size)
+   ```
+
+   Note: The above query works only with InfluxDB as the data source.
+
 2. Combining Moving Averages with Statistical Functions:
-    
-    Grafana allows you to combine moving averages with other statistical functions. For example;
-    
-    You can calculate the moving average and analyze its variability by adding standard deviation. This can help you understand the volatility around the average values:
-    
-    ```arduino
-    SELECT moving_average(mean("co"), 5), stddev("co") 
-    FROM "airSensors" 
-    GROUP BY time(1m)
-    ```
-    
-    This query will return both the moving average of the `co` sensor data and the standard deviation over time. You can visualize both metrics on the same graph for comparison.
-    
-    <Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%206.webp" alt="Combining Moving Averages with Statistical Functions" caption="Combining Moving Averages with Statistical Functions" />
-    
+
+   Grafana allows you to combine moving averages with other statistical functions. For example;
+
+   You can calculate the moving average and analyze its variability by adding standard deviation. This can help you understand the volatility around the average values:
+
+   ```arduino
+   SELECT moving_average(mean("co"), 5), stddev("co")
+   FROM "airSensors"
+   GROUP BY time(1m)
+   ```
+
+   This query will return both the moving average of the `co` sensor data and the standard deviation over time. You can visualize both metrics on the same graph for comparison.
+
+   <Figure
+     src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%206.webp"
+     alt="Combining Moving Averages with Statistical Functions"
+     caption="Combining Moving Averages with Statistical Functions"
+   />
+
 3. Create custom panels for specialized visualizations:
-Develop plugins that offer unique ways to display moving averages, such as ribbon charts or multi-timeframe overlays.
+   Develop plugins that offer unique ways to display moving averages, such as ribbon charts or multi-timeframe overlays.
 
 ## Key Takeaways
 
@@ -387,4 +421,8 @@ Simple moving averages (SMA) give equal weight to all data points in the window.
 
 Use Grafana's CSV export feature to download panel data, including moving averages. For more complex needs, consider using Grafana's API to programmatically extract data or integrate with external analysis tools.
 
-<Figure src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%207.webp" alt="Export Grafana moving average calculations for further analysis" caption="Export Grafana moving average calculations for further analysis" />
\ No newline at end of file
+<Figure
+  src="/img/guides/2024/10/is-there-a-way-to-have-a-moving-average-in-grafana-image%207.webp"
+  alt="Export Grafana moving average calculations for further analysis"
+  caption="Export Grafana moving average calculations for further analysis"
+/>
diff --git a/data/guides/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus.mdx b/data/guides/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus.mdx
index 9becc972a..6b821d1de 100644
--- a/data/guides/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus.mdx
+++ b/data/guides/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to Monitor Kubernetes CronJobs with Prometheus - A Guide
-slug: is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus
 date: 2024-11-29
 tags: [prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to monitor Kubernetes CronJobs using Prometheus with step-by-step setup, best practices, and advanced monitoring techniques.
-keywords: [kubernetes cronjobs, prometheus monitoring, kubernetes monitoring, cronjob metrics, prometheus setup, kubernetes observability]
-
+keywords:
+  [
+    kubernetes cronjobs,
+    prometheus monitoring,
+    kubernetes monitoring,
+    cronjob metrics,
+    prometheus setup,
+    kubernetes observability,
+  ]
 ---
 
 Monitoring Kubernetes CronJobs can be challenging because they execute at scheduled times and often lack persistent metrics for Prometheus to scrape reliably. However, tools like the PushGateway, combined with custom metrics and effective configuration, can enable Prometheus to monitor these jobs effectively.
@@ -41,25 +46,29 @@ To monitor Kubernetes CronJobs effectively, you need to configure Prometheus to
 
 The monitoring setup:
 
-<Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image.webp" alt="Setting Up Prometheus for Kubernetes CronJob Monitoring" caption="Setting Up Prometheus for Kubernetes CronJob Monitoring" />
+<Figure
+  src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image.webp"
+  alt="Setting Up Prometheus for Kubernetes CronJob Monitoring"
+  caption="Setting Up Prometheus for Kubernetes CronJob Monitoring"
+/>
 
 ### Prerequisites for Prometheus Setup
 
 - Kubernetes Cluster: Ensure you have a running Kubernetes cluster.
 - Helm Installed: Helm is useful for installing and managing Prometheus in Kubernetes.
 - Prometheus and PushGateway: Install Prometheus and PushGateway. They can be installed using Helm or other tools, as long as they are configured to communicate within the cluster.
-    
-    ```sql
-    helm install prometheus prometheus-community/kube-prometheus-stack 
-    helm install pushgateway prometheus-community/prometheus-pushgateway
-    ```
-    
-    Verify the installation using the command `kubectl get pods`.
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%201.webp" alt="Prometheus and PushGateway Installation Verification" caption="Prometheus and PushGateway Installation Verification" />
-    
-    The `-n monitoring` filters out the list of pods in the namespace name `monitoring`. 
-    
+  ```sql
+  helm install prometheus prometheus-community/kube-prometheus-stack
+  helm install pushgateway prometheus-community/prometheus-pushgateway
+  ```
+  Verify the installation using the command `kubectl get pods`.
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%201.webp"
+    alt="Prometheus and PushGateway Installation Verification"
+    caption="Prometheus and PushGateway Installation Verification"
+  />
+  The `-n monitoring` filters out the list of pods in the namespace name `monitoring`.
 
 Note: By default, PushGateway exposes metrics at the `/metrics` endpoint, so you don’t need to specify this path explicitly in the Prometheus configuration. Prometheus will look for it automatically.
 
@@ -78,24 +87,24 @@ metadata:
   name: test-cronjob
   namespace: default
 spec:
-  schedule: "*/1 * * * *"  # Runs every 1 minute
+  schedule: '*/1 * * * *' # Runs every 1 minute
   jobTemplate:
     spec:
       template:
         spec:
           containers:
-          - name: test-cronjob
-            image: curlimages/curl:latest
-            args:
-              - /bin/sh
-              - -c
-              - |
-                echo "new: Pushing metrics to PushGateway"
-                # Push a simulated metric to the PushGateway
-                echo 'example_metric{job="test-cronjob"} 1' | curl --data-binary @- http://pushgateway-prometheus-pushgateway.monitoring.svc.cluster.local:9091/metrics/job/test_cronjob
-            env:
-              - name: PUSHGATEWAY_URL
-                value: "pushgateway-prometheus-pushgateway.monitoring.svc.cluster.local:9091"
+            - name: test-cronjob
+              image: curlimages/curl:latest
+              args:
+                - /bin/sh
+                - -c
+                - |
+                  echo "new: Pushing metrics to PushGateway"
+                  # Push a simulated metric to the PushGateway
+                  echo 'example_metric{job="test-cronjob"} 1' | curl --data-binary @- http://pushgateway-prometheus-pushgateway.monitoring.svc.cluster.local:9091/metrics/job/test_cronjob
+              env:
+                - name: PUSHGATEWAY_URL
+                  value: 'pushgateway-prometheus-pushgateway.monitoring.svc.cluster.local:9091'
           restartPolicy: OnFailure
 ```
 
@@ -111,7 +120,11 @@ This CronJob will attempt to push a metric named `example_metric` to PushGateway
 
 Check if your cronjob is configured properly by running the command `kubectl get jobs`:
 
-<Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%202.webp" alt="CronJob Running" caption="CronJob Running" />
+<Figure
+  src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%202.webp"
+  alt="CronJob Running"
+  caption="CronJob Running"
+/>
 
 ### 2. Create a Secret for Scraping Metrics from PushGateway
 
@@ -147,30 +160,38 @@ kubectl apply -f additional-scrape-configs.yaml
 The next step is to configure the Prometheus Custom Resource (CR) to reference this Secret, which will enable Prometheus to scrape metrics from PushGateway.
 
 1. Find the Prometheus Custom Resource in your cluster:
-    
-    ```bash
-    kubectl get prometheus -n monitoring
-    ```
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%203.webp" alt="Find the Prometheus Custom Resource" caption="Find the Prometheus Custom Resource" /> 
-    
+
+   ```bash
+   kubectl get prometheus -n monitoring
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%203.webp"
+     alt="Find the Prometheus Custom Resource"
+     caption="Find the Prometheus Custom Resource"
+   />{' '}
+
 2. Once you’ve identified the name of your Prometheus CR, edit it:
-    
-    ```bash
-    kubectl edit prometheus <your-prometheus-cr-name> -n monitoring
-    ```
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%204.webp" alt="Editing the Custom Resource" caption="Editing the Custom Resource" />
-    
+
+   ```bash
+   kubectl edit prometheus <your-prometheus-cr-name> -n monitoring
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%204.webp"
+     alt="Editing the Custom Resource"
+     caption="Editing the Custom Resource"
+   />
+
 3. In the `spec` section of the Prometheus CR, add a reference to the new Secret you just created:
-    
-    ```yaml
-    spec:
-      additionalScrapeConfigs:
-        name: additional-scrape-configs
-        key: additional-scrape-configs.yaml
-    ```
-    
+
+   ```yaml
+   spec:
+     additionalScrapeConfigs:
+       name: additional-scrape-configs
+       key: additional-scrape-configs.yaml
+   ```
+
 4. Save and exit the editor. The Prometheus Operator will automatically detect and apply the additional scrape configurations.
 
 Tip: The `/metrics` endpoint on PushGateway is the default for Prometheus to scrape metrics, so you don’t need additional configuration for the path unless you are using a custom endpoint.
@@ -182,7 +203,11 @@ To confirm that Prometheus is now scraping metrics from PushGateway, check the P
 1. Open the Prometheus UI in your browser.
 2. Go to Status > Targets and verify if the PushGateway target is listed and actively being scraped.
 
-<Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%205.webp" alt="Prometheus is scraping metrics from PushGateway" caption="Prometheus is scraping metrics from PushGateway" />
+<Figure
+  src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%205.webp"
+  alt="Prometheus is scraping metrics from PushGateway"
+  caption="Prometheus is scraping metrics from PushGateway"
+/>
 
 By completing these steps, Prometheus will now collect metrics from the PushGateway, allowing you to monitor your CronJob's metrics effectively.
 
@@ -205,11 +230,11 @@ spec:
     matchLabels:
       app: pushgateway
   endpoints:
-  - port: web
-    interval: 15s
+    - port: web
+      interval: 15s
   namespaceSelector:
     matchNames:
-    - monitoring
+      - monitoring
 ```
 
 - `selector.matchLabels`: Ensures that the ServiceMonitor matches the correct PushGateway service using its labels.
@@ -244,26 +269,26 @@ Label selection is crucial for ensuring that your [Prometheus metrics](https://s
 Steps to Define Label Selection:
 
 1. Job Names and Identifiers:
-    - Include a label for the CronJob name to uniquely identify each CronJob in your metrics.
-    - Example: `job_name="<your_cronjob_name>"`.
+   - Include a label for the CronJob name to uniquely identify each CronJob in your metrics.
+   - Example: `job_name="<your_cronjob_name>"`.
 2. Namespace:
-    - Add a label for the namespace in which the CronJob is running, especially if you’re managing multiple environments.
-    - Example: `namespace="<namespace>"`.
+   - Add a label for the namespace in which the CronJob is running, especially if you’re managing multiple environments.
+   - Example: `namespace="<namespace>"`.
 3. Status:
-    - Track job statuses such as `success` or `failure` with specific labels like `status="<success/failure>"`.
+   - Track job statuses such as `success` or `failure` with specific labels like `status="<success/failure>"`.
 4. Instance or Pod Information:
-    - For detailed monitoring, include pod name or instance as a label for identifying which pod is being monitored in case of failures or issues.
-    - Example: `instance="<pod_name>"`.
+   - For detailed monitoring, include pod name or instance as a label for identifying which pod is being monitored in case of failures or issues.
+   - Example: `instance="<pod_name>"`.
 5. Custom Labels:
-    - If needed, you can also use additional labels such as priority or job type to filter and aggregate your metrics more effectively based on your monitoring needs.
+   - If needed, you can also use additional labels such as priority or job type to filter and aggregate your metrics more effectively based on your monitoring needs.
 
 Example Label Definition:
 
 ```yaml
-job_name: "example-cronjob"
-namespace: "default"
-status: "success"
-instance: "example-cronjob-pod-1234"
+job_name: 'example-cronjob'
+namespace: 'default'
+status: 'success'
+instance: 'example-cronjob-pod-1234'
 ```
 
 ## Configuring Job Metrics
@@ -297,7 +322,7 @@ Example Metric for Job Duration:
 
 ```yaml
 # Job Duration Metric
-job_duration_seconds{job="example-cronjob"} 45.2  # CronJob took 45.2 seconds
+job_duration_seconds{job="example-cronjob"} 45.2 # CronJob took 45.2 seconds
 ```
 
 - job_duration_seconds: This metric captures the execution duration in seconds.
@@ -310,115 +335,114 @@ Note: You can add these metrics by updating the cronjob scripts.
 To stay informed of any issues with your CronJobs, set up alerting rules based on the metrics you’ve collected.
 
 1. Alert for CronJob Failures:
-    - An alert rule that fires when any CronJob fails more than a specified number of times within a given period.
-    
-    Example Alert Rule:
-    
-    ```yaml
-    groups:
-    - name: cronjob_alerts
-      rules:
-      - alert: CronJobFailed
-        expr: job_error{job_name="example-cronjob", status="failure"} > 3
-        for: 5m
-        labels:
-          severity: critical
-        annotations:
-          summary: "CronJob example-cronjob has failed 3 times in the last 5 minutes"
-    ```
-    
+
+   - An alert rule that fires when any CronJob fails more than a specified number of times within a given period.
+
+   Example Alert Rule:
+
+   ```yaml
+   groups:
+     - name: cronjob_alerts
+       rules:
+         - alert: CronJobFailed
+           expr: job_error{job_name="example-cronjob", status="failure"} > 3
+           for: 5m
+           labels:
+             severity: critical
+           annotations:
+             summary: 'CronJob example-cronjob has failed 3 times in the last 5 minutes'
+   ```
+
 2. Alert for Long-Running CronJobs:
-    - You can also set up an alert rule to notify you if a CronJob runs longer than expected.
-    
-    Example Alert Rule:
-    
-    ```yaml
-    groups:
-    - name: cronjob_alerts
-      rules:
-      - alert: CronJobDurationTooLong
-        expr: job_duration_seconds{job_name="example-cronjob", status="success"} > 300
-        for: 5m
-        labels:
-          severity: warning
-        annotations:
-          summary: "CronJob example-cronjob took longer than expected"
-    ```
-    
-    Note: The alert updates need to be added to the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file
-    
-    To verify if the alerts are firing:
-    
-    - Access Prometheus Alerting Page: Go to the Prometheus UI (`http://<prometheus-server>:9090/alerts`).
-    - Check Alerts: You should see the alerts like `CronJobFailed` and `CronJobDurationTooLong` if your simulated conditions met the threshold.
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%206.webp" alt="Configuring Alerting Rules for K8s CronJob" caption="Configuring Alerting Rules for K8s CronJob" /> 
-    
+
+   - You can also set up an alert rule to notify you if a CronJob runs longer than expected.
+
+   Example Alert Rule:
+
+   ```yaml
+   groups:
+     - name: cronjob_alerts
+       rules:
+         - alert: CronJobDurationTooLong
+           expr: job_duration_seconds{job_name="example-cronjob", status="success"} > 300
+           for: 5m
+           labels:
+             severity: warning
+           annotations:
+             summary: 'CronJob example-cronjob took longer than expected'
+   ```
+
+   Note: The alert updates need to be added to the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file
+
+   To verify if the alerts are firing:
+
+   - Access Prometheus Alerting Page: Go to the Prometheus UI (`http://<prometheus-server>:9090/alerts`).
+   - Check Alerts: You should see the alerts like `CronJobFailed` and `CronJobDurationTooLong` if your simulated conditions met the threshold.
+
+   <Figure
+     src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%206.webp"
+     alt="Configuring Alerting Rules for K8s CronJob"
+     caption="Configuring Alerting Rules for K8s CronJob"
+   />{' '}
 
 ## Implementing Monitoring Best Practices
 
 To ensure your CronJobs are properly monitored and perform efficiently, follow these best practices:
 
 - Using Custom [Metric Labels](https://signoz.io/guides/what-are-prometheus-labels/): Customize your metric labels for better granularity and filtering. For example, include labels like `job_name`, `status`, `environment`, and `schedule` to categorize CronJob executions and easily filter metrics in Prometheus or Grafana. This helps with better visibility and tracking of different job states (e.g., `job_success`, `job_failure`).
-    
-    Example:
-    
-    ```yaml
-    job_success{job="example-cronjob", status="success", environment="production"} 1
-    ```
-    
+  Example:
+  ```yaml
+  job_success{job="example-cronjob", status="success", environment="production"} 1
+  ```
 - Setting Up Meaningful Alerts: Configure alerts based on job failures, durations, or other key metrics. Set severity levels for alerts (e.g., `critical`, `warning`) and ensure that annotations provide context for troubleshooting. For example, alert when a job exceeds a set duration or fails more than a specified number of times.
-    
-    Example Alert for Failures:
-    
-    ```yaml
-    groups:
+  Example Alert for Failures:
+  ```yaml
+  groups:
     - name: cronjob_alerts
       rules:
-      - alert: CronJobFailed
-        expr: job_error{job_name="example-cronjob", status="failure"} > 3
-        for: 5m
-        labels:
-          severity: critical
-    ```
-    
+        - alert: CronJobFailed
+          expr: job_error{job_name="example-cronjob", status="failure"} > 3
+          for: 5m
+          labels:
+            severity: critical
+  ```
 - Handling Job Timeouts: Set reasonable timeouts for your CronJobs to prevent them from running indefinitely. If a job exceeds the time limit, consider aborting it to free up resources. Use Kubernetes' `timeoutSeconds` or implement timeouts within the job itself.
-    
-    Example Timeout in CronJob YAML:
-    
-    ```yaml
-    containers:
+  Example Timeout in CronJob YAML:
+  ```yaml
+  containers:
     - name: cronjob-container
       image: your-cronjob-image
       args:
-      - /bin/bash
-      - -c
-      - "timeout 300s your-script.sh"  # Timeout after 5 minutes
-    ```
-    
+        - /bin/bash
+        - -c
+        - 'timeout 300s your-script.sh' # Timeout after 5 minutes
+  ```
 - Implementing Retry Mechanisms: Use retries to handle temporary failures due to issues like resource contention or transient errors. Set a backoff policy for retries and a maximum retry limit to avoid infinite retry loops.
-    
-    Example Retry in CronJob YAML:
-    
-    ```yaml
-    restartPolicy: OnFailure
-    backoffLimit: 3  # Retry up to 3 times
-    ```
-    
+  Example Retry in CronJob YAML:
+  ```yaml
+  restartPolicy: OnFailure
+  backoffLimit: 3 # Retry up to 3 times
+  ```
 
 ## Advanced Monitoring with SigNoz
 
-[SigNoz](https://signoz.io) is an open-source observability platform that provides comprehensive monitoring for your CronJobs. 
+[SigNoz](https://signoz.io) is an open-source observability platform that provides comprehensive monitoring for your CronJobs.
 
 - It helps track key performance metrics, such as job success rates, execution durations, and failure counts, all in real time.
 - SigNoz's ability to collect and visualize these [metrics in intuitive dashboards](https://signoz.io/metrics-and-dashboards/) allows you to quickly identify issues, optimize job performance, and ensure that your CronJobs run smoothly.
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%207.webp" alt="SigNoz: metrics and dashboards" caption="SigNoz: metrics and dashboards" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%207.webp"
+    alt="SigNoz: metrics and dashboards"
+    caption="SigNoz: metrics and dashboards"
+  />
 - With advanced [alerting capabilities](https://signoz.io/alerts-management/), SigNoz can notify you of critical failures or performance bottlenecks, making it an essential tool for [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and faster troubleshooting.
-    
-    <Figure src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%208.webp" alt="SigNoz: Alerting Capabilities" caption="SigNoz: Alerting Capabilities" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/is-there-a-way-to-monitor-kube-cron-jobs-using-prometheus-image%208.webp"
+    alt="SigNoz: Alerting Capabilities"
+    caption="SigNoz: Alerting Capabilities"
+  />
 
 <GetStartedSigNoz />
 
@@ -434,18 +458,18 @@ By utilizing SigNoz's cloud offering, built-in dashboards, and powerful alerting
 When building dashboards to monitor your CronJobs, it’s important to focus on essential metrics and organize them for clarity and usability.
 
 - Essential Metrics to Display:
-    - Job Success/Failure: Track the success and failure of CronJobs.
-    - Job Duration: Visualize the execution time to spot performance issues.
-    - Job Error Rate: Monitor failures over time to ensure system health.
+  - Job Success/Failure: Track the success and failure of CronJobs.
+  - Job Duration: Visualize the execution time to spot performance issues.
+  - Job Error Rate: Monitor failures over time to ensure system health.
 - Dashboard Organization Tips:
-    - Group related metrics, such as success rate and failure rate, in a single panel for easy comparison.
-    - Prioritize high-impact metrics like failure rates or long-running jobs at the top of the dashboard for immediate visibility.
+  - Group related metrics, such as success rate and failure rate, in a single panel for easy comparison.
+  - Prioritize high-impact metrics like failure rates or long-running jobs at the top of the dashboard for immediate visibility.
 - Visualization Best Practices:
-    - Use line graphs to show trends in job success and duration over time.
-    - Opt for heat maps or bar charts to highlight failure rates or anomalies.
+  - Use line graphs to show trends in job success and duration over time.
+  - Opt for heat maps or bar charts to highlight failure rates or anomalies.
 - Alert Correlation Setup:
-    - Link alerts to specific [dashboard panels](https://signoz.io/docs/userguide/manage-panels/) to make it easier to investigate issues immediately when an alert is triggered.
-    - Use annotations or color coding on graphs to highlight time periods when alerts were fired, aiding quicker troubleshooting.
+  - Link alerts to specific [dashboard panels](https://signoz.io/docs/userguide/manage-panels/) to make it easier to investigate issues immediately when an alert is triggered.
+  - Use annotations or color coding on graphs to highlight time periods when alerts were fired, aiding quicker troubleshooting.
 
 ## Key Takeaways
 
@@ -470,4 +494,4 @@ Yes, you can monitor multiple CronJobs using a single Prometheus configuration b
 
 ### What's the difference between push and pull metrics?
 
-[Push metrics](https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/) are sent by jobs to a collector like PushGateway, which is then scraped by Prometheus. In contrast, pull metrics are retrieved directly by Prometheus from endpoints at specified intervals, with Prometheus actively polling the targets.
\ No newline at end of file
+[Push metrics](https://signoz.io/guides/is-prometheus-monitoring-push-or-pull/) are sent by jobs to a collector like PushGateway, which is then scraped by Prometheus. In contrast, pull metrics are retrieved directly by Prometheus from endpoints at specified intervals, with Prometheus actively polling the targets.
diff --git a/data/guides/java-application-profiling.mdx b/data/guides/java-application-profiling.mdx
index 8cffb9d4e..bd5eca72f 100644
--- a/data/guides/java-application-profiling.mdx
+++ b/data/guides/java-application-profiling.mdx
@@ -1,13 +1,22 @@
 ---
-
 title: "The Developer's Guide to Java Profiling [Tools & Best Practices Included]"
-slug: "java-application-profiling"
-date: "2025-08-08"
+date: '2025-08-08'
 tags: [Performance Monitoring, Java]
 authors: [niyati_thakkar]
-description: "Master Java application profiling with our comprehensive guide covering 15+ tools, performance optimization techniques, memory analysis, and best practices for 2025. Learn how to identify and fix performance bottlenecks in your Java applications."
-keywords: [java profiling, performance optimization, memory analysis, CPU profiling, profiling tools, java performance monitoring, memory leak detection, thread profiling, application performance, java debugging]
-
+description: 'Master Java application profiling with our comprehensive guide covering 15+ tools, performance optimization techniques, memory analysis, and best practices for 2025. Learn how to identify and fix performance bottlenecks in your Java applications.'
+keywords:
+  [
+    java profiling,
+    performance optimization,
+    memory analysis,
+    CPU profiling,
+    profiling tools,
+    java performance monitoring,
+    memory leak detection,
+    thread profiling,
+    application performance,
+    java debugging,
+  ]
 ---
 
 Java applications can slow down for many reasons, such as memory leaks, inefficient algorithms, database bottlenecks, or thread contention. Often, these performance issues remain hidden until real production traffic hits and users begin to complain about slowness. Even experienced developers might spend days diagnosing the root cause of a slowdown without a systematic approach.
@@ -16,7 +25,7 @@ Profiling provides a solution. Instead of guessing where a problem lies, profili
 
 ## What is Java Application Profiling?
 
-Java application profiling is the process of measuring and analyzing a program's behavior and performance as it runs. In simpler terms, profiling tells you what your application *actually* does at runtime (and where it spends time or uses memory), rather than what the code *appears* to do. 
+Java application profiling is the process of measuring and analyzing a program's behavior and performance as it runs. In simpler terms, profiling tells you what your application _actually_ does at runtime (and where it spends time or uses memory), rather than what the code _appears_ to do.
 
 Profiling provides insights that can lead to improved responsiveness, reduced resource usage, and a better user experience. It is especially useful for identifying performance bottlenecks in large-scale applications, pinpointing memory leaks, analyzing thread contention issues, and understanding I/O bottlenecks.
 
@@ -24,9 +33,9 @@ Profiling provides insights that can lead to improved responsiveness, reduced re
 
 It's important to distinguish profiling from infrastructure monitoring and distributed tracing:
 
-* **[Infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/)** might tell you that your server's CPU usage is at 90%. **Profiling** goes deeper and tells you which specific Java method or operation is consuming that CPU time.
+- **[Infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/)** might tell you that your server's CPU usage is at 90%. **Profiling** goes deeper and tells you which specific Java method or operation is consuming that CPU time.
 
-* **[Distributed tracing](https://signoz.io/blog/distributed-tracing/)** might show that a certain request took 5 seconds as it traveled through various microservices. **Profiling** can reveal *why* it took 5 seconds by pinpointing the exact lines of code or database calls that consumed most of the time.
+- **[Distributed tracing](https://signoz.io/blog/distributed-tracing/)** might show that a certain request took 5 seconds as it traveled through various microservices. **Profiling** can reveal _why_ it took 5 seconds by pinpointing the exact lines of code or database calls that consumed most of the time.
 
 In essence, monitoring and tracing expose high-level symptoms at the system or service level, whereas profiling drills down to the code level root causes.
 
@@ -34,13 +43,13 @@ In essence, monitoring and tracing expose high-level symptoms at the system or s
 
 Performance issues in Java applications tend to fall into a few common categories:
 
-* **CPU bottlenecks**: One or a few methods consume an inordinate amount of processing time. Examples include a nested loop that inadvertently grows into O(n²) or O(n³) complexity, or heavy computation that isn't optimized.
+- **CPU bottlenecks**: One or a few methods consume an inordinate amount of processing time. Examples include a nested loop that inadvertently grows into O(n²) or O(n³) complexity, or heavy computation that isn't optimized.
 
-* **Memory issues**: These manifest as high memory usage or **OutOfMemoryError** crashes. Causes include objects accumulating faster than garbage collection can reclaim them, static collections that grow indefinitely (memory leaks), or improper heap usage causing frequent garbage collection pauses.
+- **Memory issues**: These manifest as high memory usage or **OutOfMemoryError** crashes. Causes include objects accumulating faster than garbage collection can reclaim them, static collections that grow indefinitely (memory leaks), or improper heap usage causing frequent garbage collection pauses.
 
-* **Concurrency problems**: Issues in multi-threaded code can degrade performance significantly. Common problems are threads waiting on locks (leading to thread contention), deadlocks, or thread pools misconfigured for the workload.
+- **Concurrency problems**: Issues in multi-threaded code can degrade performance significantly. Common problems are threads waiting on locks (leading to thread contention), deadlocks, or thread pools misconfigured for the workload.
 
-* **I/O delays**: Input/Output operations (database queries, file reads/writes, network calls) are much slower than in-memory operations. Performance problems arise from things like database queries that are not optimized (missing indexes or using N+1 query patterns), or performing blocking network calls in a tight loop.
+- **I/O delays**: Input/Output operations (database queries, file reads/writes, network calls) are much slower than in-memory operations. Performance problems arise from things like database queries that are not optimized (missing indexes or using N+1 query patterns), or performing blocking network calls in a tight loop.
 
 Remember that performance bugs are as critical as functional bugs—they may not throw exceptions, but they hurt the user experience and, in the worst cases, can bring down systems. Performance issues often take longer to surface (usually under high load or large data volumes) and can be harder to reproduce, which is why a proactive approach with profiling is important.
 
@@ -52,38 +61,42 @@ There are many Java profiling tools available, but a handful of tried-and-true t
 
 Before exploring external profilers, it’s wise to start with the tools that come bundled with the JDK. They cost nothing extra and are readily available in any Java environment:
 
-* **Java Flight Recorder (JFR)** – Now included for free in OpenJDK (since Java 11). It runs with very low overhead (often less than 2%) even in production. JFR can record CPU samples, memory allocations, garbage collection events, thread states, and more.
+- **Java Flight Recorder (JFR)** – Now included for free in OpenJDK (since Java 11). It runs with very low overhead (often less than 2%) even in production. JFR can record CPU samples, memory allocations, garbage collection events, thread states, and more.
 
-    For example, you can start a flight recording on a running application with:
+  For example, you can start a flight recording on a running application with:
 
-    ```bash
-    # Start recording on a running Java application for 60 seconds
-    java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=myapp.jfr MyApplication
+  ```bash
+  # Start recording on a running Java application for 60 seconds
+  java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=myapp.jfr MyApplication
 
-    # Alternatively, attach to an already running process by PID
-    jcmd <pid> JFR.start duration=60s filename=recording.jfr
-    ```
+  # Alternatively, attach to an already running process by PID
+  jcmd <pid> JFR.start duration=60s filename=recording.jfr
+  ```
 
-* **JDK command-line tools** – The JDK provides several command-line utilities that can be invaluable for quick profiling and troubleshooting:
+- **JDK command-line tools** – The JDK provides several command-line utilities that can be invaluable for quick profiling and troubleshooting:
 
+  ```bash
+  jconsole                # GUI to monitor JVM performance
+  jmap -histo <pid>       # Prints heap object usage histogram
+  jstack <pid>            # Dumps all thread stacks (find deadlocks)
+  jcmd <pid> GC.heap_info # Heap usage summary
+  ```
 
-    ```bash
-    jconsole                # GUI to monitor JVM performance
-    jmap -histo <pid>       # Prints heap object usage histogram
-    jstack <pid>            # Dumps all thread stacks (find deadlocks)
-    jcmd <pid> GC.heap_info # Heap usage summary
-    ```
-    These tools work anywhere you have a JVM running and require no setup. For instance, if you suspect a memory leak, jmap -histo can immediately show which object classes are occupying the most heap space. If your application seems hung, jstack can show if threads are stuck waiting on locks. Because they’re on-demand, you can use them in production as a first line of investigation with very low risk.
+  These tools work anywhere you have a JVM running and require no setup. For instance, if you suspect a memory leak, jmap -histo can immediately show which object classes are occupying the most heap space. If your application seems hung, jstack can show if threads are stuck waiting on locks. Because they’re on-demand, you can use them in production as a first line of investigation with very low risk.
 
 ### Open-Source Profilers
 
 There are several open-source profilers available that provide more advanced features or nicer interfaces on top of what the JDK offers:
 
-* **VisualVM** – Free profiling tool with an easy GUI for profiling local applications. Connect to a running JVM, hit "Profile", and see CPU usage, memory usage, thread activity, and more. Excellent for development and testing environments.
+- **VisualVM** – Free profiling tool with an easy GUI for profiling local applications. Connect to a running JVM, hit "Profile", and see CPU usage, memory usage, thread activity, and more. Excellent for development and testing environments.
 
-<Figure src="/img/guides/2024/09/java-application-profiling-Analyze_JVM_Memory_using_JVisual_VM___Memory_Leak___Heap__Thread_Dump___Profiling___Java_Techie_6-15_screenshot.webp" alt="Profiling in VisualVM" caption="Profiling in VisualVM" />
+<Figure
+  src="/img/guides/2024/09/java-application-profiling-Analyze_JVM_Memory_using_JVisual_VM___Memory_Leak___Heap__Thread_Dump___Profiling___Java_Techie_6-15_screenshot.webp"
+  alt="Profiling in VisualVM"
+  caption="Profiling in VisualVM"
+/>
 
-* **Async Profiler** – Low-overhead Java profiler specializing in CPU and memory profiling using sampling. Often used to generate *flame graphs* for CPU usage.
+- **Async Profiler** – Low-overhead Java profiler specializing in CPU and memory profiling using sampling. Often used to generate _flame graphs_ for CPU usage.
 
   ```bash
   ./profiler.sh -e cpu -d 30 -f flamegraph.html <pid>
@@ -91,13 +104,13 @@ There are several open-source profilers available that provide more advanced fea
 
   This runs a 30-second CPU profile and outputs an HTML [flame graph](https://signoz.io/blog/flamegraphs/). Ideal for production due to minimal overhead.
 
-* **Eclipse Memory Analyzer (MAT)** – Tool for analyzing heap dumps. When you suspect a memory leak, take a heap dump and open it in MAT. It has a "Leak Suspects" report that automatically points out likely memory leaks.
+- **Eclipse Memory Analyzer (MAT)** – Tool for analyzing heap dumps. When you suspect a memory leak, take a heap dump and open it in MAT. It has a "Leak Suspects" report that automatically points out likely memory leaks.
 
 ### Commercial Profilers
 
 There are also commercial profiling tools which come with additional features, integration, and support. Two of the most popular ones are:
 
-* **JProfiler** and **YourKit** – Comprehensive profilers with intuitive UIs, CPU call graphs, memory allocation hotspots, and IDE integration. Teams that regularly diagnose performance issues often find the cost justified by time saved. However, free tools are usually sufficient for occasional profiling.
+- **JProfiler** and **YourKit** – Comprehensive profilers with intuitive UIs, CPU call graphs, memory allocation hotspots, and IDE integration. Teams that regularly diagnose performance issues often find the cost justified by time saved. However, free tools are usually sufficient for occasional profiling.
 
 ## The Four Pillars of Java Application Profiling
 
@@ -111,23 +124,27 @@ CPU profiling focuses on which methods or operations consume the most CPU time.
 
 The most intuitive output is the **flame graph**. It visualizes the call stack vertically and time spent in each method horizontally. Wide blocks indicate hotspots consuming large fractions of CPU time.
 
-<Figure src="/img/guides/2024/09/java-application-profiling-image.webp" alt="Flame Graph to view CPU consumption for different methods" caption="Flame Graph to view CPU consumption for different methods" />
+<Figure
+  src="/img/guides/2024/09/java-application-profiling-image.webp"
+  alt="Flame Graph to view CPU consumption for different methods"
+  caption="Flame Graph to view CPU consumption for different methods"
+/>
 
 When interpreting a flame graph or profile report, look for:
 
-* **Wide blocks or high percentages**: These indicate hotspots that consume a large fraction of CPU time. If one function is, say, 40% of the total execution time, that’s an area to investigate for potential optimization.
+- **Wide blocks or high percentages**: These indicate hotspots that consume a large fraction of CPU time. If one function is, say, 40% of the total execution time, that’s an area to investigate for potential optimization.
 
-* **Repeated patterns**: If you see the same sequence of calls repeated many times in the profile, it might indicate an unnecessary repetition in the code (for example, doing an expensive operation inside a loop instead of once).
+- **Repeated patterns**: If you see the same sequence of calls repeated many times in the profile, it might indicate an unnecessary repetition in the code (for example, doing an expensive operation inside a loop instead of once).
 
-* **Deep call stacks**: A very deep stack in a profile might suggest that a lot of layers (or recursion) are involved in a computation. Sometimes simplifying the call stack (inlining logic or reducing recursion) can help performance.
+- **Deep call stacks**: A very deep stack in a profile might suggest that a lot of layers (or recursion) are involved in a computation. Sometimes simplifying the call stack (inlining logic or reducing recursion) can help performance.
 
-* **Methods that shouldn’t be hot**: Sometimes profiling reveals a surprise – a method that you thought was trivial is actually consuming a lot of time. This often leads to discovering a bug or an inefficiency (e.g., a library method being misused in a way that makes it expensive).
+- **Methods that shouldn’t be hot**: Sometimes profiling reveals a surprise – a method that you thought was trivial is actually consuming a lot of time. This often leads to discovering a bug or an inefficiency (e.g., a library method being misused in a way that makes it expensive).
 
 #### CPU Profiling Fixes
 
 Once a CPU hotspot is identified, how do we go about fixing it? The approach depends on what the hotspot is:
 
-* **Optimize the algorithm**: If profiling shows a method is slow because it’s doing too much work, see if the logic can be improved. For example, replace nested loops with a more efficient algorithm, or use a data structure that provides faster lookups. A classic case is replacing an O(n^2) search with a HashSet for O(n) or using a caching mechanism to avoid repeated calculations.
+- **Optimize the algorithm**: If profiling shows a method is slow because it’s doing too much work, see if the logic can be improved. For example, replace nested loops with a more efficient algorithm, or use a data structure that provides faster lookups. A classic case is replacing an O(n^2) search with a HashSet for O(n) or using a caching mechanism to avoid repeated calculations.
 
   ```java
   // Inefficient O(n * m) complexity:
@@ -152,10 +169,9 @@ Once a CPU hotspot is identified, how do we go about fixing it? The approach dep
   }
   ```
 
-* **Cache results**: Profiling might show a method that calculates something expensive is being called repeatedly with the same inputs. In such cases, caching can help. By storing the result of an expensive computation the first time and reusing it on subsequent calls, you trade memory for CPU time.
-
-* **Leverage JIT optimizations**: The Java Just-In-Time (JIT) compiler will optimize hot code at runtime. One nuance in profiling is that if you profile too early, you might catch methods before the JIT optimizes them. A best practice is to let the application “warm up” (execute for some time) before profiling, so that the hottest code paths are JIT-compiled. 
+- **Cache results**: Profiling might show a method that calculates something expensive is being called repeatedly with the same inputs. In such cases, caching can help. By storing the result of an expensive computation the first time and reusing it on subsequent calls, you trade memory for CPU time.
 
+- **Leverage JIT optimizations**: The Java Just-In-Time (JIT) compiler will optimize hot code at runtime. One nuance in profiling is that if you profile too early, you might catch methods before the JIT optimizes them. A best practice is to let the application “warm up” (execute for some time) before profiling, so that the hottest code paths are JIT-compiled.
 
 ### 2. Memory Profiling: Optimizing Heap Usage
 
@@ -165,13 +181,18 @@ Memory profiling deals with how your application uses the heap (the memory alloc
 
 A memory leak in Java doesn’t mean the same as in C (where memory is lost and cannot be freed due to missing free() calls). In Java, a “leak” usually means you still have references to objects that you don’t need, so the garbage collector can’t reclaim that memory. Over time, these unneeded objects pile up.
 
-<Figure src="/img/guides/2024/09/java-application-profiling-8c2f5751-1092-49a3-929e-ca8a64d68cfa.webp" caption="Graph demonstrating memory leak" alt="Graph demonstrating memory leak" />
+<Figure
+  src="/img/guides/2024/09/java-application-profiling-8c2f5751-1092-49a3-929e-ca8a64d68cfa.webp"
+  caption="Graph demonstrating memory leak"
+  alt="Graph demonstrating memory leak"
+/>
 
 To catch leaks:
-* Enable heap dump on OOM: `-XX:+HeapDumpOnOutOfMemoryError`
-* Trigger heap dumps manually: `jcmd <pid> GC.heap_dump filename.hprof`
-* Use Eclipse MAT's "Leak Suspects" report
-* Look for collections that keep growing
+
+- Enable heap dump on OOM: `-XX:+HeapDumpOnOutOfMemoryError`
+- Trigger heap dumps manually: `jcmd <pid> GC.heap_dump filename.hprof`
+- Use Eclipse MAT's "Leak Suspects" report
+- Look for collections that keep growing
 
 Once you identify a memory leak, the fix usually involves removing references to objects that should be garbage-collected.
 
@@ -180,9 +201,10 @@ Once you identify a memory leak, the fix usually involves removing references to
 Even when you don’t leak memory, creating a lot of objects can hurt performance because the JVM has to allocate and later garbage-collect those objects. Memory profiling can show the allocation rate (how quickly your program is creating new objects). If the allocation rate is extremely high, it means the GC will be working hard to collect short-lived objects.
 
 Ways to reduce allocations:
-* **Reuse objects**: Consider object pooling for frequently created objects
-* **Avoid object creation in loops**: Move creation outside when possible
-* **Use primitive types**: Prefer primitive arrays over `List<Integer>`
+
+- **Reuse objects**: Consider object pooling for frequently created objects
+- **Avoid object creation in loops**: Move creation outside when possible
+- **Use primitive types**: Prefer primitive arrays over `List<Integer>`
 
 Here’s a simple example of avoiding unnecessary string garbage:
 
@@ -205,20 +227,21 @@ In the above, many short-lived String objects would be created in the first vers
 Thread profiling examines how an application uses threads – crucial for understanding performance in a concurrent environment. If your application is multi-threaded (which most server applications are, by virtue of handling multiple requests, using thread pools, etc.), you need to ensure threads are running efficiently and not stepping on each other’s toes.
 
 Symptoms of issues include:
-* Application freezes under load (deadlocks or contention)
-* Low CPU but low throughput (threads idle or waiting)
+
+- Application freezes under load (deadlocks or contention)
+- Low CPU but low throughput (threads idle or waiting)
 
 #### Identifying Issues
 
 When suspecting a thread issue, the first step is to take a thread dump (using jstack or VisualVM’s thread viewer). A thread dump will list all threads, their states, and the locks they hold or are waiting for. Key things to look for:
 
-* **BLOCKED threads**: Waiting to acquire locks
-* **WAITING threads**: Waiting on conditions
-* **Deadlock detection**: Thread dumps explicitly highlight deadlocks
+- **BLOCKED threads**: Waiting to acquire locks
+- **WAITING threads**: Waiting on conditions
+- **Deadlock detection**: Thread dumps explicitly highlight deadlocks
 
 #### Resolving Contention
 
-* **Reduce lock scope**: Minimize work inside synchronized blocks:
+- **Reduce lock scope**: Minimize work inside synchronized blocks:
 
   ```java
   // Improved: limit lock scope
@@ -232,13 +255,12 @@ When suspecting a thread issue, the first step is to take a thread dump (using j
 
   By reducing what’s inside the synchronized block, other threads don’t have to wait as long.
 
-* **Use finer-grained locks or lock-free structures**: Sometimes a single lock is protecting too much (e.g., a global lock for all data). Using multiple locks for independent parts of data can allow more concurrency. Or use concurrent data structures from java.util.concurrent which handle synchronization internally and more efficiently (like ConcurrentHashMap, ConcurrentLinkedQueue, etc., which avoid locking the whole structure for many operations by using internal locks or non-blocking algorithms).
+- **Use finer-grained locks or lock-free structures**: Sometimes a single lock is protecting too much (e.g., a global lock for all data). Using multiple locks for independent parts of data can allow more concurrency. Or use concurrent data structures from java.util.concurrent which handle synchronization internally and more efficiently (like ConcurrentHashMap, ConcurrentLinkedQueue, etc., which avoid locking the whole structure for many operations by using internal locks or non-blocking algorithms).
 
-* **Thread pool tuning**: Thread pools are a common way to manage concurrency. But if the pool is too small, threads will be waiting for work, and if it’s too large, there will be contention for the limited number of threads. The ideal number of threads is roughly the number of CPU cores, plus a small buffer for I/O-bound tasks (where threads spend most of their time waiting).
-
-  * CPU-bound tasks: threads ≈ CPU cores
-  * I/O-bound tasks: threads ≈ cores × (1 + wait time/compute time)
+- **Thread pool tuning**: Thread pools are a common way to manage concurrency. But if the pool is too small, threads will be waiting for work, and if it’s too large, there will be contention for the limited number of threads. The ideal number of threads is roughly the number of CPU cores, plus a small buffer for I/O-bound tasks (where threads spend most of their time waiting).
 
+  - CPU-bound tasks: threads ≈ CPU cores
+  - I/O-bound tasks: threads ≈ cores × (1 + wait time/compute time)
 
 ### 4. I/O Profiling: Optimizing External Operations
 
@@ -246,26 +268,26 @@ I/O operations are often the slowest part of a Java application’s execution pr
 
 Signs of I/O issues include:
 
-* High response times even when CPU is mostly idle (the app is waiting on I/O).
-* Database CPU is high or queries are slow (could indicate inefficient SQL).
-* Lots of waiting threads for network or database calls (as seen in thread dumps in WAITING state on socket read, etc.).
-* Large spikes in latency correlated with certain operations (maybe when a big file is read or written).
+- High response times even when CPU is mostly idle (the app is waiting on I/O).
+- Database CPU is high or queries are slow (could indicate inefficient SQL).
+- Lots of waiting threads for network or database calls (as seen in thread dumps in WAITING state on socket read, etc.).
+- Large spikes in latency correlated with certain operations (maybe when a big file is read or written).
 
 #### Database Performance
 
 For applications using a database, the database is a common source of latency:
 
-* Enable query logging to find slow queries (in dev or with caution in production). Tools like p6spy or datasource-proxy can log all SQL statements executed and how long they took. By reviewing the logs, you might find one particular query that is called far too often or takes too long.
-* Look for [N+1 query](https://signoz.io/blog/N-1-query-distributed-tracing/) patterns (common in ORMs)
-* Check connection pool sizing
+- Enable query logging to find slow queries (in dev or with caution in production). Tools like p6spy or datasource-proxy can log all SQL statements executed and how long they took. By reviewing the logs, you might find one particular query that is called far too often or takes too long.
+- Look for [N+1 query](https://signoz.io/blog/N-1-query-distributed-tracing/) patterns (common in ORMs)
+- Check connection pool sizing
 
 #### Network and File I/O
 
 If your application calls external HTTP services (REST APIs, microservice calls, etc.), profiling might show those calls as hotspots:
 
-* Use timeouts on network calls. A very common mistake is not setting a timeout, meaning if the remote service hangs, your thread could hang indefinitely.
-* Use asynchronous or non-blocking I/O if appropriate (for example, using CompletableFuture with an async HTTP client) so that waiting on a slow network call doesn’t block an OS thread that could do other work.
-* Just like with database, look for repetitive patterns. Are you calling the same service repeatedly for data you could cache? Are you making calls in series that could be made in parallel?
+- Use timeouts on network calls. A very common mistake is not setting a timeout, meaning if the remote service hangs, your thread could hang indefinitely.
+- Use asynchronous or non-blocking I/O if appropriate (for example, using CompletableFuture with an async HTTP client) so that waiting on a slow network call doesn’t block an OS thread that could do other work.
+- Just like with database, look for repetitive patterns. Are you calling the same service repeatedly for data you could cache? Are you making calls in series that could be made in parallel?
 
 ## Modern Profiling Challenges (Cloud & Microservices)
 
@@ -282,9 +304,10 @@ Without tracing, you might profile Service A (where the issue was noticed) and f
 ### Container Considerations
 
 When running Java in containers:
-* The JVM needs to know it’s in a container with limited resources. Modern JVM versions (Java 11+) do this automatically by reading cgroup limits. But it’s good to explicitly set memory limits via options like -XX:MaxRAMPercentage to ensure the JVM doesn’t try to use more heap than the container allows.
-* Always use resource requests/limits in Kubernetes that match your profiling configuration. If you profile an app with 4 CPU cores and 8 GB RAM on your machine but deploy it with a 1 CPU, 1 GB limit, the performance characteristics will be very different.
-* Be aware of port/file sharing requirements for profiling tools
+
+- The JVM needs to know it’s in a container with limited resources. Modern JVM versions (Java 11+) do this automatically by reading cgroup limits. But it’s good to explicitly set memory limits via options like -XX:MaxRAMPercentage to ensure the JVM doesn’t try to use more heap than the container allows.
+- Always use resource requests/limits in Kubernetes that match your profiling configuration. If you profile an app with 4 CPU cores and 8 GB RAM on your machine but deploy it with a 1 CPU, 1 GB limit, the performance characteristics will be very different.
+- Be aware of port/file sharing requirements for profiling tools
 
 ### Continuous Profiling in Production
 
@@ -296,7 +319,6 @@ java -XX:StartFlightRecording=maxage=1h,settings=profile.jfc,name=ContinuousReco
 
 This keeps a rolling window of the last 1 hour of profiling data. If something goes wrong, you can dump the recording to analyze it. To minimize overhead, continuous profiling typically uses wide sampling intervals and only records high-level data. If a specific alert triggers (say latency goes above X), you might temporarily increase the profiling detail.
 
-
 ## Best Practices for Effective Profiling
 
 To wrap up, here are some best practices to integrate profiling into your development and maintenance process:
@@ -305,43 +327,43 @@ To wrap up, here are some best practices to integrate profiling into your develo
 
 Don't wait until your application is in production and users report issues to think about performance. It's much easier to catch and fix performance problems during development or testing:
 
-* **Include a basic performance test as part of your CI pipeline.** It could be as simple as starting the application, hitting a few key endpoints with a tool like Apache Bench or JMeter, and collecting a CPU/memory profile for 30 seconds. This can catch obvious regressions (e.g., a new change causing CPU to double for a specific action).
+- **Include a basic performance test as part of your CI pipeline.** It could be as simple as starting the application, hitting a few key endpoints with a tool like Apache Bench or JMeter, and collecting a CPU/memory profile for 30 seconds. This can catch obvious regressions (e.g., a new change causing CPU to double for a specific action).
 
-* **When developing a new feature, consider writing a benchmark test for its core algorithm using JMH (Java Microbenchmark Harness)** if it's computationally heavy. This way you can verify the algorithm's efficiency and compare different implementation approaches objectively.
+- **When developing a new feature, consider writing a benchmark test for its core algorithm using JMH (Java Microbenchmark Harness)** if it's computationally heavy. This way you can verify the algorithm's efficiency and compare different implementation approaches objectively.
 
-* **Run VisualVM or JProfiler on your app locally every so often,** even if nothing seems wrong, just to see if there are any unexpected hot spots or growing memory usage. You might discover a minor issue (like an inefficient loop) that isn't yet a problem but could worsen at scale.
+- **Run VisualVM or JProfiler on your app locally every so often,** even if nothing seems wrong, just to see if there are any unexpected hot spots or growing memory usage. You might discover a minor issue (like an inefficient loop) that isn't yet a problem but could worsen at scale.
 
 ### Set Realistic Performance Goals
 
 Have concrete, realistic goals for performance, based on requirements or user expectations:
 
-* **For example:** "P99 (99th percentile) response time for checkout should be < 500 ms under 1000 concurrent users" or "The service should handle 100 requests per second with < 70% CPU usage on 4 cores."
+- **For example:** "P99 (99th percentile) response time for checkout should be < 500 ms under 1000 concurrent users" or "The service should handle 100 requests per second with < 70% CPU usage on 4 cores."
 
-* **These goals help determine if you need to profile and optimize further.** If your current performance is far from the goal, you know you have work to do. Conversely, if you're already meeting targets with room to spare, you might focus optimization efforts elsewhere.
+- **These goals help determine if you need to profile and optimize further.** If your current performance is far from the goal, you know you have work to do. Conversely, if you're already meeting targets with room to spare, you might focus optimization efforts elsewhere.
 
-* **Having goals helps in making trade-off decisions.** You might not need to hyper-optimize a piece of code if it already meets the goal thresholds, allowing you to prioritize other features or improvements.
+- **Having goals helps in making trade-off decisions.** You might not need to hyper-optimize a piece of code if it already meets the goal thresholds, allowing you to prioritize other features or improvements.
 
 ### Make Performance Visible
 
 Integrate performance monitoring into your application dashboards so that you notice issues quickly:
 
-* **Track key metrics like request latency (p50, p95, p99), throughput, error rates,** as well as resource metrics like CPU, memory, and GC pause times. Tools like SigNoz (open-source), Prometheus/Grafana, or commercial APMs can help here.
+- **Track key metrics like request latency (p50, p95, p99), throughput, error rates,** as well as resource metrics like CPU, memory, and GC pause times. Tools like SigNoz (open-source), Prometheus/Grafana, or commercial APMs can help here.
 
-* **Set up alerts for abnormal conditions** (e.g., CPU stays above 90% for 5 minutes, or error rate > 1%). When an alert fires, it's an indicator to possibly profile to see what's happening.
+- **Set up alerts for abnormal conditions** (e.g., CPU stays above 90% for 5 minutes, or error rate > 1%). When an alert fires, it's an indicator to possibly profile to see what's happening.
 
-* **Share performance findings with your team.** If you fixed a performance issue, explain what it was (e.g., "We found a bottleneck in the OrderService where it was making N+1 DB calls. We batched those calls and brought the response time down from 3s to 300ms."). This builds a performance-aware culture and helps others learn from that experience.
+- **Share performance findings with your team.** If you fixed a performance issue, explain what it was (e.g., "We found a bottleneck in the OrderService where it was making N+1 DB calls. We batched those calls and brought the response time down from 3s to 300ms."). This builds a performance-aware culture and helps others learn from that experience.
 
 ### Know Your Tools (Before a Crisis)
 
 Become familiar with the profiling tools before you have an emergency:
 
-* **Practice taking thread dumps and heap dumps on a test application** so you know the commands by heart and can interpret the output confidently.
+- **Practice taking thread dumps and heap dumps on a test application** so you know the commands by heart and can interpret the output confidently.
 
-* **Try out JFR and open the recording in Mission Control** to see what kind of data you get and how to navigate the interface effectively.
+- **Try out JFR and open the recording in Mission Control** to see what kind of data you get and how to navigate the interface effectively.
 
-* **Generate a flame graph using Async Profiler on a simple app,** just so you know end-to-end how to do it when needed and can quickly spot patterns in the visualization.
+- **Generate a flame graph using Async Profiler on a simple app,** just so you know end-to-end how to do it when needed and can quickly spot patterns in the visualization.
 
-* **If using an APM like SigNoz, explore the dashboards and tracing** so you know where to look when something is off and how to correlate different types of data.
+- **If using an APM like SigNoz, explore the dashboards and tracing** so you know where to look when something is off and how to correlate different types of data.
 
 This way, when an issue arises at 3 AM, you're not trying to learn a new tool under pressure – you already have an idea of what to do and can focus on solving the problem rather than fighting with unfamiliar interfaces.
 
@@ -349,29 +371,29 @@ This way, when an issue arises at 3 AM, you're not trying to learn a new tool un
 
 There's no one-size-fits-all profiler. Use a combination of tools depending on the situation:
 
-* **If an issue is reported in production but hard to reproduce,** start with lightweight tools (JFR or Async Profiler) that you can safely run in production without significantly impacting performance.
+- **If an issue is reported in production but hard to reproduce,** start with lightweight tools (JFR or Async Profiler) that you can safely run in production without significantly impacting performance.
 
-* **If the issue is easily reproduced in a test or staging environment,** you can afford to use heavier tools (like JProfiler/YourKit or instrumentation mode) to get more detailed information about method-level performance.
+- **If the issue is easily reproduced in a test or staging environment,** you can afford to use heavier tools (like JProfiler/YourKit or instrumentation mode) to get more detailed information about method-level performance.
 
-* **Use thread dumps for locking issues, heap dumps for memory leaks, and CPU sampling for general slowness.** Each tool type excels at revealing different kinds of problems.
+- **Use thread dumps for locking issues, heap dumps for memory leaks, and CPU sampling for general slowness.** Each tool type excels at revealing different kinds of problems.
 
-* **Don't forget logs** – sometimes adding logging around a suspected slow operation can confirm if it's being called too often or taking too long. Logging complements profiling by providing context about when and why certain code paths are executed.
+- **Don't forget logs** – sometimes adding logging around a suspected slow operation can confirm if it's being called too often or taking too long. Logging complements profiling by providing context about when and why certain code paths are executed.
 
 ### Continuously Reassess
 
 After making optimizations, always re-profile to ensure the changes had the intended effect and didn't introduce new issues. Performance tuning can sometimes have unintended side effects, so verify the results under the same conditions. Also, as dependencies or usage patterns change (new versions of a library, or users start using a feature much more), the performance landscape can change. Periodic profiling (even when things seem fine) can catch issues early.
 
-
 ## Profiling with SigNoz (APM Integration)
 
 While profiling tools show you code-level details, an Application Performance Monitoring tool like SigNoz provides observability at the system and application level. SigNoz (a [unified observability](https://signoz.io/unified-observability/) tool with logs, metrics, and traces in a single pane) can work hand-in-hand with profiling:
 
-* **Performance dashboards**: Identify which service/endpoint has issues
-* **Distributed tracing**: Shows request timeline across services
-* **Database tracking**: Lists slow queries automatically
-* **Correlation**: Links logs, errors, and performance data
+- **Performance dashboards**: Identify which service/endpoint has issues
+- **Distributed tracing**: Shows request timeline across services
+- **Database tracking**: Lists slow queries automatically
+- **Correlation**: Links logs, errors, and performance data
 
 **Workflow example:**
+
 1. [SigNoz](https://signoz.io/docs/introduction/) alerts high latency on `/checkout` endpoint
 2. Trace shows time spent in `PaymentService`
 3. Profile PaymentService to find exact slow method
@@ -399,11 +421,11 @@ While profiling tools show you code-level details, an Application Performance Mo
 
 ### How often should I profile?
 
-* During development of complex features
-* In CI/CD performance tests
-* Before major releases
-* Continuously in production (if using low-overhead tools)
-* When issues are reported
+- During development of complex features
+- In CI/CD performance tests
+- Before major releases
+- Continuously in production (if using low-overhead tools)
+- When issues are reported
 
 ### Which tool should I start with?
 
@@ -411,12 +433,12 @@ Beginners: Start with **VisualVM** (graphical, easy). For production: Use **JFR*
 
 ### What metrics should I focus on?
 
-* **Slow application**: Response times, CPU usage, method execution times
-* **Memory issues**: Heap usage, GC frequency, object counts
-* **Hanging**: Thread states, blocked/waiting threads
-* **High CPU**: CPU profiles, flame graphs
-* **Database-heavy**: Query counts, query times
+- **Slow application**: Response times, CPU usage, method execution times
+- **Memory issues**: Heap usage, GC frequency, object counts
+- **Hanging**: Thread states, blocked/waiting threads
+- **High CPU**: CPU profiles, flame graphs
+- **Database-heavy**: Query counts, query times
 
 ---
 
-We hope this guide has helped demystify Java application profiling and provided a clear strategy to diagnose and fix performance issues. For more questions or to discuss specific challenges, join our [Slack community](https://signoz.io/slack/) or subscribe to our [SigNoz newsletter](https://newsletter.signoz.io/) for regular performance optimization tips.
\ No newline at end of file
+We hope this guide has helped demystify Java application profiling and provided a clear strategy to diagnose and fix performance issues. For more questions or to discuss specific challenges, join our [Slack community](https://signoz.io/slack/) or subscribe to our [SigNoz newsletter](https://newsletter.signoz.io/) for regular performance optimization tips.
diff --git a/data/guides/java-lang-classnotfoundexception-org-apache-logging-log4j-logger-after-updating-log4j-1-2-17-to-2-13-0.mdx b/data/guides/java-lang-classnotfoundexception-org-apache-logging-log4j-logger-after-updating-log4j-1-2-17-to-2-13-0.mdx
index 89eaf48f4..1beaee865 100644
--- a/data/guides/java-lang-classnotfoundexception-org-apache-logging-log4j-logger-after-updating-log4j-1-2-17-to-2-13-0.mdx
+++ b/data/guides/java-lang-classnotfoundexception-org-apache-logging-log4j-logger-after-updating-log4j-1-2-17-to-2-13-0.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to Fix Log4j ClassNotFoundException After Upgrade to 2.x
-slug: java-lang-classnotfoundexception-org-apache-logging-log4j-logger-after-updating-log4j-1-2-17-to-2-13-0
 date: 2024-10-03
 tags: [logging, faq]
 authors: [nilesh_sinha]
 description: Learn how to fix the Log4j ClassNotFoundException error when upgrading from 1.x to 2.x. Step-by-step guide to resolve dependency issues and update your code.
-keywords: [Log4j ClassNotFoundException, Log4j upgrade, Java logging, Error resolution, Dependency management, Log4j 2.x migration]
-
+keywords:
+  [
+    Log4j ClassNotFoundException,
+    Log4j upgrade,
+    Java logging,
+    Error resolution,
+    Dependency management,
+    Log4j 2.x migration,
+  ]
 ---
 
 Upgrading logging frameworks is a critical task for Java developers, but it often comes with unexpected challenges. One common issue that arises when moving from Log4j 1.x to 2.x is the `java.lang.ClassNotFoundException: org.apache.logging.log4j.Logger` error. This error can halt your application's functionality and disrupt your logging capabilities. In this comprehensive guide, we'll explore the root causes of this error and provide you with practical solutions to resolve it efficiently.
@@ -19,158 +24,125 @@ The `java.lang.ClassNotFoundException: org.apache.logging.log4j.Logger` error ty
 Common scenarios where this error surfaces include:
 
 - Incomplete dependency updates in your project's build file:
-    
-    It could be possible if you're upgrading to Log4j 2.x but haven't updated all related dependencies, the application may still look for Log4j 1.x classes.
-    
-    In Maven, here’s what it looks like in the case of incomplete dependency:
-    
-    ```xml
-    <!-- Incorrect or incomplete dependency configuration (still using Log4j 1.x) -->
-    <dependency>
-        <groupId>log4j</groupId>
-        <artifactId>log4j</artifactId>
-        <version>1.2.17</version>
-    </dependency>
-    
-    <!-- Missing Log4j 2.x API dependency -->
-    ```
-    
-    This is how you can fix it:
-    
-    ```xml
-    <dependency>
-        <groupId>org.apache.logging.log4j</groupId>
-        <artifactId>log4j-api</artifactId>
-        <version>2.17.1</version>
-    </dependency>
-    
-    <dependency>
-        <groupId>org.apache.logging.log4j</groupId>
-        <artifactId>log4j-core</artifactId>
-        <version>2.17.1</version>
-    </dependency>
-    ```
-    
-    For Gradle, add this to your `build.gradle`:
-    
-    ```groovy
-    dependencies {
-      implementation 'org.apache.logging.log4j:log4j-api:2.13.0'
-      implementation 'org.apache.logging.log4j:log4j-core:2.13.0'
-    }
-    ```
-    
+  It could be possible if you're upgrading to Log4j 2.x but haven't updated all related dependencies, the application may still look for Log4j 1.x classes.
+  In Maven, here’s what it looks like in the case of incomplete dependency:
+  ```xml
+  <!-- Incorrect or incomplete dependency configuration (still using Log4j 1.x) -->
+  <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+      <version>1.2.17</version>
+  </dependency>
+
+  <!-- Missing Log4j 2.x API dependency -->
+  ```
+  This is how you can fix it:
+  ```xml
+  <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <version>2.17.1</version>
+  </dependency>
+
+  <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <version>2.17.1</version>
+  </dependency>
+  ```
+  For Gradle, add this to your `build.gradle`:
+  ```groovy
+  dependencies {
+    implementation 'org.apache.logging.log4j:log4j-api:2.13.0'
+    implementation 'org.apache.logging.log4j:log4j-core:2.13.0'
+  }
+  ```
 - Mixing Log4j 1.x and 2.x dependencies:
-    
-    Mixing both Log4j 1.x and Log4j 2.x dependencies can lead to `ClassNotFoundException`, especially when Log4j 2.x classes like `org.apache.logging.log4j.Logger` are referenced, but Log4j 1.x dependencies are still in the classpath.
-    
-    ```xml
-    <!-- Log4j 1.x dependency still present, it should be removed when Log4j 2.x is in use -->
-    <dependency>
-        <groupId>log4j</groupId>
-        <artifactId>log4j</artifactId>
-        <version>1.2.17</version>
-    </dependency>
-    
-    <!-- Log4j 2.x API dependency -->
-    <dependency>
-        <groupId>org.apache.logging.log4j</groupId>
-        <artifactId>log4j-api</artifactId>
-        <version>2.17.1</version>
-    </dependency>
-    ```
-    
+  Mixing both Log4j 1.x and Log4j 2.x dependencies can lead to `ClassNotFoundException`, especially when Log4j 2.x classes like `org.apache.logging.log4j.Logger` are referenced, but Log4j 1.x dependencies are still in the classpath.
+  ```xml
+  <!-- Log4j 1.x dependency still present, it should be removed when Log4j 2.x is in use -->
+  <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+      <version>1.2.17</version>
+  </dependency>
+
+  <!-- Log4j 2.x API dependency -->
+  <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <version>2.17.1</version>
+  </dependency>
+  ```
 - Incorrect classpath configuration:
-    
-    If your classpath does not correctly point to the Log4j 2.x JARs, the `ClassNotFoundException` will occur even if the dependencies are specified in the build file.
-    
-    If youever come across `ClassNotFoundException`, the scenario could be due to the incorrect classpath as shown here:
-    
-    ```bash
-    java -cp /path/to/wrong/log4j1.jar:. MainClass
-    ```
-    
-    Fix: Correct the classpath to point to the Log4j 2.x JARs.
-    
-    ```bash
-    java -cp /path/to/log4j-api-2.17.1.jar:/path/to/log4j-core-2.17.1.jar:. MainClass
-    ```
-    
+  If your classpath does not correctly point to the Log4j 2.x JARs, the `ClassNotFoundException` will occur even if the dependencies are specified in the build file.
+  If youever come across `ClassNotFoundException`, the scenario could be due to the incorrect classpath as shown here:
+  ```bash
+  java -cp /path/to/wrong/log4j1.jar:. MainClass
+  ```
+  Fix: Correct the classpath to point to the Log4j 2.x JARs.
+  ```bash
+  java -cp /path/to/log4j-api-2.17.1.jar:/path/to/log4j-core-2.17.1.jar:. MainClass
+  ```
 - Outdated import statements in your Java code:
-If your project has upgraded to Log4j 2.x, but your code still imports Log4j 1.x classes, this will cause `ClassNotFoundException` when the application looks for Log4j 2.x classes at runtime.
-    
-    Here’s how your trouble would look like when the import statements are outdated:
-    
-    ```java
-    // Still using Log4j 1.x imports
-    import org.apache.log4j.Logger;
-    
-    public class MainClass {
-        private static final Logger logger = Logger.getLogger(MainClass.class);
-    
-        public static void main(String[] args) {
-            logger.info("Logging with Log4j 1.x");
-        }
-    }
-    ```
-    
-    The above code imports `org.apache.log4j.Logger`, which is from the Log4j 1.x package. This will only work if Log4j 1.x is included in the classpath.
-    
-    Fix: Update your import statements to use Log4j 2.x classes.
-    
-    ```java
-    // Use Log4j 2.x imports
-    import org.apache.logging.log4j.LogManager;
-    import org.apache.logging.log4j.Logger;
-    
-    public class MainClass {
-        private static final Logger logger = LogManager.getLogger(MainClass.class);
-    
-        public static void main(String[] args) {
-            logger.info("Logging with Log4j 2.x");
-        }
-    }
-    ```
-    
-    The corrected code imports `org.apache.logging.log4j.Logger`, which is from the Log4j 2.x package. This requires Log4j 2.x libraries in the classpath.
-    
+  If your project has upgraded to Log4j 2.x, but your code still imports Log4j 1.x classes, this will cause `ClassNotFoundException` when the application looks for Log4j 2.x classes at runtime.
+      Here’s how your trouble would look like when the import statements are outdated:
+
+      ```java
+      // Still using Log4j 1.x imports
+      import org.apache.log4j.Logger;
+
+      public class MainClass {
+          private static final Logger logger = Logger.getLogger(MainClass.class);
+
+          public static void main(String[] args) {
+              logger.info("Logging with Log4j 1.x");
+          }
+      }
+      ```
+
+      The above code imports `org.apache.log4j.Logger`, which is from the Log4j 1.x package. This will only work if Log4j 1.x is included in the classpath.
+
+      Fix: Update your import statements to use Log4j 2.x classes.
+
+      ```java
+      // Use Log4j 2.x imports
+      import org.apache.logging.log4j.LogManager;
+      import org.apache.logging.log4j.Logger;
+
+      public class MainClass {
+          private static final Logger logger = LogManager.getLogger(MainClass.class);
+
+          public static void main(String[] args) {
+              logger.info("Logging with Log4j 2.x");
+          }
+      }
+      ```
+
+      The corrected code imports `org.apache.logging.log4j.Logger`, which is from the Log4j 2.x package. This requires Log4j 2.x libraries in the classpath.
 
 The impact of this error can be severe, potentially preventing your application from starting or causing critical logging failures. To resolve this issue, you need to understand the key differences between Log4j 1.x and 2.x and make the necessary adjustments to your project configuration and code.
 
 ## Key Differences Between Log4j 1.x and 2.x
 
-Log4j 1.x is outdated and no longer maintained, which means it’s a sitting duck for security risks. After the whole Log4Shell fiasco, which caused major issues in Log4j 2.x, it became even clearer that sticking with older versions is risky. While Log4j 1.x wasn’t hit by Log4Shell directly, it’s still not getting any new security patches or features, leaving your app vulnerable. Upgrading to Log4j 2.x not only keeps you safe but also gives you better performance and modern logging features. 
+Log4j 1.x is outdated and no longer maintained, which means it’s a sitting duck for security risks. After the whole Log4Shell fiasco, which caused major issues in Log4j 2.x, it became even clearer that sticking with older versions is risky. While Log4j 1.x wasn’t hit by Log4Shell directly, it’s still not getting any new security patches or features, leaving your app vulnerable. Upgrading to Log4j 2.x not only keeps you safe but also gives you better performance and modern logging features.
 
 Log4j 2.x introduced significant changes compared to its predecessor. Now, the real question is why we need the change and not just stick with its predecessor. Let's have an overview of the major changes in Log4j 2.x and also consider the improvements that justify this upgrade.
 
 - API and Package Structure:
-    
-    Log4j 1.x uses `org.apache.log4j`, while Log4j 2.x uses `org.apache.logging.log4j`. This reflects a more modern and modular design in Log4j 2.x.
-    
+  Log4j 1.x uses `org.apache.log4j`, while Log4j 2.x uses `org.apache.logging.log4j`. This reflects a more modern and modular design in Log4j 2.x.
 - Asynchronous Logging:
-    
-    Log4j 2.x introduces asynchronous logging by default, using the LMAX Disruptor for high performance. This improves efficiency, especially in high-throughput applications.
-    
+  Log4j 2.x introduces asynchronous logging by default, using the LMAX Disruptor for high performance. This improves efficiency, especially in high-throughput applications.
 - Configuration Changes:
-    
-    Log4j 1.x uses `log4j.properties` or `log4j.xml` for configuration. Log4j 2.x supports configurations in `XML`, `JSON`, `YAML`, or `Properties` format, providing greater flexibility.
-    
+  Log4j 1.x uses `log4j.properties` or `log4j.xml` for configuration. Log4j 2.x supports configurations in `XML`, `JSON`, `YAML`, or `Properties` format, providing greater flexibility.
 - Better Performance:
-    
-    Log4j 2.x is built with performance in mind, especially in multi-threaded environments. Its asynchronous capabilities and efficient use of resources make it more suitable for modern applications.
-    
+  Log4j 2.x is built with performance in mind, especially in multi-threaded environments. Its asynchronous capabilities and efficient use of resources make it more suitable for modern applications.
 - Plugin System:
-    
-    Log4j 2.x has a plugin-based architecture, allowing developers to extend functionality easily (e.g., custom appenders or filters).
-    
+  Log4j 2.x has a plugin-based architecture, allowing developers to extend functionality easily (e.g., custom appenders or filters).
 - SLF4J Compatibility:
-    
-    Log4j 2.x provides better integration with SLF4J, a popular logging facade, by offering adapters that allow it to be used seamlessly with existing SLF4J-based projects.
-    
+  Log4j 2.x provides better integration with SLF4J, a popular logging facade, by offering adapters that allow it to be used seamlessly with existing SLF4J-based projects.
 - Garbage-Free Logging:
-    
-    Log4j 2.x is designed to be garbage-free (no object allocation) during normal operations, significantly reducing GC overhead in high-throughput systems.
-    
+  Log4j 2.x is designed to be garbage-free (no object allocation) during normal operations, significantly reducing GC overhead in high-throughput systems.
 
 ### Compatibility Issues When Migrating from Log4j 1.x to 2.x:
 
@@ -189,85 +161,69 @@ These changes justify the upgrade but also contribute to compatibility issues wh
 
 When dealing with legacy code that still uses Log4j 1.x, consider these strategies:
 
-1. Use the Log4j 1.x bridge:
-The Log4j 1.x bridge is a compatibility layer that allows old code written for Log4j 1.x to work with the newer Log4j 2.x framework. It acts like a translator, so you don’t have to rewrite all your logging code when upgrading to Log4j 2.x.
-    
-    Add the log4j-1.2-api dependency to maintain compatibility with older code.
-    
-    ```xml
-    <dependency>
-      <groupId>org.apache.logging.log4j</groupId>
-      <artifactId>log4j-1.2-api</artifactId>
-      <version>2.13.0</version>
-    </dependency>
-    ```
-    
-    The log4j-1.2-api dependency works as a bridge that mimics the Log4j 1.x API using Log4j 2.x under the hood. It intercepts calls from your old code that still uses Log4j 1.x classes and methods (like `org.apache.log4j.Logger`) and redirects them to Log4j 2.x
-    
-2. Gradually migrate your codebase:
-    
+1.  Use the Log4j 1.x bridge:
+    The Log4j 1.x bridge is a compatibility layer that allows old code written for Log4j 1.x to work with the newer Log4j 2.x framework. It acts like a translator, so you don’t have to rewrite all your logging code when upgrading to Log4j 2.x.
+        Add the log4j-1.2-api dependency to maintain compatibility with older code.
+
+        ```xml
+        <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-1.2-api</artifactId>
+          <version>2.13.0</version>
+        </dependency>
+        ```
+
+        The log4j-1.2-api dependency works as a bridge that mimics the Log4j 1.x API using Log4j 2.x under the hood. It intercepts calls from your old code that still uses Log4j 1.x classes and methods (like `org.apache.log4j.Logger`) and redirects them to Log4j 2.x
+2.  Gradually migrate your codebase:
+
     Identify modules or packages still using Log4j 1.x. Update them one at a time, starting with the least dependent modules. Use the bridge as a temporary solution while migrating.
-    
-3. Update third-party libraries:
-    
+
+3.  Update third-party libraries:
+
     Check for updates of libraries that depend on Log4j 1.x. If updates are not available, consider using the Log4j 1.x bridge or finding alternative libraries.
-    
 
 The log4j-1.2-api bridge allows legacy applications using Log4j 1.x APIs to run on Log4j 2.x without major code changes. This bridge mimics the Log4j 1.x API while using Log4j 2.x under the hood, ensuring compatibility with older code.
 
 1. Add the Bridge Dependency:
-    
-    Add log4j-1.2-api to your project to support old Log4j 1.x code.
-    
-    ```xml
-    <dependency>
-       <groupId>org.apache.logging.log4j</groupId>
-       <artifactId>log4j-1.2-api</artifactId>
-       <version>2.x.x</version>
-    </dependency>
-    ```
-    
+
+   Add log4j-1.2-api to your project to support old Log4j 1.x code.
+
+   ```xml
+   <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-1.2-api</artifactId>
+      <version>2.x.x</version>
+   </dependency>
+   ```
+
 2. Keep Using Log4j 1.x APIs:
-    
-    Your existing code (e.g., `Logger.getLogger()`) continues to work while running on the Log4j 2.x infrastructure.
-    
+
+   Your existing code (e.g., `Logger.getLogger()`) continues to work while running on the Log4j 2.x infrastructure.
+
 3. Gradual Migration:
-    
-    You can gradually refactor the code to use Log4j 2.x classes (`LogManager.getLogger()`), reducing technical debt over time.
-    
+
+   You can gradually refactor the code to use Log4j 2.x classes (`LogManager.getLogger()`), reducing technical debt over time.
 
 Identifying and updating third-party libraries that use older Log4j versions ensures that all dependencies in your project are compatible with Log4j 2.x, preventing conflicts and leveraging improved features and security fixes.
 
 - Identify Older Log4j Dependencies:
-    
-    Use dependency analysis tools (e.g., Maven's `dependency:tree` or Gradle's `dependencies` task) to check if any third-party libraries rely on Log4j 1.x.
-    
-    Example (Maven):
-    
-    ```bash
-    mvn dependency:tree | grep log4j
-    ```
-    
-    Example (Gradle):
-    
-    ```bash
-    ./gradlew dependencies | grep log4j
-    ```
-    
+  Use dependency analysis tools (e.g., Maven's `dependency:tree` or Gradle's `dependencies` task) to check if any third-party libraries rely on Log4j 1.x.
+  Example (Maven):
+  ```bash
+  mvn dependency:tree | grep log4j
+  ```
+  Example (Gradle):
+  ```bash
+  ./gradlew dependencies | grep log4j
+  ```
 - Update Library Versions:
-    
-    Check if newer versions of these libraries support Log4j 2.x. Update the libraries to the latest version in your `pom.xml` or `build.gradle`.
-    
+  Check if newer versions of these libraries support Log4j 2.x. Update the libraries to the latest version in your `pom.xml` or `build.gradle`.
 - Use the log4j-1.2-api Bridge:
-    
-    If no update is available, use the log4j-1.2-api bridge to maintain compatibility between third-party libraries still using Log4j 1.x and your Log4j 2.x codebase.
-    
+  If no update is available, use the log4j-1.2-api bridge to maintain compatibility between third-party libraries still using Log4j 1.x and your Log4j 2.x codebase.
 - Monitor for Security Issues:
-    
-    Regularly review third-party library updates for critical fixes, especially security vulnerabilities related to Log4j.
-    
+  Regularly review third-party library updates for critical fixes, especially security vulnerabilities related to Log4j.
 
-Gradual migration helps ensure a smooth transition from Log4j 1.x to Log4j 2.x by minimizing disruptions and allowing for thorough testing and adjustments in a large codebase. 
+Gradual migration helps ensure a smooth transition from Log4j 1.x to Log4j 2.x by minimizing disruptions and allowing for thorough testing and adjustments in a large codebase.
 
 - Plan Incrementally, Break the Migration: Divide the migration into manageable phases. Start with core modules and then move to less critical areas.
 - Use the Log4j 1.x Bridge: Add the log4j-1.2-api bridge to support existing Log4j 1.x code while transitioning to Log4j 2.x.
@@ -291,78 +247,77 @@ Troubleshooting persistent `ClassNotFoundException` involves using specific tool
 If you're still encountering the `ClassNotFoundException` after following the steps above, try these troubleshooting techniques:
 
 1. Using Maven Dependency Plugin:
-    
-    The Maven Dependency Plugin helps you view and troubleshoot your project's dependency tree.
-    
-    Example:
-    
-    ```bash
-    mvn dependency:tree
-    ```
-    
-    Output:
-    
-    ```bash
-    [INFO] com.example:myapp:jar:1.0
-    [INFO] +- log4j:log4j:jar:1.2.17:compile
-    [INFO] \- org.apache.commons:commons-lang:jar:2.6:compile
-    ```
-    
-    Check for version conflicts or missing dependencies. If Log4j is missing, add it to your `pom.xml`.
-    
+
+   The Maven Dependency Plugin helps you view and troubleshoot your project's dependency tree.
+
+   Example:
+
+   ```bash
+   mvn dependency:tree
+   ```
+
+   Output:
+
+   ```bash
+   [INFO] com.example:myapp:jar:1.0
+   [INFO] +- log4j:log4j:jar:1.2.17:compile
+   [INFO] \- org.apache.commons:commons-lang:jar:2.6:compile
+   ```
+
+   Check for version conflicts or missing dependencies. If Log4j is missing, add it to your `pom.xml`.
+
 2. Debugging Classpath Issues:
-    
-    Use your IDE's classpath configuration features to ensure all required libraries are included. Use `verbose:class` to trace which classes are being loaded and from where.
-    
-    Example:
-    
-    ```bash
-    java -verbose:class -cp /path/to/classes com.example.Main
-    ```
-    
-    Output:
-    
-    ```bash
-    [Loaded com.example.Main from file:/path/to/classes/com/example/Main.class]
-    [Loaded org.apache.log4j.Logger from file:/path/to/log4j.jar]
-    ```
-    
-    Ensure all required classes are loaded from the expected locations.
-    
+
+   Use your IDE's classpath configuration features to ensure all required libraries are included. Use `verbose:class` to trace which classes are being loaded and from where.
+
+   Example:
+
+   ```bash
+   java -verbose:class -cp /path/to/classes com.example.Main
+   ```
+
+   Output:
+
+   ```bash
+   [Loaded com.example.Main from file:/path/to/classes/com/example/Main.class]
+   [Loaded org.apache.log4j.Logger from file:/path/to/log4j.jar]
+   ```
+
+   Ensure all required classes are loaded from the expected locations.
+
 3. Leveraging Logging Frameworks' Debug Output:
-    
-    Enable debug output in your logging framework to see detailed information about its configuration.
-    
-    Example:
-    
-    For Log4j 2.x, add the following to your `log4j2.xml`:
-    
-    ```xml
-    <Configuration status="DEBUG">
-        <!-- your configuration here -->
-    </Configuration>
-    ```
-    
-    Review the logs for configuration errors or missing files.
-    
+
+   Enable debug output in your logging framework to see detailed information about its configuration.
+
+   Example:
+
+   For Log4j 2.x, add the following to your `log4j2.xml`:
+
+   ```xml
+   <Configuration status="DEBUG">
+       <!-- your configuration here -->
+   </Configuration>
+   ```
+
+   Review the logs for configuration errors or missing files.
+
 4. Strategies for Isolating Problems in Multi-Module Projects:
-    
-    Test each module independently to identify which module is causing the issue.
-    
-    Example:
-    
-    If `ModuleA` depends on `ModuleB`, ensure `ModuleB` is correctly included in the classpath of `ModuleA`. Check `ModuleA`'s build configuration for missing or incorrect dependencies:
-    
-    ```xml
-    <dependency>
-        <groupId>com.example</groupId>
-        <artifactId>moduleB</artifactId>
-        <version>1.0</version>
-    </dependency>
-    ```
-    
-    Isolate the problem by verifying each module’s dependencies and classpath setup.
-    
+
+   Test each module independently to identify which module is causing the issue.
+
+   Example:
+
+   If `ModuleA` depends on `ModuleB`, ensure `ModuleB` is correctly included in the classpath of `ModuleA`. Check `ModuleA`'s build configuration for missing or incorrect dependencies:
+
+   ```xml
+   <dependency>
+       <groupId>com.example</groupId>
+       <artifactId>moduleB</artifactId>
+       <version>1.0</version>
+   </dependency>
+   ```
+
+   Isolate the problem by verifying each module’s dependencies and classpath setup.
 
 ## Optimizing Logging Performance with SigNoz
 
@@ -381,76 +336,75 @@ To configure Log4j 2.x with SigNoz:
 Following best practices for Log4j 2.x ensures optimal performance, security, and effective log management in your applications.
 
 1. Leveraging Asynchronous Logging:
-    
-    Use Log4j 2.x's asynchronous logging to boost performance by offloading logging to a separate thread, reducing the impact on application performance.
-    
-    Example:
-    
-    ```xml
-    <Configuration>
-        <Appenders>
-            <Async name="AsyncAppender">
-                <AppenderRef ref="Console"/>
-            </Async>
-            <Console name="Console" target="SYSTEM_OUT">
-                <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5p %c - %m%n"/>
-            </Console>
-        </Appenders>
-        <Loggers>
-            <Root level="info">
-                <AppenderRef ref="AsyncAppender"/>
-            </Root>
-        </Loggers>
-    </Configuration>
-    ```
-    
-    This configuration uses an asynchronous appender to handle log messages, which improves performance by decoupling logging from the main application thread.
-    
+
+   Use Log4j 2.x's asynchronous logging to boost performance by offloading logging to a separate thread, reducing the impact on application performance.
+
+   Example:
+
+   ```xml
+   <Configuration>
+       <Appenders>
+           <Async name="AsyncAppender">
+               <AppenderRef ref="Console"/>
+           </Async>
+           <Console name="Console" target="SYSTEM_OUT">
+               <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5p %c - %m%n"/>
+           </Console>
+       </Appenders>
+       <Loggers>
+           <Root level="info">
+               <AppenderRef ref="AsyncAppender"/>
+           </Root>
+       </Loggers>
+   </Configuration>
+   ```
+
+   This configuration uses an asynchronous appender to handle log messages, which improves performance by decoupling logging from the main application thread.
+
 2. Implementing Proper Log Levels and Categories:
-    
-    Use appropriate log levels (`TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`) and categories to capture relevant information and facilitate debugging.
-    
-    Example:
-    
-    ```xml
-    <Logger name="com.example.service" level="debug" additivity="false">
-        <AppenderRef ref="Console"/>
-    </Logger>
-    ```
-    
-    This setup configures a specific logger for the `com.example.service` package at the `DEBUG` level, helping to filter and control the amount of log output based on the desired level of detail.
-    
+
+   Use appropriate log levels (`TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`) and categories to capture relevant information and facilitate debugging.
+
+   Example:
+
+   ```xml
+   <Logger name="com.example.service" level="debug" additivity="false">
+       <AppenderRef ref="Console"/>
+   </Logger>
+   ```
+
+   This setup configures a specific logger for the `com.example.service` package at the `DEBUG` level, helping to filter and control the amount of log output based on the desired level of detail.
+
 3. Utilizing Built-in Security Features:
-    
-    Take advantage of Log4j 2.x's security features, such as `ConfigurationFactory` to prevent attacks related to log injection and external configuration.
-    
-    Example:
-    
-    ```xml
-    <Configuration status="ERROR">
-        <!-- Configuration to prevent external attacks -->
-    </Configuration>
-    ```
-    
-    This example ensures that the configuration setup includes security measures to mitigate risks related to log data and configuration files.
-    
+
+   Take advantage of Log4j 2.x's security features, such as `ConfigurationFactory` to prevent attacks related to log injection and external configuration.
+
+   Example:
+
+   ```xml
+   <Configuration status="ERROR">
+       <!-- Configuration to prevent external attacks -->
+   </Configuration>
+   ```
+
+   This example ensures that the configuration setup includes security measures to mitigate risks related to log data and configuration files.
+
 4. Strategies for Log Rotation and Archiving:
-    
-    Implement log rotation and archiving to handle log file size and maintain manageable log files.
-    
-    Example:
-    
-    ```xml
-    <RollingFile name="RollingFile" fileName="logs/app.log" filePattern="logs/app-%d{yyyy-MM-dd}.log">
-        <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5p %c - %m%n"/>
-        <Policies>
-            <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
-        </Policies>
-    </RollingFile>
-    ```
-    
-    This configuration rotates log files daily and archives them, ensuring that log files do not grow indefinitely and are manageable over time.
-    
+
+   Implement log rotation and archiving to handle log file size and maintain manageable log files.
+
+   Example:
+
+   ```xml
+   <RollingFile name="RollingFile" fileName="logs/app.log" filePattern="logs/app-%d{yyyy-MM-dd}.log">
+       <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5p %c - %m%n"/>
+       <Policies>
+           <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
+       </Policies>
+   </RollingFile>
+   ```
+
+   This configuration rotates log files daily and archives them, ensuring that log files do not grow indefinitely and are manageable over time.
 
 ## Key Takeaways
 
@@ -487,4 +441,4 @@ Yes, Log4j 2.x is compatible with Java 9+ modules. Ensure you add the necessary
 
 ```java
 requires org.apache.logging.log4j;
-```
\ No newline at end of file
+```
diff --git a/data/guides/java-log.mdx b/data/guides/java-log.mdx
index 28df8ef53..1d7e6c3ce 100644
--- a/data/guides/java-log.mdx
+++ b/data/guides/java-log.mdx
@@ -1,14 +1,12 @@
 ---
-title: "Master Java Logging: From System.out.println to Production-Ready Logs"
-slug: java-log
+title: 'Master Java Logging: From System.out.println to Production-Ready Logs'
 date: 2025-09-16
-tags: ["java", "logging"]
-authors: ["niyati_thakkar", "yuvraj"]
-description: "Move your Java application from println debugging to production-ready logging with this hands-on guide."
-keywords: ["java logging", "log4j2", "slf4j", "logging tutorial", "java logging best practices"]
+tags: ['java', 'logging']
+authors: ['niyati_thakkar', 'yuvraj']
+description: 'Move your Java application from println debugging to production-ready logging with this hands-on guide.'
+keywords: ['java logging', 'log4j2', 'slf4j', 'logging tutorial', 'java logging best practices']
 ---
 
-
 If you're still debugging with `System.out.println`, this article is for you. The statement is handy for quick experiments, yet it should not be used in real applications because it hides context, timing, and severity when production issues arise.
 
 This guide shows you how to move from println-driven debugging to production-grade logging that actually speeds up incident response. We'll build the logging stack step by step, explain why each choice matters, and highlight the details you need to keep operations calm once the system goes live.
@@ -21,7 +19,7 @@ Let's start with the code every Java developer writes when they're starting out:
 public class PaymentService {
     public void processPayment(String orderId, double amount) {
         System.out.println("Processing payment");
-        
+
         try {
             // Payment logic here
             chargeCard(orderId, amount);
@@ -39,9 +37,13 @@ Now that we understand the problem, let's fix it properly.
 
 ## Setting Up Real Java Logging in Your Java Application
 
-First, you need the right tools. Java logging uses two key concepts: a logging facade (SLF4J) that provides a consistent API, and a logging implementation (Log4j2) that does the actual work. 
+First, you need the right tools. Java logging uses two key concepts: a logging facade (SLF4J) that provides a consistent API, and a logging implementation (Log4j2) that does the actual work.
 
-<Figure src="/img/guides/2025/09/java-log-slf4jvslog4j2.webp" alt="Java Logging Setup with SLF4J and Log4j2" caption="Java Logging Setup with SLF4J and Log4j2" />
+<Figure
+  src="/img/guides/2025/09/java-log-slf4jvslog4j2.webp"
+  alt="Java Logging Setup with SLF4J and Log4j2"
+  caption="Java Logging Setup with SLF4J and Log4j2"
+/>
 
 This separation means you can switch logging implementations later without changing your code.
 
@@ -55,14 +57,14 @@ Add these dependencies to your Maven `pom.xml` (check [Maven Central](https://se
         <artifactId>slf4j-api</artifactId>
         <version>2.0.17</version>
     </dependency>
-    
+
     <!-- Log4j2 Implementation -->
     <dependency>
         <groupId>org.apache.logging.log4j</groupId>
         <artifactId>log4j-core</artifactId>
         <version>2.25.0</version>
     </dependency>
-    
+
     <!-- Bridge between SLF4J and Log4j2 -->
     <dependency>
         <groupId>org.apache.logging.log4j</groupId>
@@ -90,10 +92,10 @@ import org.slf4j.LoggerFactory;
 
 public class PaymentService {
     private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
-    
+
     public void processPayment(String orderId, double amount) {
         logger.info("Processing payment for order: {} with amount: ${}", orderId, amount);
-        
+
         try {
             chargeCard(orderId, amount);
             logger.info("Payment successful for order: {}", orderId);
@@ -125,7 +127,7 @@ Your logger needs instructions on where to write logs and how to format them. Cr
             <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
         </Console>
     </Appenders>
-    
+
     <Loggers>
         <Root level="info">
             <AppenderRef ref="Console"/>
@@ -157,9 +159,9 @@ Console output works great during development, but production systems need persi
         <Console name="Console" target="SYSTEM_OUT">
             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
         </Console>
-        
+
         <!-- Rolling file for production -->
-        <RollingFile name="RollingFile" 
+        <RollingFile name="RollingFile"
                      fileName="logs/app.log"
                      filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
             <PatternLayout pattern="%d{ISO8601} [%thread] %-5level %logger - %msg%n"/>
@@ -173,7 +175,7 @@ Console output works great during development, but production systems need persi
             <DefaultRolloverStrategy max="30"/>
         </RollingFile>
     </Appenders>
-    
+
     <Loggers>
         <Root level="info">
             <AppenderRef ref="Console"/>
@@ -191,32 +193,32 @@ With the basics covered, take the next step and tune the configuration so produc
 
 Not all logs are created equal. Log4j2 provides six log levels, each serving a specific purpose:
 
-| Level | Purpose | Example |
-|-------|---------|---------|
-| **TRACE** | Most detailed information, typically only enabled when diagnosing problems | Method entry/exit, variable values at each step |
-| **DEBUG** | Detailed information useful during development | SQL queries, configuration values, intermediate calculations |
-| **INFO** | Important business events that should be tracked | User login, payment processed, order shipped |
-| **WARN** | Potentially harmful situations that need attention | Deprecated API usage, recoverable errors, slow queries |
-| **ERROR** | Error events that might still allow the application to continue | Payment failure, external service timeout, validation errors |
-| **FATAL** | Severe errors that will likely cause the application to abort | Database connection lost, out of memory, corrupted data |
+| Level     | Purpose                                                                    | Example                                                      |
+| --------- | -------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| **TRACE** | Most detailed information, typically only enabled when diagnosing problems | Method entry/exit, variable values at each step              |
+| **DEBUG** | Detailed information useful during development                             | SQL queries, configuration values, intermediate calculations |
+| **INFO**  | Important business events that should be tracked                           | User login, payment processed, order shipped                 |
+| **WARN**  | Potentially harmful situations that need attention                         | Deprecated API usage, recoverable errors, slow queries       |
+| **ERROR** | Error events that might still allow the application to continue            | Payment failure, external service timeout, validation errors |
+| **FATAL** | Severe errors that will likely cause the application to abort              | Database connection lost, out of memory, corrupted data      |
 
 Here's how to use them effectively in your code:
 
 ```java
 public class PaymentService {
     private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
-    
+
     public void processPayment(String orderId, double amount) {
         logger.trace("Entering processPayment with orderId: {}, amount: {}", orderId, amount);
         logger.debug("Validating payment request for order: {}", orderId);
-        
+
         if (amount <= 0) {
             logger.warn("Invalid amount {} for order: {}", amount, orderId);
             throw new IllegalArgumentException("Amount must be positive");
         }
-        
+
         logger.info("Processing payment for order: {} with amount: ${}", orderId, amount);
-        
+
         try {
             chargeCard(orderId, amount);
             logger.info("Payment successful for order: {}", orderId);
@@ -253,13 +255,13 @@ Your application logs are important, but framework logs can be overwhelming. You
 <Loggers>
     <!-- Your application: DEBUG level for detailed troubleshooting -->
     <Logger name="com.myapp" level="debug"/>
-    
+
     <!-- Database queries: Show warnings only to reduce noise -->
     <Logger name="org.hibernate" level="warn"/>
-    
+
     <!-- Spring Framework: Info level for important events -->
     <Logger name="org.springframework" level="info"/>
-    
+
     <!-- Everything else defaults to INFO level -->
     <Root level="info">
         <AppenderRef ref="Console"/>
@@ -281,22 +283,22 @@ import org.slf4j.MDC;
 
 public class RequestHandler {
     private static final Logger logger = LoggerFactory.getLogger(RequestHandler.class);
-    
+
     public void handleRequest(String requestId, String userId, String orderId) {
         // Add context at the beginning of request processing
         MDC.put("requestId", requestId);
         MDC.put("userId", userId);
         MDC.put("orderId", orderId);
-        
+
         try {
             logger.info("Starting request processing");
-            
+
             // These methods don't need to know about requestId or userId
             // but their logs will still include this context
             validateUser();
             processOrder();
             sendNotification();
-            
+
             logger.info("Request completed successfully");
         } catch (Exception e) {
             logger.error("Request failed", e);
@@ -305,7 +307,7 @@ public class RequestHandler {
             MDC.clear();
         }
     }
-    
+
     private void processOrder() {
         // This log automatically includes requestId, userId, and orderId
         // even though we didn't pass them to this method
@@ -343,9 +345,9 @@ Plain text logs work, but structured logs are searchable, filterable, and analyz
         <Console name="Console" target="SYSTEM_OUT">
             <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n"/>
         </Console>
-        
+
         <!-- JSON format for production analysis -->
-        <RollingFile name="JsonFile" 
+        <RollingFile name="JsonFile"
                      fileName="logs/app.json"
                      filePattern="logs/app-%d{yyyy-MM-dd}-%i.json.gz">
             <JsonLayout compact="true" eventEol="true">
@@ -359,7 +361,7 @@ Plain text logs work, but structured logs are searchable, filterable, and analyz
             </Policies>
         </RollingFile>
     </Appenders>
-    
+
     <Loggers>
         <Root level="info">
             <AppenderRef ref="Console"/>
@@ -400,7 +402,7 @@ Logging I/O can slow down your application. Every time you log, your thread migh
             <PatternLayout pattern="%d{ISO8601} [%thread] %-5level %logger - %msg%n"/>
         </RollingFile>
     </Appenders>
-    
+
     <Loggers>
         <!-- AsyncRoot makes all logging asynchronous -->
         <AsyncRoot level="info">
@@ -488,7 +490,7 @@ import org.apache.logging.log4j.core.LoggerContext;
 
 // Check where Log4j2 is loading configuration from
 LoggerContext context = (LoggerContext) LogManager.getContext(false);
-System.out.println("Config location: " + 
+System.out.println("Config location: " +
     context.getConfiguration().getConfigurationSource().getLocation());
 ```
 
@@ -554,7 +556,7 @@ public class Application {
         // Install SLF4J bridge
         SLF4JBridgeHandler.install();
     }
-    
+
     public static void main(String[] args) {
         // JUL logs now go through your Log4j2 configuration
     }
@@ -585,15 +587,15 @@ Here's a battle-tested production configuration that implements all these practi
             %d{ISO8601} [%thread] %-5level %logger - %X{correlationId} - %msg%n
         </Property>
     </Properties>
-    
+
     <Appenders>
         <!-- Async wrapper for performance -->
         <AsyncAppender name="AsyncFile" includeLocation="true">
             <AppenderRef ref="RollingFile"/>
         </AsyncAppender>
-        
+
         <!-- Main application logs with rotation -->
-        <RollingFile name="RollingFile" 
+        <RollingFile name="RollingFile"
                      fileName="logs/app.log"
                      filePattern="logs/app-%d{yyyy-MM-dd}-%i.log.gz">
             <PatternLayout pattern="${LOG_PATTERN}"/>
@@ -603,24 +605,24 @@ Here's a battle-tested production configuration that implements all these practi
             </Policies>
             <DefaultRolloverStrategy max="30"/>
         </RollingFile>
-        
+
         <!-- Separate error log for monitoring -->
-        <RollingFile name="ErrorFile" 
+        <RollingFile name="ErrorFile"
                      fileName="logs/error.log"
                      filePattern="logs/error-%d{yyyy-MM-dd}.log.gz">
             <PatternLayout pattern="${LOG_PATTERN}"/>
             <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY"/>
         </RollingFile>
     </Appenders>
-    
+
     <Loggers>
         <!-- Your app: Configurable via environment -->
         <Logger name="com.myapp" level="${env:APP_LOG_LEVEL:-INFO}"/>
-        
+
         <!-- Frameworks: WARN only to reduce noise -->
         <Logger name="org.springframework" level="WARN"/>
         <Logger name="org.hibernate" level="WARN"/>
-        
+
         <Root level="INFO">
             <AppenderRef ref="AsyncFile"/>
             <AppenderRef ref="ErrorFile"/>
@@ -645,7 +647,7 @@ If the query shows no events for a few minutes, alert the on-call engineer, beca
 
 ## Get Started with SigNoz
 
-SigNoz offers three deployment paths. Start quickly with the [SigNoz cloud](https://signoz.io/teams/) trial, which provides full-feature access for 30 days. Teams that must retain data on their own infrastructure can pick the [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/). If you prefer to manage the stack yourself, deploy the [community edition](https://signoz.io/docs/install/self-host/). 
+SigNoz offers three deployment paths. Start quickly with the [SigNoz cloud](https://signoz.io/teams/) trial, which provides full-feature access for 30 days. Teams that must retain data on their own infrastructure can pick the [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/). If you prefer to manage the stack yourself, deploy the [community edition](https://signoz.io/docs/install/self-host/).
 
 Once you have SigNoz running, point the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/)to the structured log file you created earlier. The `filelog` receiver tails the JSON output and forwards it to SigNoz without additional changes to your application code:
 
@@ -660,7 +662,7 @@ exporters:
   otlp:
     endpoint: https://ingest.signoz.io:443
     headers:
-      signoz-ingestion-key: "{SIGNOZ_INGESTION_KEY}"
+      signoz-ingestion-key: '{SIGNOZ_INGESTION_KEY}'
 
 service:
   pipelines:
@@ -671,13 +673,17 @@ service:
 
 With SigNoz, you can correlate logs with traces and metrics, search across all your services, and set up intelligent alerts for critical errors. Your logs become part of a complete observability solution.
 
-<Figure src="/img/guides/2025/09/java-log-signoz-log-dashboard.webp" alt="SigNoz log dashboard" caption="SigNoz log dashboard" />
+<Figure
+  src="/img/guides/2025/09/java-log-signoz-log-dashboard.webp"
+  alt="SigNoz log dashboard"
+  caption="SigNoz log dashboard"
+/>
 
 For end-to-end instructions on forwarding Java logs, follow the [SigNoz guide for collecting application logs with the OpenTelemetry Java SDK](https://signoz.io/docs/userguide/collecting_application_logs_otel_sdk_java/).
 
 ## Your Next Steps
 
-You now have a clear path from println debugging to [production-ready](https://signoz.io/guides/production-readiness-checklist/) logging. 
+You now have a clear path from println debugging to [production-ready](https://signoz.io/guides/production-readiness-checklist/) logging.
 
 Remember, good logging isn't about logging everything, it's about logging the right things with enough context to solve problems quickly. The difference between finding a production bug in minutes versus hours often comes down to the quality of your logs.
 
diff --git a/data/guides/jmx-monitoring.mdx b/data/guides/jmx-monitoring.mdx
index 53d017dfa..7da781f7b 100644
--- a/data/guides/jmx-monitoring.mdx
+++ b/data/guides/jmx-monitoring.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: JMX Monitoring - A Beginner's Guide to Java Performance
-slug: jmx-monitoring
 date: 2024-08-23
 tags: [monitoring]
 authors: [nilesh_sinha]
 description: Learn how JMX monitoring can improve Java application performance. This guide covers JMX basics, implementation, and advanced techniques for developers.
-keywords: [JMX Monitoring, Java Performance, MBeans, JVM Monitoring, Application Management, Performance Metrics, Java Developers]
-
+keywords:
+  [
+    JMX Monitoring,
+    Java Performance,
+    MBeans,
+    JVM Monitoring,
+    Application Management,
+    Performance Metrics,
+    Java Developers,
+  ]
 ---
 
 Java developers often face challenges in monitoring and managing their applications effectively. How do you gain real-time insights into your Java application's performance? What tools can you use to identify bottlenecks and optimize resource usage? JMX monitoring offers a powerful solution to these questions. This guide will walk you through the essentials of JMX monitoring, its implementation, and how it can significantly enhance your Java application's performance.
@@ -18,13 +24,13 @@ Before we get into the gist of monitoring, let's start with the basics of JMX an
 
 Java Management Extensions or JMX provide a standardized way to manage resources such as applications, system objects, and devices. With JMX, you can keep tabs on key metrics like memory usage, thread count, and database connections. It’s like having a dashboard for your application’s health, where you can spot issues before they turn into disasters.
 
-Now let's delve into a higher-level overview of the JMX architecture. 
+Now let's delve into a higher-level overview of the JMX architecture.
 
 JMX monitoring involves:
 
 1. MBeans (Managed Beans): Java objects that represent resources to be managed. MBeans represent the resources or components you want to manage, such as memory usage, thread pools, or custom application metrics. MBeans expose attributes (like data points) and operations (like commands) that you can query or manipulate.
-2. MBean Server: A core component that acts as a registry for MBeans. The request to interact with an MBean goes to the MBean server which then finds out the exact MBean you're looking for and executes the command. 
-3. JMX Agent: The management entity that controls resources and makes them available.  It manages the interaction between the MBean Server and external monitoring tools. The agent includes protocol adaptors and connectors that allow remote applications or tools (like JConsole or VisualVM) to connect and manage the MBeans.
+2. MBean Server: A core component that acts as a registry for MBeans. The request to interact with an MBean goes to the MBean server which then finds out the exact MBean you're looking for and executes the command.
+3. JMX Agent: The management entity that controls resources and makes them available. It manages the interaction between the MBean Server and external monitoring tools. The agent includes protocol adaptors and connectors that allow remote applications or tools (like JConsole or VisualVM) to connect and manage the MBeans.
 
 The benefits of using JMX for performance monitoring include:
 
@@ -45,23 +51,23 @@ JMX monitoring is crucial for Java developers for several reasons:
 
 It's always better to understand the analogy to incorporate the entire scenario. How about visualizing a large, complex factory with numerous machines involved in the workflow?
 
-The MBeans are the individual machines in the factory, each equipped with a dashboard showing its current status and buttons to adjust its settings. 
+The MBeans are the individual machines in the factory, each equipped with a dashboard showing its current status and buttons to adjust its settings.
 
-The MBean Server is like the factory’s control room, where all the machine dashboards are displayed. 
+The MBean Server is like the factory’s control room, where all the machine dashboards are displayed.
 
 In addition, the JMX Agent is the factory’s communication system, allowing remote operators to monitor and control the machines from outside the factory.
 
 JMX monitoring operates through a set of interconnected components:
 
 1. MBeans: These are Java objects that represent manageable resources. There are four types:
-    - Standard MBeans: These are the most common type of MBeans, defined by implementing a management interface and its corresponding class. The interface defines the operations and attributes that can be managed.
-    - Dynamic MBeans: They allow you to define their management interface at runtime rather than at compile time and are, therefore more flexible. This is useful when the set of attributes or operations is not known in advance.
-    - Open MBeans: They are a specialized type of Dynamic MBeans that use a standardized data format. This makes them interoperable and easier to use across different systems and applications. Think of it as universal remote controls that can work with any device, regardless of brand.
-    - Model MBeans: They can be configured to behave like any of the other MBeans, allowing for rich and complex management capabilities.
+   - Standard MBeans: These are the most common type of MBeans, defined by implementing a management interface and its corresponding class. The interface defines the operations and attributes that can be managed.
+   - Dynamic MBeans: They allow you to define their management interface at runtime rather than at compile time and are, therefore more flexible. This is useful when the set of attributes or operations is not known in advance.
+   - Open MBeans: They are a specialized type of Dynamic MBeans that use a standardized data format. This makes them interoperable and easier to use across different systems and applications. Think of it as universal remote controls that can work with any device, regardless of brand.
+   - Model MBeans: They can be configured to behave like any of the other MBeans, allowing for rich and complex management capabilities.
 2. MBean Server: This component acts as a registry for MBeans, allowing management applications to access them. It acts as the core management hub, where all the Managed Beans (MBeans) register themselves, allowing you to manage and monitor your Java applications. Moreover, it also organizes MBeans using unique ObjectNames, similar to how files are organized in a directory. This naming system allows for easy identification and access to MBeans.
 3. JMX Connectors: These enable remote access to the MBean server. They facilitate communication between the MBean Server and remote clients over various protocols. They provide the necessary infrastructure to manage Java applications from different locations, often over a network.
-4. Protocol Adapters: They allow non-JMX-aware management applications to interact with JMX-enabled resources. 
-A protocol adapter is like a translator who converts what you say into a language each participant understands.
+4. Protocol Adapters: They allow non-JMX-aware management applications to interact with JMX-enabled resources.
+   A protocol adapter is like a translator who converts what you say into a language each participant understands.
 
 Popular [JMX monitoring tools](https://signoz.io/guides/jmx-monitoring/#how-jmx-monitoring-works) include JConsole and VisualVM, which provide graphical interfaces for viewing and managing JMX-exposed metrics.
 
@@ -70,49 +76,49 @@ Popular [JMX monitoring tools](https://signoz.io/guides/jmx-monitoring/#how-jmx-
 To enable JMX monitoring in your Java application:
 
 1. Enable JMX: Add the following JVM arguments when starting your application:
-    
-    ```bash
-    # Enable JMX remote management.
-    -Dcom.sun.management.jmxremote
-    
-    # Specify the port number for JMX connections (e.g., 9010).
-    -Dcom.sun.management.jmxremote.port=9010
-    
-    # Disable authentication for JMX connections.
-    # NOTE: This is not recommended for production environments.
-    -Dcom.sun.management.jmxremote.authenticate=false
-    
-    # Disable SSL for JMX connections.
-    # NOTE: This is also not recommended for production environments.
-    -Dcom.sun.management.jmxremote.ssl=false
-    ```
-    
+
+   ```bash
+   # Enable JMX remote management.
+   -Dcom.sun.management.jmxremote
+
+   # Specify the port number for JMX connections (e.g., 9010).
+   -Dcom.sun.management.jmxremote.port=9010
+
+   # Disable authentication for JMX connections.
+   # NOTE: This is not recommended for production environments.
+   -Dcom.sun.management.jmxremote.authenticate=false
+
+   # Disable SSL for JMX connections.
+   # NOTE: This is also not recommended for production environments.
+   -Dcom.sun.management.jmxremote.ssl=false
+   ```
+
 2. Configure security: In production environments, enable authentication and SSL:
-    
-    ```bash
-    # Enable JMX remote management.
-    -Dcom.sun.management.jmxremote
-    
-    # Specify the port number for JMX connections (e.g., 9010).
-    -Dcom.sun.management.jmxremote.port=9010
-    
-    # Enable authentication for JMX connections to secure access.
-    -Dcom.sun.management.jmxremote.authenticate=true
-    
-    # Enable SSL to encrypt communication and secure JMX connections.
-    -Dcom.sun.management.jmxremote.ssl=true
-    
-    # Specify the path to the password file, which contains credentials for authentication.
-    -Dcom.sun.management.jmxremote.password.file=/path/to/jmxremote.password
-    
-    # Specify the path to the access file, which defines user roles and permissions.
-    -Dcom.sun.management.jmxremote.access.file=/path/to/jmxremote.access
-    ```
-    
+
+   ```bash
+   # Enable JMX remote management.
+   -Dcom.sun.management.jmxremote
+
+   # Specify the port number for JMX connections (e.g., 9010).
+   -Dcom.sun.management.jmxremote.port=9010
+
+   # Enable authentication for JMX connections to secure access.
+   -Dcom.sun.management.jmxremote.authenticate=true
+
+   # Enable SSL to encrypt communication and secure JMX connections.
+   -Dcom.sun.management.jmxremote.ssl=true
+
+   # Specify the path to the password file, which contains credentials for authentication.
+   -Dcom.sun.management.jmxremote.password.file=/path/to/jmxremote.password
+
+   # Specify the path to the access file, which defines user roles and permissions.
+   -Dcom.sun.management.jmxremote.access.file=/path/to/jmxremote.access
+   ```
+
 3. Connect to JMX: Use a JMX client like JConsole to connect to your application using the configured port. The following steps would be required to connect to any JMX client like JConsole.
-    - Launch JConsole: JConsole is included with the JDK and can be started from the command line or your IDE.
-    - Connect to Your Application: Enter the hostname and port you configured (e.g., `localhost:9010`). If authentication is enabled, provide the necessary credentials.
-    - Monitor and Manage: Once connected, you can explore MBeans, monitor performance metrics, and perform management operations.
+   - Launch JConsole: JConsole is included with the JDK and can be started from the command line or your IDE.
+   - Connect to Your Application: Enter the hostname and port you configured (e.g., `localhost:9010`). If authentication is enabled, provide the necessary credentials.
+   - Monitor and Manage: Once connected, you can explore MBeans, monitor performance metrics, and perform management operations.
 
 Best practices for JMX configuration in production:
 
@@ -125,69 +131,71 @@ Best practices for JMX configuration in production:
 JMX exposes various critical performance metrics:
 
 1. JVM memory usage:
-    - Heap memory utilization: The Java Virtual Machine (JVM) uses heap memory to hold application-created objects. Understanding how much memory your program is using and spotting possible memory leaks depend on keeping an eye on heap memory use.
-    - Non-heap memory usage: The JVM uses non-heap memory to hold metadata like interned strings and class declarations. You can discover more about how much memory is being used by the JVM itself instead of the application by keeping an eye on non-heap memory utilization.
-    - Garbage collection statistics: Garbage collection (GC) is the process by which the JVM reclaims memory used by objects that are no longer referenced by the application. Monitoring GC activity helps you understand the impact of garbage collection on your application's performance.
+   - Heap memory utilization: The Java Virtual Machine (JVM) uses heap memory to hold application-created objects. Understanding how much memory your program is using and spotting possible memory leaks depend on keeping an eye on heap memory use.
+   - Non-heap memory usage: The JVM uses non-heap memory to hold metadata like interned strings and class declarations. You can discover more about how much memory is being used by the JVM itself instead of the application by keeping an eye on non-heap memory utilization.
+   - Garbage collection statistics: Garbage collection (GC) is the process by which the JVM reclaims memory used by objects that are no longer referenced by the application. Monitoring GC activity helps you understand the impact of garbage collection on your application's performance.
 2. Thread management:
-    - Thread pool utilization: Thread pool utilization gives insights into how threads are being used in your application, such as the number of active threads, the number of threads waiting, and the total number of threads created. You can use `ThreadMXBean` to monitor the thread pool utilization.
-    
-    ```java
-    // Access the MBean for thread management
-    ThreadMXBean threadMBean = ManagementFactory.getThreadMXBean();
-    
-    // Get the total number of threads currently running
-    int threadCount = threadMBean.getThreadCount();
-    
-    // Get the peak thread count since the JVM started or the peak was reset
-    int peakThreadCount = threadMBean.getPeakThreadCount();
-    
-    // Get the total number of threads created since the JVM started
-    long totalStartedThreadCount = threadMBean.getTotalStartedThreadCount();
-    ```
-    
-    - Deadlock detection: Deadlocks occur when two or more threads are blocked forever, each waiting on the other to release a resource. Detecting and resolving deadlocks is crucial to maintaining application stability. To detect deadlocks, you can use the `findDeadlockedThreads()` method provided by the `ThreadMXBean` . We’d use simple print statements in our example code to demonstrate the identification of deadlocks.
-    
-    ```java
-    // Get the IDs of threads that are deadlocked, if any
-    long[] deadlockedThreads = threadMBean.findDeadlockedThreads();
-    
-    if (deadlockedThreads != null && deadlockedThreads.length > 0) {
-        System.out.println("Deadlock detected!");
-    
-        // Get thread information for the deadlocked threads
-        ThreadInfo[] threadInfos = threadMBean.getThreadInfo(deadlockedThreads);
-    
-        for (ThreadInfo threadInfo : threadInfos) {
-            // Print details about each deadlocked thread
-            System.out.println("Thread Name: " + threadInfo.getThreadName());
-            System.out.println("Thread State: " + threadInfo.getThreadState());
-            System.out.println("Blocked on Lock: " + threadInfo.getLockName());
-            System.out.println("Blocked by Thread: " + threadInfo.getLockOwnerName());
-            System.out.println("Stack Trace:");
-            for (StackTraceElement stackTraceElement : threadInfo.getStackTrace()) {
-                System.out.println("\t" + stackTraceElement);
-            }
-        }
-    } else {
-        System.out.println("No deadlocks detected.");
-    }
-    ```
-    
+
+   - Thread pool utilization: Thread pool utilization gives insights into how threads are being used in your application, such as the number of active threads, the number of threads waiting, and the total number of threads created. You can use `ThreadMXBean` to monitor the thread pool utilization.
+
+   ```java
+   // Access the MBean for thread management
+   ThreadMXBean threadMBean = ManagementFactory.getThreadMXBean();
+
+   // Get the total number of threads currently running
+   int threadCount = threadMBean.getThreadCount();
+
+   // Get the peak thread count since the JVM started or the peak was reset
+   int peakThreadCount = threadMBean.getPeakThreadCount();
+
+   // Get the total number of threads created since the JVM started
+   long totalStartedThreadCount = threadMBean.getTotalStartedThreadCount();
+   ```
+
+   - Deadlock detection: Deadlocks occur when two or more threads are blocked forever, each waiting on the other to release a resource. Detecting and resolving deadlocks is crucial to maintaining application stability. To detect deadlocks, you can use the `findDeadlockedThreads()` method provided by the `ThreadMXBean` . We’d use simple print statements in our example code to demonstrate the identification of deadlocks.
+
+   ```java
+   // Get the IDs of threads that are deadlocked, if any
+   long[] deadlockedThreads = threadMBean.findDeadlockedThreads();
+
+   if (deadlockedThreads != null && deadlockedThreads.length > 0) {
+       System.out.println("Deadlock detected!");
+
+       // Get thread information for the deadlocked threads
+       ThreadInfo[] threadInfos = threadMBean.getThreadInfo(deadlockedThreads);
+
+       for (ThreadInfo threadInfo : threadInfos) {
+           // Print details about each deadlocked thread
+           System.out.println("Thread Name: " + threadInfo.getThreadName());
+           System.out.println("Thread State: " + threadInfo.getThreadState());
+           System.out.println("Blocked on Lock: " + threadInfo.getLockName());
+           System.out.println("Blocked by Thread: " + threadInfo.getLockOwnerName());
+           System.out.println("Stack Trace:");
+           for (StackTraceElement stackTraceElement : threadInfo.getStackTrace()) {
+               System.out.println("\t" + stackTraceElement);
+           }
+       }
+   } else {
+       System.out.println("No deadlocks detected.");
+   }
+   ```
+
 3. System load:
-    - Average system load: The average system load gives an overview of the system's workload over time, indicating how much demand is placed on the CPU. The `getSystemLoadAverage()` returns the average system load for the last minute. A return value of `-1.0` indicates that the system load average is not available.
-    
-    ```java
-    import java.lang.management.ManagementFactory;
-    import com.sun.management.OperatingSystemMXBean;
-    
-    // Access the Operating System MBean
-    OperatingSystemMXBean osMBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
-    
-    // Get the system load average for the last minute
-    double systemLoadAverage = osMBean.getSystemLoadAverage();
-    
-    ```
-    
+
+   - Average system load: The average system load gives an overview of the system's workload over time, indicating how much demand is placed on the CPU. The `getSystemLoadAverage()` returns the average system load for the last minute. A return value of `-1.0` indicates that the system load average is not available.
+
+   ```java
+   import java.lang.management.ManagementFactory;
+   import com.sun.management.OperatingSystemMXBean;
+
+   // Access the Operating System MBean
+   OperatingSystemMXBean osMBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+
+   // Get the system load average for the last minute
+   double systemLoadAverage = osMBean.getSystemLoadAverage();
+
+   ```
+
 - Available processors: The number of available processors indicates the computing capacity of the system, which helps in understanding the parallel processing capabilities.
 
 ```java
@@ -196,165 +204,164 @@ int availableProcessors = osMBean.getAvailableProcessors();
 ```
 
 1. Custom application metrics: You can create custom metrics to keep an eye on particular areas of your application. Transaction rates, response times, and error rates are a few examples of these. You can develop custom MBeans to keep an eye on these. There are some code examples below to provide an insight.
-    - Transaction rates: Transaction rates measure how many transactions are processed per unit of time, providing insights into the workload and performance of your application.
-    
-    ```java
-    import javax.management.MBeanServer;
-    import javax.management.ObjectName;
-    import java.lang.management.ManagementFactory;
-    import java.util.concurrent.atomic.AtomicLong;
-    
-    public class TransactionMetrics {
-        // AtomicLong to keep track of transaction counts
-        private final AtomicLong transactionCount = new AtomicLong();
-    
-        public void recordTransaction() {
-            // Increment the transaction count
-            transactionCount.incrementAndGet();
-        }
-    
-        public long getTransactionCount() {
-            return transactionCount.get();
-        }
-    
-        public static void main(String[] args) throws Exception {
-            // Register the MBean
-            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
-            ObjectName name = new ObjectName("com.example:type=TransactionMetrics");
-            TransactionMetrics mbean = new TransactionMetrics();
-            mbs.registerMBean(mbean, name);
-    
-            // Simulate transaction recording
-            for (int i = 0; i < 100; i++) {
-                mbean.recordTransaction();
-                Thread.sleep(1000); // Sleep for demonstration purposes
-            }
-        }
-    }
-    
-    ```
-    
-    - Response times: Response times measure the time it takes for your application to respond to requests, which is crucial for understanding performance.
-    
-    ```java
-    import javax.management.MBeanServer;
-    import javax.management.ObjectName;
-    import java.lang.management.ManagementFactory;
-    import java.util.concurrent.atomic.AtomicLong;
-    import java.util.concurrent.atomic.AtomicLongArray;
-    
-    public class ResponseTimeMetrics {
-        private final AtomicLongArray responseTimes = new AtomicLongArray(100);
-        private int index = 0;
-    
-        public void recordResponseTime(long responseTime) {
-            // Record the response time
-            responseTimes.set(index % responseTimes.length(), responseTime);
-            index++;
-        }
-    
-        public long getAverageResponseTime() {
-            long sum = 0;
-            for (int i = 0; i < responseTimes.length(); i++) {
-                sum += responseTimes.get(i);
-            }
-            return sum / responseTimes.length();
-        }
-    
-        public static void main(String[] args) throws Exception {
-            // Register the MBean
-            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
-            ObjectName name = new ObjectName("com.example:type=ResponseTimeMetrics");
-            ResponseTimeMetrics mbean = new ResponseTimeMetrics();
-            mbs.registerMBean(mbean, name);
-    
-            // Simulate response time recording
-            for (int i = 0; i < 100; i++) {
-                mbean.recordResponseTime((long) (Math.random() * 500)); // Random response time
-                Thread.sleep(1000); // Sleep for demonstration purposes
-            }
-        }
-    }
-    ```
-    
-    - Error rates: Error rates measure the frequency of errors occurring in your application, helping you identify issues and maintain reliability.
-    
-    ```java
-    import javax.management.MBeanServer;
-    import javax.management.ObjectName;
-    import java.lang.management.ManagementFactory;
-    import java.util.concurrent.atomic.AtomicLong;
-    
-    public class ErrorMetrics {
-        private final AtomicLong errorCount = new AtomicLong();
-    
-        public void recordError() {
-            // Increment the error count
-            errorCount.incrementAndGet();
-        }
-    
-        public long getErrorCount() {
-            return errorCount.get();
-        }
-    
-        public static void main(String[] args) throws Exception {
-            // Register the MBean
-            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
-            ObjectName name = new ObjectName("com.example:type=ErrorMetrics");
-            ErrorMetrics mbean = new ErrorMetrics();
-            mbs.registerMBean(mbean, name);
-    
-            // Simulate error recording
-            for (int i = 0; i < 50; i++) {
-                mbean.recordError();
-                Thread.sleep(2000); // Sleep for demonstration purposes
-            }
-        }
-    }
-    ```
-    
+
+   - Transaction rates: Transaction rates measure how many transactions are processed per unit of time, providing insights into the workload and performance of your application.
+
+   ```java
+   import javax.management.MBeanServer;
+   import javax.management.ObjectName;
+   import java.lang.management.ManagementFactory;
+   import java.util.concurrent.atomic.AtomicLong;
+
+   public class TransactionMetrics {
+       // AtomicLong to keep track of transaction counts
+       private final AtomicLong transactionCount = new AtomicLong();
+
+       public void recordTransaction() {
+           // Increment the transaction count
+           transactionCount.incrementAndGet();
+       }
+
+       public long getTransactionCount() {
+           return transactionCount.get();
+       }
+
+       public static void main(String[] args) throws Exception {
+           // Register the MBean
+           MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+           ObjectName name = new ObjectName("com.example:type=TransactionMetrics");
+           TransactionMetrics mbean = new TransactionMetrics();
+           mbs.registerMBean(mbean, name);
+
+           // Simulate transaction recording
+           for (int i = 0; i < 100; i++) {
+               mbean.recordTransaction();
+               Thread.sleep(1000); // Sleep for demonstration purposes
+           }
+       }
+   }
+
+   ```
+
+   - Response times: Response times measure the time it takes for your application to respond to requests, which is crucial for understanding performance.
+
+   ```java
+   import javax.management.MBeanServer;
+   import javax.management.ObjectName;
+   import java.lang.management.ManagementFactory;
+   import java.util.concurrent.atomic.AtomicLong;
+   import java.util.concurrent.atomic.AtomicLongArray;
+
+   public class ResponseTimeMetrics {
+       private final AtomicLongArray responseTimes = new AtomicLongArray(100);
+       private int index = 0;
+
+       public void recordResponseTime(long responseTime) {
+           // Record the response time
+           responseTimes.set(index % responseTimes.length(), responseTime);
+           index++;
+       }
+
+       public long getAverageResponseTime() {
+           long sum = 0;
+           for (int i = 0; i < responseTimes.length(); i++) {
+               sum += responseTimes.get(i);
+           }
+           return sum / responseTimes.length();
+       }
+
+       public static void main(String[] args) throws Exception {
+           // Register the MBean
+           MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+           ObjectName name = new ObjectName("com.example:type=ResponseTimeMetrics");
+           ResponseTimeMetrics mbean = new ResponseTimeMetrics();
+           mbs.registerMBean(mbean, name);
+
+           // Simulate response time recording
+           for (int i = 0; i < 100; i++) {
+               mbean.recordResponseTime((long) (Math.random() * 500)); // Random response time
+               Thread.sleep(1000); // Sleep for demonstration purposes
+           }
+       }
+   }
+   ```
+
+   - Error rates: Error rates measure the frequency of errors occurring in your application, helping you identify issues and maintain reliability.
+
+   ```java
+   import javax.management.MBeanServer;
+   import javax.management.ObjectName;
+   import java.lang.management.ManagementFactory;
+   import java.util.concurrent.atomic.AtomicLong;
+
+   public class ErrorMetrics {
+       private final AtomicLong errorCount = new AtomicLong();
+
+       public void recordError() {
+           // Increment the error count
+           errorCount.incrementAndGet();
+       }
+
+       public long getErrorCount() {
+           return errorCount.get();
+       }
+
+       public static void main(String[] args) throws Exception {
+           // Register the MBean
+           MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+           ObjectName name = new ObjectName("com.example:type=ErrorMetrics");
+           ErrorMetrics mbean = new ErrorMetrics();
+           mbs.registerMBean(mbean, name);
+
+           // Simulate error recording
+           for (int i = 0; i < 50; i++) {
+               mbean.recordError();
+               Thread.sleep(2000); // Sleep for demonstration purposes
+           }
+       }
+   }
+   ```
 
 ## Implementing JMX Monitoring in Your Java Application
 
 To implement custom JMX monitoring:
 
 1. Create an MBean interface:
-    
-    ```java
-    public interface ApplicationStatsMBean {
-        int getActiveUsers();
-        long getTotalRequests();
-    }
-    
-    ```
-    
+
+   ```java
+   public interface ApplicationStatsMBean {
+       int getActiveUsers();
+       long getTotalRequests();
+   }
+
+   ```
+
 2. Implement the MBean:
-    
-    ```java
-    public class ApplicationStats implements ApplicationStatsMBean {
-        private int activeUsers;
-        private long totalRequests;
-    
-        public int getActiveUsers() {
-            return activeUsers;
-        }
-    
-        public long getTotalRequests() {
-            return totalRequests;
-        }
-    }
-    
-    ```
-    
+
+   ```java
+   public class ApplicationStats implements ApplicationStatsMBean {
+       private int activeUsers;
+       private long totalRequests;
+
+       public int getActiveUsers() {
+           return activeUsers;
+       }
+
+       public long getTotalRequests() {
+           return totalRequests;
+       }
+   }
+
+   ```
+
 3. Register the MBean:
-    
-    ```java
-    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
-    ObjectName name = new ObjectName("com.example:type=ApplicationStats");
-    ApplicationStats mbean = new ApplicationStats();
-    mbs.registerMBean(mbean, name);
-    ```
-    
+
+   ```java
+   MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+   ObjectName name = new ObjectName("com.example:type=ApplicationStats");
+   ApplicationStats mbean = new ApplicationStats();
+   mbs.registerMBean(mbean, name);
+   ```
 
 ### Exposing Application-Specific Metrics Through JMX
 
@@ -382,9 +389,9 @@ public class TransactionMetrics implements TransactionMetricsMBean {
 }
 ```
 
-Updating the metrics: 
+Updating the metrics:
 
-You also need to make sure that the application updates the metrics correctly as and when required. 
+You also need to make sure that the application updates the metrics correctly as and when required.
 
 Here’s an example to the demonstrate the same:
 
@@ -407,99 +414,97 @@ Best practices for custom MBeans:
 To take your JMX monitoring to the next level:
 
 1. Enable remote JMX over SSL:
-    - Generate keystores and truststores: The keystore holds the server’s private key and certificate. You can use `keytool` to create a keystore.
-    
-    ```bash
-    keytool -genkey -alias myserver -keyalg RSA -keysize 2048 -keystore mykeystore.jks -validity 365
-    ```
-    
-    This command generates a keystore named `mykeystore.jks` with a self-signed certificate valid for 365 days.
-    
-    A truststore stores trusted certificates from other sources (like the client’s certificates). 
-    Import the server's certificate into a truststore named `mytruststore.jks`.
-    
-    ```bash
-    keytool -import -alias myserver -file mycert.cer -keystore mytruststore.jks
-    ```
-    
-    - Configure JMX to use SSL with appropriate system properties: Set these JVM arguments to enable SSL for JMX communication. These settings configure JMX to use SSL, specifying keystore and truststore paths and passwords for secure communication.
-    
-    ```bash
-    -Dcom.sun.management.jmxremote
-    -Dcom.sun.management.jmxremote.port=9010
-    -Dcom.sun.management.jmxremote.ssl=true
-    -Dcom.sun.management.jmxremote.ssl.need.client.auth=true
-    -Dcom.sun.management.jmxremote.keystore.path=/path/to/mykeystore.jks
-    -Dcom.sun.management.jmxremote.keystore.password=keystore_password
-    -Dcom.sun.management.jmxremote.truststore.path=/path/to/mytruststore.jks
-    -Dcom.sun.management.jmxremote.truststore.password=truststore_password
-    
-    ```
-    
+
+   - Generate keystores and truststores: The keystore holds the server’s private key and certificate. You can use `keytool` to create a keystore.
+
+   ```bash
+   keytool -genkey -alias myserver -keyalg RSA -keysize 2048 -keystore mykeystore.jks -validity 365
+   ```
+
+   This command generates a keystore named `mykeystore.jks` with a self-signed certificate valid for 365 days.
+
+   A truststore stores trusted certificates from other sources (like the client’s certificates).
+   Import the server's certificate into a truststore named `mytruststore.jks`.
+
+   ```bash
+   keytool -import -alias myserver -file mycert.cer -keystore mytruststore.jks
+   ```
+
+   - Configure JMX to use SSL with appropriate system properties: Set these JVM arguments to enable SSL for JMX communication. These settings configure JMX to use SSL, specifying keystore and truststore paths and passwords for secure communication.
+
+   ```bash
+   -Dcom.sun.management.jmxremote
+   -Dcom.sun.management.jmxremote.port=9010
+   -Dcom.sun.management.jmxremote.ssl=true
+   -Dcom.sun.management.jmxremote.ssl.need.client.auth=true
+   -Dcom.sun.management.jmxremote.keystore.path=/path/to/mykeystore.jks
+   -Dcom.sun.management.jmxremote.keystore.password=keystore_password
+   -Dcom.sun.management.jmxremote.truststore.path=/path/to/mytruststore.jks
+   -Dcom.sun.management.jmxremote.truststore.password=truststore_password
+
+   ```
+
 2. [Monitor JMX](https://signoz.io/guides/jmx-monitoring/#advanced-jmx-monitoring-techniques) in containerized environments:
-    - Expose JMX ports in your container configuration
-    
-    Expose JMX Ports:
-    
-    - Dockerfile: Expose the JMX port in your Dockerfile. This makes the JMX port (9010) accessible outside the container.
-        
-        ```
-        EXPOSE 9010
-        ```
-        
-    - Kubernetes Manifest: Configure Kubernetes to expose the JMX port. This configuration exposes the port for JMX within the Kubernetes service.
-        
-        ```yaml
-        ports:
-          - containerPort: 9010
-        ```
-        
-    - Use container orchestration tools to manage JMX access
-    
-    Service Discovery: Use tools like Kubernetes for managing and discovering JMX endpoints. You can define services to access your application. This service definition allows access to the JMX port on your application.
-    
-    ```yaml
-    kind: Service
-    apiVersion: v1
-    metadata:
-      name: my-java-app
-    spec:
-      ports:
-        - port: 9010
-          targetPort: 9010
-      selector:
-        app: my-java-app
-    ```
-    
+
+   - Expose JMX ports in your container configuration
+
+   Expose JMX Ports:
+
+   - Dockerfile: Expose the JMX port in your Dockerfile. This makes the JMX port (9010) accessible outside the container.
+     ```
+     EXPOSE 9010
+     ```
+   - Kubernetes Manifest: Configure Kubernetes to expose the JMX port. This configuration exposes the port for JMX within the Kubernetes service.
+     ```yaml
+     ports:
+       - containerPort: 9010
+     ```
+   - Use container orchestration tools to manage JMX access
+
+   Service Discovery: Use tools like Kubernetes for managing and discovering JMX endpoints. You can define services to access your application. This service definition allows access to the JMX port on your application.
+
+   ```yaml
+   kind: Service
+   apiVersion: v1
+   metadata:
+     name: my-java-app
+   spec:
+     ports:
+       - port: 9010
+         targetPort: 9010
+     selector:
+       app: my-java-app
+   ```
+
 3. Integrate with monitoring platforms:
-    - Use JMX exporters to send metrics to centralized monitoring systems: Java Management Extensions (JMX) are commonly used by Java programs to expose different metrics and management data. Metrics related to garbage collection, thread activity, memory usage, and custom application-specific metrics are some of its examples. However, [JMX metrics](https://signoz.io/docs/tutorial/jmx-metrics/) are available in a Java-specific format, which isn't directly compatible with the majority of centralized monitoring solutions. In this scenario, JMX Exporters act as intermediaries that translate JMX metrics into a format that centralized monitoring systems can understand.
+   - Use JMX exporters to send metrics to centralized monitoring systems: Java Management Extensions (JMX) are commonly used by Java programs to expose different metrics and management data. Metrics related to garbage collection, thread activity, memory usage, and custom application-specific metrics are some of its examples. However, [JMX metrics](https://signoz.io/docs/tutorial/jmx-metrics/) are available in a Java-specific format, which isn't directly compatible with the majority of centralized monitoring solutions. In this scenario, JMX Exporters act as intermediaries that translate JMX metrics into a format that centralized monitoring systems can understand.
 4. Optimize performance impact:
-    - Limit the number of exposed metrics: You can adapt selective exposure technique to only expose essential metrics to avoid excessive overhead. It’s important to focus on high-impact metrics like heap memory usage or transaction rates.
-    - Use sampling for high-frequency metrics: Collecting metrics at regular intervals can be a significant factor in reducing the load. You can do so by updating metrics only at specified intervals to reduce the monitoring impact.
-    
-    ```bash
-    long lastSampleTime = System.currentTimeMillis();
-    long sampleInterval = 60000; // 1 minute
-    
-    public void updateMetric() {
-        long currentTime = System.currentTimeMillis();
-        if (currentTime - lastSampleTime >= sampleInterval) {
-            // Update and record metric
-            lastSampleTime = currentTime;
-        }
-    }
-    ```
-    
-    - Consider using asynchronous operations for time-consuming management tasks: Perform time-consuming tasks asynchronously to avoid blocking. It’s a better approach to use a separate thread for tasks that take time to prevent blocking the main application.
-    
-    ```bash
-    public void performTimeConsumingTask() {
-        Executors.newSingleThreadExecutor().submit(() -> {
-            // Perform the task
-        });
-    }
-    ```
-    
+
+   - Limit the number of exposed metrics: You can adapt selective exposure technique to only expose essential metrics to avoid excessive overhead. It’s important to focus on high-impact metrics like heap memory usage or transaction rates.
+   - Use sampling for high-frequency metrics: Collecting metrics at regular intervals can be a significant factor in reducing the load. You can do so by updating metrics only at specified intervals to reduce the monitoring impact.
+
+   ```bash
+   long lastSampleTime = System.currentTimeMillis();
+   long sampleInterval = 60000; // 1 minute
+
+   public void updateMetric() {
+       long currentTime = System.currentTimeMillis();
+       if (currentTime - lastSampleTime >= sampleInterval) {
+           // Update and record metric
+           lastSampleTime = currentTime;
+       }
+   }
+   ```
+
+   - Consider using asynchronous operations for time-consuming management tasks: Perform time-consuming tasks asynchronously to avoid blocking. It’s a better approach to use a separate thread for tasks that take time to prevent blocking the main application.
+
+   ```bash
+   public void performTimeConsumingTask() {
+       Executors.newSingleThreadExecutor().submit(() -> {
+           // Perform the task
+       });
+   }
+   ```
 
 ## Enhancing JMX Monitoring with SigNoz
 
@@ -555,4 +560,4 @@ Common JMX connection issues can be resolved by:
 
 ## Resources
 
-- [Java Application Monitoring - How to & Top 10 Tools | SigNoz](https://signoz.io/guides/monitoring-java-applications/)
\ No newline at end of file
+- [Java Application Monitoring - How to & Top 10 Tools | SigNoz](https://signoz.io/guides/monitoring-java-applications/)
diff --git a/data/guides/kafka-metrics.mdx b/data/guides/kafka-metrics.mdx
index 5bd200b71..01fe210c1 100644
--- a/data/guides/kafka-metrics.mdx
+++ b/data/guides/kafka-metrics.mdx
@@ -1,16 +1,22 @@
 ---
-
 title: Mastering Kafka Metrics - A Comprehensive Guide
-slug: kafka-metrics
 date: 2024-12-05
 tags: [monitoring]
 authors: [bhavya_sachdeva]
 description: Dive deep into Kafka metrics with our comprehensive guide. Learn essential broker, producer, consumer, and ZooKeeper metrics for optimal performance monitoring.
-keywords: [Kafka metrics, performance monitoring, broker metrics, consumer metrics, producer metrics, ZooKeeper metrics, Kafka optimization]
-
+keywords:
+  [
+    Kafka metrics,
+    performance monitoring,
+    broker metrics,
+    consumer metrics,
+    producer metrics,
+    ZooKeeper metrics,
+    Kafka optimization,
+  ]
 ---
 
-Apache Kafka is a cornerstone of modern data streaming architectures, acting as the backbone for real-time analytics, event-driven systems, and data pipelines. But even the most robust systems require diligent monitoring to perform at their best, and Kafka is no exception. To ensure smooth operations, Kafka metrics are like the health check for your Kafka cluster. They keep track of how everything is running, spotting any issues early so you can fix them before they become bigger problems. 
+Apache Kafka is a cornerstone of modern data streaming architectures, acting as the backbone for real-time analytics, event-driven systems, and data pipelines. But even the most robust systems require diligent monitoring to perform at their best, and Kafka is no exception. To ensure smooth operations, Kafka metrics are like the health check for your Kafka cluster. They keep track of how everything is running, spotting any issues early so you can fix them before they become bigger problems.
 
 This guide explores Kafka metrics in detail, their importance, and how they can be leveraged to maintain optimal cluster management. Think of Kafka metrics as the dashboard indicators in a car—they keep you informed about engine health, fuel levels, and performance, allowing you to act before a problem stalls the journey.
 
@@ -21,21 +27,20 @@ Kafka metrics are quantitative indicators that offer a real-time view of how you
 ### Why Do Kafka Metrics Matter?
 
 1. Monitoring Cluster Health
-    
-    Imagine running a manufacturing plant—machines must be checked regularly to avoid sudden breakdowns. Kafka metrics allow you to monitor your cluster's "machines" (brokers, producers, consumers) to detect and resolve issues before they disrupt operations.
-    
+
+   Imagine running a manufacturing plant—machines must be checked regularly to avoid sudden breakdowns. Kafka metrics allow you to monitor your cluster's "machines" (brokers, producers, consumers) to detect and resolve issues before they disrupt operations.
+
 2. Optimizing Performance
-    
-    Performance tuning is like fine-tuning a musical instrument; every adjustment affects the harmony. Kafka metrics help identify bottlenecks or inefficiencies, allowing you to optimize configurations for smoother performance and better throughput.
-    
+
+   Performance tuning is like fine-tuning a musical instrument; every adjustment affects the harmony. Kafka metrics help identify bottlenecks or inefficiencies, allowing you to optimize configurations for smoother performance and better throughput.
+
 3. Capacity Planning
-    
-    Think of Kafka metrics as the load gauge on a bridge. They help you understand current usage and predict when additional capacity will be needed to handle increased loads. This proactive approach ensures your cluster can scale seamlessly as demands grow.
-    
+
+   Think of Kafka metrics as the load gauge on a bridge. They help you understand current usage and predict when additional capacity will be needed to handle increased loads. This proactive approach ensures your cluster can scale seamlessly as demands grow.
+
 4. Efficient Troubleshooting
-    
-    When issues arise, metrics act as the breadcrumbs leading to the root cause. Just as a mechanic uses diagnostic codes to identify car issues, Kafka metrics pinpoint where a problem lies, reducing downtime and simplifying fixes.
-    
+
+   When issues arise, metrics act as the breadcrumbs leading to the root cause. Just as a mechanic uses diagnostic codes to identify car issues, Kafka metrics pinpoint where a problem lies, reducing downtime and simplifying fixes.
 
 Kafka metrics fall into four main categories:
 
@@ -53,13 +58,13 @@ This metric represents the total number of active brokers in the Kafka cluster.
 ### Why Monitor This Metric?
 
 1. Cluster Stability:
-    - A drop in the broker count indicates that one or more brokers have become unresponsive or gone offline.
-    - It is crucial to maintain the expected broker count to ensure data availability and fault tolerance.
+   - A drop in the broker count indicates that one or more brokers have become unresponsive or gone offline.
+   - It is crucial to maintain the expected broker count to ensure data availability and fault tolerance.
 2. Replication and Partition Distribution:
-    - A decrease in brokers impacts partition replication and may lead to an increase in under-replicated partitions.
-    - Uneven partition distribution can arise when brokers go offline, affecting performance.
+   - A decrease in brokers impacts partition replication and may lead to an increase in under-replicated partitions.
+   - Uneven partition distribution can arise when brokers go offline, affecting performance.
 3. Detect Failures Early:
-    - Monitoring this metric helps detect and address broker crashes or connectivity failures.
+   - Monitoring this metric helps detect and address broker crashes or connectivity failures.
 
 ### Recommended Actions:
 
@@ -74,17 +79,17 @@ This metric measures the time taken to handle requests in the Kafka cluster.
 ### Why Monitor This Metric?
 
 1. Identify Latency Issues:
-    - High request times indicate delays in processing producer, consumer, or admin requests, which could lead to bottlenecks.
+   - High request times indicate delays in processing producer, consumer, or admin requests, which could lead to bottlenecks.
 2. Detect Resource Constraints:
-    - Spikes in request times might suggest insufficient broker resources (CPU, memory, disk I/O).
+   - Spikes in request times might suggest insufficient broker resources (CPU, memory, disk I/O).
 3. Monitor Cluster Performance:
-    - Persistent high request times may result in delayed message delivery, affecting downstream systems.
+   - Persistent high request times may result in delayed message delivery, affecting downstream systems.
 
 ### No Data Scenario:
 
 - If no data is shown for request times, it may mean that either:
-    - No significant requests were made during the monitoring period.
-    - The monitoring system might not be capturing this metric due to misconfiguration.
+  - No significant requests were made during the monitoring period.
+  - The monitoring system might not be capturing this metric due to misconfiguration.
 
 ### Recommended Actions:
 
@@ -99,14 +104,14 @@ These metrics represent the rate of incoming and outgoing network traffic in byt
 ### Why Are These Metrics Important?
 
 1. Cluster Throughput Assessment:
-    - BytesInPerSec reflects the amount of data being produced to the cluster.
-    - BytesOutPerSec indicates the data consumed from the cluster.
-    - Together, they provide a measure of the cluster's throughput, helping you evaluate whether the brokers can handle the current workload.
+   - BytesInPerSec reflects the amount of data being produced to the cluster.
+   - BytesOutPerSec indicates the data consumed from the cluster.
+   - Together, they provide a measure of the cluster's throughput, helping you evaluate whether the brokers can handle the current workload.
 2. Identify Network Bottlenecks:
-    - Sudden spikes in traffic can overwhelm network interfaces, leading to message delivery delays or dropped messages.
-    - A persistent high value may suggest the need to optimize the network setup or upgrade bandwidth.
+   - Sudden spikes in traffic can overwhelm network interfaces, leading to message delivery delays or dropped messages.
+   - A persistent high value may suggest the need to optimize the network setup or upgrade bandwidth.
 3. Capacity Planning:
-    - Monitoring these metrics over time enables proactive planning for network upgrades to accommodate future traffic growth.
+   - Monitoring these metrics over time enables proactive planning for network upgrades to accommodate future traffic growth.
 
 ### Recommended Actions:
 
@@ -121,13 +126,13 @@ This metric tracks the number of messages produced to the cluster per second.
 ### Why Is This Metric Important?
 
 1. Understand Processing Capacity:
-    - Monitoring MessagesInPerSec helps gauge your cluster's ability to handle the current load of incoming messages.
-    - A consistently high rate could indicate the need to scale up resources.
+   - Monitoring MessagesInPerSec helps gauge your cluster's ability to handle the current load of incoming messages.
+   - A consistently high rate could indicate the need to scale up resources.
 2. Identify Traffic Anomalies:
-    - A sudden spike might indicate a new producer sending excessive messages, while a drop could signal producer issues or reduced application activity.
+   - A sudden spike might indicate a new producer sending excessive messages, while a drop could signal producer issues or reduced application activity.
 3. Correlate with Other Metrics:
-    - When analyzed alongside BytesInPerSec, it provides insights into the size of incoming messages.
-    - A high MessagesInPerSec with low BytesInPerSec might mean smaller message payloads, while the reverse indicates larger payloads.
+   - When analyzed alongside BytesInPerSec, it provides insights into the size of incoming messages.
+   - A high MessagesInPerSec with low BytesInPerSec might mean smaller message payloads, while the reverse indicates larger payloads.
 
 ### Recommended Actions:
 
@@ -152,18 +157,18 @@ This metric indicates the number of active controllers in the Kafka cluster. Kaf
 ### Why It Matters:
 
 1. Cluster Coordination:
-    - The controller manages the cluster's metadata and ensures synchronization between brokers.
-    - Multiple active controllers can lead to split-brain scenarios, where conflicting states arise between brokers.
+   - The controller manages the cluster's metadata and ensures synchronization between brokers.
+   - Multiple active controllers can lead to split-brain scenarios, where conflicting states arise between brokers.
 2. Cluster Availability:
-    - If no active controller exists, Kafka cannot handle partition leadership changes or other administrative tasks, which can cause outages.
+   - If no active controller exists, Kafka cannot handle partition leadership changes or other administrative tasks, which can cause outages.
 3. High Availability:
-    - An active controller ensures that leader elections and partition assignments are performed efficiently during broker failures.
+   - An active controller ensures that leader elections and partition assignments are performed efficiently during broker failures.
 
 ### Recommended Actions:
 
 - If ActiveControllerCount is not 1, check:
-    - The health of ZooKeeper (or KRaft, if used) as it manages controller elections.
-    - Broker logs for errors indicating controller election failures.
+  - The health of ZooKeeper (or KRaft, if used) as it manages controller elections.
+  - Broker logs for errors indicating controller election failures.
 - Configure proper timeouts for controller elections in Kafka settings (`zookeeper.session.timeout.ms`).
 
 ### 2. OfflinePartitionsCount
@@ -179,17 +184,17 @@ This metric tracks the number of partitions that are unavailable for reads or wr
 ### Why It Matters:
 
 1. Data Availability:
-    - Offline partitions cannot process messages, causing disruptions for producers and consumers.
+   - Offline partitions cannot process messages, causing disruptions for producers and consumers.
 2. Risk of Data Loss:
-    - Persistent offline partitions can lead to message loss if the cluster cannot replicate the missing data.
+   - Persistent offline partitions can lead to message loss if the cluster cannot replicate the missing data.
 3. Cluster Imbalance:
-    - Offline partitions often indicate broker failures or issues with partition replication.
+   - Offline partitions often indicate broker failures or issues with partition replication.
 
 ### Recommended Actions:
 
 - Investigate the cause of offline partitions:
-    - Check broker logs for errors related to storage, memory, or network failures.
-    - Ensure that brokers hosting the partitions are online and reachable.
+  - Check broker logs for errors related to storage, memory, or network failures.
+  - Ensure that brokers hosting the partitions are online and reachable.
 - Review replication factors and ensure that critical topics have sufficient redundancy.
 - Set up alerts for non-zero OfflinePartitionsCount to address issues promptly.
 
@@ -206,17 +211,17 @@ This metric shows the frequency of leadership changes for partitions in the Kafk
 ### Why It Matters:
 
 1. Cluster Stability:
-    - Frequent leader elections indicate instability caused by broker failures, high network latency, or misconfigurations.
+   - Frequent leader elections indicate instability caused by broker failures, high network latency, or misconfigurations.
 2. Performance Impact:
-    - Leadership changes disrupt partition processing temporarily, increasing producer and consumer latencies.
+   - Leadership changes disrupt partition processing temporarily, increasing producer and consumer latencies.
 3. Configuration Issues:
-    - Misconfigured timeout settings can lead to premature leader elections, even when brokers are healthy.
+   - Misconfigured timeout settings can lead to premature leader elections, even when brokers are healthy.
 
 ### Recommended Actions:
 
 - Identify and resolve causes of frequent leader elections:
-    - Check broker logs for errors indicating failures or network connectivity issues.
-    - Review timeout settings (`session.timeout.ms` and `heartbeat.interval.ms`) to prevent unnecessary leader changes.
+  - Check broker logs for errors indicating failures or network connectivity issues.
+  - Review timeout settings (`session.timeout.ms` and `heartbeat.interval.ms`) to prevent unnecessary leader changes.
 - Scale the cluster if frequent elections occur due to resource contention.
 
 ### 4. UncleanLeaderElectionsPerSec
@@ -232,18 +237,18 @@ This metric tracks the rate of unclean leader elections in the cluster. An uncle
 ### Why It Matters:
 
 1. Data Consistency:
-    - An unclean leader election can result in data loss because the new leader may not have the latest data.
+   - An unclean leader election can result in data loss because the new leader may not have the latest data.
 2. Cluster Reliability:
-    - Frequent unclean elections indicate serious issues with replication, such as insufficient ISRs or slow replica recovery.
+   - Frequent unclean elections indicate serious issues with replication, such as insufficient ISRs or slow replica recovery.
 3. Replication Settings:
-    - Misconfigured replication settings (e.g., low replication factors or incorrect `min.insync.replicas`) increase the risk of unclean elections.
+   - Misconfigured replication settings (e.g., low replication factors or incorrect `min.insync.replicas`) increase the risk of unclean elections.
 
 ### Recommended Actions:
 
 - Prevent unclean elections:
-    - Set `unclean.leader.election.enable=false` to disable unclean elections entirely.
-    - Increase replication factors for critical topics to ensure more ISRs are available.
-    - Ensure brokers have sufficient resources (CPU, memory, disk I/O) to handle replication efficiently.
+  - Set `unclean.leader.election.enable=false` to disable unclean elections entirely.
+  - Increase replication factors for critical topics to ensure more ISRs are available.
+  - Ensure brokers have sufficient resources (CPU, memory, disk I/O) to handle replication efficiently.
 - Monitor replication lag and troubleshoot brokers with slow replicas.
 
 ## Critical Kafka Producer Metrics for Optimal Performance
@@ -349,21 +354,20 @@ This metric shows the total number of znodes in your ZooKeeper ensemble. Monitor
 Effective monitoring requires proper collection and visualization of Kafka metrics. Here's how you can set it up:
 
 1. Use JMX for Kafka Metrics
-    
-    Kafka exposes metrics via JMX (Java Management Extensions) by default. Ensure your Kafka brokers are configured to enable remote JMX connections.
-    
+
+   Kafka exposes metrics via JMX (Java Management Extensions) by default. Ensure your Kafka brokers are configured to enable remote JMX connections.
+
 2. Collect Metrics with SigNoz
-    
-    SigNoz provides built-in support for collecting Kafka metrics seamlessly. Set up SigNoz to ingest these metrics through its [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-based architecture.
-    
+
+   SigNoz provides built-in support for collecting Kafka metrics seamlessly. Set up SigNoz to ingest these metrics through its [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-based architecture.
+
 3. Visualize Metrics in SigNoz
-    
-    Leverage SigNoz's intuitive dashboards to monitor Kafka metrics in real-time. These dashboards are customizable, allowing you to focus on the metrics most critical to your operations.
-    
+
+   Leverage SigNoz's intuitive dashboards to monitor Kafka metrics in real-time. These dashboards are customizable, allowing you to focus on the metrics most critical to your operations.
+
 4. Configure Alerts in SigNoz
-    
-    Set up intelligent alerts in SigNoz to notify your team when key Kafka metrics exceed predefined thresholds. This ensures proactive identification and resolution of potential issues.
-    
+
+   Set up intelligent alerts in SigNoz to notify your team when key Kafka metrics exceed predefined thresholds. This ensures proactive identification and resolution of potential issues.
 
 By using SigNoz for Kafka monitoring, you gain a unified solution that combines metric collection, visualization, and alerting with advanced observability capabilities.
 
@@ -383,104 +387,112 @@ To monitor Kafka, ensure your Kafka instance is up and running with proper confi
 ### Kafka Installation:
 
 1. Download Kafka:
-    
-    Obtain the latest <a href="https://kafka.apache.org/downloads" rel="noopener noreferrer nofollow" target="_blank">Kafka release</a> and extract it:
-    
-    ```bash
-    tar -xzf kafka-3.9.0-src.tgz
-    cd kafka-3.9.0-src
-    ```
-    
+
+   Obtain the latest <a href="https://kafka.apache.org/downloads" rel="noopener noreferrer nofollow" target="_blank">Kafka release</a> and extract it:
+
+   ```bash
+   tar -xzf kafka-3.9.0-src.tgz
+   cd kafka-3.9.0-src
+   ```
+
 2. Start ZooKeeper (if not using KRaft):
-    
-    Kafka requires ZooKeeper for managing brokers:
-    
-    ```bash
-    bin/zookeeper-server-start.sh config/zookeeper.properties
-    
-    ```
-    
-    <Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_8.12.25_AM.webp" alt="" caption="" />3. Configure and Start Two Kafka Brokers:
+
+   Kafka requires ZooKeeper for managing brokers:
+
+   ```bash
+   bin/zookeeper-server-start.sh config/zookeeper.properties
+
+   ```
+
+   <Figure
+     src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_8.12.25_AM.webp"
+     alt=""
+     caption=""
+   />
+   3. Configure and Start Two Kafka Brokers:
+
 - Copy the default server configuration file and customize it:
-    
-    ```bash
-    cp config/server.properties config/s1.properties
-    
-    ```
-    
+  ```bash
+  cp config/server.properties config/s1.properties
+
+  ```
 - Edit `s1.properties` to set the following:
-    
-    ```
-    broker.id=0
-    listeners=PLAINTEXT://localhost:9092
-    logs.dirs=/tmp/kafka-logs-1
-    zookeeper.connect=localhost:2181
-    ```
-    
+  ```
+  broker.id=0
+  listeners=PLAINTEXT://localhost:9092
+  logs.dirs=/tmp/kafka-logs-1
+  zookeeper.connect=localhost:2181
+  ```
 - Repeat for the second broker (`s2.properties`) with:
-    
-    ```
-    broker.id=1
-    listeners=PLAINTEXT://localhost:9093
-    logs.dirs=/tmp/kafka-logs-2
-    zookeeper.connect=localhost:2181
-    
-    ```
-    
+  ```
+  broker.id=1
+  listeners=PLAINTEXT://localhost:9093
+  logs.dirs=/tmp/kafka-logs-2
+  zookeeper.connect=localhost:2181
+
+  ```
 - Start both brokers in separate terminals:
-    
-    ```bash
-    JMX_PORT=2020 bin/kafka-server-start.sh config/s1.properties
-    JMX_PORT=2021 bin/kafka-server-start.sh config/s2.properties
-    
-    ```
-    
+  ```bash
+  JMX_PORT=2020 bin/kafka-server-start.sh config/s1.properties
+  JMX_PORT=2021 bin/kafka-server-start.sh config/s2.properties
+
+  ```
+
 1.  Create Kafka Topics:
-    
+
     ```bash
     bin/kafka-topics.sh --create --topic topic1 --bootstrap-server localhost:9092 --replication-factor 2 --partitions 2
     bin/kafka-topics.sh --create --topic topic2 --bootstrap-server localhost:9092 --replication-factor 2 --partitions 1
-    
+
     ```
-    
-    <Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.41.20_PM.webp" alt="" caption="" />Verify the setup:
-    
+
+    <Figure
+      src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.41.20_PM.webp"
+      alt=""
+      caption=""
+    />
+    Verify the setup:
+
     ```bash
     bin/kafka-topics.sh --describe --topic topic1 --bootstrap-server localhost:9092
     bin/kafka-topics.sh --describe --topic topic2 --bootstrap-server localhost:9092
     ```
-    
-2. Test Kafka Setup:
-    
+
+2.  Test Kafka Setup:
+
     Produce and consume messages:
-    
+
     ```bash
     bin/kafka-console-producer.sh --topic topic1 --bootstrap-server localhost:9092
     # (Write some messages)
     bin/kafka-console-consumer.sh --topic topic1 --from-beginning --bootstrap-server localhost:9092
-    
+
     ```
-    
-    <Figure src="/img/guides/2024/12/kafka-metrics-f563e248-c0a2-4397-bee5-e9998393c3bb.webp" alt="" caption="" />### Step 2: Install OpenTelemetry Java Agent
+
+    <Figure
+      src="/img/guides/2024/12/kafka-metrics-f563e248-c0a2-4397-bee5-e9998393c3bb.webp"
+      alt=""
+      caption=""
+    />
+    ### Step 2: Install OpenTelemetry Java Agent
 
 Instrument your Kafka clients with OpenTelemetry for traces and metrics.
 
 1. Verify the Java Agent:
-    
-    Ensure the agent file exists:
-    
-    ```bash
-    cd kafka-opentelemetry-instrumentation/opentelemetry-javagent
-    ls | grep opentelemetry-javaagent.jar
-    
-    ```
-    
+
+   Ensure the agent file exists:
+
+   ```bash
+   cd kafka-opentelemetry-instrumentation/opentelemetry-javagent
+   ls | grep opentelemetry-javaagent.jar
+
+   ```
+
 2. (Optional) Download the Latest Agent:
-    
-    ```bash
-    curl -L -o opentelemetry-javaagent.jar https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
-    ```
-    
+
+   ```bash
+   curl -L -o opentelemetry-javaagent.jar https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
+   ```
 
 ---
 
@@ -489,125 +501,143 @@ Instrument your Kafka clients with OpenTelemetry for traces and metrics.
 Run the producer and consumer apps with OpenTelemetry instrumentation.
 
 1. Start the Producer App:
-    
-    ```bash
-    java -javaagent:${PWD}/opentelemetry-javagent/opentelemetry-javaagent.jar \
-         -Dotel.service.name=producer-svc \
-         -Dotel.traces.exporter=otlp \
-         -Dotel.metrics.exporter=otlp \
-         -Dotel.logs.exporter=otlp \
-         -jar ${PWD}/kafka-app-otel/kafka-producer/target/kafka-producer-1.0-SNAPSHOT-jar-with-dependencies.jar
-    
-    ```
-    
+
+   ```bash
+   java -javaagent:${PWD}/opentelemetry-javagent/opentelemetry-javaagent.jar \
+        -Dotel.service.name=producer-svc \
+        -Dotel.traces.exporter=otlp \
+        -Dotel.metrics.exporter=otlp \
+        -Dotel.logs.exporter=otlp \
+        -jar ${PWD}/kafka-app-otel/kafka-producer/target/kafka-producer-1.0-SNAPSHOT-jar-with-dependencies.jar
+
+   ```
+
 2. Start the Consumer App:
-    
-    ```bash
-    java -javaagent:${PWD}/opentelemetry-javagent/opentelemetry-javaagent.jar \
-         -Dotel.service.name=consumer-svc \
-         -Dotel.traces.exporter=otlp \
-         -Dotel.metrics.exporter=otlp \
-         -Dotel.logs.exporter=otlp \
-         -Dotel.instrumentation.kafka.producer-propagation.enabled=true \
-         -Dotel.instrumentation.kafka.experimental-span-attributes=true \
-         -Dotel.instrumentation.kafka.metric-reporter.enabled=true \
-         -jar ${PWD}/kafka-app-otel/kafka-consumer/target/kafka-consumer.-1.0-SNAPSHOT-jar-with-dependencies.jar
-    
-    ```
-    
+
+   ```bash
+   java -javaagent:${PWD}/opentelemetry-javagent/opentelemetry-javaagent.jar \
+        -Dotel.service.name=consumer-svc \
+        -Dotel.traces.exporter=otlp \
+        -Dotel.metrics.exporter=otlp \
+        -Dotel.logs.exporter=otlp \
+        -Dotel.instrumentation.kafka.producer-propagation.enabled=true \
+        -Dotel.instrumentation.kafka.experimental-span-attributes=true \
+        -Dotel.instrumentation.kafka.metric-reporter.enabled=true \
+        -jar ${PWD}/kafka-app-otel/kafka-consumer/target/kafka-consumer.-1.0-SNAPSHOT-jar-with-dependencies.jar
+
+   ```
 
 ### Step 4: Install SigNoz
 
 Choose between SigNoz Cloud or a self-hosted deployment for observability.
 
 1. Install SigNoz:
-    
-    Follow the instructions from the [SigNoz documentation](https://signoz.io/docs/install/).
-    
+
+   Follow the instructions from the [SigNoz documentation](https://signoz.io/docs/install/).
+
 2. Configure Kafka Metrics Collection:
-    
-    Set up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) to push Kafka metrics to SigNoz.
-    
+
+   Set up the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) to push Kafka metrics to SigNoz.
 
 ### Step 5: OpenTelemetry Collector Setup
 
 1. Download the OpenTelemetry Collector:
-    
-    Install the `otelcol-contrib` collector in the root directory of the project kafka-opentelemetry-instrumentation:
-    
-    ```bash
-    wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.114.0/otelcol-contrib_0.114.0_darwin_arm64.tar.gz
-    tar -xzf  otelcol-contrib_0.114.0_darwin_arm64.tar.gz                                                                                         
-    
-    ```
-    
+
+   Install the `otelcol-contrib` collector in the root directory of the project kafka-opentelemetry-instrumentation:
+
+   ```bash
+   wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.114.0/otelcol-contrib_0.114.0_darwin_arm64.tar.gz
+   tar -xzf  otelcol-contrib_0.114.0_darwin_arm64.tar.gz
+
+   ```
+
 2. Use the Provided Configuration:
-    
-    Save the configuration file (`collector/collector-contrib-config.yaml`) to the root directory.
-    
-    Make sure to modify the collector-contrib-config.yaml if you are using SigNoz Cloud:
-    
-    ```jsx
-    receivers:
-      # Read more about kafka metrics receiver - https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/kafkametricsreceiver/README.md
-      kafkametrics:
-        brokers:
-          - localhost:9092
-          - localhost:9093
-          - localhost:9094
-        protocol_version: 2.0.0
-        scrapers:
-          - brokers
-          - topics
-          - consumers
-      # Read more about jmx receiver - https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/jmxreceiver/README.md
-      jmx/1:
-        # configure the path where you installed opentelemetry-jmx-metrics jar
-        jar_path: /Users/bhavyasachdeva/desktop/kafka-opentelemetry-instrumentation/collector/opentelemetry-jmx-metrics.jar #change this to the path to you opentelemetry-jmx-metrics jar file you downloaded above
-        endpoint: service:jmx:rmi:///jndi/rmi://localhost:9991/jmxrmi
-        target_system: jvm,kafka,kafka-consumer,kafka-producer
-        collection_interval: 10s
-        log_level: info
-        resource_attributes:
-          broker.name: broker1
-      jmx/2:
-        jar_path: /Users/bhavyasachdeva/desktop/kafka-opentelemetry-instrumentation/collector/opentelemetry-jmx-metrics.jar
-        endpoint: service:jmx:rmi:///jndi/rmi://localhost:9992/jmxrmi
-        target_system: jvm,kafka,kafka-consumer,kafka-producer
-        collection_interval: 10s
-        log_level: info
-        resource_attributes:
-          broker.name: broker2
-    exporters:
-      otlp:
-        endpoint: "ingest.{region}.signoz.cloud:443"
-        tls:
-          insecure: false
-        headers:
-          "signoz-ingestion-key": "<ingestion-key>"
-      debug:
-        verbosity: detailed
-    
-    service:
-      pipelines:
-        metrics:
-          receivers: [kafkametrics, jmx/1, jmx/2]
-          exporters: [otlp]
-    ```
-    
+
+   Save the configuration file (`collector/collector-contrib-config.yaml`) to the root directory.
+
+   Make sure to modify the collector-contrib-config.yaml if you are using SigNoz Cloud:
+
+   ```jsx
+   receivers:
+     # Read more about kafka metrics receiver - https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/kafkametricsreceiver/README.md
+     kafkametrics:
+       brokers:
+         - localhost:9092
+         - localhost:9093
+         - localhost:9094
+       protocol_version: 2.0.0
+       scrapers:
+         - brokers
+         - topics
+         - consumers
+     # Read more about jmx receiver - https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/jmxreceiver/README.md
+     jmx/1:
+       # configure the path where you installed opentelemetry-jmx-metrics jar
+       jar_path: /Users/bhavyasachdeva/desktop/kafka-opentelemetry-instrumentation/collector/opentelemetry-jmx-metrics.jar #change this to the path to you opentelemetry-jmx-metrics jar file you downloaded above
+       endpoint: service:jmx:rmi:///jndi/rmi://localhost:9991/jmxrmi
+       target_system: jvm,kafka,kafka-consumer,kafka-producer
+       collection_interval: 10s
+       log_level: info
+       resource_attributes:
+         broker.name: broker1
+     jmx/2:
+       jar_path: /Users/bhavyasachdeva/desktop/kafka-opentelemetry-instrumentation/collector/opentelemetry-jmx-metrics.jar
+       endpoint: service:jmx:rmi:///jndi/rmi://localhost:9992/jmxrmi
+       target_system: jvm,kafka,kafka-consumer,kafka-producer
+       collection_interval: 10s
+       log_level: info
+       resource_attributes:
+         broker.name: broker2
+   exporters:
+     otlp:
+       endpoint: "ingest.{region}.signoz.cloud:443"
+       tls:
+         insecure: false
+       headers:
+         "signoz-ingestion-key": "<ingestion-key>"
+     debug:
+       verbosity: detailed
+
+   service:
+     pipelines:
+       metrics:
+         receivers: [kafkametrics, jmx/1, jmx/2]
+         exporters: [otlp]
+   ```
+
 3. Start the Collector:
-    
-    ```bash
-    ./otelcol-contrib --config ${PWD}/collector/collector-contrib-config.yaml
-    ```
-    
-    <Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-28_at_8.33.07_AM.webp" alt="" caption="" />---
+
+   ```bash
+   ./otelcol-contrib --config ${PWD}/collector/collector-contrib-config.yaml
+   ```
+
+   <Figure
+     src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-28_at_8.33.07_AM.webp"
+     alt=""
+     caption=""
+   />
+   ---
 
 ### Step 6: Monitor Kafka in SigNoz
 
 Once you have completed setting up the Kafka environment, configured the OpenTelemetry Collector, and run the producer and consumer applications, it's time to monitor and visualize Kafka metrics in SigNoz.
 
-<Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.38.23_PM.webp" alt="" caption="" /><Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.39.23_PM.webp" alt="" caption="" /><Figure src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-28_at_8.37.53_AM.webp" alt="" caption="" />You can also create alerts based on critical Kafka metrics for proactive issue resolution.
+<Figure
+  src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.38.23_PM.webp"
+  alt=""
+  caption=""
+/>
+<Figure
+  src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-26_at_3.39.23_PM.webp"
+  alt=""
+  caption=""
+/>
+<Figure
+  src="/img/guides/2024/12/kafka-metrics-Screenshot_2024-11-28_at_8.37.53_AM.webp"
+  alt=""
+  caption=""
+/>
+You can also create alerts based on critical Kafka metrics for proactive issue resolution.
 
 SigNoz provides several advantages for Kafka monitoring:
 
@@ -686,4 +716,4 @@ Choose a tool that integrates well with your existing infrastructure and meets y
 ## Resources
 
 - [Deep dive into the observability of Messaging Queues with OpenTelemetry](https://signoz.io/blog/kafka-monitoring-opentelemetry/)
-- [Monitor Kafka Service](https://signoz.io/docs/messaging-queues/kafka/)
\ No newline at end of file
+- [Monitor Kafka Service](https://signoz.io/docs/messaging-queues/kafka/)
diff --git a/data/guides/kibana-server-is-not-ready-yet.mdx b/data/guides/kibana-server-is-not-ready-yet.mdx
index f4199a2f1..ed801d86c 100644
--- a/data/guides/kibana-server-is-not-ready-yet.mdx
+++ b/data/guides/kibana-server-is-not-ready-yet.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: Troubleshooting Kibana Server Not Ready Yet - Quick Fix
-slug: kibana-server-is-not-ready-yet
 date: 2024-12-26
 tags: [kibana, faq]
 authors: [nilesh_sinha]
 description: Learn how to quickly resolve the Kibana server is not ready yet error with our comprehensive troubleshooting guide. Get your Kibana instance back online fast.
-keywords: [Kibana troubleshooting, Elasticsearch issues, ELK stack errors, Kibana server problems, data visualization troubleshooting, Elastic Stack maintenance]
-
+keywords:
+  [
+    Kibana troubleshooting,
+    Elasticsearch issues,
+    ELK stack errors,
+    Kibana server problems,
+    data visualization troubleshooting,
+    Elastic Stack maintenance,
+  ]
 ---
 
 The "Kibana server is not ready yet" error can bring your data visualization workflows to a screeching halt. This frustrating message often appears when you're eager to dive into your Elasticsearch data, leaving you stuck at the login screen. But don't worry — we've got you covered with a comprehensive guide to diagnose, fix, and prevent this common Kibana hiccup.
@@ -41,152 +46,127 @@ By understanding the root causes and impacts of the "Kibana Server Is Not Ready
 If you encounter the "Kibana Server Is Not Ready Yet" error, follow these steps to diagnose and resolve the issue efficiently:
 
 1. Check Elasticsearch Connection and Status
+
 - Ensure that Elasticsearch is running and accessible from the server where Kibana is installed.
-    
-    > If Elasticsearch security features are enabled, accessing the cluster health API without authentication will result in a 401 Unauthorized error. Ensure you provide basic authentication credentials in the `curl` command.
-    > 
-    
-    Unauthenticated Request:
-    
-    ```bash
-    curl -X GET "http://localhost:9200/_cluster/health?pretty"
-    ```
-    
-    Error Response:
-    
-    ```bash
-    {
-      "error" : {
-        "root_cause" : [
-          {
-            "type" : "security_exception",
-            "reason" : "missing authentication credentials for REST request [/_cluster/health?pretty]",
-            "header" : {
-              "WWW-Authenticate" : [
-                "Basic realm=\"security\", charset=\"UTF-8\"",
-                "ApiKey"
-              ]
-            }
+  > If Elasticsearch security features are enabled, accessing the cluster health API without authentication will result in a 401 Unauthorized error. Ensure you provide basic authentication credentials in the `curl` command.
+  Unauthenticated Request:
+  ```bash
+  curl -X GET "http://localhost:9200/_cluster/health?pretty"
+  ```
+  Error Response:
+  ```bash
+  {
+    "error" : {
+      "root_cause" : [
+        {
+          "type" : "security_exception",
+          "reason" : "missing authentication credentials for REST request [/_cluster/health?pretty]",
+          "header" : {
+            "WWW-Authenticate" : [
+              "Basic realm=\"security\", charset=\"UTF-8\"",
+              "ApiKey"
+            ]
           }
-        ],
-        "type" : "security_exception",
-        "reason" : "missing authentication credentials for REST request [/_cluster/health?pretty]",
-        "header" : {
-          "WWW-Authenticate" : [
-            "Basic realm=\"security\", charset=\"UTF-8\"",
-            "ApiKey"
-          ]
         }
-      },
-      "status" : 401
-    }
-    ```
-    
-    Authenticated Request:
-    
-    Include the username and password in the `curl` command using the `-u` flag.
-    
-    ```bash
-    curl -u username:password -X GET "http://localhost:9200/_cluster/health?pretty"
-    ```
-    
-    Successful Response:
-    
-    ```bash
-    {
-      "cluster_name" : "docker-cluster",
-      "status" : "green",
-      "timed_out" : false,
-      "number_of_nodes" : 1,
-      "number_of_data_nodes" : 1,
-      "active_primary_shards" : 35,
-      "active_shards" : 35,
-      "relocating_shards" : 0,
-      "initializing_shards" : 0,
-      "unassigned_shards" : 0,
-      "delayed_unassigned_shards" : 0,
-      "number_of_pending_tasks" : 0,
-      "number_of_in_flight_fetch" : 0,
-      "task_max_waiting_in_queue_millis" : 0,
-      "active_shards_percent_as_number" : 100.0
-    }
-    ```
-    
-    - Look for a "green" or "yellow" status. A "red" status indicates problems with the Elasticsearch cluster that need to be resolved.
+      ],
+      "type" : "security_exception",
+      "reason" : "missing authentication credentials for REST request [/_cluster/health?pretty]",
+      "header" : {
+        "WWW-Authenticate" : [
+          "Basic realm=\"security\", charset=\"UTF-8\"",
+          "ApiKey"
+        ]
+      }
+    },
+    "status" : 401
+  }
+  ```
+  Authenticated Request:
+  Include the username and password in the `curl` command using the `-u` flag.
+  ```bash
+  curl -u username:password -X GET "http://localhost:9200/_cluster/health?pretty"
+  ```
+  Successful Response:
+  ```bash
+  {
+    "cluster_name" : "docker-cluster",
+    "status" : "green",
+    "timed_out" : false,
+    "number_of_nodes" : 1,
+    "number_of_data_nodes" : 1,
+    "active_primary_shards" : 35,
+    "active_shards" : 35,
+    "relocating_shards" : 0,
+    "initializing_shards" : 0,
+    "unassigned_shards" : 0,
+    "delayed_unassigned_shards" : 0,
+    "number_of_pending_tasks" : 0,
+    "number_of_in_flight_fetch" : 0,
+    "task_max_waiting_in_queue_millis" : 0,
+    "active_shards_percent_as_number" : 100.0
+  }
+  ```
+  - Look for a "green" or "yellow" status. A "red" status indicates problems with the Elasticsearch cluster that need to be resolved.
+
 1. Verify Kibana and Elasticsearch Version Compatibility
-    - Kibana and Elasticsearch must have matching versions to work together.
-    - Check the versions installed on your system:
-        - Kibana: Run `kibana --version` or check the version in the Kibana UI.
-        - Elasticsearch: Check the version via the Elasticsearch cluster health command or the logs.
-    - Refer to the <a href="https://www.elastic.co/support/matrix" rel="noopener noreferrer nofollow" target="_blank">Elastic Compatibility Matrix</a> to ensure compatibility.
+   - Kibana and Elasticsearch must have matching versions to work together.
+   - Check the versions installed on your system:
+     - Kibana: Run `kibana --version` or check the version in the Kibana UI.
+     - Elasticsearch: Check the version via the Elasticsearch cluster health command or the logs.
+   - Refer to the <a href="https://www.elastic.co/support/matrix" rel="noopener noreferrer nofollow" target="_blank">Elastic Compatibility Matrix</a> to ensure compatibility.
 2. Review Kibana Configuration File (kibana.yml) Settings
-    - Open the `kibana.yml` file, typically located in `/etc/kibana/`.
-    - Ensure the following critical settings are correct:
-        - Elasticsearch host URL: Verify that the `elasticsearch.hosts` entry points to the correct Elasticsearch instance.
-            
-            ```yaml
-            elasticsearch.hosts: ["http://localhost:9200"]
-            ```
-            
-        - Server configuration: Check the `server.host` and `server.port` settings.
-        - Authentication: If security is enabled, confirm that the username and password for Kibana to connect to Elasticsearch are properly configured.
+   - Open the `kibana.yml` file, typically located in `/etc/kibana/`.
+   - Ensure the following critical settings are correct:
+     - Elasticsearch host URL: Verify that the `elasticsearch.hosts` entry points to the correct Elasticsearch instance.
+       ```yaml
+       elasticsearch.hosts: ['http://localhost:9200']
+       ```
+     - Server configuration: Check the `server.host` and `server.port` settings.
+     - Authentication: If security is enabled, confirm that the username and password for Kibana to connect to Elasticsearch are properly configured.
 3. Restart Kibana Service and Allow Sufficient Time for Initialization
-    - Restart the Kibana service using your system’s service manager:
-        
-        ```bash
-        sudo systemctl restart kibana
-        ```
-        
-    - Monitor the Kibana logs to track its startup process:
-        
-        ```bash
-        sudo journalctl -u kibana -f
-        ```
-        
-    - Allow a few minutes for the service to initialize fully, especially on systems with limited resources or large Elasticsearch clusters.
-    
-    By following these steps, you can address the most common causes of the "Kibana Server Is Not Ready Yet" error and restore Kibana’s functionality.
-    
+
+   - Restart the Kibana service using your system’s service manager:
+     ```bash
+     sudo systemctl restart kibana
+     ```
+   - Monitor the Kibana logs to track its startup process:
+     ```bash
+     sudo journalctl -u kibana -f
+     ```
+   - Allow a few minutes for the service to initialize fully, especially on systems with limited resources or large Elasticsearch clusters.
+
+   By following these steps, you can address the most common causes of the "Kibana Server Is Not Ready Yet" error and restore Kibana’s functionality.
 
 ### Common Configuration Mismatches
 
 Misconfigurations are a frequent cause of the "Kibana Server Is Not Ready Yet" error. Here are some common issues to check and address:
 
 1. Incorrect Elasticsearch URL in Kibana Settings
-    - Symptom: Kibana cannot establish a connection to Elasticsearch due to an incorrect URL in the `kibana.yml` configuration file.
-    - Solution: Verify and update the `elasticsearch.hosts` entry in `kibana.yml` to ensure it points to the correct Elasticsearch instance. Example:
-        
-        ```yaml
-        elasticsearch.hosts: ["http://localhost:9200"]
-        ```
-        
+   - Symptom: Kibana cannot establish a connection to Elasticsearch due to an incorrect URL in the `kibana.yml` configuration file.
+   - Solution: Verify and update the `elasticsearch.hosts` entry in `kibana.yml` to ensure it points to the correct Elasticsearch instance. Example:
+     ```yaml
+     elasticsearch.hosts: ['http://localhost:9200']
+     ```
 2. Firewall Blocking Communication Between Kibana and Elasticsearch
-    - Symptom: Network issues prevent Kibana from reaching Elasticsearch.
-    - Solution: Check your firewall settings to ensure the Elasticsearch port (default: `9200`) is open and accessible from the Kibana server.
-        
-        ```bash
-        sudo ufw allow 9200/tcp
-        ```
-        
+   - Symptom: Network issues prevent Kibana from reaching Elasticsearch.
+   - Solution: Check your firewall settings to ensure the Elasticsearch port (default: `9200`) is open and accessible from the Kibana server.
+     ```bash
+     sudo ufw allow 9200/tcp
+     ```
 3. SSL/TLS Certificate Issues
-    - Symptom: If SSL/TLS is enabled, improperly configured certificates can block secure communication between Kibana and Elasticsearch.
-    - Solution: Ensure that the `elasticsearch.ssl.certificate` and `elasticsearch.ssl.key` entries in `kibana.yml` are correctly configured and point to valid certificate files. Example:
-        
-        ```yaml
-        elasticsearch.ssl.certificate: /path/to/cert.pem
-        elasticsearch.ssl.key: /path/to/key.pem
-        ```
-        
+   - Symptom: If SSL/TLS is enabled, improperly configured certificates can block secure communication between Kibana and Elasticsearch.
+   - Solution: Ensure that the `elasticsearch.ssl.certificate` and `elasticsearch.ssl.key` entries in `kibana.yml` are correctly configured and point to valid certificate files. Example:
+     ```yaml
+     elasticsearch.ssl.certificate: /path/to/cert.pem
+     elasticsearch.ssl.key: /path/to/key.pem
+     ```
 4. Insufficient System Resources Allocated to Kibana
-    - Symptom: Limited memory, CPU, or disk space causes Kibana to fail during startup.
-    - Solution: Increase system resources allocated to Kibana. For example, adjust the heap size in the Kibana environment configuration:
-        
-        ```bash
-        export NODE_OPTIONS="--max-old-space-size=2048"
-        ```
-        
-        Restart the Kibana service after making the change.
-        
+   - Symptom: Limited memory, CPU, or disk space causes Kibana to fail during startup.
+   - Solution: Increase system resources allocated to Kibana. For example, adjust the heap size in the Kibana environment configuration:
+     ```bash
+     export NODE_OPTIONS="--max-old-space-size=2048"
+     ```
+     Restart the Kibana service after making the change.
 
 By addressing these common configuration mismatches, you can resolve many of the underlying causes of Kibana startup issues and ensure smooth operation.
 
@@ -198,73 +178,59 @@ When the "Kibana Server Is Not Ready Yet" error occurs, diagnosing the root caus
 
 - Purpose: Kibana logs provide detailed information about its startup process and any encountered issues.
 - How to Check:
-Or, check the log file directly if configured (e.g., `/var/log/kibana/kibana.log`).
-    
-    ```bash
-    sudo journalctl -u kibana -f
-    ```
-    
+  Or, check the log file directly if configured (e.g., `/var/log/kibana/kibana.log`).
+      ```bash
+      sudo journalctl -u kibana -f
+      ```
 - What to Look For:
-    - Elasticsearch connectivity issues
-    - Configuration errors
-    - Resource limitations
+  - Elasticsearch connectivity issues
+  - Configuration errors
+  - Resource limitations
 
 ### 2. Using curl Commands to Test Elasticsearch Connectivity
 
 - Purpose: Ensure Kibana can communicate with the Elasticsearch cluster.
 - Test Command:
-    
-    ```bash
-    curl -X GET "http://localhost:9200/_cluster/health?pretty"
-    ```
-    
+  ```bash
+  curl -X GET "http://localhost:9200/_cluster/health?pretty"
+  ```
 - Expected Output: Look for a "green" or "yellow" cluster status. A "red" status indicates issues with the Elasticsearch cluster.
 - Check Version Compatibility:
-Confirm that the version matches the Kibana version.
-    
-    ```bash
-    curl -X GET "http://localhost:9200"
-    ```
-    
+  Confirm that the version matches the Kibana version.
+      ```bash
+      curl -X GET "http://localhost:9200"
+      ```
 
 ### 3. Verifying Network Connectivity Between Kibana and Elasticsearch
 
 - Purpose: Ensure there are no network issues preventing Kibana from accessing Elasticsearch.
 - How to Check:
-    - Use `ping` to verify the Elasticsearch server is reachable:
-        
-        ```bash
-        ping <elasticsearch-host>
-        ```
-        
-    - Use `telnet` or `curl` to confirm the Elasticsearch port (default: `9200`) is open:
-        
-        ```bash
-        telnet <elasticsearch-host> 9200
-        ```
-        
+  - Use `ping` to verify the Elasticsearch server is reachable:
+    ```bash
+    ping <elasticsearch-host>
+    ```
+  - Use `telnet` or `curl` to confirm the Elasticsearch port (default: `9200`) is open:
+    ```bash
+    telnet <elasticsearch-host> 9200
+    ```
 - Firewall Check:
-Ensure firewalls or security groups allow traffic between Kibana and Elasticsearch.
+  Ensure firewalls or security groups allow traffic between Kibana and Elasticsearch.
 
 ### 4. Checking for Kibana Index Corruption or Deletion in Elasticsearch
 
 - Purpose: Kibana relies on the `.kibana` index in Elasticsearch for its configuration and state. If this index is missing or corrupted, Kibana may fail to start.
 - How to Check:
-Look for the `.kibana` index in the output.
-    
-    ```bash
-    curl -X GET "http://localhost:9200/_cat/indices?v"
-    ```
-    
+  Look for the `.kibana` index in the output.
+      ```bash
+      curl -X GET "http://localhost:9200/_cat/indices?v"
+      ```
 - Fixing Issues:
-    - If the index is missing, recreate it by restarting Kibana (it should automatically regenerate the index).
-    - For corruption, delete the index (data will be lost) and let Kibana recreate it:
+  - If the index is missing, recreate it by restarting Kibana (it should automatically regenerate the index).
+  - For corruption, delete the index (data will be lost) and let Kibana recreate it:
     Restart Kibana afterward.
-        
         ```bash
         curl -X DELETE "http://localhost:9200/.kibana"
         ```
-        
 
 By following these diagnostic steps, you can identify the underlying cause of the "[Kibana Server Is Not Ready Yet](https://signoz.io/guides/kibana-server-is-not-ready-yet/#quick-fix-steps-to-resolve-kibana-server-issues)" error and take the necessary corrective actions to restore functionality.
 
@@ -273,124 +239,92 @@ By following these diagnostic steps, you can identify the underlying cause of th
 When basic diagnostic steps fail to resolve the "Kibana Server Is Not Ready Yet" error, advanced troubleshooting techniques may be necessary. These methods address more complex underlying issues:
 
 1. Analyzing Elasticsearch Cluster Health
-    - Purpose: Ensure that the Elasticsearch cluster is in a healthy state, as Kibana relies on it for operations.
-    - How to Check:
-        
-        ```bash
-        curl -X GET "http://localhost:9200/_cluster/health?pretty"
-        ```
-        
-    - What to Look For:
-        - "Red" status: Indicates critical issues in the cluster (e.g., shard allocation failures).
-        - Node count: Verify that all nodes in the cluster are operational.
-    - Next Steps:
-        - Resolve shard allocation issues by using the following command:
-            
-            ```bash
-            curl -X POST "http://localhost:9200/_cluster/reroute?retry_failed=true"
-            ```
-            
-        - Check Elasticsearch logs for detailed error messages.
+   - Purpose: Ensure that the Elasticsearch cluster is in a healthy state, as Kibana relies on it for operations.
+   - How to Check:
+     ```bash
+     curl -X GET "http://localhost:9200/_cluster/health?pretty"
+     ```
+   - What to Look For:
+     - "Red" status: Indicates critical issues in the cluster (e.g., shard allocation failures).
+     - Node count: Verify that all nodes in the cluster are operational.
+   - Next Steps:
+     - Resolve shard allocation issues by using the following command:
+       ```bash
+       curl -X POST "http://localhost:9200/_cluster/reroute?retry_failed=true"
+       ```
+     - Check Elasticsearch logs for detailed error messages.
 2. Investigating Potential Plugin Conflicts
-    - Purpose: Plugins installed in Kibana or Elasticsearch can sometimes introduce compatibility issues.
-    - How to Check:
-        - Review the Kibana logs for plugin-related errors:
-            
-            ```bash
-            sudo journalctl -u kibana -f
-            ```
-            
-        - List installed plugins in Elasticsearch:
-            
-            ```bash
-            curl -X GET "http://localhost:9200/_cat/plugins?v"
-            ```
-            
-    - Next Steps:
-        - Disable problematic plugins in the `kibana.yml` configuration file or uninstall them:
-            
-            ```bash
-            sudo bin/kibana-plugin remove <plugin-name>
-            ```
-            
-        - Verify plugin compatibility with your versions of Kibana and Elasticsearch.
+   - Purpose: Plugins installed in Kibana or Elasticsearch can sometimes introduce compatibility issues.
+   - How to Check:
+     - Review the Kibana logs for plugin-related errors:
+       ```bash
+       sudo journalctl -u kibana -f
+       ```
+     - List installed plugins in Elasticsearch:
+       ```bash
+       curl -X GET "http://localhost:9200/_cat/plugins?v"
+       ```
+   - Next Steps:
+     - Disable problematic plugins in the `kibana.yml` configuration file or uninstall them:
+       ```bash
+       sudo bin/kibana-plugin remove <plugin-name>
+       ```
+     - Verify plugin compatibility with your versions of Kibana and Elasticsearch.
 3. Addressing Memory and CPU Utilization Issues
-    - Purpose: Insufficient resources can prevent Kibana from initializing properly.
-    - How to Check:
-        - Monitor system resources:
-            
-            ```bash
-            top
-            ```
-            
-        - Check for memory allocation issues in Kibana logs.
-    - Next Steps:
-        - Increase available memory for Kibana:
-            
-            ```bash
-            export NODE_OPTIONS="--max-old-space-size=4096"
-            ```
-            
-        - Optimize Elasticsearch heap size (e.g., set to 50% of available memory):
-            
-            ```bash
-            export ES_JAVA_OPTS="-Xms2g -Xmx2g"
-            ```
-            
-            Ensure the server has adequate CPU and memory resources for both Kibana and Elasticsearch.
-            
-        - Restart Kibana or Elasticsearch to ensure the changes take effect, and restart the respective services:
-            
-            For Kibana:
-            
-            ```bash
-            sudo systemctl restart kibana
-            ```
-            
-            Or, if running manually:
-            
-            ```bash
-            ./bin/kibana
-            ```
-            
-            For Elasticsearch:
-            
-            ```bash
-            sudo systemctl restart elasticsearch
-            ```
-            
-            Or, if running manually:
-            
-            ```bash
-            ./bin/elasticsearch
-            ```
-            
+   - Purpose: Insufficient resources can prevent Kibana from initializing properly.
+   - How to Check:
+     - Monitor system resources:
+       ```bash
+       top
+       ```
+     - Check for memory allocation issues in Kibana logs.
+   - Next Steps:
+     - Increase available memory for Kibana:
+       ```bash
+       export NODE_OPTIONS="--max-old-space-size=4096"
+       ```
+     - Optimize Elasticsearch heap size (e.g., set to 50% of available memory):
+       ```bash
+       export ES_JAVA_OPTS="-Xms2g -Xmx2g"
+       ```
+       Ensure the server has adequate CPU and memory resources for both Kibana and Elasticsearch.
+     - Restart Kibana or Elasticsearch to ensure the changes take effect, and restart the respective services:
+       For Kibana:
+       ```bash
+       sudo systemctl restart kibana
+       ```
+       Or, if running manually:
+       ```bash
+       ./bin/kibana
+       ```
+       For Elasticsearch:
+       ```bash
+       sudo systemctl restart elasticsearch
+       ```
+       Or, if running manually:
+       ```bash
+       ./bin/elasticsearch
+       ```
 4. Resolving Index Template and Mapping Problems
-    - Purpose: Misconfigured or corrupt index templates can lead to issues with Kibana’s `.kibana` index.
-    - How to Check:
-        - List index templates in Elasticsearch:
-            
-            ```bash
-            curl -X GET "http://localhost:9200/_template?pretty"
-            ```
-            
-        - Inspect the mappings of the `.kibana` index:
-            
-            ```bash
-            curl -X GET "http://localhost:9200/.kibana/_mapping?pretty"
-            ```
-            
-    - Next Steps:
-        - If an issue is identified, delete and recreate the `.kibana` index:
-            
-            ```bash
-            curl -X DELETE "http://localhost:9200/.kibana"
-            ```
-            
-        - Restart Kibana to allow it to regenerate the index with default templates.
-    
-    By employing these advanced troubleshooting techniques, you can address complex problems affecting Kibana’s readiness, ensuring the server is restored to full functionality.
-    
+
+   - Purpose: Misconfigured or corrupt index templates can lead to issues with Kibana’s `.kibana` index.
+   - How to Check:
+     - List index templates in Elasticsearch:
+       ```bash
+       curl -X GET "http://localhost:9200/_template?pretty"
+       ```
+     - Inspect the mappings of the `.kibana` index:
+       ```bash
+       curl -X GET "http://localhost:9200/.kibana/_mapping?pretty"
+       ```
+   - Next Steps:
+     - If an issue is identified, delete and recreate the `.kibana` index:
+       ```bash
+       curl -X DELETE "http://localhost:9200/.kibana"
+       ```
+     - Restart Kibana to allow it to regenerate the index with default templates.
+
+   By employing these advanced troubleshooting techniques, you can address complex problems affecting Kibana’s readiness, ensuring the server is restored to full functionality.
 
 ### Dealing with Docker-specific Challenges
 
@@ -401,90 +335,76 @@ Running Kibana in Docker environments introduces unique challenges. Addressing t
 - Symptom: Kibana cannot connect to Elasticsearch when running in separate containers, but both containers are present on the same Docker network.
 - Cause: Misconfigured Docker networking settings can prevent inter-container communication.
 - Solution:
-    - Ensure both containers are part of the same Docker network. This ensures they can resolve each other's container names as hostnames and establish proper connectivity.
-        
-        ```bash
-        docker network create elastic-network
-        docker run --name elasticsearch --network elastic-network elasticsearch
-        docker run --name kibana --network elastic-network kibana
-        ```
-        
-    - Use container names as hostnames in the `kibana.yml` file:
-        
-        ```yaml
-        elasticsearch.hosts: ["http://elasticsearch:9200"]
-        ```
-        
+  - Ensure both containers are part of the same Docker network. This ensures they can resolve each other's container names as hostnames and establish proper connectivity.
+    ```bash
+    docker network create elastic-network
+    docker run --name elasticsearch --network elastic-network elasticsearch
+    docker run --name kibana --network elastic-network kibana
+    ```
+  - Use container names as hostnames in the `kibana.yml` file:
+    ```yaml
+    elasticsearch.hosts: ['http://elasticsearch:9200']
+    ```
 
 2. Volume Mounting and Permission Problems
 
 - Symptom: Kibana fails to start due to permission issues when mounting configuration or data volumes.
 - Cause: The container’s user may not have the necessary permissions for the mounted host directories.
 - Solution:
-    - Ensure the directory permissions match the container’s requirements:
-        
-        ```bash
-        sudo chown 1000:1000 /path/to/host/directory
-        ```
-        
-    - Use Docker’s `-user` flag to run the container with specific user permissions:
-        
-        ```bash
-        docker run --user $(id -u):$(id -g) -v /path/to/host/directory:/usr/share/kibana kibana
-        ```
-        
+  - Ensure the directory permissions match the container’s requirements:
+    ```bash
+    sudo chown 1000:1000 /path/to/host/directory
+    ```
+  - Use Docker’s `-user` flag to run the container with specific user permissions:
+    ```bash
+    docker run --user $(id -u):$(id -g) -v /path/to/host/directory:/usr/share/kibana kibana
+    ```
 
 3. Docker Compose Configuration Best Practices
 
 - Symptom: Kibana and Elasticsearch services fail to communicate or start correctly in a Docker Compose setup.
 - Solution:
-    - Use the following example Docker Compose configuration to ensure proper setup:
-        
-        ```yaml
-        services:
-          elasticsearch:
-            image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
-            container_name: elasticsearch
-            environment:
-              - discovery.type=single-node
-            networks:
-              - elastic-network
-          kibana:
-            image: docker.elastic.co/kibana/kibana:7.10.2
-            container_name: kibana
-            depends_on:
-              - elasticsearch
-            environment:
-              - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
-            networks:
-              - elastic-network
+  - Use the following example Docker Compose configuration to ensure proper setup:
+    ```yaml
+    services:
+      elasticsearch:
+        image: docker.elastic.co/elasticsearch/elasticsearch:7.10.2
+        container_name: elasticsearch
+        environment:
+          - discovery.type=single-node
         networks:
-          elastic-network:
-            driver: bridge
-        ```
-        
-    - Run `docker-compose up` to start the services, ensuring proper connectivity and configuration.
+          - elastic-network
+      kibana:
+        image: docker.elastic.co/kibana/kibana:7.10.2
+        container_name: kibana
+        depends_on:
+          - elasticsearch
+        environment:
+          - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
+        networks:
+          - elastic-network
+    networks:
+      elastic-network:
+        driver: bridge
+    ```
+  - Run `docker-compose up` to start the services, ensuring proper connectivity and configuration.
 
 4. Troubleshooting Multi-Container Setups
 
 - Symptom: Issues arise when running Kibana alongside other services like Logstash or custom applications.
 - Solution:
-    - Check inter-container communication using `docker exec` and `curl`. If Elasticsearch security is enabled, add credentials:
-        
-        ```bash
-        	docker exec kibana curl -u username:password "http://elasticsearch:9200"
-        ```
-        
-    - Use Docker Compose health checks to ensure services are ready before dependent containers start:
-        
-        ```yaml
-        healthcheck:
-          test: ["CMD", "curl", "-f", "http://elasticsearch:9200"]
-          interval: 30s
-          timeout: 10s
-          retries: 3
-        ```
-        
+  - Check inter-container communication using `docker exec` and `curl`. If Elasticsearch security is enabled, add credentials:
+    ```bash
+    	docker exec kibana curl -u username:password "http://elasticsearch:9200"
+    ```
+  - Use Docker Compose health checks to ensure services are ready before dependent containers start:
+    ```yaml
+    healthcheck:
+      test: ['CMD', 'curl', '-f', 'http://elasticsearch:9200']
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    ```
 
 By addressing these Docker-specific challenges, you can optimize Kibana’s deployment in containerized environments, ensuring reliable performance and connectivity.
 
@@ -496,94 +416,102 @@ To avoid recurring instances of the "Kibana Server Is Not Ready Yet" error, cons
 
 - Purpose: Regular health checks help identify potential issues early.
 - How to Implement:
-    - Use monitoring tools like <a href="https://signoz.io" rel="noopener noreferrer nofollow" target="_blank">SigNoz</a> or [Elastic APM](https://signoz.io/comparisons/opentelemetry-vs-elastic-apm/) to track system health.
-    - Periodically query Elasticsearch cluster health:
-        
-        ```bash
-        curl -X GET "http://localhost:9200/_cluster/health?pretty"
-        ```
-        
-    - Monitor Kibana logs for errors or warnings.
+  - Use monitoring tools like <a href="https://signoz.io" rel="noopener noreferrer nofollow" target="_blank">SigNoz</a> or [Elastic APM](https://signoz.io/comparisons/opentelemetry-vs-elastic-apm/) to track system health.
+  - Periodically query Elasticsearch cluster health:
+    ```bash
+    curl -X GET "http://localhost:9200/_cluster/health?pretty"
+    ```
+  - Monitor Kibana logs for errors or warnings.
 
 ### 2. Setting Up Alerts for Kibana and Elasticsearch Services
 
 - Purpose: Alerts ensure that IT teams are notified promptly about any anomalies.
 - How to Implement:
-    - Configure alerting in Kibana using the built-in Watcher or third-party tools.
-    - Example alert for Elasticsearch node issues:
-        
-        ```json
-        {
-          "trigger": {
-            "schedule": { "interval": "5m" }
-          },
-          "input": {
-            "search": {
-              "request": {
-                "indices": [".kibana"],
-                "body": {
-                  "query": { "match_all": {} }
-                }
-              }
-            }
-          },
-          "actions": {
-            "notify": {
-              "logging": {
-                "text": "Kibana service detected an anomaly."
-              }
+  - Configure alerting in Kibana using the built-in Watcher or third-party tools.
+  - Example alert for Elasticsearch node issues:
+    ```json
+    {
+      "trigger": {
+        "schedule": { "interval": "5m" }
+      },
+      "input": {
+        "search": {
+          "request": {
+            "indices": [".kibana"],
+            "body": {
+              "query": { "match_all": {} }
             }
           }
         }
-        ```
-        
+      },
+      "actions": {
+        "notify": {
+          "logging": {
+            "text": "Kibana service detected an anomaly."
+          }
+        }
+      }
+    }
+    ```
 
 ### 3. Following Best Practices for Elastic Stack Upgrades
 
 - Purpose: Ensures compatibility and smooth transitions during version updates.
 - How to Implement:
-    - Always review the <a href="https://www.elastic.co/guide/en/elastic-stack/current/elastic-stack-compatibility.html" rel="noopener noreferrer nofollow" target="_blank">Elastic Stack Compatibility Matrix</a> before upgrading.
-    - Perform upgrades in a staging environment to identify potential issues.
-    - Upgrade Elasticsearch before Kibana to maintain compatibility.
+  - Always review the <a href="https://www.elastic.co/guide/en/elastic-stack/current/elastic-stack-compatibility.html" rel="noopener noreferrer nofollow" target="_blank">Elastic Stack Compatibility Matrix</a> before upgrading.
+  - Perform upgrades in a staging environment to identify potential issues.
+  - Upgrade Elasticsearch before Kibana to maintain compatibility.
 
 ### 4. Optimizing Kibana and Elasticsearch Configurations for Performance
 
 - Purpose: Proper configurations enhance stability and prevent resource-related issues.
 - How to Implement:
-    - Allocate sufficient heap size for Elasticsearch and Kibana:
-        
-        ```bash
-        export ES_JAVA_OPTS="-Xms2g -Xmx2g"
-        export NODE_OPTIONS="--max-old-space-size=2048"
-        ```
-        
-    - Optimize Elasticsearch index settings for large datasets.
-    - Regularly audit `kibana.yml` and `elasticsearch.yml` configurations to ensure they meet current workload requirements.
+  - Allocate sufficient heap size for Elasticsearch and Kibana:
+    ```bash
+    export ES_JAVA_OPTS="-Xms2g -Xmx2g"
+    export NODE_OPTIONS="--max-old-space-size=2048"
+    ```
+  - Optimize Elasticsearch index settings for large datasets.
+  - Regularly audit `kibana.yml` and `elasticsearch.yml` configurations to ensure they meet current workload requirements.
 
 By adopting these measures, you can reduce the risk of encountering "Kibana Server Is Not Ready Yet" errors, ensuring smoother operations and better system reliability.
 
 ## SigNoz as an Alternative
 
-<a href="https://signoz.io" rel="noopener noreferrer nofollow" target="_blank">SigNoz</a> is a modern, open-source observability platform that provides a compelling alternative to Kibana for monitoring and analyzing system performance. While Kibana excels in visualizing log data and integrating with Elasticsearch, SigNoz offers a more streamlined and focused approach to observability, particularly for metrics, traces, and logs in distributed systems.
+<a href="https://signoz.io" rel="noopener noreferrer nofollow" target="_blank">
+  SigNoz
+</a> is a modern, open-source observability platform that provides a compelling alternative to
+Kibana for monitoring and analyzing system performance. While Kibana excels in visualizing log data
+and integrating with Elasticsearch, SigNoz offers a more streamlined and focused approach to
+observability, particularly for metrics, traces, and logs in distributed systems.
 
 ### Key Benefits of Using SigNoz as an Alternative to Kibana
 
 - Integrated Metrics and Logs: SigNoz combines metrics, traces, and logs into a single platform, unlike Kibana, which primarily focuses on log and visualization data from Elasticsearch. This integrated approach simplifies monitoring by offering a unified view of system health.
-    
-    <Figure src="https://signoz.io/img/blog/common/signoz_charts_application_metrics.webp" alt="Measure things like application latency, requests per sec, error percentage and see your top endpoints with SigNoz." caption="Measure things like application latency, requests per sec, error percentage and see your top endpoints with SigNoz." />
-
-    
+  {' '}
+  <Figure
+    src="https://signoz.io/img/blog/common/signoz_charts_application_metrics.webp"
+    alt="Measure things like application latency, requests per sec, error percentage and see your top endpoints with SigNoz."
+    caption="Measure things like application latency, requests per sec, error percentage and see your top endpoints with SigNoz."
+  />
 - Real-Time Observability: SigNoz provides real-time insights into the performance and health of your systems, including infrastructure, services, and applications. This is especially useful for tracking resource usage, detecting slowdowns, and identifying performance issues in your system.
-    
-    <Figure src="/img/guides/2024/12/kibana-server-is-not-ready-yet-image.webp" alt="" caption="" />- User-Friendly Dashboards: SigNoz offers pre-built dashboards for monitoring a wide range of system metrics, making it easy to get started without needing to build complex visualizations. These dashboards cover metrics like CPU usage, memory consumption, network traffic, and application latency.
+  {' '}
+  <Figure src="/img/guides/2024/12/kibana-server-is-not-ready-yet-image.webp" alt="" caption="" />-
+  User-Friendly Dashboards: SigNoz offers pre-built dashboards for monitoring a wide range of system
+  metrics, making it easy to get started without needing to build complex visualizations. These
+  dashboards cover metrics like CPU usage, memory consumption, network traffic, and application
+  latency.
 - [Distributed Tracing](https://signoz.io/blog/distributed-tracing/): SigNoz supports distributed tracing, allowing you to visualize and trace the flow of requests through various microservices, giving you a deeper understanding of how your system components are interacting.
-    
-    <Figure src="/img/guides/2024/12/kibana-server-is-not-ready-yet-flamegraphs-express.webp" alt="View of traces at a particular timestamp" caption="View of traces at a particular timestamp" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/kibana-server-is-not-ready-yet-flamegraphs-express.webp"
+    alt="View of traces at a particular timestamp"
+    caption="View of traces at a particular timestamp"
+  />
 
 To get started with monitoring your applications with SigNoz, check out our [blog section](https://signoz.io/resource-center/blog/).
 
-<GetStartedSigNoz/>
+<GetStartedSigNoz />
 
 ## Key Takeaways
 
diff --git a/data/guides/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get.mdx b/data/guides/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get.mdx
index 39b3f848c..79784c3b2 100644
--- a/data/guides/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get.mdx
+++ b/data/guides/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Fix Kubectl Error - Troubleshooting API Group List Issues
-slug: kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get
 date: 2024-09-06
 tags: [faq]
 authors: [bhavya_sachdeva]
 description: Learn how to fix the kubectl error "[memcache.go -265] couldn't get current server API group list - Get". This guide provides step-by-step troubleshooting tips for Kubernetes users.
-keywords: [kubectl error, API group list, Kubernetes troubleshooting, memcache.go:265, kubectl debugging, Kubernetes API server, SigNoz]
-
+keywords:
+  [
+    kubectl error,
+    API group list,
+    Kubernetes troubleshooting,
+    memcache.go:265,
+    kubectl debugging,
+    Kubernetes API server,
+    SigNoz,
+  ]
 ---
 
 Kubernetes administrators often encounter the frustrating kubectl error: memcache.go:265". This error can cause cluster mismanagement and hinder critical operations. Understanding its causes and implementing effective solutions is crucial for maintaining a smooth Kubernetes workflow. This comprehensive guide walks you through the error's encountered, common causes, and step-by-step troubleshooting methods to resolve the issue and prevent future occurrences.
@@ -47,30 +53,47 @@ Several factors can contribute to the "couldn't get current server API group lis
 To pinpoint the exact cause of the error, use these debugging techniques:
 
 1. Use verbose logging: Run kubectl commands with the `v=10` flag to enable detailed logging:
-    
-    ```
-    kubectl get pods -v=10
-    ```
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.49.35_AM.webp" alt="pod details" caption="pod details" />
-    
-    This output provides insights into the API calls and potential failure points. You can see that there is an error when you run the above command. Let’s figure out why this error came, and why you are unable to get pods. Suppose you run the above command and notice that kubectl is unable to connect to the API server. If you are using Minikube, you can check its status using `minikube status`. 
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.52.42_AM.webp" alt="minikube status" caption="minikube status" />
-    
-    You can see from the above output that your minikube is not running. You can use `minikube start` command to start minikube and you will be  able to see  pods running after starting minikube. 
-    
 
-<Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-26_at_8.16.39_AM.webp" alt="minikube start" caption="minikube start" />
+   ```
+   kubectl get pods -v=10
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.49.35_AM.webp"
+     alt="pod details"
+     caption="pod details"
+   />
+
+   This output provides insights into the API calls and potential failure points. You can see that there is an error when you run the above command. Let’s figure out why this error came, and why you are unable to get pods. Suppose you run the above command and notice that kubectl is unable to connect to the API server. If you are using Minikube, you can check its status using `minikube status`.
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.52.42_AM.webp"
+     alt="minikube status"
+     caption="minikube status"
+   />
 
-       
+   You can see from the above output that your minikube is not running. You can use `minikube start` command to start minikube and you will be able to see pods running after starting minikube.
+
+<Figure
+  src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-26_at_8.16.39_AM.webp"
+  alt="minikube start"
+  caption="minikube start"
+/>
 
 1. Analyze server logs: Review the Kubernetes API server logs for any error messages or warnings related to API group list retrieval. You can find logs in `/var/log/kubernetes/kube-apiserver.log` on the control plane locally or integrate SigNoz to view the [pod logs.](https://signoz.io/blog/kubernetes-logging/)
-2. Check network connectivity: Sometimes there is an issue with network connectivity. Verify that your local machine can reach the API server using the below command. Use this command `curl -k https://<api-server-endpoint>` to test whether your local machine can reach the Kubernetes API server. If the connection fails, it suggests a network issue, such as a misconfigured firewall or DNS problem.  `curl` command fails to connect, you might need to check your firewall settings to ensure that traffic to the API server's port (typically 6443) is allowed. Alternatively, verify that your DNS configuration correctly resolves the API server's hostname.You will see in the below section how to fix this network issue. Sometimes you need to change the endpoints if they are configured in the wrong way.
+2. Check network connectivity: Sometimes there is an issue with network connectivity. Verify that your local machine can reach the API server using the below command. Use this command `curl -k https://<api-server-endpoint>` to test whether your local machine can reach the Kubernetes API server. If the connection fails, it suggests a network issue, such as a misconfigured firewall or DNS problem. `curl` command fails to connect, you might need to check your firewall settings to ensure that traffic to the API server's port (typically 6443) is allowed. Alternatively, verify that your DNS configuration correctly resolves the API server's hostname.You will see in the below section how to fix this network issue. Sometimes you need to change the endpoints if they are configured in the wrong way.
 
-<Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.00.10_AM.webp" alt="Network connectivity" caption="Network connectivity" />
+<Figure
+  src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.00.10_AM.webp"
+  alt="Network connectivity"
+  caption="Network connectivity"
+/>
 
-<Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.24.59_AM.webp" alt="Use of telnet" caption="Use of telnet" />
+<Figure
+  src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.24.59_AM.webp"
+  alt="Use of telnet"
+  caption="Use of telnet"
+/>
 
 1. Verify client and server version compatibility: Ensure your kubectl version is compatible with the Kubernetes cluster version. This command shows the versions of both the kubectl client and the Kubernetes API server. If there is a significant version mismatch, it may lead to compatibility issues which results in the API group list error.
 
@@ -83,159 +106,186 @@ kubectl version --short
 Follow these steps to resolve the "[couldn't get current server API group list: Get](https://signoz.io/guides/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get/#common-causes-of-the-api-group-list-error)" error:
 
 1. Update kubectl to the latest version: Using the latest version of kubectl ensures compatibility with the most recent Kubernetes API changes and reduces the chances of bugs or deprecated features.
-    - Download the latest kubectl binary from the <a href="https://kubernetes.io/releases/" rel="noopener noreferrer nofollow" target="_blank">official Kubernetes</a> release page.
-    - Replace your existing kubectl binary with the updated version.
-    
-    ```bash
-    curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
-    sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
-    ```
-    
-2. Verify and reconfigure kubectl context: Ensuring kubectl uses the correct context is important for proper connection with the Kubernetes API server. 
 
-       Steps:
+   - Download the latest kubectl binary from the <a href="https://kubernetes.io/releases/" rel="noopener noreferrer nofollow" target="_blank">official Kubernetes</a> release page.
+   - Replace your existing kubectl binary with the updated version.
 
-- Run the below command to check your current configuration.:
-    
-    ```bash
-    kubectl config view
-    ```
-    
-    - Identify and switch to the correct context using :
-    
-    ```bash
-    kubectl config use-context <your-context-name>
-    ```
-    
-    - If the context is misconfigured, manually edit the kubeconfig file or regenerate it with valid details.
-    
-    Example: In a multi-cluster setup, using the wrong context may cause issues. Switch to the correct context to resolve them.
-    
+   ```bash
+   curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
+   sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
+   ```
+
+2. Verify and reconfigure kubectl context: Ensuring kubectl uses the correct context is important for proper connection with the Kubernetes API server.
 
- You can see this in the below output:
+   Steps:
 
-<Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.59.46_PM.webp" alt="use-context" caption="use-context" /> 
+- Run the below command to check your current configuration.:
+  ```bash
+  kubectl config view
+  ```
+  - Identify and switch to the correct context using :
+  ```bash
+  kubectl config use-context <your-context-name>
+  ```
+  - If the context is misconfigured, manually edit the kubeconfig file or regenerate it with valid details.
+  Example: In a multi-cluster setup, using the wrong context may cause issues. Switch to the correct context to resolve them.
+
+You can see this in the below output:
+
+<Figure
+  src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.59.46_PM.webp"
+  alt="use-context"
+  caption="use-context"
+/>{' '}
 
 1. Check and renew Kubernetes credentials:
-    - Review your kubeconfig file for expired certificates.
-    - Regenerate client certificates if necessary.
+   - Review your kubeconfig file for expired certificates.
+   - Regenerate client certificates if necessary.
 2. Ensure proper network access to the API server:
-    - Verify firewall rules allow traffic to the API server port (typically 6443).
-    - Check DNS resolution for the API server hostname.
+   - Verify firewall rules allow traffic to the API server port (typically 6443).
+   - Check DNS resolution for the API server hostname.
 
 ### Advanced Debugging Techniques
 
 For persistent issues, try these advanced troubleshooting methods:
 
 1. Use kubectl config view to inspect the current configuration: You can use the below command which outputs your entire kubeconfig file in raw format, including any sensitive data like certificates and tokens. It's a helpful way to examine the full configuration and ensure that all settings, such as contexts, clusters, and users, are correct.
-    
-    ```
-    kubectl config view --raw
-    ```
-    
-2. Leverage kubectl auth can-i for permission checks: 
-    
-    ```
-    kubectl auth can-i --list
-    ```
-    
-    This command lists all actions that the currently authenticated user is authorized to perform. It helps diagnose RBAC-related issues that might be preventing access to the API group list.If you notice that certain permissions are missing or incorrect, you can update the RBAC policies by creating or editing Roles and RoleBindings to ensure the user has the necessary access.
-    
-    You can see the below output where there is no permission for user pod-nginx in namespace nginx to list the pod :
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.48.16_PM.webp" alt="auth list" caption="auth list" />
-    
-    You can edit role pod-nginx and add verb to create, get and list the pods using below command:
-    
-    ```bash
-    kubectl edit role pod-nginx
-    ```
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.54.13_PM.webp" alt="Role" caption="Role" />
-    
-    You can see that only you are able to delete pod so you can add these verbs as shown in below image:
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.56.58_PM.webp" alt="Role edited" caption="Role edited" />
-    
+
+   ```
+   kubectl config view --raw
+   ```
+
+2. Leverage kubectl auth can-i for permission checks:
+
+   ```
+   kubectl auth can-i --list
+   ```
+
+   This command lists all actions that the currently authenticated user is authorized to perform. It helps diagnose RBAC-related issues that might be preventing access to the API group list.If you notice that certain permissions are missing or incorrect, you can update the RBAC policies by creating or editing Roles and RoleBindings to ensure the user has the necessary access.
+
+   You can see the below output where there is no permission for user pod-nginx in namespace nginx to list the pod :
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.48.16_PM.webp"
+     alt="auth list"
+     caption="auth list"
+   />
+
+   You can edit role pod-nginx and add verb to create, get and list the pods using below command:
+
+   ```bash
+   kubectl edit role pod-nginx
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.54.13_PM.webp"
+     alt="Role"
+     caption="Role"
+   />
+
+   You can see that only you are able to delete pod so you can add these verbs as shown in below image:
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-09-03_at_8.56.58_PM.webp"
+     alt="Role edited"
+     caption="Role edited"
+   />
+
 3. Use kubectl cluster-info dump for comprehensive diagnostics: This command gathers and displays detailed information about the cluster’s current state, including configurations, logs, and events from all components. It’s particularly useful when dealing with complex issues that require a broad overview of the cluster’s status.
-    
-    ```
-    kubectl cluster-info dump
-    ```
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.14.08_AM.webp" alt="Cluster-info dump" caption="Cluster-info dump" />
-    
-    This command provides complete information about your cluster's current state.
-    
+
+   ```
+   kubectl cluster-info dump
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.14.08_AM.webp"
+     alt="Cluster-info dump"
+     caption="Cluster-info dump"
+   />
+
+   This command provides complete information about your cluster's current state.
+
 4. Utilize kubectl proxy to isolate client-side issues: `kubectl proxy` sets up a proxy server that relays requests from your local machine to the Kubernetes API server. This setup can help isolate issues by determining whether the problem lies with kubectl or with the API server itself. You can use the below command for this:
-    
-    ```
-    kubectl proxy
-    curl <http://localhost:8001/api/>
-    ```
-    
-    If accessing the API server through `kubectl proxy` works but direct access does not, the issue is likely with your local network configuration or direct API server accessibility.
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.17.57_PM.webp" alt="output of curl command" caption="output of curl command" />
-    
+
+   ```
+   kubectl proxy
+   curl <http://localhost:8001/api/>
+   ```
+
+   If accessing the API server through `kubectl proxy` works but direct access does not, the issue is likely with your local network configuration or direct API server accessibility.
+
+   <Figure
+     src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_9.17.57_PM.webp"
+     alt="output of curl command"
+     caption="output of curl command"
+   />
 
 ## Resolving Common Scenarios
 
 Here are solutions for frequently encountered situations:
 
-1. Fixing "Unable to connect to the server" errors: This error typically indicates a connectivity issue between your machine and the Kubernetes API server. It may result from incorrect endpoints, blocked ports, or DNS issues. You can follow the below steps to resolve this:
+1.  Fixing "Unable to connect to the server" errors: This error typically indicates a connectivity issue between your machine and the Kubernetes API server. It may result from incorrect endpoints, blocked ports, or DNS issues. You can follow the below steps to resolve this:
+
     - Verify the API server endpoint in your kubeconfig file: Ensure that the endpoint is correct and up-to-date.
     - Ensure your network allows connections to the API server port: Check firewall rules and open ports as necessary.
     - You can use `ping` or `traceroute` to diagnose network paths: These tools can help you understand where the connection might be failing.
     - Use `minikube status` to check whether it is running with expected endpoint.
-    
-    You can see the below output where expected end point is this: 127.0.0.1:62300  and you are using this: 192.0.2.1:6443
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.54.36_AM.webp" alt="" caption="" />You can use the below command to set the correct end-point for server:
-    
+
+    You can see the below output where expected end point is this: 127.0.0.1:62300 and you are using this: 192.0.2.1:6443
+
+    <Figure
+      src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_10.54.36_AM.webp"
+      alt=""
+      caption=""
+    />
+    You can use the below command to set the correct end-point for server:
+
     ```bash
     kubectl config set-cluster minikube --server=https://127.0.0.1:62300
     ```
-    
-    <Figure src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_8.40.56_PM.webp" alt="config set-cluster" caption="config set-cluster" />
-    
-2. Addressing credential-related issues: There can be credential issues often stem from expired certificates, tokens, or misconfigured kubeconfig entries.
-    
+
+    <Figure
+      src="/img/guides/2024/09/kubectl-error-memcache-go-265-couldnt-get-current-server-api-group-list-get-Screenshot_2024-08-29_at_8.40.56_PM.webp"
+      alt="config set-cluster"
+      caption="config set-cluster"
+    />
+
+2.  Addressing credential-related issues: There can be credential issues often stem from expired certificates, tokens, or misconfigured kubeconfig entries.
+
     You can update your kubeconfig with the new certificate using the below command:
-    
+
     ```
     kubectl create certificatesigningrequest <csr-name> --from-file=<csr-file>
     kubectl certificate approve <csr-name>
-    
+
     ```
-    
 
          Ensure that the new certificates are correctly configured in your kubeconfig file.
 
-1. Resolving version mismatch problems:  Mismatched versions between kubectl and the Kubernetes API server can lead to compatibility issues. You can upgrade or downgrade kubectl to match your cluster version:
+3.  Resolving version mismatch problems: Mismatched versions between kubectl and the Kubernetes API server can lead to compatibility issues. You can upgrade or downgrade kubectl to match your cluster version:
 
 ```bash
 curl -LO "<https://dl.k8s.io/release/$>(kubectl version --short | awk -Fv '/Server Version: /{print $3}')/bin/linux/amd64/kubectl"
 ```
 
-1. Troubleshooting network-related API access issues: Network issues are often at the root of connectivity problems with the Kubernetes API server. You can use tools like traceroute or tcpdump to diagnose network connectivity problems and also verify that your local DNS resolves the API server hostname correctly. 
+1. Troubleshooting network-related API access issues: Network issues are often at the root of connectivity problems with the Kubernetes API server. You can use tools like traceroute or tcpdump to diagnose network connectivity problems and also verify that your local DNS resolves the API server hostname correctly.
 
 ## Best Practices for Preventing API Group List Errors
 
 Implement these practices to minimize the occurrence of API group list errors:
 
 1. Regular updates of kubectl and cluster components:
-    - Set up automated update notifications for kubectl and your Kubernetes distribution.
-    - Test updates in a non-production environment before applying them to critical clusters.
+   - Set up automated update notifications for kubectl and your Kubernetes distribution.
+   - Test updates in a non-production environment before applying them to critical clusters.
 2. Implement proper credential management and rotation:
-    - Use tools like cert-manager for automated certificate management.
-    - Implement a regular schedule for rotating cluster credentials.
+   - Use tools like cert-manager for automated certificate management.
+   - Implement a regular schedule for rotating cluster credentials.
 3. Monitor cluster health and API server performance:
-    - Set up alerts for API server response times and error rates.
-    - Regularly review API server logs for potential issues.
+   - Set up alerts for API server response times and error rates.
+   - Regularly review API server logs for potential issues.
 4. Maintain consistent client-server version compatibility:
-    - Document your cluster version and required kubectl version.
-    - Implement version checks in your CI/CD pipelines to ensure compatibility.
+   - Document your cluster version and required kubectl version.
+   - Implement version checks in your CI/CD pipelines to ensure compatibility.
 
 ## Leveraging SigNoz for Enhanced Kubernetes Monitoring
 
@@ -271,4 +321,4 @@ While this error can occur in various kubectl versions, it's more common when th
 
 ### Can this error occur even with proper authentication in place?
 
-Yes, even with valid authentication, this error can occur due to network issues, API server problems, or misconfigurations. While proper authentication is necessary, it doesn't guarantee successful communication with the API server. Always check for other potential causes, such as network connectivity or API server health, when troubleshooting this error.
\ No newline at end of file
+Yes, even with valid authentication, this error can occur due to network issues, API server problems, or misconfigurations. While proper authentication is necessary, it doesn't guarantee successful communication with the API server. Always check for other potential causes, such as network connectivity or API server health, when troubleshooting this error.
diff --git a/data/guides/kubernetes-cronjobs.mdx b/data/guides/kubernetes-cronjobs.mdx
index 50c2d1547..2407c60ee 100644
--- a/data/guides/kubernetes-cronjobs.mdx
+++ b/data/guides/kubernetes-cronjobs.mdx
@@ -1,15 +1,13 @@
 ---
-
 title: Kubernetes CronJobs - How to Create and Monitor CronJobs in SigNoz
-slug: kubernetes-cronjobs
 date: 2024-06-17
 tags: [kubernetes]
 authors: [daniel]
-description: Kubernetes CronJobs automates the execution of containerized tasks at specified times or any repetitive task that needs to be performed on a recurring schedule. 
+description: Kubernetes CronJobs automates the execution of containerized tasks at specified times or any repetitive task that needs to be performed on a recurring schedule.
 image: /img/blog/2024/06/kubernetes-cronjobs.webp
-keywords: [kubernetes,monitoring,cronjobs]
-
+keywords: [kubernetes, monitoring, cronjobs]
 ---
+
 Kubernetes CronJobs are designed to schedule and automate repetitive tasks within your cluster. Whether you're managing routine system maintenance, orchestrating complex data pipelines, or handling application-specific operations, CronJobs provides a reliable and efficient way to streamline your workflows.
 
 <Figure src="/img/guides/2024/06/kubernetes-cron-job-monitoring-cover.webp" alt="" caption="" />
@@ -30,11 +28,11 @@ For example, if you want to run a script that cleans up old log files every day
 
 The table below shows a rough outline of their differences:
 
-| Feature | Job | CronJob |
-| --- | --- | --- |
-| Execution | One-time execution | Repeating execution on a schedule |
-| Use Cases | One-off tasks, batch processing | Periodic tasks, scheduled maintenance |
-| Schedule | Not applicable | Defined using cron syntax |
+| Feature     | Job                                       | CronJob                               |
+| ----------- | ----------------------------------------- | ------------------------------------- |
+| Execution   | One-time execution                        | Repeating execution on a schedule     |
+| Use Cases   | One-off tasks, batch processing           | Periodic tasks, scheduled maintenance |
+| Schedule    | Not applicable                            | Defined using cron syntax             |
 | Termination | Automatically terminates after completion | Manages multiple executions over time |
 
 ### How do CronJobs Work (Lifecycle)?
@@ -44,14 +42,15 @@ In this section, we will walk through the Lifecycle of CronJobs, from creation t
 1. YAML Definition: CronJobs are defined in YAML manifests. These manifests contain all the necessary details to define and run a job, including the schedule, job template, and other specifications.
 2. Scheduling: Kubernetes uses the cron `schedule` specified in the CronJob manifest to determine when to create Job objects. The CronJob <a href="https://kubernetes.io/docs/concepts/architecture/controller/" rel="noopener noreferrer nofollow" target="_blank">controller</a> continuously monitors all CronJobs in your cluster and handles the lifecycle of CronJobs. When the specified schedule time matches the current time, the controller triggers the CronJob.
 3. Job Creation: Upon triggering, the CronJob controller creates a Job object based on the `jobTemplate` specified in the CronJob manifest. This Job object is a standard Kubernetes Job, which is responsible for managing the execution of your task within Pods (containers).
-    
-    If a previous Job triggered by the same CronJob is still running, the behavior depends on the `concurrencyPolicy`:
-    
-    - Allow: A new Job will be created and run concurrently with the existing one.
-    - Forbid: The new Job will be skipped, and the schedule will be considered missed.
-    - Replace: The existing Job will be terminated, and a new one will be created in its place.
+
+   If a previous Job triggered by the same CronJob is still running, the behavior depends on the `concurrencyPolicy`:
+
+   - Allow: A new Job will be created and run concurrently with the existing one.
+   - Forbid: The new Job will be skipped, and the schedule will be considered missed.
+   - Replace: The existing Job will be terminated, and a new one will be created in its place.
+
 4. Pod Creation and Execution: The Job created by the CronJob then creates one or more Pods, depending on your Job's configuration (e.g. parallel execution). Inside these Pods, your specified Docker image is pulled from a registry, and the command you defined is executed. The Job controller manages the lifecycle of the Pods, including restarts if failures occur.
-5. Completion and Cleanup: Once the Pods successfully complete the task or reach a specified termination condition, the Job is considered finished. By default, Kubernetes doesn't keep any history. The number of completed Jobs retained in history is configurable using `successfulJobsHistoryLimit` and `failedJobsHistoryLimit`. 
+5. Completion and Cleanup: Once the Pods successfully complete the task or reach a specified termination condition, the Job is considered finished. By default, Kubernetes doesn't keep any history. The number of completed Jobs retained in history is configurable using `successfulJobsHistoryLimit` and `failedJobsHistoryLimit`.
 
 ### Common Use Cases for CronJobs
 
@@ -98,7 +97,7 @@ spec:
               command:
                 - /bin/sh
                 - -c
-                - date; echo "Kubernetes cronjob completed" 
+                - date; echo "Kubernetes cronjob completed"
           restartPolicy: OnFailure
 ```
 
@@ -106,7 +105,7 @@ Let's walk through what the configuration does:
 
 - `apiVersion` and `kind` specify the object type (CronJob) and the Kubernetes API version to use.
 - `metadata.name` is the name you give to your CronJob.
-- `spec.schedule`: This is a Cron expression that defines when the CronJob should run. In the provided example, it's set to "* * * * *" which means every minute. You can customize this to match your desired schedule.
+- `spec.schedule`: This is a Cron expression that defines when the CronJob should run. In the provided example, it's set to "\* \* \* \* \*" which means every minute. You can customize this to match your desired schedule.
 - `spec.successfulJobsHistoryLimit`: This setting determines how many completed Jobs the CronJob will keep in its history for reference (defaults to 3).
 - `JobTemplate`: This is the core of the CronJob. It acts as a blueprint for the Jobs that the CronJob creates each time the schedule triggers.
 - `spec.template.spec.containers`: Defines the container(s) that will run within the Job's Pods. In this case, a busy box image that prints the current date/time and a completion message.
@@ -261,7 +260,7 @@ kubectl apply -f clusterrole.yaml
 
 Create a ClusterRoleBinding
 
-A ClusterRoleBinding is a Kubernetes resource that associates a ClusterRole (a set of cluster-wide permissions) with one or more subjects (users, groups, or service accounts). It acts as the "glue" that connects the permissions defined in a ClusterRole with the entities that need those permissions to perform actions on resources within the Kubernetes cluster. 
+A ClusterRoleBinding is a Kubernetes resource that associates a ClusterRole (a set of cluster-wide permissions) with one or more subjects (users, groups, or service accounts). It acts as the "glue" that connects the permissions defined in a ClusterRole with the entities that need those permissions to perform actions on resources within the Kubernetes cluster.
 
 In your text editor, create a file called `clusterrolebinding.yaml` and paste in the below configuration:
 
@@ -329,11 +328,14 @@ From the above configuration;
 
 - The `k8s_events` receiver is configured to collect Kubernetes events only from the `default` namespace. You can modify this list to include other namespaces if needed.
 - The `otlp` exporter is set up to send the collected event data to SigNoz at the specified endpoint. Replace `{region}` with your selected region when creating your SigNoz cloud account and replace `<SIGNOZ-INGESTION-KEY>` with the ingestion key for your cloud account.
-    
-    To get your region and ingestion key, navigate to your SigNoz account URL > settings > ingestion settings and copy them.
-    
+  To get your region and ingestion key, navigate to your SigNoz account URL > settings > ingestion settings and copy them.
 
-<Figure src="/img/guides/2024/06/Ingestion_Key.webp" alt="Ingestion settings" caption="Ingestion settings" /><br></br>To create the ConfigMap:
+<Figure
+  src="/img/guides/2024/06/Ingestion_Key.webp"
+  alt="Ingestion settings"
+  caption="Ingestion settings"
+/>
+<br></br>To create the ConfigMap:
 
 ```bash
 kubectl apply -f configmap.yaml
@@ -377,7 +379,7 @@ spec:
             name: otelcontribcol
 ```
 
-The above Deployment manifest deploys a single instance of a Pod (`otelcontribcol`) based on the `otel/opentelemetry-collector-contrib` Docker image. The Pod is configured to use a specific `ConfigMap` (`otelcontribcol`) to provide configuration files (`config.yaml`) mounted at `/etc/config` inside the container. 
+The above Deployment manifest deploys a single instance of a Pod (`otelcontribcol`) based on the `otel/opentelemetry-collector-contrib` Docker image. The Pod is configured to use a specific `ConfigMap` (`otelcontribcol`) to provide configuration files (`config.yaml`) mounted at `/etc/config` inside the container.
 
 This setup ensures that the OpenTelemetry Collector Contrib component (`otelcontribcol`) runs with the specified configuration in a Kubernetes environment.
 
@@ -433,17 +435,35 @@ Output:
 
 Navigate to your SigNoz cloud account to see the logs coming in from your cluster, most especially logs from the CronJobs.
 
-<Figure src="/img/guides/2024/06/log-monitoring.webp" alt="Log monitoring in SigNoz" caption="Log monitoring in SigNoz" /><br></br>With SigNoz, you can create custom dashboards tailored to your specific monitoring and observability needs.
+<Figure
+  src="/img/guides/2024/06/log-monitoring.webp"
+  alt="Log monitoring in SigNoz"
+  caption="Log monitoring in SigNoz"
+/>
+<br></br>With SigNoz, you can create custom dashboards tailored to your specific monitoring and
+observability needs.
 
 To create a custom dashboard for CronJob visualization, click on Dashboards > New Dashboard > Create Dashboard > Configure > Save > New Panel.
 
 Here, you have the flexibility to choose the visualization type that best suits your needs, whether it's a time series graph, a simple value display, a bar chart for comparison, or even a table for detailed data presentation.
 
-Within the query builder, craft and execute queries targeting your CronJobs to gain insights into their performance. 
-
-<Figure src="/img/guides/2024/06/query-builder.webp" alt="Running queries in the query builder" caption="Running queries in the query builder" /><br></br>The above query `k8s_cronjob_active_jobs` set to `k8s_cronjob_name = my-cron-job` returns the number of active jobs for the CronJob named "my-cronjob".
-
-<Figure src="/img/guides/2024/06/cronjob-dashboard.webp" alt="CronJob monitoring dashboard" caption="CronJob monitoring dashboard" /><br></br>You can execute additional queries and create more visualization in your dashboard as needed.
+Within the query builder, craft and execute queries targeting your CronJobs to gain insights into their performance.
+
+<Figure
+  src="/img/guides/2024/06/query-builder.webp"
+  alt="Running queries in the query builder"
+  caption="Running queries in the query builder"
+/>
+<br></br>The above query `k8s_cronjob_active_jobs` set to `k8s_cronjob_name = my-cron-job` returns
+the number of active jobs for the CronJob named "my-cronjob".
+
+<Figure
+  src="/img/guides/2024/06/cronjob-dashboard.webp"
+  alt="CronJob monitoring dashboard"
+  caption="CronJob monitoring dashboard"
+/>
+<br></br>You can execute additional queries and create more visualization in your dashboard as
+needed.
 
 ## Getting Started with SigNoz
 
diff --git a/data/guides/kubernetes-deployments.mdx b/data/guides/kubernetes-deployments.mdx
index f474ac76e..1414231f2 100644
--- a/data/guides/kubernetes-deployments.mdx
+++ b/data/guides/kubernetes-deployments.mdx
@@ -1,15 +1,13 @@
 ---
-
 title: Kubernetes Deployments - A Comprehensive Guide
-slug: kubernetes-deployments
 date: 2024-06-14
 tags: [kubernetes]
 authors: [daniel]
 description: Managing the lifecycle of containerized applications across a distributed environment can be a complex, and error-prone process due to the manual processes involved. Kubernetes Deployments address this challenge by…
 image: /img/blog/2024/06/kubernetes-deployments-cover.webp
-keywords: [kubernetes,deployments]
-
+keywords: [kubernetes, deployments]
 ---
+
 Managing the lifecycle of containerized applications across a distributed environment can be a complex, inconsistent and error-prone process due to the manual process of deploying, scaling, and updating applications across multiple nodes.
 
 Kubernetes Deployments address this challenge by providing a declarative and automated approach to releasing, updating, and scaling applications, ensuring that the desired state of your system is consistently maintained.
@@ -28,7 +26,12 @@ Kubernetes Deployments manage the lifecycle of your applications within a cluste
 
 A Kubernetes Deployment does not directly by itself create the desired number of pods you declared, it achieves this through the use of <a href="https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/" rel="noopener noreferrer nofollow" target="_blank">ReplicaSets</a>. A ReplicaSet is a Kubernetes object that ensures a specified number of pod replicas are running at any given time. They can be used independently, but they are primarily utilized by Deployments to orchestrate the creation, deletion, and updates of Pods. Once a Deployment is created, the Deployment creates a ReplicaSet, and the ReplicaSet creates the Pods.
 
-<Figure src="/img/guides/2024/06/deployment.webp" alt="How a Deployment works" caption="How a Deployment works" /><br></br>
+<Figure
+  src="/img/guides/2024/06/deployment.webp"
+  alt="How a Deployment works"
+  caption="How a Deployment works"
+/>
+<br></br>
 
 ### Benefits of Kubernetes Deployment
 
@@ -52,7 +55,7 @@ Two different approaches can be taken in creating Deployments. They are;
 1. Imperative approach
 2. Declarative approach
 
-1. Imperative Approach
+3. Imperative Approach
 
 In the imperative approach, you use direct commands through the `kubectl` command-line tool to instruct Kubernetes on exactly how to create the Deployment and its associated resources.
 
@@ -161,7 +164,7 @@ To roll back a Deployment, identify the deployment you want to roll back:
 kubectl get deployments
 ```
 
-This command lists all available deployments in your cluster. 
+This command lists all available deployments in your cluster.
 
 Let’s assume we have a deployment named `my-app` using the `nginx:latest` image, which is working fine. To simulate a scenario where you need to roll back, update the deployment image to a non-existent version:
 
@@ -213,7 +216,7 @@ my-app-fb5d5dc59-kg2vm              0/1     ImagePullBackOff   0       2m29s
 my-app-fb5d5dc59-q48k8              0/1     ImagePullBackOff   0       2m28s
 ```
 
-The image update was unsuccessful because the image version `1.260` does not exist. 
+The image update was unsuccessful because the image version `1.260` does not exist.
 
 To roll back to the previous version (revision 1):
 
@@ -279,7 +282,7 @@ Syntax:
 kubectl edit deployment/<deployment-name>
 ```
 
- If you already have a YAML file defining your Deployment, you can directly edit the `replicas` field within it to your desired number. 
+If you already have a YAML file defining your Deployment, you can directly edit the `replicas` field within it to your desired number.
 
 Once you have modified the number of replicas you want, run the below command:
 
@@ -320,7 +323,12 @@ Different deployment strategies can be employed for managing application deploym
 
 The Recreate deployment strategy is a method of updating applications running in a Kubernetes cluster. This approach is straightforward: it stops all the old versions of the application before starting the new ones. This causes downtime, once the upgrade is triggered, all existing pods will be immediately terminated and replaced by new pods with a new version. Recreate deployment strategy is provided out of the box in Kubernetes.
 
-<Figure src="/img/guides/2024/06/Recreate.webp" alt="Recreate deployment strategy" caption="Recreate deployment strategy" /><br></br>Example:
+<Figure
+  src="/img/guides/2024/06/Recreate.webp"
+  alt="Recreate deployment strategy"
+  caption="Recreate deployment strategy"
+/>
+<br></br>Example:
 
 ```bash
 apiVersion: apps/v1
@@ -365,7 +373,12 @@ This is one of the most common deployment strategies that comes out of the box i
 
 If issues arise during the rollout of the new pods, Kubernetes allows you to easily roll back to the previous version.
 
-<Figure src="/img/guides/2024/06/rolling-update.webp" alt="Rolling update deployment strategy" caption="Rolling update deployment strategy" /><br></br>Example:
+<Figure
+  src="/img/guides/2024/06/rolling-update.webp"
+  alt="Rolling update deployment strategy"
+  caption="Rolling update deployment strategy"
+/>
+<br></br>Example:
 
 ```bash
 apiVersion: apps/v1
@@ -405,11 +418,11 @@ From the above, during the initial creation, Kubernetes will create 5 pods of yo
 Note: If the strategy section is not configured for the Deployment object, Kubernetes uses the default settings for the deployment strategy which are;
 
 1. Deployment Strategy: RollingUpdate
-    - Kubernetes will replace the old pods with new ones in a rolling fashion, ensuring that the application remains available during the update process.
+   - Kubernetes will replace the old pods with new ones in a rolling fashion, ensuring that the application remains available during the update process.
 2. MaxUnavailable: 25%
-    - By default, up to 25% of the desired number of pods can be unavailable during the update. This means if you have a deployment with 4 replicas, at most 1 pod can be unavailable during the rolling update.
+   - By default, up to 25% of the desired number of pods can be unavailable during the update. This means if you have a deployment with 4 replicas, at most 1 pod can be unavailable during the rolling update.
 3. MaxSurge: 25%
-    - By default, up to 25% more than the desired number of pods can be created during the update process. This means if you have a deployment with 4 replicas, at most 1 additional pod can be created during the rolling update.
+   - By default, up to 25% more than the desired number of pods can be created during the update process. This means if you have a deployment with 4 replicas, at most 1 additional pod can be created during the rolling update.
 
 ```bash
 spec:
@@ -447,9 +460,14 @@ Blue/Green deployment is a release management strategy that reduces downtime and
 
 In this deployment strategy, you deploy the new version of the application to the Green environment while the Blue environment continues to serve traffic. Once the Green environment is fully tested and confirmed to be stable, switch the traffic from the Blue environment to the Green environment. The Blue environment then becomes idle and can be kept as a backup or used for the next deployment.
 
-<Figure src="/img/guides/2024/06/blue-green.webp" alt="Blue/Green deployment strategy" caption="Blue/Green deployment strategy" /><br></br>Example:
+<Figure
+  src="/img/guides/2024/06/blue-green.webp"
+  alt="Blue/Green deployment strategy"
+  caption="Blue/Green deployment strategy"
+/>
+<br></br>Example:
 
-You start by deploying the current version of your application (Blue). 
+You start by deploying the current version of your application (Blue).
 
 ```bash
 apiVersion: apps/v1
@@ -530,7 +548,7 @@ metadata:
 spec:
   selector:
     app: my-app
-    environment: green 
+    environment: green
   ports:
     - protocol: TCP
       port: 8080
@@ -553,7 +571,12 @@ When Not to Use the Blue/Green Deployments Strategy
 
 Canary deployment is another strategy used to reduce the risk of introducing a new software version into production. It involves gradually rolling out the new version to a small subset of users before rolling it out to the entire user base. This allows you to monitor the new version for issues on a smaller scale and make adjustments before a full rollout.
 
-<Figure src="/img/guides/2024/06/canary.webp" alt="Canary deployment strategy" caption="Canary deployment strategy" /><br></br>Example:
+<Figure
+  src="/img/guides/2024/06/canary.webp"
+  alt="Canary deployment strategy"
+  caption="Canary deployment strategy"
+/>
+<br></br>Example:
 
 Using Kubernetes native objects, we will see how canary deployments can be carried out in Kubernetes. For the initial version of your application, create a deployment and a service:
 
@@ -650,7 +673,7 @@ Choosing the right deployment strategy for your application in Kubernetes involv
 
 ## Monitoring Kubernetes Deployments in SigNoz
 
-SigNoz is an open-source observability platform that provides real-time insights into your applications and infrastructure. SigNoz is built on OpenTelemetry, an emerging standard for generating telemetry data. It seamlessly integrates metrics, logs, and traces within a unified interface. 
+SigNoz is an open-source observability platform that provides real-time insights into your applications and infrastructure. SigNoz is built on OpenTelemetry, an emerging standard for generating telemetry data. It seamlessly integrates metrics, logs, and traces within a unified interface.
 
 With SigNoz, you can monitor your Kubernetes Deployments. By leveraging its integration capabilities with OpenTelemetry, SigNoz allows you to collect and visualize metrics, logs and traces directly from your Kubernetes environments. This comprehensive view ensures that you can quickly identify and troubleshoot issues, optimize performance, and ensure the reliability of your applications running on Kubernetes.
 
diff --git a/data/guides/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api.mdx b/data/guides/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api.mdx
index 009e89827..ac2c6d821 100644
--- a/data/guides/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api.mdx
+++ b/data/guides/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api.mdx
@@ -1,20 +1,27 @@
 ---
-
 title: Troubleshooting Kubernetes HPA - Fixing Metric Retrieval Issues
-slug: kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api
 date: 2024-09-24
 tags: [faq]
 authors: [bhavya_sachdeva]
 description: Learn how to troubleshoot and fix Kubernetes HPA metric retrieval issues, including the "Unable to get metrics for resource memory" error. Optimize your HPA for better performance.
-keywords: [Kubernetes HPA, metric retrieval, troubleshooting, autoscaling, metrics server, resource metrics API, HPA configuration, SigNoz]
-
+keywords:
+  [
+    Kubernetes HPA,
+    metric retrieval,
+    troubleshooting,
+    autoscaling,
+    metrics server,
+    resource metrics API,
+    HPA configuration,
+    SigNoz,
+  ]
 ---
 
 Kubernetes Horizontal Pod Autoscaler (HPA) automatically scales your applications based on resource utilization. However, you may encounter issues with metric retrieval, hindering HPA's ability to make scaling decisions. This article addresses the common error: “Unable to get metrics for resource memory: no metrics returned from resource metrics API” and provides a comprehensive guide to troubleshooting and resolving HPA metric retrieval problems.
 
 ## Understanding Kubernetes HPA and Metric Retrieval Issues
 
-Kubernetes HPA automatically adjusts the number of pods in a deployment or replica set based on observed CPU utilization or other select metrics. It relies on the metrics server to collect and provide resource usage data.  However, sometimes HPA faces issues in retrieving metrics. These problems can occur for various reasons, such as misconfigurations or issues with the metrics server (which provides data to HPA). If HPA can't get the right metrics, it might not scale your application properly, either leaving it under-resourced or over-resourced.
+Kubernetes HPA automatically adjusts the number of pods in a deployment or replica set based on observed CPU utilization or other select metrics. It relies on the metrics server to collect and provide resource usage data. However, sometimes HPA faces issues in retrieving metrics. These problems can occur for various reasons, such as misconfigurations or issues with the metrics server (which provides data to HPA). If HPA can't get the right metrics, it might not scale your application properly, either leaving it under-resourced or over-resourced.
 
 The error "Unable to get metrics for resource memory" indicates that HPA is unable to fetch memory metrics from the resource metrics API. This could be caused by problems with the metrics server, communication issues, or incorrect settings in HPA.
 
@@ -27,11 +34,11 @@ The Horizontal Pod Autoscaler (HPA) adjusts the number of pods in a Kubernetes a
 3. Incorrect HPA configuration: Misconfigurations in the HPA definition can lead to failed metric queries.
 4. Networking problems: Network issues between HPA and the metrics sources can prevent successful metric retrieval.
 5. The reliability of HPA depends on accurate metric collection and processing. Some common problems with metric retrieval that can affect HPA include:
-    - Missing Metrics: HPA might fail to retrieve metrics due to misconfigurations or missing components.
-    - Incorrect Metrics: The metrics returned by the Metrics API may not reflect the actual state of the system.
-    - Metrics API Not Available: If the Kubernetes Metrics API server is not running or is improperly configured, HPA won't be able to retrieve the necessary data.
-    - Metrics Server Down: The Kubernetes Metrics Server, which provides resource usage data (CPU, memory, etc.), might be unavailable.
-    - Insufficient Permissions: The HPA might not have the correct Role-Based Access Control (RBAC) permissions to access the Metrics API
+   - Missing Metrics: HPA might fail to retrieve metrics due to misconfigurations or missing components.
+   - Incorrect Metrics: The metrics returned by the Metrics API may not reflect the actual state of the system.
+   - Metrics API Not Available: If the Kubernetes Metrics API server is not running or is improperly configured, HPA won't be able to retrieve the necessary data.
+   - Metrics Server Down: The Kubernetes Metrics Server, which provides resource usage data (CPU, memory, etc.), might be unavailable.
+   - Insufficient Permissions: The HPA might not have the correct Role-Based Access Control (RBAC) permissions to access the Metrics API
 
 ### Diagnosing Metric Retrieval Issues in HPA
 
@@ -53,18 +60,29 @@ Example:
 
 After running the command, you may see an error message such as being unable to fetch metrics from resource metrics API. This message suggests that there is a communication issue between the HPA and the metrics server or that the metrics API is unavailable. You can see the below output HPA for nginx-deployment gives you errors but in the next step we have created another hpa which does not give you an error.
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.04_PM.webp" alt="hpa-nginx" caption="hpa-nginx" />
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.04_PM.webp"
+  alt="hpa-nginx"
+  caption="hpa-nginx"
+/>
 
 You can see here the below image and there is no error and in the next section, we will learn to troubleshoot.
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.22.46_AM.webp" alt="example-hpa" caption="example-hpa" />
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.22.46_AM.webp"
+  alt="example-hpa"
+  caption="example-hpa"
+/>
 
 What to Look For:
 
 - Error Messages: Pay attention to any error messages or warnings in the output. These can tell you whether the issue is related to missing metrics, a misconfigured HPA, or connectivity issues with the metrics API.
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-6aa66ac1-c78b-4e42-a523-6fe8a23c838d.webp" alt="hpa-error" caption="hpa-error" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-6aa66ac1-c78b-4e42-a523-6fe8a23c838d.webp"
+    alt="hpa-error"
+    caption="hpa-error"
+  />
 - Current Metrics Status: Check whether the HPA is receiving any metrics at all. If the current value for CPU or memory utilization is `N/A`, it indicates that the HPA is not able to retrieve the metrics needed for scaling.
 
 2. Check Metrics Server Logs for Issues
@@ -83,7 +101,11 @@ Example:
 
 In the logs, you might see messages like failed to scrape node metrics or unable to connect to the node. This could indicate that the metrics server is having difficulty collecting metrics from certain nodes or that there are network issues preventing communication between the server and the nodes. In the below output, the metrics-server is working properly but sometimes the error is maybe related to the metrics-server.
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.30_PM.webp" alt="metrics-server" caption="metrics-server" />
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.30_PM.webp"
+  alt="metrics-server"
+  caption="metrics-server"
+/>
 
 What to Look For:
 
@@ -106,7 +128,11 @@ Example:
 
 If the API call fails, you might receive an error message like `error: the server could not find the requested resource`. This indicates that the metrics API is either not available or not properly configured.
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.46_PM.webp" alt="Raw metrics" caption="Raw metrics" />
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.16.46_PM.webp"
+  alt="Raw metrics"
+  caption="Raw metrics"
+/>
 
 What to Look For:
 
@@ -130,125 +156,131 @@ You might find that a pod has no defined resource requests for CPU or memory, me
 What to Look For:
 
 - Correctly Defined Resource Requests: Ensure that the pod has appropriate resource requests and limits for CPU and memory. This will allow the metrics server to collect usage data, which the HPA can then use to make scaling decisions.
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_9.01.57_AM.webp" alt="pod describe" caption="pod describe" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_9.01.57_AM.webp"
+    alt="pod describe"
+    caption="pod describe"
+  />
 - Resource Utilization: Check whether the resource utilization of the pod matches the target metrics defined in the HPA. If there is a significant discrepancy, it might indicate an issue with the way metrics are being collected or reported.
 
 ## Step-by-Step Troubleshooting Guide
 
 Follow these steps to resolve HPA metric retrieval issues:
 
-1. Ensure metrics server is properly deployed and running:
-The metrics server is essential for HPA as it aggregates resource usage data that HPA uses to make scaling decisions.
-    - Check Metrics-Server Deployment:
+1.  Ensure metrics server is properly deployed and running:
+    The metrics server is essential for HPA as it aggregates resource usage data that HPA uses to make scaling decisions. - Check Metrics-Server Deployment:
     Use the following command to check if the Metrics-Server is deployed in the kube-system namespace:
-        
-        ```bash
-        kubectl get deployment metrics-server -n kube-system
-        ```
-        
-        Expected Output: You should see the deployment details of the Metrics-Server. If it's not present, you will need to install it.
-        
-        <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.17.19_PM.webp" alt="Get metrics server" caption="Get metrics server" />
-        
-    - Installation:
-    If the Metrics-Server is not installed,  you can install it using the official Kubernetes YAML manifest. You can find the latest version of the Metrics-Server and its deployment instructions on the <a href="https://github.com/kubernetes-sigs/metrics-server" rel="noopener noreferrer nofollow" target="_blank">Kubernetes Metrics Server GitHub page</a>.
-2. Verify metrics-server version compatibility:
-    
+            ```bash
+            kubectl get deployment metrics-server -n kube-system
+            ```
+
+            Expected Output: You should see the deployment details of the Metrics-Server. If it's not present, you will need to install it.
+
+            <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.17.19_PM.webp" alt="Get metrics server" caption="Get metrics server" />
+
+        - Installation:
+        If the Metrics-Server is not installed,  you can install it using the official Kubernetes YAML manifest. You can find the latest version of the Metrics-Server and its deployment instructions on the <a href="https://github.com/kubernetes-sigs/metrics-server" rel="noopener noreferrer nofollow" target="_blank">Kubernetes Metrics Server GitHub page</a>.
+2.  Verify metrics-server version compatibility:
+
     Ensuring that the Metrics-Server version is compatible with your Kubernetes cluster version is critical for its proper function.
-    
+
     - Check Compatibility:
-    Review the Metrics-Server release notes or documentation to confirm that its version is compatible with your cluster's Kubernetes version.
+      Review the Metrics-Server release notes or documentation to confirm that its version is compatible with your cluster's Kubernetes version.
     - Update Metrics-Server:
-    If an update is necessary, apply the latest compatible Metrics-Server manifest. This can be done by downloading the updated YAML file from the Kubernetes GitHub repository and applying it with `kubectl apply`.
-        - Confirm your metrics-server version is compatible with your Kubernetes cluster version.
-        - Update if necessary using the appropriate manifest for your cluster version.
-3. Check RBAC permissions: HPA and Metrics-Server require specific RBAC permissions to function properly.
+      If an update is necessary, apply the latest compatible Metrics-Server manifest. This can be done by downloading the updated YAML file from the Kubernetes GitHub repository and applying it with `kubectl apply`. - Confirm your metrics-server version is compatible with your Kubernetes cluster version. - Update if necessary using the appropriate manifest for your cluster version.
+
+3.  Check RBAC permissions: HPA and Metrics-Server require specific RBAC permissions to function properly.
+
     - Verify Cluster Roles and Bindings:
-    Use these commands to check the necessary roles and bindings:
-        
-        ```bash
-        kubectl get clusterrole system:aggregated-metrics-reader
-        kubectl get clusterrolebinding metrics-server:system:auth-delegator
-        ```
-        
-        Expected Output: These commands should return the configuration of the roles and bindings that allow Metrics-Server to access and [aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/).
-        
-    
-          You can see the below output:
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.18.36_PM.webp" alt="Clusterrole" caption="Clusterrole" />
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.19.29_PM.webp" alt="Clusterbinding" caption="Clusterbinding" />
-    
-4. Validate resource requests and limits:
-Proper configuration of resource requests and limits is crucial for accurate metrics collection by the metrics server.
-    - Review and Adjust Resource Specifications:
+      Use these commands to check the necessary roles and bindings:
+
+          ```bash
+          kubectl get clusterrole system:aggregated-metrics-reader
+          kubectl get clusterrolebinding metrics-server:system:auth-delegator
+          ```
+
+          Expected Output: These commands should return the configuration of the roles and bindings that allow Metrics-Server to access and [aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/).
+
+
+            You can see the below output:
+
+    <Figure
+      src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.18.36_PM.webp"
+      alt="Clusterrole"
+      caption="Clusterrole"
+    />
+
+    <Figure
+      src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.19.29_PM.webp"
+      alt="Clusterbinding"
+      caption="Clusterbinding"
+    />
+
+4.  Validate resource requests and limits:
+    Proper configuration of resource requests and limits is crucial for accurate metrics collection by the metrics server. - Review and Adjust Resource Specifications:
     Check your pod specifications to ensure they have appropriate resource requests and limits. This affects how Kubernetes schedules and scales these pods. Example configuration:
-        
-        ```yaml
-        resources:
-          requests:
-            memory: "64Mi"
-            cpu: "250m"
-          limits:
-            memory: "128Mi"
-            cpu: "500m"
-        
-        ```
-        
-        Adjust these values based on your application's specific needs and typical resource usage to ensure efficient scaling.
-        
+            ```yaml
+            resources:
+              requests:
+                memory: "64Mi"
+                cpu: "250m"
+              limits:
+                memory: "128Mi"
+                cpu: "500m"
+
+            ```
+
+            Adjust these values based on your application's specific needs and typical resource usage to ensure efficient scaling.
+
 
 ## Resolving "No Metrics Returned" Errors
 
 The "no metrics returned" error in Kubernetes typically occurs when the Horizontal Pod Autoscaler (HPA) is unable to retrieve the necessary metrics from the Kubernetes Metrics Server. This issue can stem from various factors such as a misconfigured metrics server, incorrect resource requests, or outdated components. The following solutions provide detailed steps to resolve this error and ensure your HPA functions correctly.
 
-1. Restart the metrics-server pod:  
-The Kubernetes Metrics Server is responsible for providing resource usage metrics (like CPU and memory) to the HPA. If the metrics server is experiencing issues or crashes, restarting the server pod can often resolve the problem. This action ensures that any temporary issues, such as network connectivity problems or memory leaks, are cleared.
+1.  Restart the metrics-server pod:  
+    The Kubernetes Metrics Server is responsible for providing resource usage metrics (like CPU and memory) to the HPA. If the metrics server is experiencing issues or crashes, restarting the server pod can often resolve the problem. This action ensures that any temporary issues, such as network connectivity problems or memory leaks, are cleared.
 
-    
-    ```bash
-    kubectl rollout restart deployment metrics-server -n kube-system
-    ```
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.30.33_PM.webp" alt="rollout deployment" caption="rollout deployment" />
-    
-    After restarting the metrics-server, check the pod status using:
-    
-    ```bash
-    kubectl get pods -n kube-system
-    ```
-    
-    If the pod is successfully restarted, you should see the new pod in a `Running` state. Once the metrics server is back online, check if the HPA is now able to retrieve the required metrics.
-    
+        ```bash
+        kubectl rollout restart deployment metrics-server -n kube-system
+        ```
+
+        <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-17_at_7.30.33_PM.webp" alt="rollout deployment" caption="rollout deployment" />
+
+        After restarting the metrics-server, check the pod status using:
+
+        ```bash
+        kubectl get pods -n kube-system
+        ```
+
+        If the pod is successfully restarted, you should see the new pod in a `Running` state. Once the metrics server is back online, check if the HPA is now able to retrieve the required metrics.
+
+1.  Update metrics-server to the latest compatible version:
 
-1. Update metrics-server to the latest compatible version:
-    
     Running an outdated version of the metrics server can lead to compatibility issues with newer Kubernetes versions. It’s essential to ensure that the version of the metrics server you are running is compatible with your cluster's Kubernetes version. Newer releases often include bug fixes, security patches, and performance improvements that can resolve issues related to metrics retrieval.
-    
+
     To update the metrics-server:
-    
+
     1. Visit the official metrics-server GitHub repository or Kubernetes documentation to find the latest compatible version for your Kubernetes version.
     2. Once you’ve identified the correct version, update your metrics server by editing the deployment or redeploying it with the correct version.
-    
+
     Example:
-    
+
     If you’re using Helm, the command to update the metrics-server might look like this:
-    
+
     ```bash
     helm upgrade --install metrics-server stable/metrics-server --version <latest_version> --namespace kube-system
     ```
-    
+
     After the update, verify that the metrics server is running the new version and check if the HPA is now receiving metrics.
-    
-2. Configure proper resource requests for monitored pods:
+
+1.  Configure proper resource requests for monitored pods:
+
     - For the HPA to function properly, the pods being monitored must have resource requests and limits defined. Without proper CPU and memory resource requests, the metrics server won’t be able to collect and report metrics, leading to the "no metrics returned" error.
     - Ensure that each pod under the HPA’s control has appropriate resource requests and limits defined in its specification. This allows the metrics server to track the pod's resource utilization and provide the necessary data to the HPA.
-    
+
     Here’s an example of a properly defined pod specification with resource requests:
-    
+
     ```yaml
     apiVersion: v1
     kind: Pod
@@ -256,38 +288,37 @@ The Kubernetes Metrics Server is responsible for providing resource usage metric
       name: example-pod
     spec:
       containers:
-      - name: example-container
-        image: nginx
-        resources:
-          requests:
-            memory: "64Mi"
-            cpu: "250m"
-          limits:
-            memory: "128Mi"
-            cpu: "500m"
-    
+        - name: example-container
+          image: nginx
+          resources:
+            requests:
+              memory: '64Mi'
+              cpu: '250m'
+            limits:
+              memory: '128Mi'
+              cpu: '500m'
     ```
-    
+
     Example:
-    
+
     After ensuring that the pod specifications are correctly defined, restart the pod using:
-    
+
     ```bash
     kubectl delete pod <pod-name> -n <namespace>
     ```
-    
+
     This forces the pod to restart with the correct resource requests, allowing the metrics server to begin collecting data. Then check the HPA status to see if metrics are now being returned.
-    
+
     4. Adjust the HPA Configuration
-    
+
     In some cases, the issue might be with the HPA configuration itself. The HPA may be misconfigured to query metrics that are either not available or incorrectly defined. Adjusting the HPA configuration to use the correct metrics can help resolve the error.
-    
+
     Solution:
-    
+
     Review and update the HPA definition to ensure it targets the correct metrics and includes the right thresholds for scaling. For example, if the HPA is set to scale based on CPU usage, ensure the metric name is correctly specified as `cpu` and that the target utilization is reasonable.
-    
+
     Here’s an example of a properly configured HPA:
-    
+
     ```yaml
     apiVersion: autoscaling/v1
     kind: HorizontalPodAutoscaler
@@ -301,88 +332,90 @@ The Kubernetes Metrics Server is responsible for providing resource usage metric
       minReplicas: 1
       maxReplicas: 10
       metrics:
-      - type: Resource
-        resource:
-          name: cpu
-          targetAverageUtilization: 50
+        - type: Resource
+          resource:
+            name: cpu
+            targetAverageUtilization: 50
     ```
-    
+
     Example:
-    
+
     In this example, the HPA is configured to scale between 1 and 10 replicas based on CPU usage. If the average CPU utilization across all pods exceeds 50%, the HPA will scale up the number of replicas.
-    
+
     After updating the HPA configuration, apply the changes with:
-    
+
     ```bash
     kubectl apply -f <hpa-file>.yaml
     ```
-    
+
     You can see the below output:
-    
-    <Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.19.32_AM.webp" alt="hpa apply" caption="hpa apply" />
-    
+
+    <Figure
+      src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.19.32_AM.webp"
+      alt="hpa apply"
+      caption="hpa apply"
+    />
+
     Verify that the HPA is now functioning correctly by running:
-    
+
     ```bash
     kubectl describe hpa <hpa-name>
     ```
-    
+
     You can see the below output:
-    
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.19.58_AM.webp" alt="hpa-describe" caption="hpa-describe" />
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-19_at_8.19.58_AM.webp"
+  alt="hpa-describe"
+  caption="hpa-describe"
+/>
 
 ## Advanced HPA Configuration Techniques
 
 To enhance your HPA implementation, consider these advanced techniques:
 
-1. Implement custom metrics: Use custom metrics adapters to scale based on application-specific metrics. 
-Configure HPA to Use Custom Metrics:
-    
-    ```yaml
-    metrics:
-    - type: Pods
-      pods:
-        metric:
-          name: http_requests
-        target:
-          type: AverageValue
-          averageValue: 1000
-    ```
-    
-2. Utilize external metrics providers: Integrate with external monitoring systems for more comprehensive scaling decisions like SigNoz.
-3. Configure scaling policies and behaviors: Fine-tune HPA behavior with scaling policies:
-    
+1.  Implement custom metrics: Use custom metrics adapters to scale based on application-specific metrics.
+    Configure HPA to Use Custom Metrics:
+        ```yaml
+        metrics:
+        - type: Pods
+          pods:
+            metric:
+              name: http_requests
+            target:
+              type: AverageValue
+              averageValue: 1000
+        ```
+2.  Utilize external metrics providers: Integrate with external monitoring systems for more comprehensive scaling decisions like SigNoz.
+3.  Configure scaling policies and behaviors: Fine-tune HPA behavior with scaling policies:
+
     ```yaml
     behavior:
       scaleDown:
         stabilizationWindowSeconds: 300
         policies:
-        - type: Percent
-          value: 100
-          periodSeconds: 15
-    
+          - type: Percent
+            value: 100
+            periodSeconds: 15
     ```
-    
-4. Implement multi-metric and resource-based HPAs: Combine multiple metrics for more nuanced scaling decisions:
-    
+
+4.  Implement multi-metric and resource-based HPAs: Combine multiple metrics for more nuanced scaling decisions:
+
     ```yaml
     metrics:
-    - type: Resource
-      resource:
-        name: cpu
-        target:
-          type: Utilization
-          averageUtilization: 50
-    - type: Resource
-      resource:
-        name: memory
-        target:
-          type: AverageValue
-          averageValue: 500Mi
-    
+      - type: Resource
+        resource:
+          name: cpu
+          target:
+            type: Utilization
+            averageUtilization: 50
+      - type: Resource
+        resource:
+          name: memory
+          target:
+            type: AverageValue
+            averageValue: 500Mi
     ```
-    
 
 ### Solutions to Common Metric Retrieval Problems
 
@@ -414,7 +447,12 @@ If all else fails, restarting the Metrics Server may help resolve temporary issu
 kubectl delete pod -n kube-system -l k8s-app=metrics-server
 ```
 
-<Figure src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-18_at_12.39.04_AM.webp" alt="" caption="" />## Monitoring and Debugging HPA Performance
+<Figure
+  src="/img/guides/2024/09/kubernetes-hpa-unable-to-get-metrics-for-resource-memory-no-metrics-returned-from-resource-metrics-api-Screenshot_2024-09-18_at_12.39.04_AM.webp"
+  alt=""
+  caption=""
+/>
+## Monitoring and Debugging HPA Performance
 
 Effective monitoring is crucial for maintaining a healthy HPA setup:
 
@@ -478,4 +516,4 @@ Yes, you can use custom metrics adapters or external metrics providers like Prom
 
 ### How often should I update my metrics-server and HPA configurations?
 
-It's recommended to keep your metrics-server updated with each Kubernetes version upgrade. Review and adjust your HPA configurations regularly, especially after significant changes to your application's resource usage patterns or performance requirements.
\ No newline at end of file
+It's recommended to keep your metrics-server updated with each Kubernetes version upgrade. Review and adjust your HPA configurations regularly, especially after significant changes to your application's resource usage patterns or performance requirements.
diff --git a/data/guides/kubernetes-monitoring-best-practices.mdx b/data/guides/kubernetes-monitoring-best-practices.mdx
index 968aa034d..a6a512d32 100644
--- a/data/guides/kubernetes-monitoring-best-practices.mdx
+++ b/data/guides/kubernetes-monitoring-best-practices.mdx
@@ -1,18 +1,20 @@
 ---
-
 title: Kubernetes Monitoring - 8 Best Practices for Effective Cluster Monitoring
-slug: kubernetes-monitoring-best-practices
 date: 2024-06-17
 tags: [kubernetes]
 authors: [daniel]
 description: By implementing best practices for Kubernetes monitoring, you can gain valuable insights into cluster health, quickly detect and resolve issues, optimize resource usage, and ensure….
 image: /img/blog/2024/06/kubernetes-monitoring-best-practices-cover.webp
-keywords: [kubernetes,monitoring,security]
-
+keywords: [kubernetes, monitoring, security]
 ---
+
 Monitoring Kubernetes clusters is essential for maintaining the performance, reliability, and security of your containerized applications. Given the dynamic and distributed nature of Kubernetes environments, effective monitoring can be challenging but is crucial for ensuring your applications run smoothly. By implementing best practices for Kubernetes monitoring, you can gain valuable insights into cluster health, quickly detect and resolve issues, optimize resource usage, and ensure compliance with service level agreements (SLAs).
 
-<Figure src="/img/guides/2024/06/kubernetes-monitoring-best-practices-cover.webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/06/kubernetes-monitoring-best-practices-cover.webp"
+  alt=""
+  caption=""
+/>
 
 In this article, we will discuss why Kubernetes monitoring is important, monitoring challenges, and best practices for effectively monitoring your Kubernetes clusters.
 
@@ -47,11 +49,11 @@ By following best practices for Kubernetes monitoring, you can ensure the health
 
 When monitoring your Kubernetes cluster, selecting the appropriate metrics to track is crucial for gaining insights into its health and performance. Not all metrics are equally important; rather, focus on those that directly impact your application's performance, and reliability. The selection should be based on your monitoring objectives and KPIs.
 
-Consider metrics such as resource utilization, pod and node availability, network traffic, and application performance to ensure comprehensive monitoring coverage. These metrics help you effectively gauge the cluster's behavior and detect any deviations from normal operation. 
+Consider metrics such as resource utilization, pod and node availability, network traffic, and application performance to ensure comprehensive monitoring coverage. These metrics help you effectively gauge the cluster's behavior and detect any deviations from normal operation.
 
 ### Implement the Use of Tags and Labels
 
-Tags and labels are useful for organizing and filtering your Kubernetes resources. They allow you to categorize resources, services, and applications, making it easier to track specific entities within your cluster. For example, labeling pods by deployment name makes it simple to aggregate metrics related to a particular service or application. Similarly, tagging nodes by location or purpose aids in monitoring and managing resources efficiently. 
+Tags and labels are useful for organizing and filtering your Kubernetes resources. They allow you to categorize resources, services, and applications, making it easier to track specific entities within your cluster. For example, labeling pods by deployment name makes it simple to aggregate metrics related to a particular service or application. Similarly, tagging nodes by location or purpose aids in monitoring and managing resources efficiently.
 
 Utilizing tags and labels effectively enhances the granularity and usability of your monitoring data, enabling more precise analysis and faster issue resolution.
 
@@ -112,11 +114,16 @@ podtato-kubectl   podtato-head-right-leg   1/1     1            1           37m
 
 ### Use Service Auto Discovery
 
-As your cluster grows, the number of services, pods, and other components will increase rapidly. Manually configuring monitoring for each newly deployed resource can be inefficient and prone to errors. To overcome this challenge, it is recommended to use a service auto discovery. 
+As your cluster grows, the number of services, pods, and other components will increase rapidly. Manually configuring monitoring for each newly deployed resource can be inefficient and prone to errors. To overcome this challenge, it is recommended to use a service auto discovery.
 
 Service Auto Discovery is the process by which monitoring tools automatically detect and start tracking the services running within a Kubernetes cluster as they are created, scaled, or terminated. Instead of manually configuring monitoring for each new service, the monitoring system dynamically discovers and begins monitoring them as they are deployed. You can utilize tools like Prometheus to set up auto discovery in your cluster.
 
-<Figure src="/img/guides/2024/06/prometheus-service-discovery.webp" alt="Service discovery for Kubernetes cluster in Prometheus" caption="Service discovery for Kubernetes cluster in Prometheus" /><br></br>
+<Figure
+  src="/img/guides/2024/06/prometheus-service-discovery.webp"
+  alt="Service discovery for Kubernetes cluster in Prometheus"
+  caption="Service discovery for Kubernetes cluster in Prometheus"
+/>
+<br></br>
 
 ### Monitor at Multiple Levels
 
@@ -139,11 +146,16 @@ Adopting a unified monitoring solution is an important best practice for monitor
 
 This consolidated view significantly simplifies the identification and troubleshooting of issues across the entire infrastructure. It provides real-time visibility into the cluster's health and performance and allows for the correlation of metrics with logs and traces for easier analysis of data.
 
-<Figure src="/img/guides/2024/06/kubernetes_metrics.webp" alt="Kubernetes metrics visualization in a single pane of glass" caption="Kubernetes metrics visualization in a single pane of glass" /><br></br>
+<Figure
+  src="/img/guides/2024/06/kubernetes_metrics.webp"
+  alt="Kubernetes metrics visualization in a single pane of glass"
+  caption="Kubernetes metrics visualization in a single pane of glass"
+/>
+<br></br>
 
 ### Set Up Meaningful Alerts
 
-Setting up meaningful alerts is an important practice in monitoring your Kubernetes clusters. By defining thresholds for critical metrics, you ensure that alerts are triggered when these metrics are exceeded, allowing for immediate notification of any potential issues. This proactive approach ensures that corrective actions can be taken swiftly, minimizing the impact on users. 
+Setting up meaningful alerts is an important practice in monitoring your Kubernetes clusters. By defining thresholds for critical metrics, you ensure that alerts are triggered when these metrics are exceeded, allowing for immediate notification of any potential issues. This proactive approach ensures that corrective actions can be taken swiftly, minimizing the impact on users.
 
 Alerts should be configured to notify you under several key conditions:
 
@@ -169,13 +181,18 @@ By continuously monitoring these metrics, you can proactively identify and addre
 
 If you need complete visibility into your cluster's health and performance or want to proactively address potential issues before they impact your services, [SigNoz](https://signoz.io/) provides a comprehensive monitoring solution designed for Kubernetes environments.
 
-[SigNoz](https://signoz.io/) is a full-stack open-source observability platform, built on <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a>, that provides comprehensive insights into the health, performance, and behavior of your Kubernetes environment, in a single pane of glass. It collects telemetry data from various components, including nodes, pods, containers, and services, and allows you to track key performance metrics for proactive resolution of resource constraints and performance bottlenecks. 
+[SigNoz](https://signoz.io/) is a full-stack open-source observability platform, built on <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a>, that provides comprehensive insights into the health, performance, and behavior of your Kubernetes environment, in a single pane of glass. It collects telemetry data from various components, including nodes, pods, containers, and services, and allows you to track key performance metrics for proactive resolution of resource constraints and performance bottlenecks.
 
-SigNoz provides distributed tracing capabilities, allowing you to identify root causes in your cluster. Its advanced log management capabilities let you aggregate, index, and analyze logs from all your services and pods in a centralized manner. You can also create custom dashboards to visualize metrics, traces, and logs in a way that makes sense for your team. 
+SigNoz provides distributed tracing capabilities, allowing you to identify root causes in your cluster. Its advanced log management capabilities let you aggregate, index, and analyze logs from all your services and pods in a centralized manner. You can also create custom dashboards to visualize metrics, traces, and logs in a way that makes sense for your team.
 
 We have created a comprehensive guide on [monitoring your Kubernetes clusters](https://signoz.io/blog/opentelemetry-kubernetes-cluster-metrics-monitoring/#what-is-a-kubernetes-cluster) using SigNoz.
 
-<Figure src="/img/guides/2024/06/k8s_monitoring_dashboard.webp" alt="Kubernetes monitoring dashboard in SigNoz" caption="Kubernetes monitoring dashboard in SigNoz" /><br></br>
+<Figure
+  src="/img/guides/2024/06/k8s_monitoring_dashboard.webp"
+  alt="Kubernetes monitoring dashboard in SigNoz"
+  caption="Kubernetes monitoring dashboard in SigNoz"
+/>
+<br></br>
 
 ## Getting Started with SigNoz
 
diff --git a/data/guides/kubernetes-monitoring-prometheus.mdx b/data/guides/kubernetes-monitoring-prometheus.mdx
index 02eec0453..fa2b295e9 100644
--- a/data/guides/kubernetes-monitoring-prometheus.mdx
+++ b/data/guides/kubernetes-monitoring-prometheus.mdx
@@ -1,15 +1,13 @@
 ---
-
 title: How to Monitor Kubernetes Clusters using Prometheus
-slug: kubernetes-monitoring-prometheus
 date: 2024-06-17
 tags: [kubernetes]
 authors: [daniel]
 description: Prometheus collects and analyzes metrics from your Kubernetes cluster to understand its behavior and enables proactive identification of issues to….
 image: /img/blog/2024/06/kubernetes-monitoring-prometheus-cover.webp
-keywords: [kubernetes,monitoring,prometheus]
-
+keywords: [kubernetes, monitoring, prometheus]
 ---
+
 Prometheus is a powerful open-source monitoring tool for keeping tabs on the health and performance of your Kubernetes cluster. It can collect and analyze metrics from your cluster for understanding cluster behavior, enable proactive identification of issues, and optimize resource utilization to ensure the efficient operation of your cluster.
 
 In this tutorial, you will learn to setup Prometheus for cluster monitoring and how to export the metrics collected to SigNoz for visualization.
@@ -49,8 +47,17 @@ In this section, we will walk through the process of setting up Prometheus to mo
 ### Prerequistes
 
 - A Kubernetes Cluster - <a href="https://www.docker.com/resources/kubernetes-and-docker/" rel="noopener noreferrer nofollow" target="_blank">Docker Desktop</a>, <a href="https://minikube.sigs.k8s.io/docs/start/?arch=%2Fmacos%2Fx86-64%2Fstable%2Fbinary+download" rel="noopener noreferrer nofollow" target="_blank">Minikube</a>, <a href="https://kind.sigs.k8s.io/" rel="noopener noreferrer nofollow" target="_blank">Kind</a>, or any local cluster of choice.
-- <a href="https://kubernetes.io/docs/tasks/tools/" rel="noopener noreferrer nofollow" target="_blank">Kubectl</a>.
-- <a href="https://helm.sh/" rel="noopener noreferrer nofollow" target="_blank">Helm</a> installed.
+- <a
+    href="https://kubernetes.io/docs/tasks/tools/"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    Kubectl
+  </a>
+  .
+- <a href="https://helm.sh/" rel="noopener noreferrer nofollow" target="_blank">
+    Helm
+  </a> installed.
 - A [SigNoz cloud](https://signoz.io/teams/) account.
 
 ### Installing Prometheus in the cluster
@@ -81,7 +88,7 @@ You can then view the newly added charts:
 helm search repo prometheus-community
 ```
 
-From the just added  `prometheus-community/kube-prometheus-stack` chart, install Prometheus:
+From the just added `prometheus-community/kube-prometheus-stack` chart, install Prometheus:
 
 ```bash
 helm upgrade --install prometheus prometheus-community/kube-prometheus-stack --wait
@@ -143,13 +150,25 @@ kubectl port-forward svc/prometheus-kube-prometheus-prometheus 9090:9090 -n defa
 
 On your browser, navigate to [localhost:9090](http://localhost:9090) to see the Prometheus UI:
 
-<Figure src="/img/guides/2024/06/prometheus_UI.webp" alt="Prometheus UI" caption="Prometheus UI" /><br></br>Prometheus has been configured to automatically scrape cluster metrics. To verify this, click on Status > Targets to see the Targets to see the Targets that are being monitored. 
+<Figure src="/img/guides/2024/06/prometheus_UI.webp" alt="Prometheus UI" caption="Prometheus UI" />
+<br></br>Prometheus has been configured to automatically scrape cluster metrics. To verify this,
+click on Status > Targets to see the Targets to see the Targets that are being monitored.{' '}
 
 You should see a list of endpoints that Prometheus is currently scraping for metrics.
 
-<Figure src="/img/guides/2024/06/prometheus-targets.webp" alt="Prometheus Targets" caption="Prometheus Targets" /><br></br>You can see all the target endpoints being monitored by Prometheus:
+<Figure
+  src="/img/guides/2024/06/prometheus-targets.webp"
+  alt="Prometheus Targets"
+  caption="Prometheus Targets"
+/>
+<br></br>You can see all the target endpoints being monitored by Prometheus:
 
-<Figure src="/img/guides/2024/06/target-endpoints.webp" alt="Target endpoints Prometheus scrapes metrics from" caption="Target endpoints Prometheus scrapes metrics from" /><br></br>
+<Figure
+  src="/img/guides/2024/06/target-endpoints.webp"
+  alt="Target endpoints Prometheus scrapes metrics from"
+  caption="Target endpoints Prometheus scrapes metrics from"
+/>
+<br></br>
 
 ### Configure Prometheus to Send Metrics to SigNoz
 
@@ -163,11 +182,11 @@ You can sign up [here](https://signoz.io/teams/) for a free account and get 30
 
 Create Service Account
 
-After your SigNoz cloud account has been set up, you can now set up cluster resources to collect metrics from Prometheus. The first will be a Service Account. 
+After your SigNoz cloud account has been set up, you can now set up cluster resources to collect metrics from Prometheus. The first will be a Service Account.
 
 A <a href="https://kubernetes.io/docs/concepts/security/service-accounts/" rel="noopener noreferrer nofollow" target="_blank">Service Account</a> is a special type of account that provides an identity for processes that run in a pod and enables them to authenticate to the Kubernetes API and other services. Each Service Account is associated with a set of permissions, allowing it to perform specific actions within the cluster.
 
-Create a file named `serviceaccount.yaml`  and paste the following YAML definition in that file:
+Create a file named `serviceaccount.yaml` and paste the following YAML definition in that file:
 
 ```bash
 apiVersion: v1
@@ -259,7 +278,7 @@ rules:
 Apply the ClusterRole definition:
 
 ```bash
-kubectl apply -f clusterrole.yml  
+kubectl apply -f clusterrole.yml
 ```
 
 Bind Service Account to Cluster Role
@@ -293,7 +312,7 @@ kubectl apply -f clusterrolebinding.yml
 
 Configure the Config Map
 
-A ConfigMap is a Kubernetes object used to store non-confidential configuration data, command-line arguments, environment variables, or any other configuration data needed by applications running in Kubernetes in key-value pairs.  
+A ConfigMap is a Kubernetes object used to store non-confidential configuration data, command-line arguments, environment variables, or any other configuration data needed by applications running in Kubernetes in key-value pairs.
 
 Create a file named `configmap.yaml` and paste the following YAML definition in that file:
 
@@ -341,15 +360,29 @@ To get the ingestion key for your SigNoz cloud account, go to settings > Ingesti
 
 Also, take note of the ingestion url. There are currently 2 regions available, EU (Europe) and IN (India). Copy the region where you have your account deployed in and paste in the config map.
 
-<Figure src="/img/guides/2024/06/Ingestion-Key.webp" alt="Ingestion key" caption="Ingestion key" /><br></br>Apply the config map:
+<Figure src="/img/guides/2024/06/Ingestion-Key.webp" alt="Ingestion key" caption="Ingestion key" />
+<br></br>Apply the config map:
 
 ```bash
-kubectl apply -f configmap.yml 
+kubectl apply -f configmap.yml
 ```
 
 Deploy OpenTelemetry Collector
 
-<a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> is an open-source framework that provides APIs and SDKs for instrumenting applications to generate telemetry data. The <a href="https://opentelemetry.io/docs/collector/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry Collector</a> is a specific component within the OpenTelemetry ecosystem that facilitates the collection, processing, and exporting of telemetry data. It is designed to sit between the instrumentation points in your application and your observability backend (like SigNoz). The Collector receives data from various sources, process it (for example, adding tags or annotations), and then export it to one or more destinations in a standardized format.
+<a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">
+  OpenTelemetry
+</a> is an open-source framework that provides APIs and SDKs for instrumenting applications to
+generate telemetry data. The <a
+  href="https://opentelemetry.io/docs/collector/"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  OpenTelemetry Collector
+</a> is a specific component within the OpenTelemetry ecosystem that facilitates the collection,
+processing, and exporting of telemetry data. It is designed to sit between the instrumentation
+points in your application and your observability backend (like SigNoz). The Collector receives data
+from various sources, process it (for example, adding tags or annotations), and then export it to
+one or more destinations in a standardized format.
 
 SigNoz is built on OpenTelemetry which is why it relies on the OpenTelemetry Collector to receive metrics data collected from Prometheus. The OpenTelemetry Collector will be deployed in the cluster as a Deployment.
 
@@ -391,7 +424,7 @@ spec:
 The above Deployment runs a single replica (pod) of the <a href="https://github.com/open-telemetry/opentelemetry-collector-contrib" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry Collector Contrib</a> using the assigned Service Account. The Service Account's permissions as defined earlier in the ClusterRole config determine what actions the pod can perform (including reading the ConfigMap). The Deployment mounts the "otelcontribcol" ConfigMap into the pod as a volume, making the configuration file available to the OpenTelemetry Collector. The Collector uses the configuration file to guide its data collection, processing, and exporting activities.
 
 ```bash
-kubectl apply -f deployment.yml  
+kubectl apply -f deployment.yml
 ```
 
 Verify that the OpenTelemetry Collector is receiving metrics data:
@@ -425,21 +458,62 @@ Expected output:
 
 To visualize the metrics being sent to SigNoz, navigate to your SigNoz cloud account. Click on Dashboards > New dashboard:
 
-<Figure src="/img/guides/2024/06/Create_Dashboard.webp" alt="Creating a dashboard in SigNoz" caption="Creating a dashboard in SigNoz" /><br></br>Click on Configure your new dashboard:
-
-<Figure src="/img/guides/2024/06/configure_dashboard.webp" alt="Dashboard configuration" caption="Dashboard configuration" /><br></br>Give the dashboard a name, description, and tag (optional), then save it.
-
-<Figure src="/img/guides/2024/06/dashboard-naming.webp" alt="Dashboard naming" caption="Dashboard naming" /><br></br>After the dashboard has been created, panels can be set up. Click on Add Panels > New Panel, to start creating visualizations in the dashboard:
-
-<Figure src="/img/guides/2024/06/dashboard-panel.webp" alt="Adding panels in the SigNoz dashboard" caption="Adding panels in the SigNoz dashboard" /><br></br>For the visualization option, select “Time Series”:
-
-<Figure src="/img/guides/2024/06/Time_Series.webp" alt="Visualization options" caption="Visualization options" /><br></br>You will be redirected to the query builder where you can run different queries against the metrics coming in using the time series visualization.
+<Figure
+  src="/img/guides/2024/06/Create_Dashboard.webp"
+  alt="Creating a dashboard in SigNoz"
+  caption="Creating a dashboard in SigNoz"
+/>
+<br></br>Click on Configure your new dashboard:
+
+<Figure
+  src="/img/guides/2024/06/configure_dashboard.webp"
+  alt="Dashboard configuration"
+  caption="Dashboard configuration"
+/>
+<br></br>Give the dashboard a name, description, and tag (optional), then save it.
+
+<Figure
+  src="/img/guides/2024/06/dashboard-naming.webp"
+  alt="Dashboard naming"
+  caption="Dashboard naming"
+/>
+<br></br>After the dashboard has been created, panels can be set up. Click on Add Panels > New
+Panel, to start creating visualizations in the dashboard:
+
+<Figure
+  src="/img/guides/2024/06/dashboard-panel.webp"
+  alt="Adding panels in the SigNoz dashboard"
+  caption="Adding panels in the SigNoz dashboard"
+/>
+<br></br>For the visualization option, select “Time Series”:
+
+<Figure
+  src="/img/guides/2024/06/Time_Series.webp"
+  alt="Visualization options"
+  caption="Visualization options"
+/>
+<br></br>You will be redirected to the query builder where you can run different queries against the
+metrics coming in using the time series visualization.
 
 In the query builder, type in “kube” to see Kubernetes metrics being exported to SigNoz:
 
-<Figure src="/img/guides/2024/06/query-builder.webp" alt="Kubernetes metrics exported to SigNoz" caption="Kubernetes metrics exported to SigNoz" /><br></br>For your first metrics query, type `kube_pod_container_status_running` then click on the stage and run query button:
-
-<Figure src="/img/guides/2024/06/run-queries.webp" alt="Kubernetes metrics being queried in SigNoz dashboard" caption="Kubernetes metrics being queried in SigNoz dashboard" /><br></br>The `kube_pod_container_status_running` metric is a Prometheus metric exposed by the kube-state-metrics service. This metric indicates whether containers within pods in your Kubernetes cluster is currently in a running state. It's a gauge metric, meaning it represents a value at a particular point in time.
+<Figure
+  src="/img/guides/2024/06/query-builder.webp"
+  alt="Kubernetes metrics exported to SigNoz"
+  caption="Kubernetes metrics exported to SigNoz"
+/>
+<br></br>For your first metrics query, type `kube_pod_container_status_running` then click on the
+stage and run query button:
+
+<Figure
+  src="/img/guides/2024/06/run-queries.webp"
+  alt="Kubernetes metrics being queried in SigNoz dashboard"
+  caption="Kubernetes metrics being queried in SigNoz dashboard"
+/>
+<br></br>The `kube_pod_container_status_running` metric is a Prometheus metric exposed by the
+kube-state-metrics service. This metric indicates whether containers within pods in your Kubernetes
+cluster is currently in a running state. It's a gauge metric, meaning it represents a value at a
+particular point in time.
 
 When you get a value of `1` for the `kube_pod_container_status_running` metric in Prometheus as shown above, it typically means that the condition "running" is met for the containers being monitored. In other words, all the containers targeted by the query are currently in the "running" state within their respective pods.
 
@@ -447,7 +521,12 @@ For this kind of metric, you can also decide to use the “value” visualizatio
 
 Give the panel a name and description, then select Save Changes. The panel will be automatically saved in your dashboard:
 
-<Figure src="/img/guides/2024/06/signoz-dashboard.webp" alt="Saved SigNoz dashboard" caption="Saved SigNoz dashboard" /><br></br>You can proceed to run more queries against metrics of your choice.
+<Figure
+  src="/img/guides/2024/06/signoz-dashboard.webp"
+  alt="Saved SigNoz dashboard"
+  caption="Saved SigNoz dashboard"
+/>
+<br></br>You can proceed to run more queries against metrics of your choice.
 
 ## Conclusion
 
@@ -455,4 +534,4 @@ In this tutorial, you configured Prometheus to collect metrics data from a Kuber
 
 Visit our [complete guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/) on OpenTelemetry Collector to learn more about it.
 
-If you're excited about SigNoz and want to go deeper, [join the SigNoz Slack](https://signoz-community.slack.com/join/shared_invite/zt-1v5ms4lg2-uupFbX9_qFIWNeVXbMszkw#/shared-invite/email) to be part of this awesome open-source community!
\ No newline at end of file
+If you're excited about SigNoz and want to go deeper, [join the SigNoz Slack](https://signoz-community.slack.com/join/shared_invite/zt-1v5ms4lg2-uupFbX9_qFIWNeVXbMszkw#/shared-invite/email) to be part of this awesome open-source community!
diff --git a/data/guides/kubernetes-observability.mdx b/data/guides/kubernetes-observability.mdx
index ae32f4f2c..52dbfcff6 100644
--- a/data/guides/kubernetes-observability.mdx
+++ b/data/guides/kubernetes-observability.mdx
@@ -1,16 +1,13 @@
 ---
-
 title: Mastering Kubernetes Observability - A Practical Guide
-slug: kubernetes-observability
 date: 2024-10-14
 tags: [observability]
 authors: [bhavya_sachdeva]
 description: Learn how to implement and master Kubernetes observability for enhanced system performance, security, and reliability in cloud-native architectures.
 keywords: [kubernetes observability, monitoring, logs, metrics, traces, cloud-native, microservices]
-
 ---
 
-Kubernetes has changed how we manage containers, but it can be hard to figure out how the system works and performs.  Kubernetes observability is an important way to keep cloud-based applications running smoothly and securely. In this guide, I will cover the basics of Kubernetes observability and how to put it into practice. You'll discover how to monitor your Kubernetes clusters, solve problems more quickly, and improve your applications for better performance.
+Kubernetes has changed how we manage containers, but it can be hard to figure out how the system works and performs. Kubernetes observability is an important way to keep cloud-based applications running smoothly and securely. In this guide, I will cover the basics of Kubernetes observability and how to put it into practice. You'll discover how to monitor your Kubernetes clusters, solve problems more quickly, and improve your applications for better performance.
 
 ## What is Kubernetes Observability?
 
@@ -162,23 +159,17 @@ Start by defining what you aim to achieve with observability in your Kubernetes
 For metrics, logs, and traces, choose tools that best fit your needs:
 
 - Metrics: Use Prometheus for gathering and querying time-series data.
-    
-    ```bash
-    helm install prometheus prometheus-community/prometheus --namespace monitoring --create-namespace
-    ```
-    
+  ```bash
+  helm install prometheus prometheus-community/prometheus --namespace monitoring --create-namespace
+  ```
 - Logs: Deploy Fluentd to aggregate and forward logs to a central store.
-    
-    ```bash
-    helm install fluentd fluent/fluentd --namespace logging --create-namespace
-    ```
-    
+  ```bash
+  helm install fluentd fluent/fluentd --namespace logging --create-namespace
+  ```
 - Traces: Implement Jaeger for [distributed tracing](https://signoz.io/distributed-tracing/) to follow the path requests take through your microservices.
-    
-    ```bash
-    helm install jaeger jaegertracing/jaeger --namespace tracing --create-namespace
-    ```
-    
+  ```bash
+  helm install jaeger jaegertracing/jaeger --namespace tracing --create-namespace
+  ```
 
 For a centralized observability solution, consider [SigNoz](https://signoz.io/), which offers a unified platform for viewing metrics, logs, and traces.
 
@@ -187,88 +178,72 @@ For a centralized observability solution, consider [SigNoz](https://signoz.io/),
 Implement a robust logging system:
 
 - Deploy Fluentd as a DaemonSet to ensure it runs on every node, collecting logs from all pods. Here’s an example of a Fluentd DaemonSet configuration:
-    
-    fluentd-daemonset.yaml
-    
-    ```yaml
-    apiVersion: apps/v1
-    kind: DaemonSet
-    metadata:
-      name: fluentd
-      namespace: logging
-    spec:
-      selector:
-        matchLabels:
+  fluentd-daemonset.yaml
+  ```yaml
+  apiVersion: apps/v1
+  kind: DaemonSet
+  metadata:
+    name: fluentd
+    namespace: logging
+  spec:
+    selector:
+      matchLabels:
+        name: fluentd
+    template:
+      metadata:
+        labels:
           name: fluentd
-      template:
-        metadata:
-          labels:
-            name: fluentd
-        spec:
-          containers:
+      spec:
+        containers:
           - name: fluentd
             image: fluent/fluentd-kubernetes-daemonset:v1
             env:
-            - name: FLUENT_ELASTICSEARCH_HOST
-              value: "elasticsearch.logging.svc.cluster.local"
-            - name: FLUENT_ELASTICSEARCH_PORT
-              value: "9200"
+              - name: FLUENT_ELASTICSEARCH_HOST
+                value: 'elasticsearch.logging.svc.cluster.local'
+              - name: FLUENT_ELASTICSEARCH_PORT
+                value: '9200'
             resources:
               limits:
                 memory: 200Mi
               requests:
                 cpu: 100m
                 memory: 200Mi
-    
-    ```
-    
+  ```
 - Store logs in Elasticsearch, allowing for powerful searching capabilities.
-    
-    ```bash
-    helm install elasticsearch elastic/elasticsearch --namespace logging
-    ```
-    
+  ```bash
+  helm install elasticsearch elastic/elasticsearch --namespace logging
+  ```
 - Visualize logs with Kibana, providing insights into the operational state of your applications and infrastructure.
-    
-    ```bash
-    helm install kibana elastic/kibana --namespace logging
-    ```
-    
+  ```bash
+  helm install kibana elastic/kibana --namespace logging
+  ```
 
 4. Metrics Collection
 
 Set up metrics collection to monitor the health of your services:
 
 - Install Prometheus to collect and store metrics from your Kubernetes environment.
-    
-    ```bash
-    helm install prometheus prometheus-community/prometheus --namespace monitoring --create-namespace
-    ```
-    
+  ```bash
+  helm install prometheus prometheus-community/prometheus --namespace monitoring --create-namespace
+  ```
 - Use Grafana to create visualizations and dashboards that help you understand metrics data, such as CPU load, memory usage, and network IO.
-    
-    ```bash
-    helm install grafana grafana/grafana --namespace monitoring --create-namespace
-    ```
-    
+  ```bash
+  helm install grafana grafana/grafana --namespace monitoring --create-namespace
+  ```
 
 5. Tracing Implementation
 
 Enhance system observability with tracing:
 
 - Use OpenTelemetry for consistent, high-quality telemetry data collection across services.
-    
-    ```bash
-    # Example command for setting up OpenTelemetry Collector
-    helm install opentelemetry-collector open-telemetry/opentelemetry-collector --namespace tracing --create-namespace
-    ```
-    
+  ```bash
+  # Example command for setting up OpenTelemetry Collector
+  helm install opentelemetry-collector open-telemetry/opentelemetry-collector --namespace tracing --create-namespace
+  ```
 - Set up Jaeger to analyze and visualize trace data, helping you understand the flow of requests through your applications.
-    
-    ```bash
-    helm install jaeger jaegertracing/jaeger --namespace tracing --create-namespace
-    ```
-    
+  ```bash
+  helm install jaeger jaegertracing/jaeger --namespace tracing --create-namespace
+  ```
 
 6. Integrate with CI/CD
 
@@ -316,9 +291,9 @@ helm repo add signoz <https://charts.signoz.io>
 helm install my-release signoz/signoz
 ```
 
- 2.  Instrument your applications using SigNoz's auto-instrumentation libraries
+2.  Instrument your applications using SigNoz's auto-instrumentation libraries
 
-1. Access the SigNoz UI to start exploring your observability data.
+1.  Access the SigNoz UI to start exploring your observability data.
 
 SigNoz offers both a cloud-hosted version and a self-hosted open-source version, catering to different deployment preferences and compliance requirements. Learn more about setting it up in this guide on [using SigNoz to monitor your Kubernetes cluster](https://signoz.io/blog/using-signoz-to-monitor-your-kubernetes-cluster/)
 
@@ -363,4 +338,4 @@ Several popular open-source tools can help you implement Kubernetes observabilit
 - Jaeger: For distributed tracing
 - [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/): For standardized instrumentation across logs, metrics, and traces
 
-These tools can be combined to create a comprehensive [observability stack](https://signoz.io/guides/observability-stack/) tailored to your specific needs and environment.
\ No newline at end of file
+These tools can be combined to create a comprehensive [observability stack](https://signoz.io/guides/observability-stack/) tailored to your specific needs and environment.
diff --git a/data/guides/kubernetes-security-best-practices.mdx b/data/guides/kubernetes-security-best-practices.mdx
index 647217955..c8f801f0e 100644
--- a/data/guides/kubernetes-security-best-practices.mdx
+++ b/data/guides/kubernetes-security-best-practices.mdx
@@ -1,19 +1,23 @@
 ---
 title: Top 10 Best Practices for Ensuring Kubernetes Security
-slug: kubernetes-security-best-practices
 date: 2024-06-12
 tags: [kubernetes]
 authors: [daniel]
 description: Kubernetes security is important because if cluster resources are not properly secured, it can lead to security breaches and information loss. A single vulnerability in your Kubernetes setup can expose sensitive data, disrupt critical services...
 image: /img/blog/2024/06/kubernetes-security-best-practices-cover.webp
-keywords: [kubernetes,monitoring,security]
+keywords: [kubernetes, monitoring, security]
 ---
+
 Kubernetes is a popular container orchestration tool that automates the deployment, scaling, and management of containerized applications. However, due to the complexity of configuring and deploying applications within Kubernetes clusters, cluster security is sometimes overlooked.
 
 Kubernetes security is important because if cluster resources are not properly secured, it can lead to security breaches and information loss. A single vulnerability in your Kubernetes setup can expose sensitive data, disrupt critical services, or even become a launchpad for malicious attacks.
 
-<figure data-zoomable align='center'>
-    <img className="box-shadowed-image" src="/img/blog/2024/06/kubernetes-security-best-practices-cover.webp" alt=""/>
+<figure data-zoomable align="center">
+  <img
+    className="box-shadowed-image"
+    src="/img/blog/2024/06/kubernetes-security-best-practices-cover.webp"
+    alt=""
+  />
 </figure>
 
 In this article, we will discuss Kubernetes security, the challenges associated with it, the importance of Kubernetes security, and the best practices to adopt for a secure Kubernetes environment.
@@ -72,7 +76,7 @@ Ensuring the security of your Kubernetes environment is important for protecting
 
 ### Limit Access to the Kubernetes API Server
 
-The Kubernetes API server is the central management entity for the cluster, making it a prime target for attackers. Limiting access to the API server can prevent unauthorized access and reduce the risk of potential breaches. One way to limit access to the API server is by authentication. In this process, users provide their credentials to access the cluster and are only given access when their identities have been verified. This ensures that the user’s claimed identity aligns with their actual identity, determining whether they should be granted access to the cluster or not. 
+The Kubernetes API server is the central management entity for the cluster, making it a prime target for attackers. Limiting access to the API server can prevent unauthorized access and reduce the risk of potential breaches. One way to limit access to the API server is by authentication. In this process, users provide their credentials to access the cluster and are only given access when their identities have been verified. This ensures that the user’s claimed identity aligns with their actual identity, determining whether they should be granted access to the cluster or not.
 
 When a user tries to access the cluster or its resources through the Kubernetes command line tool, the API Server receives the request made by the user and performs authentication by verifying and validating the user’s identity. The Kubernetes API server can perform authentication of users through the use of static password files containing usernames and passwords, static token files containing usernames, passwords, and tokens, certificates that serve as cryptographic proof of the authenticity of an entity, or by using third-party authentication protocols.
 
@@ -94,7 +98,7 @@ A [network policy](https://kubernetes.io/docs/concepts/services-networking/netwo
 
 By enforcing network policies, you can define which pods can communicate with each other and which cannot, restrict pod communication to necessary traffic only, and reduce the attack surface by limiting inter-pod communications within the cluster.
 
-You must use a plugin that supports network policies like CNI or Calico to create a network policy. 
+You must use a plugin that supports network policies like CNI or Calico to create a network policy.
 
 Below is an example of a network policy manifest file that allows only pods labeled "app: backend" to send traffic to pods labeled "app: frontend" within the "my-namespace" namespace. All other incoming traffic to the frontend pods will be blocked.
 
@@ -185,8 +189,6 @@ Some best practices to follow in securing your Kubernetes Secrets include:
 - **Regular Log and Audit Report Reviews**: Periodically review the collected logs and audit reports to identify unusual patterns or unauthorized access attempts. This regular scrutiny helps in the early detection of security incidents, allowing for swift response and mitigation.
 - **Configure Kubernetes Audit Logs**: Enable and properly configure Kubernetes Audit logs to capture comprehensive details about API server interactions. These logs can reveal potential security breaches, vulnerabilities, and policy violations. Effective use of audit logs supports [proactive monitoring](https://signoz.io/guides/proactive-monitoring/), ensures timely incident response, and assists in compliance auditing.
 
-
-
 ## Getting Started with SigNoz
 
-<GetStartedSigNoz />
\ No newline at end of file
+<GetStartedSigNoz />
diff --git a/data/guides/linux-server-monitoring.mdx b/data/guides/linux-server-monitoring.mdx
index a53c101fd..39837f25e 100644
--- a/data/guides/linux-server-monitoring.mdx
+++ b/data/guides/linux-server-monitoring.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Essential Linux Server Monitoring Tools and Techniques
-slug: linux-server-monitoring
 date: 2024-09-11
 tags: [monitoring]
 authors: [eromosele]
 description: Discover essential tools and techniques for effective Linux server monitoring. Learn about open-source solutions, best practices, and advanced strategies.
-keywords: [linux server monitoring, server performance, open-source tools, monitoring techniques, system administration]
-
+keywords:
+  [
+    linux server monitoring,
+    server performance,
+    open-source tools,
+    monitoring techniques,
+    system administration,
+  ]
 ---
 
 Linux server monitoring is a critical aspect of maintaining a healthy and efficient IT infrastructure. As a system administrator or DevOps professional, you need to keep a close eye on your servers' performance, security, and resource utilization. This comprehensive guide will walk you through the essential tools and techniques for effective Linux server monitoring.
@@ -34,21 +38,13 @@ Proactive monitoring means keeping an eye on your Linux server before problems a
 Monitoring a Linux server can sometimes be tricky. Here are some common challenges, tips on how to handle them, and how [SigNoz](http://signoz.io) can help:
 
 - Challenge: Too Much Data
-    
-    Solution: With so many metrics to track, it’s easy to get overwhelmed. Focus on the most important ones like CPU, memory, disk, and network. SigNoz streamlines this by offering a unified platform to aggregate and visualize metrics, logs, and traces. This consolidation allows you to focus on the most critical information without being overwhelmed by too much data. You can customize [dashboards](https://signoz.io/docs/userguide/manage-dashboards/) in SigNoz to highlight the key metrics that matter most to your server's performance.
-    
+  Solution: With so many metrics to track, it’s easy to get overwhelmed. Focus on the most important ones like CPU, memory, disk, and network. SigNoz streamlines this by offering a unified platform to aggregate and visualize metrics, logs, and traces. This consolidation allows you to focus on the most critical information without being overwhelmed by too much data. You can customize [dashboards](https://signoz.io/docs/userguide/manage-dashboards/) in SigNoz to highlight the key metrics that matter most to your server's performance.
 - Challenge: False Alarms
-    
-    Solution: While alerts are crucial, frequent false alarms can be counterproductive.  SigNoz allows you to set precise alert thresholds and notifications tailored to your specific needs. By fine-tuning these alerts, you can minimize false positives and ensure that you're only alerted to issues that genuinely need attention. Additionally, the integration of logs and traces with metrics in SigNoz provides valuable context, helping to further reduce false alarms.
-    
+  Solution: While alerts are crucial, frequent false alarms can be counterproductive. SigNoz allows you to set precise alert thresholds and notifications tailored to your specific needs. By fine-tuning these alerts, you can minimize false positives and ensure that you're only alerted to issues that genuinely need attention. Additionally, the integration of logs and traces with metrics in SigNoz provides valuable context, helping to further reduce false alarms.
 - Challenge: Complexity of Tools
-    
-    Solution: Many monitoring tools are complex and difficult to navigate. SigNoz addresses this by offering a user-friendly interface that balances powerful features with ease of use. Whether you’re new to monitoring or an experienced user, SigNoz makes it simple to start with basic monitoring and expand as needed, without the steep learning curve of more intricate tools.
-    
+  Solution: Many monitoring tools are complex and difficult to navigate. SigNoz addresses this by offering a user-friendly interface that balances powerful features with ease of use. Whether you’re new to monitoring or an experienced user, SigNoz makes it simple to start with basic monitoring and expand as needed, without the steep learning curve of more intricate tools.
 - Challenge: Adapting to Changes
-    
-    Solution: Your server environment might change over time with new software or updates. SigNoz is flexible and can easily adapt to these changes, ensuring that your monitoring setup stays relevant. It allows you to scale your monitoring efforts as your infrastructure grows, making it easier to keep up with the evolving needs of your environment.
-    
+  Solution: Your server environment might change over time with new software or updates. SigNoz is flexible and can easily adapt to these changes, ensuring that your monitoring setup stays relevant. It allows you to scale your monitoring efforts as your infrastructure grows, making it easier to keep up with the evolving needs of your environment.
 
 ## Top Open-Source Linux Monitoring Tools
 
@@ -137,14 +133,14 @@ When selecting a monitoring tool, it’s essential to evaluate several key facto
 
 Each monitoring tool offers unique features. Here’s a detailed comparison across several popular open-source tools:
 
-| Feature | Prometheus | Zabbix | SigNoz | Nagios |
-| --- | --- | --- | --- | --- |
-| Scalability | Excellent for high-traffic systems | Suitable for large enterprise | Horizontal scalability | Limited scalability without add-ons |
-| Ease of Use | Relatively easy to install and configure | Moderate, detailed configuration | User-friendly, simple setup | Moderate, manual configuration |
-| Integration Capabilities | Integrates seamlessly with a wide range of platforms | SNMP, cloud integration |  Supports many data sources | Limited by default |
-| Data Visualization | Basic Web UI | Custom visualizations available | Real-time visualizations | Basic with plugins |
-| Alerting | Built-in alert manager | Extensive alerting options | Built-in alerting mechanism | Basic alerting system |
-| Use Case | Best for monitoring and alerting | Infrastructure monitoring | End-to-End Observability | Suitable for legacy systems |
+| Feature                  | Prometheus                                           | Zabbix                           | SigNoz                      | Nagios                              |
+| ------------------------ | ---------------------------------------------------- | -------------------------------- | --------------------------- | ----------------------------------- |
+| Scalability              | Excellent for high-traffic systems                   | Suitable for large enterprise    | Horizontal scalability      | Limited scalability without add-ons |
+| Ease of Use              | Relatively easy to install and configure             | Moderate, detailed configuration | User-friendly, simple setup | Moderate, manual configuration      |
+| Integration Capabilities | Integrates seamlessly with a wide range of platforms | SNMP, cloud integration          | Supports many data sources  | Limited by default                  |
+| Data Visualization       | Basic Web UI                                         | Custom visualizations available  | Real-time visualizations    | Basic with plugins                  |
+| Alerting                 | Built-in alert manager                               | Extensive alerting options       | Built-in alerting mechanism | Basic alerting system               |
+| Use Case                 | Best for monitoring and alerting                     | Infrastructure monitoring        | End-to-End Observability    | Suitable for legacy systems         |
 
 ### Matching Tools to Specific Use Cases and Server Environments
 
@@ -162,31 +158,39 @@ Effective Linux server monitoring involves a range of techniques to ensure syste
 While specialized tools are valuable, don't overlook the power of built-in Linux utilities for basic system monitoring:
 
 1. `top`: Provides a real-time view of system processes and resource usage.
-    
-    Example usage:
-    
-    ```bash
-    # Run top with a 5-second refresh interval
-    top -d 5
-    ```
-    
-    Output:
-    
-    <Figure src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-03_at_11.10.51.webp" alt="top command" caption="top command" />
-    
+
+   Example usage:
+
+   ```bash
+   # Run top with a 5-second refresh interval
+   top -d 5
+   ```
+
+   Output:
+
+   <Figure
+     src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-03_at_11.10.51.webp"
+     alt="top command"
+     caption="top command"
+   />
+
 2. `htop`: An enhanced version of `top` with a more user-friendly interface.
-    
-    Example usage:
-    
-    ```bash
-    # Display only processes owned by user 'admin' in htop
-    htop -u admin
-    ```
-    
-    Output:
-    
-    <Figure src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-03_at_11.20.21.webp" alt="htop command" caption="htop command" />
-    
+
+   Example usage:
+
+   ```bash
+   # Display only processes owned by user 'admin' in htop
+   htop -u admin
+   ```
+
+   Output:
+
+   <Figure
+     src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-03_at_11.20.21.webp"
+     alt="htop command"
+     caption="htop command"
+   />
+
 3. `iotop`: Monitors disk I/O usage by processes.
 
 Example usage:
@@ -198,7 +202,11 @@ sudo iotop -p <PID>
 
 Output
 
-<Figure src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-09_at_05.59.16.webp" alt="iotop command" caption="iotop command" />
+<Figure
+  src="/img/guides/2024/09/linux-server-monitoring-Screenshot_2024-09-09_at_05.59.16.webp"
+  alt="iotop command"
+  caption="iotop command"
+/>
 
 ### Implement Log Monitoring and Analysis
 
@@ -311,13 +319,13 @@ Distributed tracing in a Linux server environment can provide deep insights into
 
 <GetStartedSigNoz />
 
-| Feature/Aspect | SigNoz | Prometheus + Grafana | ELK Stack (Elasticsearch, Logstash, Kibana) |
-| --- | --- | --- | --- |
-| Observability Scope | Unified platform for metrics, logs, and traces | Metrics only (Prometheus) with visualization (Grafana) | Logs and metrics, but tracing requires additional setup |
-| Distributed Tracing | Native support, integrated with metrics and logs | Requires separate tools (e.g., Jaeger) | Requires additional tools like Jaeger or Zipkin |
-| User Interface | Designed for ease of use with all observability data (metrics, logs, traces) available in one dashboard. | Grafana offers rich visualization, but the experience is fragmented as you need Prometheus for metrics and additional tools for traces and logs | Kibana has a polished UI for log and metric visualization, but integrating tracing or other features requires adding more tools, leading to fragmented user experience |
-| Deployment Complexity | Simplified, all-in-one setup | Requires configuring Prometheus and Grafana separately | More complex, involves multiple components |
-| Open-Source | Yes | Yes | Yes |
+| Feature/Aspect        | SigNoz                                                                                                   | Prometheus + Grafana                                                                                                                            | ELK Stack (Elasticsearch, Logstash, Kibana)                                                                                                                            |
+| --------------------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Observability Scope   | Unified platform for metrics, logs, and traces                                                           | Metrics only (Prometheus) with visualization (Grafana)                                                                                          | Logs and metrics, but tracing requires additional setup                                                                                                                |
+| Distributed Tracing   | Native support, integrated with metrics and logs                                                         | Requires separate tools (e.g., Jaeger)                                                                                                          | Requires additional tools like Jaeger or Zipkin                                                                                                                        |
+| User Interface        | Designed for ease of use with all observability data (metrics, logs, traces) available in one dashboard. | Grafana offers rich visualization, but the experience is fragmented as you need Prometheus for metrics and additional tools for traces and logs | Kibana has a polished UI for log and metric visualization, but integrating tracing or other features requires adding more tools, leading to fragmented user experience |
+| Deployment Complexity | Simplified, all-in-one setup                                                                             | Requires configuring Prometheus and Grafana separately                                                                                          | More complex, involves multiple components                                                                                                                             |
+| Open-Source           | Yes                                                                                                      | Yes                                                                                                                                             | Yes                                                                                                                                                                    |
 
 ## Best Practices for Effective Linux Server Monitoring
 
@@ -334,7 +342,7 @@ The most critical metrics include CPU usage, memory utilization, disk space, dis
 
 ### How often should I review my server monitoring data?
 
- For general performance trends, conduct daily or weekly reviews. Perform in-depth analyses monthly or quarterly to identify long-term patterns and optimization opportunities.
+For general performance trends, conduct daily or weekly reviews. Perform in-depth analyses monthly or quarterly to identify long-term patterns and optimization opportunities.
 
 ### Can I monitor multiple Linux servers from a single dashboard?
 
@@ -342,4 +350,4 @@ Yes, most modern monitoring tools support centralized dashboards for multiple se
 
 ### What's the difference between agent-based and agentless monitoring for Linux servers?
 
-Agent-based monitoring involves installing software on each server to collect and report data. It offers more detailed insights but requires maintenance. Agentless monitoring collects data remotely, typically via SSH or SNMP. It's easier to set up but may provide less granular information.
\ No newline at end of file
+Agent-based monitoring involves installing software on each server to collect and report data. It offers more detailed insights but requires maintenance. Agentless monitoring collects data remotely, typically via SSH or SNMP. It's easier to set up but may provide less granular information.
diff --git a/data/guides/llmops.mdx b/data/guides/llmops.mdx
index f26d0ad3b..919942c69 100644
--- a/data/guides/llmops.mdx
+++ b/data/guides/llmops.mdx
@@ -1,18 +1,19 @@
 ---
-
 title: LLMOps - Mastering Large Language Model Operations
-slug: llmops
 date: 2024-08-14
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Discover LLMOps - the key to managing large language models effectively. Learn best practices, and implementation strategies, and overcome challenges in AI operations.
 keywords: [LLMOps, AI operations, language models, MLOps, AI development, model monitoring, SigNoz]
-
 ---
 
 LLMOps or Large Language Model Operations, is transforming how businesses maintain and deploy advanced AI models. This developing field addresses the special issues associated with large language models (LLMs), expanding existing MLOps (Machine Learning Operations) approaches to meet the specific needs of AI development. LLMOps covers the complete lifespan of LLMs, from data preparation and model training to deployment and ongoing monitoring.
 
-<Figure src="/img/guides/2024/08/llmops-Untitled.webp" alt="LLMOps overview image" caption="LLMOps overview image" />
+<Figure
+  src="/img/guides/2024/08/llmops-Untitled.webp"
+  alt="LLMOps overview image"
+  caption="LLMOps overview image"
+/>
 
 ## What is LLMOps? Understanding the Basics
 
@@ -55,12 +56,12 @@ While MLOps and LLMOps share common goals, LLMOps addresses challenges that are
 
 We can summarize the comparision as:
 
-| Aspect | MLOps | LLMOps |
-| --- | --- | --- |
-| Scale | Manages computational resources for standard ML models. | Handles massive computational resources for LLMs, involving terabytes of data and thousands of GPUs. |
-| Complexity | Focuses on optimizing standard model architectures and parameter tuning. | Manages complex model architectures with billions of parameters, requiring specialized optimization. |
-| Ethical Considerations | Addresses biases and fairness in ML models. | Emphasizes minimizing biases in LLMs and ensuring responsible AI use through regular audits. |
-| Specialized Tools | Utilizes general ML frameworks like TensorFlow and PyTorch. | Leverages tools like Hugging Face's Transformers and OpenAI's GPT for specialized LLM development. |
+| Aspect                 | MLOps                                                                    | LLMOps                                                                                               |
+| ---------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| Scale                  | Manages computational resources for standard ML models.                  | Handles massive computational resources for LLMs, involving terabytes of data and thousands of GPUs. |
+| Complexity             | Focuses on optimizing standard model architectures and parameter tuning. | Manages complex model architectures with billions of parameters, requiring specialized optimization. |
+| Ethical Considerations | Addresses biases and fairness in ML models.                              | Emphasizes minimizing biases in LLMs and ensuring responsible AI use through regular audits.         |
+| Specialized Tools      | Utilizes general ML frameworks like TensorFlow and PyTorch.              | Leverages tools like Hugging Face's Transformers and OpenAI's GPT for specialized LLM development.   |
 
 LLMOps highlights the importance of effective governance and compliance management, particularly in issues such as data protection and model explainability. This focus derives from greater scrutiny of AI systems and their potential societal consequences. Implementing LLMOps entails creating clear data handling norms and protocols, assuring model interpretability and transparency, and adhering to legislation like as GDPR and CCPA. GDPR (General Data Protection Regulation) and CCPA (California Consumer Privacy Act) are both data privacy regulations, but they apply in different regions and have some distinct features.
 
@@ -69,21 +70,20 @@ LLMOps highlights the importance of effective governance and compliance manageme
 Implementing LLMOps provides various benefits to companies working with large language models, which can have a substantial impact on their AI initiatives and overall business results. Let us now take a look at the advantages and real-world applications:
 
 1. Improved Model Performance: Systematic fine-tuning and optimization of LLMs produces superior results. Organizations may increase the accuracy and relevance of their AI applications by regularly monitoring and refining the models. To achieve optimal performance approaches such as hyperparameter adjustments, gradient accumulation, and regular retraining with updated data sets are used.
-    
-    Example: In a customer service chatbot, regular fine-tuning based on user interactions helps the bot understand and respond more accurately to customer queries, enhancing the overall customer experience.
-    
+
+   Example: In a customer service chatbot, regular fine-tuning based on user interactions helps the bot understand and respond more accurately to customer queries, enhancing the overall customer experience.
+
 2. Enhanced Scalability: LLMOps methods enable the efficient deployment of LLMs across several applications. Organizations may deploy LLMs at scale by leveraging containerization, orchestration tools such as Kubernetes, and scalable cloud infrastructure, guaranteeing they can manage large numbers of requests while providing constant performance.
-    
-    Example: In e-commerce, using LLMs to power personalized recommendation systems assures that the system can scale to handle millions of users while providing real-time suggestions.
-    
+
+   Example: In e-commerce, using LLMs to power personalized recommendation systems assures that the system can scale to handle millions of users while providing real-time suggestions.
+
 3. Better Governance: Compliance with AI legislation and ethical principles is easier to manage using LLMOps. This includes putting in place data privacy controls, making sure model decisions are transparent, and assessing models regularly for biases and ethical considerations.
-    
-    Example: In healthcare, employing LLMOps to comply with HIPAA rules ensures that patient data is managed securely and that models used to make diagnosis or treatment recommendations are transparent and objective.
-    
+
+   Example: In healthcare, employing LLMOps to comply with HIPAA rules ensures that patient data is managed securely and that models used to make diagnosis or treatment recommendations are transparent and objective.
+
 4. Faster Time-to-Market: LLMOps streamline procedures, accelerating the development of AI-powered solutions. Organizations can shorten the time it takes to transition from model development to production by automating workflows, defining best practices, and using continuous integration and deployment (CI/CD) pipelines.
-    
-    Example: In content production, utilizing LLMOps enables quick development and deployment of AI models that produce and summarize material for marketing campaigns, significantly reducing the time required to launch new content initiatives.
-    
+
+   Example: In content production, utilizing LLMOps enables quick development and deployment of AI models that produce and summarize material for marketing campaigns, significantly reducing the time required to launch new content initiatives.
 
 ## Real-World Applications of LLMOps
 
@@ -99,38 +99,41 @@ LLMOps allow for the effective deployment of language models in numerous areas,
 Implementing LLMOps efficiently necessitates a systematic approach and adherence to best practices. Let us look at some of the crucial strategies for success:
 
 1. Establish a Robust Data Pipeline:
-    - Data Collection: Continuously collect data from many sources relevant to your use case. Ensure that the data is high-quality, accurate, and up-to-date. You can use numerous options for pipelines such as Azure DevOps Pipeline and Jenkins for automating data collection processes.
-    - Data Cleaning: Use automated methods to handle missing values, eliminate duplicates, and fix errors.
-    - Data Preprocessing: Normalize, tokenize, and encode data as needed for your model. For NLP tasks, text preprocessing techniques like stopword removal and stemming may be used.
-    
-    Example: You can use Pandas to preprocess data in a text-based dataset. For instance, using the `pandas` library in Python, you can remove null values and duplicates with commands like `df.dropna()` and `df.drop_duplicates()`. Additionally, Azure DevOps Pipeline can be set up to automate the entire data preprocessing workflow, ensuring data is consistently prepared for model training.
-    
-2. Implement Version Control: 
-    - Tools Git LFS is used to manage huge files, while DVC is used to version data and models.
-    - Tracking changes: Ensure that any changes to data, code, and model parameters are tracked (refer to example below). This helps with reproducibility and understanding of model evolution.
-    
-    Example: You can use DVC to track data and model versions. For example, setting up DVC in a project involves initializing DVC with `dvc init`, then adding data files with `dvc add <file>`. These files can be pushed to remote storage, ensuring all data changes are versioned alongside code in Git.
-    
+
+   - Data Collection: Continuously collect data from many sources relevant to your use case. Ensure that the data is high-quality, accurate, and up-to-date. You can use numerous options for pipelines such as Azure DevOps Pipeline and Jenkins for automating data collection processes.
+   - Data Cleaning: Use automated methods to handle missing values, eliminate duplicates, and fix errors.
+   - Data Preprocessing: Normalize, tokenize, and encode data as needed for your model. For NLP tasks, text preprocessing techniques like stopword removal and stemming may be used.
+
+   Example: You can use Pandas to preprocess data in a text-based dataset. For instance, using the `pandas` library in Python, you can remove null values and duplicates with commands like `df.dropna()` and `df.drop_duplicates()`. Additionally, Azure DevOps Pipeline can be set up to automate the entire data preprocessing workflow, ensuring data is consistently prepared for model training.
+
+2. Implement Version Control:
+
+   - Tools Git LFS is used to manage huge files, while DVC is used to version data and models.
+   - Tracking changes: Ensure that any changes to data, code, and model parameters are tracked (refer to example below). This helps with reproducibility and understanding of model evolution.
+
+   Example: You can use DVC to track data and model versions. For example, setting up DVC in a project involves initializing DVC with `dvc init`, then adding data files with `dvc add <file>`. These files can be pushed to remote storage, ensuring all data changes are versioned alongside code in Git.
+
 3. Automate Testing and Evaluation:
-    - Testing Frameworks: Develop through test cases using frameworks like `pytest` to evaluate model performance, fairness, and safety.
-    - Continuous Integration: Integrate automated tests into your CI/CD pipeline to ensure that models meet performance standards before deployment. It is crucial to differentiate between unit testing and integration testing. Integration testing ensures different components of your system work together, while unit testing focuses on individual components.
-    
-    Example: You can write a simple `pytest` function to test model accuracy.
-    
-    ```python
-    def test_model_accuracy():
-        model = load_model('path_to_model')
-        test_data = load_data('path_to_test_data')
-        accuracy = evaluate_model(model, test_data)
-        assert accuracy > 0.85
-    ```
-    
+
+   - Testing Frameworks: Develop through test cases using frameworks like `pytest` to evaluate model performance, fairness, and safety.
+   - Continuous Integration: Integrate automated tests into your CI/CD pipeline to ensure that models meet performance standards before deployment. It is crucial to differentiate between unit testing and integration testing. Integration testing ensures different components of your system work together, while unit testing focuses on individual components.
+
+   Example: You can write a simple `pytest` function to test model accuracy.
+
+   ```python
+   def test_model_accuracy():
+       model = load_model('path_to_model')
+       test_data = load_data('path_to_test_data')
+       accuracy = evaluate_model(model, test_data)
+       assert accuracy > 0.85
+   ```
+
 4. Deploy a Monitoring System:
-    - Platforms: Use platforms like [SigNoz](https://signoz.io/docs/introduction/) for real-time monitoring of model performance, drift detection, and alerting.
-    - Custom Metrics: Define and track custom metrics specific to your model's performance and operational health.
-    
-    Example: You can set up SigNoz for monitoring. Integrating SigNoz involves setting up the platform to collect metrics from your application. For instance, you can configure SigNoz to monitor your LLM's API endpoints, tracking metrics such as response time and error rates. Custom metrics can include specific indicators like model prediction confidence levels or data processing throughput, tailored to reflect the unique performance aspects of your language model. For more details, click [here](https://signoz.io/).
-    
+
+   - Platforms: Use platforms like [SigNoz](https://signoz.io/docs/introduction/) for real-time monitoring of model performance, drift detection, and alerting.
+   - Custom Metrics: Define and track custom metrics specific to your model's performance and operational health.
+
+   Example: You can set up SigNoz for monitoring. Integrating SigNoz involves setting up the platform to collect metrics from your application. For instance, you can configure SigNoz to monitor your LLM's API endpoints, tracking metrics such as response time and error rates. Custom metrics can include specific indicators like model prediction confidence levels or data processing throughput, tailored to reflect the unique performance aspects of your language model. For more details, click [here](https://signoz.io/).
 
 ## Key Stages in the LLMOps Lifecycle
 
@@ -141,36 +144,43 @@ The LLMOps lifecycle consists of several critical stages to ensure effective mod
 3. Deployment and Integration: Integrate with current systems to serve models in production environments with efficiency. This entails containerization using deployment frameworks such as Docker, or TensorFlow Serving.
 4. Continuous Monitoring and Retraining: To preserve accuracy, regularly assess model performance and retrain as necessary. The use of broad monitoring and alerting systems ensures timely detection of performance degradation.
 
-<Figure src="/img/guides/2024/08/llmops-Untitled%201.webp" alt="LLMOps lifecycle overview" caption="LLMOps lifecycle overview" />
+<Figure
+  src="/img/guides/2024/08/llmops-Untitled%201.webp"
+  alt="LLMOps lifecycle overview"
+  caption="LLMOps lifecycle overview"
+/>
 
 ## Overcoming Challenges in LLMOps Implementation
 
 There are certain challenges involved in implementing LLMOps, but these can be successfully handled with the appropriate tactics and resources:
 
 1. High Computational Requirements:
-    - Scalable Infrastructure: To train and operate large language models, invest in high-performance processing resources, such as GPUs and TPUs.
-    - Cloud-Based Solutions: Make use of cloud computing platforms like as AWS, Azure, and Google Cloud, which provide services specifically tailored for AI workloads and scalable infrastructure.
-    
-    Example: Using SageMaker and EC2 to set up an AWS training environment. AWS SageMaker offers fully managed services for training and deploying machine learning models at scale. By setting up training jobs on EC2 instances with powerful GPUs, you can utilize SageMaker's distributed training capabilities to handle large datasets and complex models efficiently. This setup enables automatic scaling, spot instance usage for cost efficiency, and integration with other AWS services for a seamless workflow.
-    
+
+   - Scalable Infrastructure: To train and operate large language models, invest in high-performance processing resources, such as GPUs and TPUs.
+   - Cloud-Based Solutions: Make use of cloud computing platforms like as AWS, Azure, and Google Cloud, which provide services specifically tailored for AI workloads and scalable infrastructure.
+
+   Example: Using SageMaker and EC2 to set up an AWS training environment. AWS SageMaker offers fully managed services for training and deploying machine learning models at scale. By setting up training jobs on EC2 instances with powerful GPUs, you can utilize SageMaker's distributed training capabilities to handle large datasets and complex models efficiently. This setup enables automatic scaling, spot instance usage for cost efficiency, and integration with other AWS services for a seamless workflow.
+
 2. Complex Versioning:
-    - Experiment Tracking: Make sure all versions of experiments, models, and datasets are documented by using tools like MLflow or Weights & Biases.
-    - Version Control Systems: Use Git LFS or DVC to version big model files and datasets.
-    
-    Example: Using MLflow to track experiments. MLflow provides a centralized repository to track experiments, recording parameters, metrics, artifacts, and models. When you are training a large language model, you can use MLflow as MLflow logs each experiment's configurations and outcomes which enables reproducibility and easy comparison of different model versions. This systematic tracking helps in fine-tuning models and ensures that the best-performing model configurations are identified and can be reproduced reliably.
-    
+
+   - Experiment Tracking: Make sure all versions of experiments, models, and datasets are documented by using tools like MLflow or Weights & Biases.
+   - Version Control Systems: Use Git LFS or DVC to version big model files and datasets.
+
+   Example: Using MLflow to track experiments. MLflow provides a centralized repository to track experiments, recording parameters, metrics, artifacts, and models. When you are training a large language model, you can use MLflow as MLflow logs each experiment's configurations and outcomes which enables reproducibility and easy comparison of different model versions. This systematic tracking helps in fine-tuning models and ensures that the best-performing model configurations are identified and can be reproduced reliably.
+
 3. Data Privacy and Security:
-    - Data Protection Measures: Encrypt sensitive data and use access controls and anonymization methods to keep it safe over the lifecycle of the LLM.
-    - Accordance: Make sure that data privacy laws such as the CCPA and GDPR are followed.
-    
-    Example: Data encryption before storage. Implementing data encryption before storage involves using encryption algorithms to convert sensitive data into unreadable formats, ensuring that unauthorized users cannot access the original information. For instance, you can use AWS Key Management Service (KMS) to encrypt data stored in S3 buckets provides an additional layer of security. 
-    
+
+   - Data Protection Measures: Encrypt sensitive data and use access controls and anonymization methods to keep it safe over the lifecycle of the LLM.
+   - Accordance: Make sure that data privacy laws such as the CCPA and GDPR are followed.
+
+   Example: Data encryption before storage. Implementing data encryption before storage involves using encryption algorithms to convert sensitive data into unreadable formats, ensuring that unauthorized users cannot access the original information. For instance, you can use AWS Key Management Service (KMS) to encrypt data stored in S3 buckets provides an additional layer of security.
+
 4. Ethical Considerations:
-    - Bias Mitigation: Put frameworks and instruments in place to evaluate and lessen biases in models and training data. To ensure impartiality, evaluate and update datasets regularly.
-    - Responsible AI: Create guidelines and procedures that support openness, responsibility, and moral application of AI.
-    
-    Example: Model fairness evaluation with Fairlearn. Fairlearn is an open-source toolkit that helps assess and remove unfairness in machine learning models. By integrating Fairlearn into your workflow, you can analyze your model's predictions across different demographic groups to identify potential biases. For example, after training a language model, you can use Fairlearn to evaluate its performance on subsets of data representing different genders or ethnicities. The toolkit provides metrics and visualizations to understand disparities and offers algorithms to adjust the model, promoting fairness and reducing bias.
-    
+
+   - Bias Mitigation: Put frameworks and instruments in place to evaluate and lessen biases in models and training data. To ensure impartiality, evaluate and update datasets regularly.
+   - Responsible AI: Create guidelines and procedures that support openness, responsibility, and moral application of AI.
+
+   Example: Model fairness evaluation with Fairlearn. Fairlearn is an open-source toolkit that helps assess and remove unfairness in machine learning models. By integrating Fairlearn into your workflow, you can analyze your model's predictions across different demographic groups to identify potential biases. For example, after training a language model, you can use Fairlearn to evaluate its performance on subsets of data representing different genders or ethnicities. The toolkit provides metrics and visualizations to understand disparities and offers algorithms to adjust the model, promoting fairness and reducing bias.
 
 ## Monitoring and Observability in LLMOps with SigNoz
 
@@ -200,25 +210,28 @@ Interested in doing LLM monitoring with SigNoz? Refer SigNoz’s [official doc o
 The need for increasingly advanced AI systems and technical developments is driving the ongoing evolution of the LLMOps area. Among the major new developments in LLMOps are the following:
 
 1. More Automation:
-    - Tools Powered by AI: utilizing AI to automate several model deployment, management, and optimization processes. This covers maintenance duties, deployment pipelines, and automated hyperparameter tweaking.
-    
-    Example: Automating model tuning and selection with AutoML frameworks.
-    
+
+   - Tools Powered by AI: utilizing AI to automate several model deployment, management, and optimization processes. This covers maintenance duties, deployment pipelines, and automated hyperparameter tweaking.
+
+   Example: Automating model tuning and selection with AutoML frameworks.
+
 2. Community-Based Education:
-    - Confidentiality-Boosting Methods: By using federated learning, localized data may be used to train models across dispersed devices or servers. This method lowers the chance of data breaches while improving privacy.
-    
-    Example: Simple Flower-based federated learning configuration.
-    
+
+   - Confidentiality-Boosting Methods: By using federated learning, localized data may be used to train models across dispersed devices or servers. This method lowers the chance of data breaches while improving privacy.
+
+   Example: Simple Flower-based federated learning configuration.
+
 3. Specialized Hardware:
-    - AI-specific Chips: Development and application of specialized hardware to boost the effectiveness and performance of huge language models, such as TPUs and AI accelerators. These processors are made to manage the computing demands of AI workloads more efficiently.
-    
-    Example: Making effective use of TPUs in TensorFlow to train models.
-    
+
+   - AI-specific Chips: Development and application of specialized hardware to boost the effectiveness and performance of huge language models, such as TPUs and AI accelerators. These processors are made to manage the computing demands of AI workloads more efficiently.
+
+   Example: Making effective use of TPUs in TensorFlow to train models.
+
 4. Industry-Specific Platforms:
-    - Tailored LLMOps Solutions: Creating tools and platforms that are suited to particular industries, like the legal, finance, and healthcare fields. These technologies enable more efficient language model deployment and management by addressing the particular needs and legal restrictions of each business.
-    
-    Example: Setting up a healthcare data LLMOps pipeline tailored to the sector.
-    
+
+   - Tailored LLMOps Solutions: Creating tools and platforms that are suited to particular industries, like the legal, finance, and healthcare fields. These technologies enable more efficient language model deployment and management by addressing the particular needs and legal restrictions of each business.
+
+   Example: Setting up a healthcare data LLMOps pipeline tailored to the sector.
 
 ## Key Takeaways
 
diff --git a/data/guides/log-messages-appearing-twice-with-python-logging.mdx b/data/guides/log-messages-appearing-twice-with-python-logging.mdx
index f3f700303..a208b630f 100644
--- a/data/guides/log-messages-appearing-twice-with-python-logging.mdx
+++ b/data/guides/log-messages-appearing-twice-with-python-logging.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Fix Duplicate Log Messages in Python Logging
-slug: log-messages-appearing-twice-with-python-logging
 date: 2024-09-11
 tags: [faq]
 authors: [soumya_gupta]
 description: Learn how to fix duplicate log messages in Python logging. This guide covers common causes, quick fixes, and advanced techniques for clean logging.
-keywords: [Python logging, duplicate logs, log messages, debugging, logger configuration, log handlers, propagation]
-
+keywords:
+  [
+    Python logging,
+    duplicate logs,
+    log messages,
+    debugging,
+    logger configuration,
+    log handlers,
+    propagation,
+  ]
 ---
 
 Python's logging module is a powerful tool for tracking events in your applications. However, developers often encounter a frustrating issue: log messages appear twice. This duplication can clutter your logs, making debugging more challenging and potentially impacting application performance. Let's dive into the causes of this problem and explore effective solutions to ensure your logs are clean, accurate, and helpful.
@@ -16,12 +22,12 @@ Python's logging module is a powerful tool for tracking events in your applicati
 
 Duplicate log messages occur when the same log entry is recorded more than once. This redundancy is not just annoying—it can lead to confusion during debugging and unnecessarily bloat your log files. The primary factors behind this issue are:
 
-1. Multiple handlers attached to the same logger:  A frequent cause of duplicate log messages is having several log handlers configured. In Python's logging system, handlers determine where the log messages go, such as to a file, console, or network. When multiple handlers are set up to handle the same messages, each one processes the message, leading to duplicates in your output.
+1. Multiple handlers attached to the same logger: A frequent cause of duplicate log messages is having several log handlers configured. In Python's logging system, handlers determine where the log messages go, such as to a file, console, or network. When multiple handlers are set up to handle the same messages, each one processes the message, leading to duplicates in your output.
 2. Multiple Loggers: If multiple loggers are used for the same events, you might end up with duplicates. This usually happens when different parts of the code use different loggers or if the loggers aren't set up to share the same handler. Each logger might generate its own log entry, leading to redundant messages.
 3. Improper configuration of logger hierarchies: If you attach a handler to a logger and also to one or more of its ancestor loggers, you might see the same log message appear multiple times. This happens because loggers are organized in a hierarchy, and if handlers aren’t managed properly across parent and child loggers, you could end up with duplicates. To avoid this, make sure handlers are attached only to the specific loggers you want and not to their ancestor loggers.
 4. Unintended logger inheritance in multi-module applications: In larger applications with multiple modules, you might run into issues where log entries show up more than once. This happens because if a logger in one module inherits handlers from a parent module, the same log message can get processed multiple times if both the parent and child loggers have their own handlers. To prevent this from happening, it's a good idea to set up and manage loggers for each module separately.
 
- We'll revisit these points for a more detailed discussion later in the article.
+We'll revisit these points for a more detailed discussion later in the article.
 
 ## Root Logger vs. Child Logger Behavior
 
@@ -29,19 +35,16 @@ Understanding the hierarchy of loggers in Python is crucial for preventing dupli
 
 - The root logger sits at the top of the hierarchy. It is the default logger created automatically by python’s logging module. It is responsible for capturing all log messages unless explicitly overridden. This logger is initialized with a default configuration such as the default level is set to `WARNING` and it can be accessed using `logging.getLogger()` without any arguments. It can be customized with handlers and formatters.
 - Child loggers are explicitly created using dot notation, forming a hierarchy such as `A.B.C` represents, `A` as a child logger of the root logger, `A.B` as child logger of parent logger `A` and similarly, `A.B.C` as a child of parent logger `A.B`.
-    
-    ```powershell
-    Root Logger (implicitly '')
-    |
-    ├── A (Logger 'A')
-    |   |
-    |   ├── A.B (Logger 'A.B')
-    |       |
-    |       └── A.B.C (Logger 'A.B.C')
-    ```
-    
-    Child loggers inherit configuration from their parent loggers, but they can also have their own handlers, formatters, and levels. This allows for fine-grained control over logging output at different parts of an application.
-    
+  ```powershell
+  Root Logger (implicitly '')
+  |
+  ├── A (Logger 'A')
+  |   |
+  |   ├── A.B (Logger 'A.B')
+  |       |
+  |       └── A.B.C (Logger 'A.B.C')
+  ```
+  Child loggers inherit configuration from their parent loggers, but they can also have their own handlers, formatters, and levels. This allows for fine-grained control over logging output at different parts of an application.
 
 ```
 
@@ -52,71 +55,69 @@ Understanding the hierarchy of loggers in Python is crucial for preventing dupli
 Before diving into detailed solutions, here's a quick checklist to address common causes of duplicate logs:
 
 1. Check for multiple handlers: Ensure you're not adding redundant handlers to your root loggers.
-    
-    The root logger sits at the top of the logger hierarchy. If there's an extra handler attached to it that we don’t need, it might cause messages to be duplicated, and it’s a good to remove it.
-    
-    Firstly, let’s list all handlers attached to the root logger:
-    
-    ```python
-    import logging
-    
-    # Setup root logger with multiple handlers
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-    
-    # Adding multiple handlers for demonstration
-    handler1 = logging.StreamHandler()
-    handler2 = logging.StreamHandler()
-    root_logger.addHandler(handler1)
-    root_logger.addHandler(handler2)
-    
-    # Check the handlers
-    for handler in root_logger.handlers:
-        print(handler)
-    ```
-    
-    Output
-    
-    ```
-    <StreamHandler (NOTSET)>
-    <StreamHandler (NOTSET)>
-    
-    ```
-    
-    This indicates that two `StreamHandler` instances are attached to the root logger. We can then remove the redundant handlers by: 
-    
-    ```python
-    
-    if len(root_logger.handlers) > 0:
-        # Remove the first handler
-        root_logger.removeHandler(root_logger.handlers[0])
-    
-    ```
-    
-    Now, let’s verify if they have been removed. 
-    
-    ```python
-    for handler in root_logger.handlers:
-        print(handler)
-    ```
-    
-    Output: 
-    
-    ```
-    <StreamHandler (NOTSET)>
-    ```
-    
-2. Change `logger.propagate` settings for loggers: 
-    1. [Centralized logging](https://signoz.io/blog/centralized-logging/) with `logger.propagate=true` : If you have several loggers in your application, each with its own handler, it can lead to duplicate log messages in your output. This can be solved by attaching a single handler to the root logger and letting log messages propagate up to it. This approach consolidates logging and prevents duplication.
-    2. Isolated logger handling with `logger.propagate=false` : If you have a custom logger for a specific module with its own handler to isolate that component in your application, enabling propagation `propagate = True` could lead to duplicate log entries. This happens because the custom logger’s handler processes the log messages, and the same messages are then propagated to the root logger’s handler, resulting in redundancy. To avoid this duplication, you should set `propagate = False` on the custom logger, ensuring that its log messages are not forwarded to the root logger and preventing multiple outputs of the same log entry.
-
-    
+
+   The root logger sits at the top of the logger hierarchy. If there's an extra handler attached to it that we don’t need, it might cause messages to be duplicated, and it’s a good to remove it.
+
+   Firstly, let’s list all handlers attached to the root logger:
+
+   ```python
+   import logging
+
+   # Setup root logger with multiple handlers
+   root_logger = logging.getLogger()
+   root_logger.setLevel(logging.DEBUG)
+
+   # Adding multiple handlers for demonstration
+   handler1 = logging.StreamHandler()
+   handler2 = logging.StreamHandler()
+   root_logger.addHandler(handler1)
+   root_logger.addHandler(handler2)
+
+   # Check the handlers
+   for handler in root_logger.handlers:
+       print(handler)
+   ```
+
+   Output
+
+   ```
+   <StreamHandler (NOTSET)>
+   <StreamHandler (NOTSET)>
+
+   ```
+
+   This indicates that two `StreamHandler` instances are attached to the root logger. We can then remove the redundant handlers by:
+
+   ```python
+
+   if len(root_logger.handlers) > 0:
+       # Remove the first handler
+       root_logger.removeHandler(root_logger.handlers[0])
+
+   ```
+
+   Now, let’s verify if they have been removed.
+
+   ```python
+   for handler in root_logger.handlers:
+       print(handler)
+   ```
+
+   Output:
+
+   ```
+   <StreamHandler (NOTSET)>
+   ```
+
+2. Change `logger.propagate` settings for loggers:
+   1. [Centralized logging](https://signoz.io/blog/centralized-logging/) with `logger.propagate=true` : If you have several loggers in your application, each with its own handler, it can lead to duplicate log messages in your output. This can be solved by attaching a single handler to the root logger and letting log messages propagate up to it. This approach consolidates logging and prevents duplication.
+   2. Isolated logger handling with `logger.propagate=false` : If you have a custom logger for a specific module with its own handler to isolate that component in your application, enabling propagation `propagate = True` could lead to duplicate log entries. This happens because the custom logger’s handler processes the log messages, and the same messages are then propagated to the root logger’s handler, resulting in redundancy. To avoid this duplication, you should set `propagate = False` on the custom logger, ensuring that its log messages are not forwarded to the root logger and preventing multiple outputs of the same log entry.
 
 ```powershell
 import logging
 
 # Setup root logger (implicitly named '')
-root_logger = logging.getLogger()  
+root_logger = logging.getLogger()
 root_handler = logging.StreamHandler()
 root_handler.setLevel(logging.DEBUG)
 root_logger.addHandler(root_handler)
@@ -149,9 +150,9 @@ child_logger2.debug('Debug message from child_logger2.')  # Propagates up to 'A'
 child_logger3.debug('Debug message from child_logger3.')  # Propagates up to 'A.B', then 'A', and finally to the root logger
 ```
 
-In the above code, `child_logger1` has its own custom handler and so we used `propagate=false` whereas for `child_logger2` and `child_logger3` that requires no custom handler, we’ve set the propagation to `true`. 
+In the above code, `child_logger1` has its own custom handler and so we used `propagate=false` whereas for `child_logger2` and `child_logger3` that requires no custom handler, we’ve set the propagation to `true`.
 
-Output: 
+Output:
 
 ```powershell
 Debug message from root logger.
@@ -160,63 +161,62 @@ Debug message from child_logger2.
 Debug message from child_logger3.
 ```
 
-1. Centralize logger configuration: Use a consistent configuration approach across your application. Take a look at how loggers are used in your codebase. Ensure that the same logger is used consistently throughout the application. If you find that different loggers are being used for the same events, try consolidating them into a single logger. This will help prevent duplicate log entries and keep your logging clean and manageable. Let’s take an example, 
-    
-    ```python
-    import logging
-    
-    # Setup root logger (implicitly named '')
-    root_logger = logging.getLogger()
-    root_handler = logging.StreamHandler()
-    root_handler.setLevel(logging.DEBUG)
-    root_logger.addHandler(root_handler)
-    root_logger.setLevel(logging.DEBUG)
-    
-    # Setup first logger
-    logger1 = logging.getLogger('logger1')
-    logger1.setLevel(logging.DEBUG)
-    # No handler added to logger1, so it will propagate up to root_logger
-    
-    # Setup second logger
-    logger2 = logging.getLogger('logger2')
-    logger2.setLevel(logging.DEBUG)
-    # No handler added to logger2, so it will propagate up to root_logger
-    
-    # Log a message with both loggers
-    logger1.debug('This is a debug message.')
-    logger2.debug('This is a debug message.')
-    ```
-    
-    Output
-    
-    ```powershell
-    This is a debug message.
-    This is a debug message.
-    ```
-    
-    As you can see, the root logger outputs the same log entry twice in the output. In order to avoid this duplication, it is recommended to consolidate such loggers into one such as: 
-    
-    ```python
-    # Create a single logger
-    consolidated_logger = logging.getLogger('consolidated_logger')
-    consolidated_logger.setLevel(logging.DEBUG)
-    
-    # Add a handler to the consolidated logger
-    file_handler = logging.StreamHandler()
-    file_handler.setLevel(logging.DEBUG)
-    consolidated_logger.addHandler(file_handler)
-    
-    # Log messages with the consolidated logger
-    consolidated_logger.debug('This is a debug message.')
-         
-    ```
-    
-    Output
-    
-    ```
-    This is a debug message.
-    ```
-    
+1. Centralize logger configuration: Use a consistent configuration approach across your application. Take a look at how loggers are used in your codebase. Ensure that the same logger is used consistently throughout the application. If you find that different loggers are being used for the same events, try consolidating them into a single logger. This will help prevent duplicate log entries and keep your logging clean and manageable. Let’s take an example,
+
+   ```python
+   import logging
+
+   # Setup root logger (implicitly named '')
+   root_logger = logging.getLogger()
+   root_handler = logging.StreamHandler()
+   root_handler.setLevel(logging.DEBUG)
+   root_logger.addHandler(root_handler)
+   root_logger.setLevel(logging.DEBUG)
+
+   # Setup first logger
+   logger1 = logging.getLogger('logger1')
+   logger1.setLevel(logging.DEBUG)
+   # No handler added to logger1, so it will propagate up to root_logger
+
+   # Setup second logger
+   logger2 = logging.getLogger('logger2')
+   logger2.setLevel(logging.DEBUG)
+   # No handler added to logger2, so it will propagate up to root_logger
+
+   # Log a message with both loggers
+   logger1.debug('This is a debug message.')
+   logger2.debug('This is a debug message.')
+   ```
+
+   Output
+
+   ```powershell
+   This is a debug message.
+   This is a debug message.
+   ```
+
+   As you can see, the root logger outputs the same log entry twice in the output. In order to avoid this duplication, it is recommended to consolidate such loggers into one such as:
+
+   ```python
+   # Create a single logger
+   consolidated_logger = logging.getLogger('consolidated_logger')
+   consolidated_logger.setLevel(logging.DEBUG)
+
+   # Add a handler to the consolidated logger
+   file_handler = logging.StreamHandler()
+   file_handler.setLevel(logging.DEBUG)
+   consolidated_logger.addHandler(file_handler)
+
+   # Log messages with the consolidated logger
+   consolidated_logger.debug('This is a debug message.')
+
+   ```
+
+   Output
+
+   ```
+   This is a debug message.
+   ```
 
 ## Identifying Sources of Duplicate Logging
 
@@ -225,68 +225,66 @@ To effectively tackle duplicate logs, you need to identify their source. Here ar
 1. Examine configuration files: Review your logging configuration files (e.g., `logging.conf` or `log_config.yaml`) for any inconsistencies or redundant handlers. In larger applications, especially those with multiple modules, it's important to configure loggers in each module independently. This helps ensure that loggers don’t unintentionally inherit or duplicate configurations from other modules, keeping your logging setup clean and effective.
 2. Use debug statements: Temporarily add debug prints to trace the flow of log messages through your application. To make sure handlers aren't triggered multiple times for the same log entry, you can include specific handlers in your configuration. Additionally, you might temporarily insert trace-level logs to pinpoint exactly where log messages are being generated and processed. This can help you spot any redundant log processing paths and clean up your logging setup.
 3. Analyze handler setup: Check each module for logger and handler configurations. Check for instances where handlers might be added multiple times. Make sure that each handler is added only once to each logger. Adding handlers to both parent and child loggers can lead to messages being processed more than once. To prevent this, remove handlers from parent loggers if you want to avoid duplication in child loggers.
-    
-    ```python
-    # In the parent logger
-    logger_a = logging.getLogger('app')
-    for handler in logger_a.handlers[:]:
-        logger_a.removeHandler(handler)
-    
-    # Add handlers only to specific loggers
-    
-    ```
-    
-4. Inspect multi-module interactions: In complex applications, loggers from different modules may interact unexpectedly. Pay special attention to imported modules and their logging setups. Let’s take an example, 
-    
-    ```python
-    # module_ a
-    import logging
-    # Module A configures a logger with a file handler
-    logger = logging.getLogger('app')
-    file_handler = logging.FileHandler('module_a.log')
-    file_handler.setFormatter(logging.Formatter('%(name)s - %(levelname)s - %(message)s'))
-    logger.addHandler(file_handler)
-    # Set logger level to DEBUG
-    logger.setLevel(logging.DEBUG)  
-    
-    # module_b 
-    # Module B reconfigures the same logger name with a console handler
-    logger = logging.getLogger('app')  # Same logger name as module_a
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
-    logger.addHandler(console_handler)
-    # Overwrites previous logging level to ERROR
-    logger.setLevel(logging.ERROR)  
-    
-    # main module
-    from module_a import logger as logger_a
-    from module_b import logger as logger_b
-    
-    # Ensuring basic config in main
-    # This can interfere with module settings
-    logging.basicConfig(level=logging.DEBUG)  
-    
-    # Intended for file, will not appear if overridden
-    logger_a.debug('Debug message from module_a')
-    # Intended for console  
-    logger_b.error('Error message from module_b')  
-    ```
-    
-    Output
-    
-    ```
-    ERROR: Error message from module_b
-    ERROR:app:Error message from module_b
-    ```
-    
-    The logger in `module_b` configured with a console handler affects the logger’s behavior set in `module_a`. The output `ERROR:app:Error` message from `module_b` shows that `module_b`'s console handler is overriding `module_a`'s file handler, causing all messages to appear on the console instead of the file.
-    
-    - Trace Imports and Initializations: Check that modules aren’t initializing or configuring logging in ways that might cause unexpected interactions.
-        
-        The `logging.basicConfig(level=logging.DEBUG)` call in [`m](http://main.py/)ain.py` affects the global logging configuration and can override settings from modules. In this case, it doesn’t directly impact the output, but it can cause unexpected behavior if configurations are not isolated properly. For instance, if `basicConfig` had set different handlers or levels, it might have altered the logging setup of `module_a` and `module_b`.
-        
-    - Consistency in Logger Naming: Ensure logger names are used consistently across modules. Inconsistent naming can lead to confusion, accidental overlap, or misconfiguration. Both `module_a` and `module_b` uses the same logger name `app`. The output `ERROR:app:Error` message from `module_b` demonstrates that using the same name for loggers across modules can lead to overlapping configurations. The `console_handler` from `module_b` is taking effect and overriding the `file_handler` from `module_a`.
-    - Module-Specific Configurations: Verify that modules with unique logging needs have their configurations properly isolated. This helps prevent unintended interactions with other modules. The logger in `module_b` reconfigures the same logger name `app` that `module_a` configured. This results in all log messages being handled by `module_b`’s console handler due to the level set to `ERROR`. This shows that configurations meant for different modules are interfering with each other because they’re not isolated, causing logs to be handled in a manner that wasn’t intended.
+
+   ```python
+   # In the parent logger
+   logger_a = logging.getLogger('app')
+   for handler in logger_a.handlers[:]:
+       logger_a.removeHandler(handler)
+
+   # Add handlers only to specific loggers
+
+   ```
+
+4. Inspect multi-module interactions: In complex applications, loggers from different modules may interact unexpectedly. Pay special attention to imported modules and their logging setups. Let’s take an example,
+
+   ```python
+   # module_ a
+   import logging
+   # Module A configures a logger with a file handler
+   logger = logging.getLogger('app')
+   file_handler = logging.FileHandler('module_a.log')
+   file_handler.setFormatter(logging.Formatter('%(name)s - %(levelname)s - %(message)s'))
+   logger.addHandler(file_handler)
+   # Set logger level to DEBUG
+   logger.setLevel(logging.DEBUG)
+
+   # module_b
+   # Module B reconfigures the same logger name with a console handler
+   logger = logging.getLogger('app')  # Same logger name as module_a
+   console_handler = logging.StreamHandler()
+   console_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
+   logger.addHandler(console_handler)
+   # Overwrites previous logging level to ERROR
+   logger.setLevel(logging.ERROR)
+
+   # main module
+   from module_a import logger as logger_a
+   from module_b import logger as logger_b
+
+   # Ensuring basic config in main
+   # This can interfere with module settings
+   logging.basicConfig(level=logging.DEBUG)
+
+   # Intended for file, will not appear if overridden
+   logger_a.debug('Debug message from module_a')
+   # Intended for console
+   logger_b.error('Error message from module_b')
+   ```
+
+   Output
+
+   ```
+   ERROR: Error message from module_b
+   ERROR:app:Error message from module_b
+   ```
+
+   The logger in `module_b` configured with a console handler affects the logger’s behavior set in `module_a`. The output `ERROR:app:Error` message from `module_b` shows that `module_b`'s console handler is overriding `module_a`'s file handler, causing all messages to appear on the console instead of the file.
+
+   - Trace Imports and Initializations: Check that modules aren’t initializing or configuring logging in ways that might cause unexpected interactions.
+     The `logging.basicConfig(level=logging.DEBUG)` call in [`m](http://main.py/)ain.py`affects the global logging configuration and can override settings from modules. In this case, it doesn’t directly impact the output, but it can cause unexpected behavior if configurations are not isolated properly. For instance, if`basicConfig`had set different handlers or levels, it might have altered the logging setup of`module_a`and`module_b`.
+   - Consistency in Logger Naming: Ensure logger names are used consistently across modules. Inconsistent naming can lead to confusion, accidental overlap, or misconfiguration. Both `module_a` and `module_b` uses the same logger name `app`. The output `ERROR:app:Error` message from `module_b` demonstrates that using the same name for loggers across modules can lead to overlapping configurations. The `console_handler` from `module_b` is taking effect and overriding the `file_handler` from `module_a`.
+   - Module-Specific Configurations: Verify that modules with unique logging needs have their configurations properly isolated. This helps prevent unintended interactions with other modules. The logger in `module_b` reconfigures the same logger name `app` that `module_a` configured. This results in all log messages being handled by `module_b`’s console handler due to the level set to `ERROR`. This shows that configurations meant for different modules are interfering with each other because they’re not isolated, causing logs to be handled in a manner that wasn’t intended.
 
 ## Step-by-Step Solutions for Common Scenarios
 
@@ -470,91 +468,90 @@ In the code, we use a `CustomDeduplicationHandler` that extends `logging.Handler
 In multi-threaded applications, use thread-safe logging techniques to ensure that log messages from multiple threads are handled correctly and consistently:
 
 1. Use `logging.getLogger()` to get thread-safe logger instances, you ensure that the logging system handles concurrency issues internally. So, when we call `logging.getLogger(name)`, it returns a logger instance which is configured to be thread-safe. The `logging` module manages internal locks to ensure that log records are processed correctly even when multiple threads generate logs simultaneously. Let’s take an example,
-    
-    ```python
-    import logging
-    
-    # Get a thread-safe logger instance
-    logger = logging.getLogger('my_logger')
-    logger.setLevel(logging.DEBUG)
-    
-    ```
-    
-    Here, the logger instance returned by `getLogger()` is thread safe. You can use this logger in different threads without worrying about race conditions or data corruption.
-    
+
+   ```python
+   import logging
+
+   # Get a thread-safe logger instance
+   logger = logging.getLogger('my_logger')
+   logger.setLevel(logging.DEBUG)
+
+   ```
+
+   Here, the logger instance returned by `getLogger()` is thread safe. You can use this logger in different threads without worrying about race conditions or data corruption.
+
 2. Consider using `QueueHandler` and `QueueListener` for asynchronous logging. For applications with high logging volume, using `QueueHandler` and `QueueListener` can help manage logging asynchronously and reduce contention between threads. `QueueHandler` sends log records to a queue, which `QueueListener` processes in a separate thread.
-    
-    ```python
-    import logging
-    import logging.handlers
-    import queue
-    import threading
-    
-    # Create a queue for log records
-    log_queue = queue.Queue()
-    
-    # Define a QueueHandler to put log records into the queue
-    queue_handler = logging.handlers.QueueHandler(log_queue)
-    
-    # Create a logger and add the QueueHandler
-    logger = logging.getLogger('my_async_logger')
-    logger.setLevel(logging.DEBUG)
-    logger.addHandler(queue_handler)
-    
-    # Define a handler to process log records from the queue
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
-    
-    # Define a QueueListener to process log records
-    queue_listener = logging.handlers.QueueListener(log_queue, console_handler)
-    queue_listener.start()
-    
-    # Function to log messages from multiple threads
-    def worker():
-        logger.info('Log message from worker thread')
-    
-    # Start threads
-    threads = [threading.Thread(target=worker) for _ in range(5)]
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join()
-    
-    # Stop the QueueListener when done
-    queue_listener.stop()
-    
-    ```
-    
-    This setup allows multiple threads to log messages concurrently without blocking each other, as the `QueueListener` handles log processing asynchronously. After all threads finish logging, the `QueueListener` is stopped to ensure all messages are processed.
-    
+
+   ```python
+   import logging
+   import logging.handlers
+   import queue
+   import threading
+
+   # Create a queue for log records
+   log_queue = queue.Queue()
+
+   # Define a QueueHandler to put log records into the queue
+   queue_handler = logging.handlers.QueueHandler(log_queue)
+
+   # Create a logger and add the QueueHandler
+   logger = logging.getLogger('my_async_logger')
+   logger.setLevel(logging.DEBUG)
+   logger.addHandler(queue_handler)
+
+   # Define a handler to process log records from the queue
+   console_handler = logging.StreamHandler()
+   console_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
+
+   # Define a QueueListener to process log records
+   queue_listener = logging.handlers.QueueListener(log_queue, console_handler)
+   queue_listener.start()
+
+   # Function to log messages from multiple threads
+   def worker():
+       logger.info('Log message from worker thread')
+
+   # Start threads
+   threads = [threading.Thread(target=worker) for _ in range(5)]
+   for t in threads:
+       t.start()
+   for t in threads:
+       t.join()
+
+   # Stop the QueueListener when done
+   queue_listener.stop()
+
+   ```
+
+   This setup allows multiple threads to log messages concurrently without blocking each other, as the `QueueListener` handles log processing asynchronously. After all threads finish logging, the `QueueListener` is stopped to ensure all messages are processed.
+
 3. Implement locks if you're creating custom handlers that aren't inherently thread safe. If you create custom log handlers or perform logging in complex multi-threaded environments, you might need to ensure that these custom components are thread safe. For instance, if your custom handler writes to a shared file or database, you should use threading locks to prevent concurrent write operations from causing issues.
-    
-    ```python
-    import logging
-    import threading
-    
-    class ThreadSafeHandler(logging.Handler):
-        def __init__(self):
-            super().__init__()
-            self.lock = threading.Lock()
-    
-        def emit(self, record):
-            with self.lock:
-                # Example: Write log message to a file
-                with open('logfile.log', 'a') as f:
-                    f.write(self.format(record) + '\\n')
-    
-    # Configure logger to use the custom thread-safe handler
-    logger = logging.getLogger('thread_safe_logger')
-    handler = ThreadSafeHandler()
-    handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
-    logger.addHandler(handler)
-    logger.setLevel(logging.DEBUG)
-    
-    ```
-    
-    In this example, `ThreadSafeHandler` uses a lock to synchronize access to the file, ensuring that log messages from different threads are written safely.
-    
+
+   ```python
+   import logging
+   import threading
+
+   class ThreadSafeHandler(logging.Handler):
+       def __init__(self):
+           super().__init__()
+           self.lock = threading.Lock()
+
+       def emit(self, record):
+           with self.lock:
+               # Example: Write log message to a file
+               with open('logfile.log', 'a') as f:
+                   f.write(self.format(record) + '\\n')
+
+   # Configure logger to use the custom thread-safe handler
+   logger = logging.getLogger('thread_safe_logger')
+   handler = ThreadSafeHandler()
+   handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
+   logger.addHandler(handler)
+   logger.setLevel(logging.DEBUG)
+
+   ```
+
+   In this example, `ThreadSafeHandler` uses a lock to synchronize access to the file, ensuring that log messages from different threads are written safely.
 
 ## Best Practices for Python Logging Configuration
 
@@ -574,7 +571,6 @@ handlers:
 root:
   level: INFO
   handlers: [console]
-
 ```
 
 This `YAML` file sets up a simple logging configuration with a console handler that logs messages at the `INFO` level and above.
@@ -608,22 +604,22 @@ logging.getLogger('suspected_logger').disabled = True
 ```
 
 1. Leverage `logging.Logger.disabled`: Temporarily disable loggers to isolate the issue. Set `logger.disabled = True` for specific loggers that you suspect might be causing the duplicates. This approach helps you confirm whether a particular logger is involved in generating duplicate messages.
-    
-    ```python
-    import logging
-    
-    # Disable the logger that might be causing duplicates
-    logger = logging.getLogger('app.module')
-    logger.disabled = True
-    
-    # Perform your tests or operations here
-    # Re-enable the logger after testing
-    logger.disabled = False
-    
-    ```
-    
-    This method allows you to control which loggers are active and helps determine if disabling certain loggers resolves the duplication problem.
-    
+
+   ```python
+   import logging
+
+   # Disable the logger that might be causing duplicates
+   logger = logging.getLogger('app.module')
+   logger.disabled = True
+
+   # Perform your tests or operations here
+   # Re-enable the logger after testing
+   logger.disabled = False
+
+   ```
+
+   This method allows you to control which loggers are active and helps determine if disabling certain loggers resolves the duplication problem.
+
 2. Use [log analysis tools](https://signoz.io/comparisons/log-analysis-tools/): Tools like <a href="https://pypi.org/project/log-analyzer/" rel="noopener noreferrer nofollow" target="_blank">log_analyzer</a> can help identify patterns in your logs. These tools can help you detect patterns, anomalies, or redundancy in your log messages. They often provide features like filtering, sorting, and visualizing log data to make it easier to spot issues
 
 ## Enhancing Logging with SigNoz for Distributed Systems
@@ -698,9 +694,13 @@ if __name__ == '__main__':
 
 ```
 
-Verify by navigating to the SigNoz Logs Dashboard and see if the logs have been received. 
+Verify by navigating to the SigNoz Logs Dashboard and see if the logs have been received.
 
-<Figure src="/img/guides/2024/09/log-messages-appearing-twice-with-python-logging-39d6d193-ff73-4c69-ac59-1fe322dd6aed.webp" alt="SigNoz Logs Dashboard Si" caption="SigNoz Logs Dashboard Si" />
+<Figure
+  src="/img/guides/2024/09/log-messages-appearing-twice-with-python-logging-39d6d193-ff73-4c69-ac59-1fe322dd6aed.webp"
+  alt="SigNoz Logs Dashboard Si"
+  caption="SigNoz Logs Dashboard Si"
+/>
 
 By correlating logs with traces, SigNoz provides a powerful tool for debugging complex systems and identifying the root cause of issues, including duplicate logs.
 
@@ -728,4 +728,4 @@ Review Django's default logging configuration in `settings.py`. Customize it to
 
 ### Can log duplication affect application performance?
 
-Yes, especially in high-volume logging scenarios. Duplicate logs can increase I/O operations, consume more storage, and make log analysis more time-consuming. It's crucial to eliminate duplicates for both clarity and performance reasons.
\ No newline at end of file
+Yes, especially in high-volume logging scenarios. Duplicate logs can increase I/O operations, consume more storage, and make log analysis more time-consuming. It's crucial to eliminate duplicates for both clarity and performance reasons.
diff --git a/data/guides/log-parsing.mdx b/data/guides/log-parsing.mdx
index debd55755..ce48090a2 100644
--- a/data/guides/log-parsing.mdx
+++ b/data/guides/log-parsing.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Log Parsing 101 - A Beginner's Guide to Structured Data
-slug: log-parsing
 date: 2024-07-26
 tags: [logging]
 authors: [nitin_gouda]
 description: Master log parsing techniques to transform unstructured data into actionable insights. Learn key concepts, tools, and best practices for effective log management.
-keywords: [log parsing, structured data, log analysis, system monitoring, data extraction, log management, log formats, parsing tools]
-
+keywords:
+  [
+    log parsing,
+    structured data,
+    log analysis,
+    system monitoring,
+    data extraction,
+    log management,
+    log formats,
+    parsing tools,
+  ]
 ---
 
 Logs are invaluable sources of information to provide insights into system operations, user activities, and application performance. Log parsing is the process of analyzing these logs to extract meaningful data, enabling organizations to monitor, troubleshoot, and optimize their systems effectively. This guide will explore the fundamentals of log parsing, common log formats, how log parsers work, popular tools, and best practices to help you harness the power of your log data.
@@ -27,31 +34,23 @@ The main aspects of log parsing, includes handling common log formats like plain
 
 Logs can come in various formats, depending on the source system or application generating them. Understanding these common log formats is essential for effective log parsing and analysis. Here are some of the most frequently encountered log formats:
 
-1. **Plaintext**: Plaintext logs are simple text files where each log entry is a line of text. They are the most basic form of logs and are easy to read and write. Often used in web server logs and application logs. 
-Example: 
-    
-    ```bash
-    2024-07-23 15:43:21 INFO User login successful - UserID: 7890, SessionID: abc123
-    ```
-    
-    `2024-07-23 15:43:21` is the timestamp, `INFO` is the log level, `User login successful - UserID: 7890, SessionID: abc123` is the message describing the event.
-    
-2. **JSON (JavaScript Object Notation)**: [JSON logs](https://signoz.io/blog/json-logs/) are structured logs that use key-value pairs, making them easily parsable and readable. JSON logs are commonly used in modern web applications, micro-services, and APIs due to their structured nature and compatibility with various data processing tools.
-Example: 
-    
-    <Figure src="/img/guides/2024/07/log-parsing-Untitled.webp" alt="Logs formatted as JSON logs" caption="Logs formatted as JSON logs" />
-    
-3. **XML (Extensible Markup Language)**:  XML logs use a markup language that is both human and machine-readable. Although XML is more verbose than JSON, it is nevertheless frequently used to describe structured data. Web services (SOAP), configuration files, and enterprise applications all frequently use XML logs.
-Example: 
-    
-    <Figure src="/img/guides/2024/07/log-parsing-Untitled%201.webp" alt="XML Logs view" caption="XML Logs view" />
-    
-4. **CSV (Comma-Separated Values)**: CSV logs use a simple text format where each log entry is a line and values are separated by commas. CSV logs are commonly used for exporting and importing data between applications, especially in spreadsheets and databases. 
-Example: 
-    
-    <Figure src="/img/guides/2024/07/log-parsing-Untitled%202.webp" alt="CSV Logs" caption="CSV Logs" />
-    
-5. **Windows Event Log**:  Windows Event Log is a proprietary [logging format](https://signoz.io/guides/what-is-pythons-default-logging-formatter/) used by the Microsoft Windows operating system. It records events related to the operating system, application software, and hardware. Windows Event Logs are used for recording system, security, and application events on Windows operating systems. To know more about Windows Logs you can checkout [Window Event Logs](https://signoz.io/guides/windows-logs/).
+1.  **Plaintext**: Plaintext logs are simple text files where each log entry is a line of text. They are the most basic form of logs and are easy to read and write. Often used in web server logs and application logs.
+    Example:
+        ```bash
+        2024-07-23 15:43:21 INFO User login successful - UserID: 7890, SessionID: abc123
+        ```
+
+        `2024-07-23 15:43:21` is the timestamp, `INFO` is the log level, `User login successful - UserID: 7890, SessionID: abc123` is the message describing the event.
+2.  **JSON (JavaScript Object Notation)**: [JSON logs](https://signoz.io/blog/json-logs/) are structured logs that use key-value pairs, making them easily parsable and readable. JSON logs are commonly used in modern web applications, micro-services, and APIs due to their structured nature and compatibility with various data processing tools.
+    Example:
+        <Figure src="/img/guides/2024/07/log-parsing-Untitled.webp" alt="Logs formatted as JSON logs" caption="Logs formatted as JSON logs" />
+3.  **XML (Extensible Markup Language)**: XML logs use a markup language that is both human and machine-readable. Although XML is more verbose than JSON, it is nevertheless frequently used to describe structured data. Web services (SOAP), configuration files, and enterprise applications all frequently use XML logs.
+    Example:
+        <Figure src="/img/guides/2024/07/log-parsing-Untitled%201.webp" alt="XML Logs view" caption="XML Logs view" />
+4.  **CSV (Comma-Separated Values)**: CSV logs use a simple text format where each log entry is a line and values are separated by commas. CSV logs are commonly used for exporting and importing data between applications, especially in spreadsheets and databases.
+    Example:
+        <Figure src="/img/guides/2024/07/log-parsing-Untitled%202.webp" alt="CSV Logs" caption="CSV Logs" />
+5.  **Windows Event Log**: Windows Event Log is a proprietary [logging format](https://signoz.io/guides/what-is-pythons-default-logging-formatter/) used by the Microsoft Windows operating system. It records events related to the operating system, application software, and hardware. Windows Event Logs are used for recording system, security, and application events on Windows operating systems. To know more about Windows Logs you can checkout [Window Event Logs](https://signoz.io/guides/windows-logs/).
 
 Understanding these common log formats and their appropriate use cases is crucial for effective log management and analysis. By choosing the right format and leveraging the appropriate tools, organisations can streamline their log parsing and gain valuable insights from their log data. The choice of log format depends on several factors, including the complexity of the data, ease of parsing, readability, and the tools available.
 
@@ -88,57 +87,46 @@ The core functionality of a log parser is to read log entries and extract meanin
 Log Parsing Techniques
 
 - Regular Expressions (Regex) Regular expressions are used to identify patterns within log entries. They are powerful and flexible, allowing the parser to match complex patterns and extract specific fields.
-Example: Consider the log entry:
-    
-    ```sql
-    2024-07-25 12:34:56,789 INFO [UserService] User 123 logged in from IP 192.168.1.1
-    ```
-    
-    Using the regex pattern: 
-    
-    ```bash
-    (?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}) (?P<log_level>INFO|ERROR|DEBUG) \[(?P<source>[^\]]+)\] (?P<message>.*?) from IP (?P<ip>\d+\.\d+\.\d+\.\d+)
-    ```
-    
-    The named groups `timestamp`, `log_level`, `source`, `message`, and `ip` will capture:
-    
-    - Timestamp: `2024-07-25 12:34:56,789`Log level: `INFO`Source: `UserService`Message: `User 123 logged in`IP Address: `192.168.1.1`
+  Example: Consider the log entry:
+      ```sql
+      2024-07-25 12:34:56,789 INFO [UserService] User 123 logged in from IP 192.168.1.1
+      ```
+
+      Using the regex pattern:
+
+      ```bash
+      (?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}) (?P<log_level>INFO|ERROR|DEBUG) \[(?P<source>[^\]]+)\] (?P<message>.*?) from IP (?P<ip>\d+\.\d+\.\d+\.\d+)
+      ```
+
+      The named groups `timestamp`, `log_level`, `source`, `message`, and `ip` will capture:
+
+      - Timestamp: `2024-07-25 12:34:56,789`Log level: `INFO`Source: `UserService`Message: `User 123 logged in`IP Address: `192.168.1.1`
 - Tokenisation Tokenisation involves splitting log entries into smaller units (tokens) based on predefined delimiters (e.g., spaces, commas). Each token is then assigned to a specific field.
-Example: Consider the log entry:
-    
-    ```bash
-    2024-07-25,12:34:56,INFO,UserService,User 123 logged in,192.168.1.1
-    ```
-    
+  Example: Consider the log entry:
+      ```bash
+      2024-07-25,12:34:56,INFO,UserService,User 123 logged in,192.168.1.1
+      ```
 - These tokens can then be mapped to fields:
-    - Date: `2024-07-25` , Time: `12:34:56`, Log level: `INFO`, Source: `UserService`, Message: `User 123 logged in`, IP Address: `192.168.1.1`
+  - Date: `2024-07-25` , Time: `12:34:56`, Log level: `INFO`, Source: `UserService`, Message: `User 123 logged in`, IP Address: `192.168.1.1`
 - Structured [Log Parsing](https://signoz.io/guides/log-parsing/#popular-log-parsing-tools) For logs in structured formats like JSON or XML, parsers can directly map the log fields to the corresponding data structures.
-    
-    Example: Consider the JSON log entry:
-    
-    ```json
-    {
-      "timestamp": "2024-07-25T12:34:56.789Z",
-      "level": "INFO",
-      "source": "UserService",
-      "message": "User 123 logged in",
-      "ip": "192.168.1.1"
-    }
-    ```
-    
-    Using a JSON parser, you can directly access and see what you need.
-    
+  Example: Consider the JSON log entry:
+  ```json
+  {
+    "timestamp": "2024-07-25T12:34:56.789Z",
+    "level": "INFO",
+    "source": "UserService",
+    "message": "User 123 logged in",
+    "ip": "192.168.1.1"
+  }
+  ```
+  Using a JSON parser, you can directly access and see what you need.
 - Unstructured Log Parsing For unstructured logs, the parser uses advanced techniques like machine learning to identify and extract relevant information.
-    
-    Example: Consider the unstructured log entry:
-    
-    ```bash
-    User 123 logged in on 2024-07-25 at 12:34:56 from IP 192.168.1.1
-    ```
-    
-    Using machine learning models trained on similar log patterns, the parser can identify and extract User ID: `123`, Action: `logged in`, Date: `2024-07-25` , Time: `12:34:56`, 
-    IP Address: `192.168.1.1`
-    
+  Example: Consider the unstructured log entry:
+  ```bash
+  User 123 logged in on 2024-07-25 at 12:34:56 from IP 192.168.1.1
+  ```
+  Using machine learning models trained on similar log patterns, the parser can identify and extract User ID: `123`, Action: `logged in`, Date: `2024-07-25` , Time: `12:34:56`,
+  IP Address: `192.168.1.1`
 
 ### Data Transformation
 
@@ -179,18 +167,16 @@ The final step involves analysing the structured log data to gain insights. This
 ## Popular Log Parsing Tools
 
 - [SigNoz](https://signoz.io/docs/introduction/) <br />
-An open-source observability platform that helps you monitor and troubleshoot your applications. It provides comprehensive insights by integrating metrics, traces, and logs into a single platform.
-    
-    <GetStartedSigNoz />
-    
-- Logstash  <br />
-Logstash is a free and open-source utility for gathering, processing, and archiving logs for later use. It integrates easily with Kibana and Elasticsearch and is a component of the Elastic Stack.
-- Fluentd  <br />
-An open-source data collector that unifies data collection and consumption. It's known for its flexibility and support for a wide range of output destinations.
-- [Graylog](https://signoz.io/comparisons/graylog-vs-splunk/)  <br />
-Graylog is a strong log management solution that gives you real-time search, analysis, and visualisation capabilities over your log data. Its great performance and scalability are designed in.
-- Splunk  <br />
-A leading platform for searching, monitoring, and analysing machine-generated big data via a web-style interface. It can handle a vast amount of data and is widely used in enterprise environments.
+  An open-source observability platform that helps you monitor and troubleshoot your applications. It provides comprehensive insights by integrating metrics, traces, and logs into a single platform.
+      <GetStartedSigNoz />
+- Logstash <br />
+  Logstash is a free and open-source utility for gathering, processing, and archiving logs for later use. It integrates easily with Kibana and Elasticsearch and is a component of the Elastic Stack.
+- Fluentd <br />
+  An open-source data collector that unifies data collection and consumption. It's known for its flexibility and support for a wide range of output destinations.
+- [Graylog](https://signoz.io/comparisons/graylog-vs-splunk/) <br />
+  Graylog is a strong log management solution that gives you real-time search, analysis, and visualisation capabilities over your log data. Its great performance and scalability are designed in.
+- Splunk <br />
+  A leading platform for searching, monitoring, and analysing machine-generated big data via a web-style interface. It can handle a vast amount of data and is widely used in enterprise environments.
 
 ## Advanced Log Parsing Techniques
 
diff --git a/data/guides/log-retention.mdx b/data/guides/log-retention.mdx
index 8f418dccf..67bd13c1b 100644
--- a/data/guides/log-retention.mdx
+++ b/data/guides/log-retention.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Log Retention 101 - What is it and Best Practices
-slug: log-retention
 date: 2024-07-21
 tags: [logging]
 authors: [eromosele]
 description: Discover essential log retention best practices and compliance requirements, covering the logs' types, the log data lifecycle, the benefits and challenges of log retention, best practices, compliance considerations, and the tools and technologies available for effective log management.
-keywords: [log retention, cybersecurity, compliance, data management, incident response, log analysis, regulatory requirements, data protection]
-
+keywords:
+  [
+    log retention,
+    cybersecurity,
+    compliance,
+    data management,
+    incident response,
+    log analysis,
+    regulatory requirements,
+    data protection,
+  ]
 ---
 
 Log retention is the process of storing log data for a specified period. Logs, which record events within software applications, operating systems, and other digital systems, contain valuable information about system activities, user actions, and other critical events. Log retention is crucial across various industries such as finance, healthcare, and technology. In finance, logs help track transactions and detect fraud. In healthcare, they ensure compliance with patient privacy regulations. In technology, logs assist in troubleshooting and improving system performance.
@@ -35,7 +42,11 @@ It's important to note that log retention differs from log management. While ret
 
 ### Lifecycle of Log Data
 
-<Figure src="/img/guides/2024/07/log-retention-Napkin Selection Log Retention.webp" alt="Napkin Selection Log Retention.webp" caption="Lifecycle of Log Data" />
+<Figure
+  src="/img/guides/2024/07/log-retention-Napkin Selection Log Retention.webp"
+  alt="Napkin Selection Log Retention.webp"
+  caption="Lifecycle of Log Data"
+/>
 
 1. Generation: Logs are created by systems, applications, and network devices.
 2. Collection: Logs are gathered from various sources into a central repository.
@@ -120,7 +131,9 @@ To put these practices into action:
 ### Popular Log Management Solutions
 
 - [Signoz](https://signoz.io/docs/introduction/): An open-source observability platform that helps developers monitor and troubleshoot their applications using logs, metrics, and traces.
-    <GetStartedSigNoz />
+
+  {' '}
+  <GetStartedSigNoz />
 
 - Splunk: A powerful tool for collecting, analyzing, and visualizing log data.
 - LogRhythm: An integrated platform for security information and event management (SIEM) and log management.
diff --git a/data/guides/loggerFactory-getLogger-cannot-be-resolved-to-a-type.mdx b/data/guides/loggerFactory-getLogger-cannot-be-resolved-to-a-type.mdx
index b9ac48cfe..d55b76e41 100644
--- a/data/guides/loggerFactory-getLogger-cannot-be-resolved-to-a-type.mdx
+++ b/data/guides/loggerFactory-getLogger-cannot-be-resolved-to-a-type.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to Resolve "LoggerFactory.getLogger" Error in Java
-slug: loggerFactory-getLogger-cannot-be-resolved-to-a-type
 date: 2024-09-24
 tags: [logging]
 authors: [sushant_gaurav]
 description: Learn how to fix the "LoggerFactory.getLogger cannot be resolved to a type" error in Java. Comprehensive guide with step-by-step solutions and best practices.
-keywords: [LoggerFactory.getLogger error, Java logging, SLF4J, error resolution, IDE troubleshooting, distributed tracing]
-
+keywords:
+  [
+    LoggerFactory.getLogger error,
+    Java logging,
+    SLF4J,
+    error resolution,
+    IDE troubleshooting,
+    distributed tracing,
+  ]
 ---
 
 Java developers frequently run into the "LoggerFactory.getLogger cannot be resolved to a type" problem while working with logging frameworks, particularly `SLF4J` (Simple Logging Facade for Java). This error might be annoying and interrupt progress due to compilation concerns. To keep your development process on track, you must first analyze the core problems and then implement appropriate remedies. This article includes a thorough description of the error, step-by-step troubleshooting procedures, and recommended practices for Java logging configuration.
@@ -76,27 +81,28 @@ In this example, `LoggerFactory.getLogger` initializes a logger that tags each m
 ### Additional Content to Consider
 
 1. Incorrect Build Settings or Classpaths: Misconfigurations in your project's build file or classpath might cause this issue. For example, in a Maven project, if `slf4j-api` or its implementation (`slf4j-simple` or `logback-classic`) is absent, the project will fail to identify `LoggerFactory`. In Gradle, ensuring that dependencies are properly defined in `build.gradle` is important.
-    
-    Example (Maven `pom.xml`):
-    
-    ```xml
-    <dependency>
-        <groupId>org.slf4j</groupId>
-        <artifactId>slf4j-api</artifactId>
-        <version>1.7.30</version> <!-- Ensure correct version -->
-    </dependency>
-    <dependency>
-        <groupId>ch.qos.logback</groupId>
-        <artifactId>logback-classic</artifactId>
-        <version><!-- Refer to Maven Central for the latest version --></version>
-    </dependency>
-    ```
-    
-    Steps to find the correct version:
-    
-    1. Visit Maven Central Repository: Go to <a href="https://search.maven.org/" rel="noopener noreferrer nofollow" target="_blank">search.maven.org</a> and search for `logback-classic`.
-    2. Official Documentation: The <a href="https://logback.qos.ch/" rel="noopener noreferrer nofollow" target="_blank">Logback official site</a> also lists the recommended versions for your project.
-    3. Check Compatibility: Ensure the version of `logback-classic` you choose is compatible with the version of `slf4j-api` you are using.
+
+   Example (Maven `pom.xml`):
+
+   ```xml
+   <dependency>
+       <groupId>org.slf4j</groupId>
+       <artifactId>slf4j-api</artifactId>
+       <version>1.7.30</version> <!-- Ensure correct version -->
+   </dependency>
+   <dependency>
+       <groupId>ch.qos.logback</groupId>
+       <artifactId>logback-classic</artifactId>
+       <version><!-- Refer to Maven Central for the latest version --></version>
+   </dependency>
+   ```
+
+   Steps to find the correct version:
+
+   1. Visit Maven Central Repository: Go to <a href="https://search.maven.org/" rel="noopener noreferrer nofollow" target="_blank">search.maven.org</a> and search for `logback-classic`.
+   2. Official Documentation: The <a href="https://logback.qos.ch/" rel="noopener noreferrer nofollow" target="_blank">Logback official site</a> also lists the recommended versions for your project.
+   3. Check Compatibility: Ensure the version of `logback-classic` you choose is compatible with the version of `slf4j-api` you are using.
+
 2. Explanation of Conflicting Frameworks: If you use other logging frameworks, such as `Log4j` or `java.util.logging`, they may conflict with `SLF4j`. The most common reason is having two logging implementations on the classpath (e.g., `Log4j` and `SLF4J` both enabled). This might result in runtime errors in which log messages are duplicated or altogether absent.
 
 ## Common Reasons for the "LoggerFactory.getLogger cannot be resolved to a type" Error
@@ -135,21 +141,17 @@ implementation 'org.slf4j:slf4j-api:1.7.32'
 ### Additional Notes:
 
 - Ensure that you also include an implementation of SLF4J, like Logback:
-    
-    ```xml
-    <dependency>
-        <groupId>ch.qos.logback</groupId>
-        <artifactId>logback-classic</artifactId>
-        <version>1.2.3</version> <!-- Ensure compatibility with SLF4J API version -->
-    </dependency>
-    ```
-    
+  ```xml
+  <dependency>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+      <version>1.2.3</version> <!-- Ensure compatibility with SLF4J API version -->
+  </dependency>
+  ```
 - In Gradle, this would look like:
-    
-    ```groovy
-    implementation 'ch.qos.logback:logback-classic:1.2.3'
-    ```
-    
+  ```groovy
+  implementation 'ch.qos.logback:logback-classic:1.2.3'
+  ```
 
 ### 2. Check Import Statements
 
@@ -198,36 +200,92 @@ Different Integrated Development Environments (IDEs) require different approache
 In Eclipse:
 
 1. Right-click on your project and select "Properties".
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image.webp" alt="" caption="" />2. Go to "Java Build Path" and select the "Libraries" tab.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%201.webp" alt="" caption="" />3. Ensure that the `SLF4J` libraries are listed under the classpath. If not:
-    - Click "Add External JARs" and navigate to the location of the SLF4J JAR file.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%202.webp" alt="" caption="" />4. Apply the changes and rebuild the project.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image.webp"
+     alt=""
+     caption=""
+   />
+   2. Go to "Java Build Path" and select the "Libraries" tab.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%201.webp"
+     alt=""
+     caption=""
+   />
+   3. Ensure that the `SLF4J` libraries are listed under the classpath. If not: - Click "Add
+   External JARs" and navigate to the location of the SLF4J JAR file.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%202.webp"
+     alt=""
+     caption=""
+   />
+   4. Apply the changes and rebuild the project.
 
 In IntelliJ IDEA:
 
 1. Navigate to "File" > "Project Structure".
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%203.webp" alt="" caption="" />2. Select "Modules" > Your Module > "Dependencies" tab.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%204.webp" alt="" caption="" />3. Check if `SLF4J` is listed under the dependencies. If missing:
-    - Click the "+" icon, and add the `SLF4J` dependency from Maven or Gradle.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%205.webp" alt="" caption="" />4. Rebuild your project by selecting "Build" > "Rebuild Project".
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%206.webp" alt="" caption="" />In NetBeans:
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%203.webp"
+     alt=""
+     caption=""
+   />
+   2. Select "Modules" > Your Module > "Dependencies" tab.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%204.webp"
+     alt=""
+     caption=""
+   />
+   3. Check if `SLF4J` is listed under the dependencies. If missing: - Click the "+" icon, and add
+   the `SLF4J` dependency from Maven or Gradle.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%205.webp"
+     alt=""
+     caption=""
+   />
+   4. Rebuild your project by selecting "Build" > "Rebuild Project".
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%206.webp"
+     alt=""
+     caption=""
+   />
+   In NetBeans:
 
 1. Right-click your project and choose "Properties".
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%207.webp" alt="" caption="" />2. Under "Libraries", check if the `SLF4J` JAR is included.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%208.webp" alt="" caption="" />3. If not, click "Add JAR/Folder" and locate the `SLF4J` JAR file.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%209.webp" alt="" caption="" />4. Save the changes and clean/build your project by selecting "Clean and Build" from the project menu.
-    
-    <Figure src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%2010.webp" alt="" caption="" />## Best Practices for Java Logging Configuration
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%207.webp"
+     alt=""
+     caption=""
+   />
+   2. Under "Libraries", check if the `SLF4J` JAR is included.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%208.webp"
+     alt=""
+     caption=""
+   />
+   3. If not, click "Add JAR/Folder" and locate the `SLF4J` JAR file.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%209.webp"
+     alt=""
+     caption=""
+   />
+   4. Save the changes and clean/build your project by selecting "Clean and Build" from the project
+   menu.
+
+   <Figure
+     src="/img/guides/2024/09/loggerFactory-getLogger-cannot-be-resolved-to-a-type-image%2010.webp"
+     alt=""
+     caption=""
+   />
+   ## Best Practices for Java Logging Configuration
 
 To avoid future complications with logging, it is important to adopt specific best practices:
 
@@ -294,4 +352,4 @@ Yes, `SLF4J` supports bridges for other popular logging frameworks like as `Log4
 
 ### What are the performance implications of using LoggerFactory.getLogger?
 
-Creating loggers using `LoggerFactory.getLogger` has a low-performance effect because it is normally done once per class. However, regular logging, particularly at DEBUG levels, imposes a significant performance penalty. It is crucial to log responsibly and avoid recording sensitive or verbose information in performance-critical pathways.
\ No newline at end of file
+Creating loggers using `LoggerFactory.getLogger` has a low-performance effect because it is normally done once per class. However, regular logging, particularly at DEBUG levels, imposes a significant performance penalty. It is crucial to log responsibly and avoid recording sensitive or verbose information in performance-critical pathways.
diff --git a/data/guides/logging-in-python.mdx b/data/guides/logging-in-python.mdx
index 17d734ba6..47fd931a0 100644
--- a/data/guides/logging-in-python.mdx
+++ b/data/guides/logging-in-python.mdx
@@ -1,159 +1,170 @@
 ---
-
 title: Python Logging - From Setup to Monitoring with Best Practices
-slug: logging-in-python
 date: 2024-08-29
 tags: [logging]
 authors: [sushant_gaurav]
 description: Master Python Logging with this Comprehensive Guide on Loggers, Handlers, Formatters, Filters, Configurations, and Best Practices for Debugging, Monitoring, and Performance.
-keywords: [logging in python,python logging example,python logging to file,python logging to the console,python logging best practices]
+keywords:
+  [
+    logging in python,
+    python logging example,
+    python logging to file,
+    python logging to the console,
+    python logging best practices,
+  ]
 ---
 
 <head>
-<script
-type="application/ld+json"
-dangerouslySetInnerHTML={{ __html: JSON.stringify({
-"@context": "https://schema.org",
-"@type": "TechArticle",
-"headline": "Python Logging - From Setup to Monitoring with Best Practices",
-"alternativeHeadline": "Master Python Logging with this Comprehensive Guide on Loggers, Handlers, Formatters, Filters, Configurations, and Best Practices for Debugging, Monitoring, and Performance",
-"author": {
-"@type": "Person",
-"name": "Sushant Gaurav"
-},
-"publisher": {
-"@type": "Organization",
-"name": "SigNoz",
-"logo": {
-"@type": "ImageObject",
-"url": "https://signoz.io/img/SigNozLogo-orange.svg"
-}
-},
-"datePublished": "2024-07-03T00:00:00Z",
-"dateModified": "2024-07-03T00:00:00Z",
-"mainEntityOfPage": {
-"@type": "WebPage",
-"@id": "https://signoz.io/guides/logging-in-python/"
-},
-"description": "Master Python Logging with this Comprehensive Guide on Loggers, Handlers, Formatters, Filters, Configurations, and Best Practices for Debugging, Monitoring, and Performance.",
-"keywords": "logging in python, python logging example, python logging to file, python logging to the console, python logging best practices",
-"articleSection": "Technology",
-"inLanguage": "en",
-"isPartOf": {
-"@type": "Blog",
-"name": "SigNoz Blog",
-"url": "https://signoz.io/blog/"
-},
-"about": [
-{
-"@type": "Thing",
-"name": "Python",
-"description": "A high-level programming language"
-},
-{
-"@type": "Thing",
-"name": "Logging",
-"description": "The process of recording events, messages, and data during software execution"
-},
-{
-"@type": "Thing",
-"name": "SigNoz",
-"description": "An open-source observability platform for monitoring applications"
-}
-],
-"mentions": [
-{
-"@type": "SoftwareApplication",
-"name": "[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)",
-"applicationCategory": "Observability Framework"
-}
-],
-"mainEntity": {
-"@type": "FAQPage",
-"mainEntity": [
-{
-"@type": "Question",
-"name": "What is logging in Python?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "Logging in Python refers to the process of recording messages that provide insights into the operation of a program. These messages can include information, debugging details, warnings, and error messages."
-}
-},
-{
-"@type": "Question",
-"name": "How to create a log in Python?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "In Python, you can create a log using the logging module. This involves configuring a logger, setting a logging level, and then using logger methods like debug(), info(), warning(), error(), and critical() to log messages."
-}
-},
-{
-"@type": "Question",
-"name": "What is the benefit of logging in Python?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "Logging helps in monitoring and debugging applications by providing a way to track events and issues that occur during execution. It aids in diagnosing problems, understanding application flow, and maintaining a history of events."
-}
-},
-{
-"@type": "Question",
-"name": "When to use Python logging?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "Python logging should be used to record important events and errors that occur during the execution of a program. It is particularly useful for debugging, monitoring the application's performance, and auditing purposes."
-}
-},
-{
-"@type": "Question",
-"name": "What are the 3 types of logging?",
-"acceptedAnswer": {
-"@type": "Answer",
-"text": "There are three main types of logging: 1) Error Logging: capturing error messages and exceptions. 2) Transaction Logging: recording business or user transactions and interactions. 3) Performance Logging: tracking performance metrics like execution time and resource usage."
-}
-}
-]
-},
-"tutorial": {
-"@type": "HowTo",
-"name": "Setting Up Python Logging",
-"step": [
-{
-"@type": "HowToStep",
-"name": "Import logging module",
-"text": "Import the logging module in your Python script."
-},
-{
-"@type": "HowToStep",
-"name": "Configure basic logging",
-"text": "Use logging.basicConfig() to set up basic logging configuration."
-},
-{
-"@type": "HowToStep",
-"name": "Create a logger",
-"text": "Create a logger using logging.getLogger(name)."
-},
-{
-"@type": "HowToStep",
-"name": "Set logging level",
-"text": "Set the logging level using logger.setLevel()."
-},
-{
-"@type": "HowToStep",
-"name": "Add handlers",
-"text": "Add handlers to direct log output to desired destinations."
-},
-{
-"@type": "HowToStep",
-"name": "Use logging methods",
-"text": "Use logger methods like debug(), info(), warning(), error(), and critical() to log messages."
-}
-]
-}
-}) }}
-/>
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Python Logging - From Setup to Monitoring with Best Practices',
+        alternativeHeadline:
+          'Master Python Logging with this Comprehensive Guide on Loggers, Handlers, Formatters, Filters, Configurations, and Best Practices for Debugging, Monitoring, and Performance',
+        author: {
+          '@type': 'Person',
+          name: 'Sushant Gaurav',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-03T00:00:00Z',
+        dateModified: '2024-07-03T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/logging-in-python/',
+        },
+        description:
+          'Master Python Logging with this Comprehensive Guide on Loggers, Handlers, Formatters, Filters, Configurations, and Best Practices for Debugging, Monitoring, and Performance.',
+        keywords:
+          'logging in python, python logging example, python logging to file, python logging to the console, python logging best practices',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Python',
+            description: 'A high-level programming language',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logging',
+            description:
+              'The process of recording events, messages, and data during software execution',
+          },
+          {
+            '@type': 'Thing',
+            name: 'SigNoz',
+            description: 'An open-source observability platform for monitoring applications',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: '[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)',
+            applicationCategory: 'Observability Framework',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is logging in Python?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Logging in Python refers to the process of recording messages that provide insights into the operation of a program. These messages can include information, debugging details, warnings, and error messages.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How to create a log in Python?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'In Python, you can create a log using the logging module. This involves configuring a logger, setting a logging level, and then using logger methods like debug(), info(), warning(), error(), and critical() to log messages.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the benefit of logging in Python?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Logging helps in monitoring and debugging applications by providing a way to track events and issues that occur during execution. It aids in diagnosing problems, understanding application flow, and maintaining a history of events.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'When to use Python logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Python logging should be used to record important events and errors that occur during the execution of a program. It is particularly useful for debugging, monitoring the application's performance, and auditing purposes.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the 3 types of logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'There are three main types of logging: 1) Error Logging: capturing error messages and exceptions. 2) Transaction Logging: recording business or user transactions and interactions. 3) Performance Logging: tracking performance metrics like execution time and resource usage.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Setting Up Python Logging',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Import logging module',
+              text: 'Import the logging module in your Python script.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure basic logging',
+              text: 'Use logging.basicConfig() to set up basic logging configuration.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a logger',
+              text: 'Create a logger using logging.getLogger(name).',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set logging level',
+              text: 'Set the logging level using logger.setLevel().',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add handlers',
+              text: 'Add handlers to direct log output to desired destinations.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use logging methods',
+              text: 'Use logger methods like debug(), info(), warning(), error(), and critical() to log messages.',
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
-Python logging is a powerful tool that enhances your ability to understand, debug, and monitor your applications. As your projects grow in complexity, proper logging becomes crucial for maintaining code quality and troubleshooting issues efficiently. 
+Python logging is a powerful tool that enhances your ability to understand, debug, and monitor your applications. As your projects grow in complexity, proper logging becomes crucial for maintaining code quality and troubleshooting issues efficiently.
 
 This guide takes you through the essentials of Python logging, from basic concepts to advanced techniques, helping you implement robust logging practices in your projects.
 
@@ -173,7 +184,11 @@ The Python logging module consists of several core components:
 - **Formatters**: Define the structure and content of log messages.
 - **Filters**: Provide fine-grained control over which log records to output.
 
-<Figure src="/img/guides/2024/08/logging-in-python-image.webp" alt="Python Logging Components" caption="Python Logging Components" />
+<Figure
+  src="/img/guides/2024/08/logging-in-python-image.webp"
+  alt="Python Logging Components"
+  caption="Python Logging Components"
+/>
 
 Implementing proper logging is crucial for:
 
@@ -349,16 +364,17 @@ logger.addHandler(file_handler)
 **Explanation**:
 
 1. **Formatter**: The `logging.Formatter` class is used to create a formatter object. In this example, the formatter is defined with a specific format string:
-    - `%(asctime)s`: Timestamp when the log record was created.
-    - `%(name)s`: Name of the logger that produced the log message.
-    - `%(levelname)s`: Log level of the message (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).
-    - `%(message)s`: The actual log message.
-    
-    The format string specifies that each log message will include the timestamp, logger name, log level, and message, separated by hyphens.
-    
+
+   - `%(asctime)s`: Timestamp when the log record was created.
+   - `%(name)s`: Name of the logger that produced the log message.
+   - `%(levelname)s`: Log level of the message (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL).
+   - `%(message)s`: The actual log message.
+
+   The format string specifies that each log message will include the timestamp, logger name, log level, and message, separated by hyphens.
+
 2. **setFormatter**: The `setFormatter` method is used to assign the formatter to a handler. This tells the handler to use the specified format for all log messages it handles.
-    - `console_handler.setFormatter(formatter)`: Sets the formatter for the `StreamHandler`, which sends log messages to the console.
-    - `file_handler.setFormatter(formatter)`: Sets the same formatter for the `FileHandler`, which writes log messages to the specified file (`app.log`).
+   - `console_handler.setFormatter(formatter)`: Sets the formatter for the `StreamHandler`, which sends log messages to the console.
+   - `file_handler.setFormatter(formatter)`: Sets the same formatter for the `FileHandler`, which writes log messages to the specified file (`app.log`).
 
 By defining a formatter and setting it for the handlers, you ensure that log messages are consistently formatted, making them easier to read and analyze.
 
@@ -407,9 +423,9 @@ logger.warning('Another message without the keyword')
 **Explanation**:
 
 1. **SpecificFilter**: The `SpecificFilter` class inherits from `logging.Filter` and override the `filter` method. This method is where the custom filtering logic is implemented. It takes a `record` argument, which represents a log record, and returns `True` if the log message should be passed to the handlers, and `False` otherwise.
-    - In this example, the filter method checks if the word "specific" is in the log message using `record.getMessage()`.
+   - In this example, the filter method checks if the word "specific" is in the log message using `record.getMessage()`.
 2. **Adding the Filter**: The `addFilter` method is used to add the `SpecificFilter` to the logger. This ensures that only log messages passing the filter criteria are dispatched to the handlers.
-    - `logger.addFilter(SpecificFilter())`: Adds an instance of `SpecificFilter` to the logger.
+   - `logger.addFilter(SpecificFilter())`: Adds an instance of `SpecificFilter` to the logger.
 3. **Filter Method Invocation**: The `filter` method is invoked automatically by the logger for each log record it processes. When a log message is generated, the logger passes the log record through all its filters. If a filter returns `False`, the log record is not passed to the handlers.
 
 In this example, only the message "This message contains a specific keyword" will be logged to the console because it passes the filter criteria. The other messages are ignored.
@@ -464,29 +480,29 @@ payment_logger.error('Payment processing failed due to insufficient funds')
 **Explanation**:
 
 1. **Creating Custom Loggers**:
-    - `auth_logger = logging.getLogger('my_app.auth')`: Creates a custom logger for the authentication module.
-    - `payment_logger = logging.getLogger('my_app.payment')`: Creates a custom logger for the payment processing module.
-    - The hierarchical naming (dot-separated) indicates that these loggers are sub-loggers of a parent logger `my_app`.
+   - `auth_logger = logging.getLogger('my_app.auth')`: Creates a custom logger for the authentication module.
+   - `payment_logger = logging.getLogger('my_app.payment')`: Creates a custom logger for the payment processing module.
+   - The hierarchical naming (dot-separated) indicates that these loggers are sub-loggers of a parent logger `my_app`.
 2. **Setting Logging Levels**:
-    - `auth_logger.setLevel(logging.INFO)`: Sets the logging level to `INFO` for the authentication logger.
-    - `payment_logger.setLevel(logging.DEBUG)`: Sets the logging level to `DEBUG` for the payment logger.
+   - `auth_logger.setLevel(logging.INFO)`: Sets the logging level to `INFO` for the authentication logger.
+   - `payment_logger.setLevel(logging.DEBUG)`: Sets the logging level to `DEBUG` for the payment logger.
 3. **Creating and Configuring Handlers**:
-    - `console_handler = logging.StreamHandler()`: Creates a handler to send log messages to the console.
-    - `file_handler = logging.FileHandler('app.log')`: Creates a handler to write log messages to a file (`app.log`).
+   - `console_handler = logging.StreamHandler()`: Creates a handler to send log messages to the console.
+   - `file_handler = logging.FileHandler('app.log')`: Creates a handler to write log messages to a file (`app.log`).
 4. **Creating and Setting Formatters**:
-    - `formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')`: Defines the format for log messages.
-    - `console_handler.setFormatter(formatter)`: Sets the formatter for the console handler.
-    - `file_handler.setFormatter(formatter)`: Sets the formatter for the file handler.
+   - `formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')`: Defines the format for log messages.
+   - `console_handler.setFormatter(formatter)`: Sets the formatter for the console handler.
+   - `file_handler.setFormatter(formatter)`: Sets the formatter for the file handler.
 5. **Adding Handlers to Loggers**:
-    - `auth_logger.addHandler(console_handler)`: Adds the console handler to the authentication logger.
-    - `auth_logger.addHandler(file_handler)`: Adds the file handler to the authentication logger.
-    - `payment_logger.addHandler(console_handler)`: Adds the console handler to the payment logger.
-    - `payment_logger.addHandler(file_handler)`: Adds the file handler to the payment logger.
+   - `auth_logger.addHandler(console_handler)`: Adds the console handler to the authentication logger.
+   - `auth_logger.addHandler(file_handler)`: Adds the file handler to the authentication logger.
+   - `payment_logger.addHandler(console_handler)`: Adds the console handler to the payment logger.
+   - `payment_logger.addHandler(file_handler)`: Adds the file handler to the payment logger.
 6. **Logging Messages**:
-    - `auth_logger.info('User login successful')`: Logs an informational message from the authentication module.
-    - `auth_logger.warning('User login attempt failed')`: Logs a warning message from the authentication module.
-    - `payment_logger.debug('Payment processing started')`: Logs a debug message from the payment processing module.
-    - `payment_logger.error('Payment processing failed due to insufficient funds')`: Logs an error message from the payment processing module.
+   - `auth_logger.info('User login successful')`: Logs an informational message from the authentication module.
+   - `auth_logger.warning('User login attempt failed')`: Logs a warning message from the authentication module.
+   - `payment_logger.debug('Payment processing started')`: Logs a debug message from the payment processing module.
+   - `payment_logger.error('Payment processing failed due to insufficient funds')`: Logs an error message from the payment processing module.
 
 By creating custom loggers, you can better organize your logging strategy and have more control over which messages are logged by different parts of your application. This approach enhances modularity and makes it easier to debug and maintain your code.
 
@@ -586,12 +602,12 @@ file_handler.setFormatter(formatter)
 **Explanation**:
 
 - **`logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')`**:
-    - `%(asctime)s`: The timestamp when the log message was created.
-    - `%(name)s`: The name of the logger that generated the log message.
-    - `%(levelname)s`: The log level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL) of the log message.
-    - `%(message)s`: The actual log message.
+  - `%(asctime)s`: The timestamp when the log message was created.
+  - `%(name)s`: The name of the logger that generated the log message.
+  - `%(levelname)s`: The log level (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL) of the log message.
+  - `%(message)s`: The actual log message.
 - **`console_handler.setFormatter(formatter)`** and **`file_handler.setFormatter(formatter)`**:
-    - These lines set the formatter for the console handler and the file handler, respectively. This means that all log messages handled by these handlers will be formatted according to the specified layout.
+  - These lines set the formatter for the console handler and the file handler, respectively. This means that all log messages handled by these handlers will be formatted according to the specified layout.
 
 ### Adding Contextual Information
 
@@ -811,11 +827,11 @@ custom_logger.setLevel(logging.ERROR)
 **Impact of Overlogging:**
 
 1. Logging System's Storage:
-    - **Disk Space:** Excessive logging can consume disk space on the server where log files are stored. This is particularly relevant when logs are saved to files (`FileHandler` in Python's logging module) or a database.
-    - **Performance:** Writing too many logs to disk can degrade system performance, especially in high-throughput applications or systems with limited disk I/O bandwidth.
+   - **Disk Space:** Excessive logging can consume disk space on the server where log files are stored. This is particularly relevant when logs are saved to files (`FileHandler` in Python's logging module) or a database.
+   - **Performance:** Writing too many logs to disk can degrade system performance, especially in high-throughput applications or systems with limited disk I/O bandwidth.
 2. Console (Output) Display:
-    - **User Interface:** In environments where logs are displayed in real-time on a console or terminal, excessive logging can overwhelm the display, making it difficult to read and follow important log messages.
-    - **User Experience:** Continuous output of non-critical or verbose logs can distract or obscure critical information for developers or operators monitoring the system.
+   - **User Interface:** In environments where logs are displayed in real-time on a console or terminal, excessive logging can overwhelm the display, making it difficult to read and follow important log messages.
+   - **User Experience:** Continuous output of non-critical or verbose logs can distract or obscure critical information for developers or operators monitoring the system.
 
 ### Sensitive Information in Logs
 
@@ -836,7 +852,7 @@ To optimize the logging, we can:
 
 - Use the appropriate logging level (`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`) based on the importance of the message. Avoid logging verbose or unnecessary information at lower levels (`DEBUG`) in production environments.
 - Wrap debug-level logging statements in conditional checks to ensure they are only executed when needed, minimizing unnecessary logging overhead.
-**Example**:
+  **Example**:
 
 ```python
 if custom_logger.isEnabledFor(logging.DEBUG):
@@ -846,7 +862,7 @@ if custom_logger.isEnabledFor(logging.DEBUG):
 
 - Use buffered handlers (`BufferingHandler`) to accumulate log messages and write them out in batches. This reduces the frequency of I/O operations, which can be a bottleneck in high-throughput scenarios.
 - Employ asynchronous logging handlers (`AsyncHandler`) that offload log writing operations to separate threads or processes. This allows the main application thread to continue executing without waiting for I/O operations to complete.
-**Example**:
+  **Example**:
 
 ```python
 async_handler = logging.handlers.AsyncHandler()
@@ -878,9 +894,9 @@ To cover all the above major components, you can make use of tools like [**SigNo
 **Key architecture features:**
 
 - **Logs, Metrics, and traces under a single dashboard**
-SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
+  SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
 - **Native OpenTelemetry support**
-SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">**OpenTelemetry**</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
+  SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">**OpenTelemetry**</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
 
 ### **Setup SigNoz**
 
@@ -940,40 +956,36 @@ While logging is crucial for debugging and monitoring, it's important to optimiz
 - Use Log Levels Wisely: Reserve DEBUG logs for development. In production, use INFO and above to reduce logging overhead.
 - Lazy Logging: Use lazy evaluation for expensive operations in log messages.
 - Buffered Logging: For high-volume logs, use a buffering handler to reduce I/O operations:
-    
-    ```
-    handler = logging.handlers.MemoryHandler(capacity=1000, flushLevel=logging.ERROR)
-    logger.addHandler(handler)
-    
-    ```
-    
+  ```
+  handler = logging.handlers.MemoryHandler(capacity=1000, flushLevel=logging.ERROR)
+  logger.addHandler(handler)
+
+  ```
 - Asynchronous Logging: Consider using libraries like concurrent-log-handler for non-blocking log writes.
 - Sampling: In very high-volume scenarios, implement log sampling to log only a percentage of events.
-By implementing these optimizations, you can maintain comprehensive logging while minimizing the performance impact on your Python applications.
+  By implementing these optimizations, you can maintain comprehensive logging while minimizing the performance impact on your Python applications.
 
 ## **Troubleshooting Common Logging Issues**
 
 Even with a well-designed logging system, you may encounter issues. Here are some common problems and their solutions:
 
 1. **Circular import problems with loggers**:
-    - Solution: Use `logging.getLogger(__name__)` in each module instead of creating a global logger.
+   - Solution: Use `logging.getLogger(__name__)` in each module instead of creating a global logger.
 2. **Missing log output**:
-    - Check the logging level of both the logger and its handlers.
-    - Ensure that handlers are correctly added to the logger.
+   - Check the logging level of both the logger and its handlers.
+   - Ensure that handlers are correctly added to the logger.
 3. **Incorrect log levels**:
-    - Review your logging configuration and ensure that the desired log levels are set for both loggers and handlers.
+   - Review your logging configuration and ensure that the desired log levels are set for both loggers and handlers.
 4. **Encoding issues in log files**:
-    - Specify the encoding when creating file handlers:
-        
-        ```python
-        handler = logging.FileHandler('app.log', encoding='utf-8')
-        
-        ```
-        
+   - Specify the encoding when creating file handlers:
+     ```python
+     handler = logging.FileHandler('app.log', encoding='utf-8')
+
+     ```
 5. **Performance issues in high-throughput applications**:
-    - Use asynchronous logging handlers.
-    - Implement buffering to reduce I/O operations.
-    - Consider using a [centralized logging system](https://signoz.io/blog/centralized-logging/) to offload logging from your application servers.
+   - Use asynchronous logging handlers.
+   - Implement buffering to reduce I/O operations.
+   - Consider using a [centralized logging system](https://signoz.io/blog/centralized-logging/) to offload logging from your application servers.
 
 By following these best practices and troubleshooting tips, you can create a robust, efficient, and informative logging system for your Python applications.
 
@@ -987,7 +999,14 @@ By following these best practices and troubleshooting tips, you can create a rob
 
 ## Resources
 
-- <a href="https://docs.python.org/3/library/logging.html" rel="noopener noreferrer nofollow" target="_blank">Python Logging Documentation</a>.
+- <a
+    href="https://docs.python.org/3/library/logging.html"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    Python Logging Documentation
+  </a>
+  .
 - [SigNoz Documentation](https://signoz.io/docs/).
 
 ## FAQs
@@ -1109,4 +1128,4 @@ logger.addHandler(handler)
 
 ```
 
-These approaches allow you to include additional contextual information in your log messages.
\ No newline at end of file
+These approaches allow you to include additional contextual information in your log messages.
diff --git a/data/guides/loggly-pricing.mdx b/data/guides/loggly-pricing.mdx
index 12e8854f9..4e3a5f108 100644
--- a/data/guides/loggly-pricing.mdx
+++ b/data/guides/loggly-pricing.mdx
@@ -1,11 +1,18 @@
 ---
 title: Loggly Pricing Guide - Plans, Features, and Costs Explained
-slug: loggly-pricing
 date: 2025-03-11
 tags: [logging, loggly, observability]
 authors: [bhavya_sachdeva]
 description: Explore Loggly's pricing tiers, features, and costs. Learn how to choose the right plan for your log management needs and optimize your spending.
-keywords: [loggly pricing, log management, pricing tiers, cost optimization, enterprise logging, log retention]
+keywords:
+  [
+    loggly pricing,
+    log management,
+    pricing tiers,
+    cost optimization,
+    enterprise logging,
+    log retention,
+  ]
 ---
 
 Managing application logs efficiently requires both technical capability and cost awareness. Loggly, a SolarWinds product, offers cloud-based log management with various pricing tiers to accommodate different organization sizes and needs. This guide examines Loggly's pricing structure in depth, highlighting potential hidden costs, comparison with alternatives like SigNoz, and strategies to optimize your logging expenditure.
@@ -17,6 +24,7 @@ Loggly uses a tiered pricing approach based primarily on daily log ingestion vol
 ### Lite Plan (Free Tier)
 
 **Technical Specifications:**
+
 - **Daily Ingest Volume:** 200 MB/day hard limit
 - **Retention Period:** 7 days only
 - **Data Exceedance Policy:** Logs beyond the daily limit are dropped until the next day
@@ -25,8 +33,8 @@ Loggly uses a tiered pricing approach based primarily on daily log ingestion vol
 The Lite plan serves as an entry point for developers exploring [log centralization](https://signoz.io/blog/centralized-logging/) but has significant limitations:
 
 <KeyPointCallout title="Lite Plan Calculation Example">
-Application with 50 microservices generating 5 MB of logs daily:
-50 services × 5 MB = 250 MB/day (exceeds free tier by 50 MB)
+  Application with 50 microservices generating 5 MB of logs daily: 50 services × 5 MB = 250 MB/day
+  (exceeds free tier by 50 MB)
 </KeyPointCallout>
 
 At this volume, you would lose approximately 20% of your logs each day, making the free tier unsuitable for production environments with multiple services.
@@ -34,6 +42,7 @@ At this volume, you would lose approximately 20% of your logs each day, making t
 ### Standard Plan ($79/month annually)
 
 **Technical Specifications:**
+
 - **Daily Ingest Volume:** 1 GB/day baseline
 - **Retention Period:** 15 days fixed
 - **Data Exceedance Policy:** No overage protection; logs beyond limit are dropped
@@ -42,7 +51,8 @@ At this volume, you would lose approximately 20% of your logs each day, making t
 The Standard tier provides essential features for small production environments:
 
 <KeyPointCallout title="Standard Plan Cost Analysis">
-For a 1.5 GB daily log volume on the Standard plan, you'll lose 0.5 GB/day (33% of logs) due to the 1 GB limit.
+  For a 1.5 GB daily log volume on the Standard plan, you'll lose 0.5 GB/day (33% of logs) due to
+  the 1 GB limit.
 </KeyPointCallout>
 
 For teams generating more than 1 GB daily, this overage behavior is a hidden cost – either in lost data or necessary plan upgrades.
@@ -50,6 +60,7 @@ For teams generating more than 1 GB daily, this overage behavior is a hidden cos
 ### Pro Plan ($159/month annually)
 
 **Technical Specifications:**
+
 - **Daily Ingest Volume:** Custom plans up to 100 GB/day
 - **Retention Period:** 15-30 days (varies by specific plan)
 - **Data Exceedance Policy:** Peak Overage Protection allows bursts up to 2× limit (or +50 GB, whichever is lower) on 3 days monthly
@@ -58,9 +69,9 @@ For teams generating more than 1 GB daily, this overage behavior is a hidden cos
 The Pro tier introduces flexible storage options and operational resilience against log spikes:
 
 <KeyPointCallout title="S3 Archiving Cost-Efficiency Example">
-10 GB/day ingest with 1 year retention requirement: <br />
-- In Loggly-only setup: Enterprise plan required <br />
-- With Pro + S3 archive: ~\$250/month (Loggly) + ~\$30/month (S3 standard)
+  10 GB/day ingest with 1 year retention requirement: <br />
+  - In Loggly-only setup: Enterprise plan required <br />- With Pro + S3 archive: ~\$250/month
+  (Loggly) + ~\$30/month (S3 standard)
 </KeyPointCallout>
 
 This tier represents the sweet spot for most production environments, especially when paired with archiving for long-term storage.
@@ -68,10 +79,11 @@ This tier represents the sweet spot for most production environments, especially
 ### Enterprise Plan (Starting at $279/month annually)
 
 **Technical Specifications:**
+
 - **Daily Ingest Volume:** Customizable to terabyte scale
 - **Retention Period:** Flexible from 15-90 days
 - **Data Exceedance Policy:** Same Peak Overage Protection as Pro, with customizable limits
-- **Enterprise Features:** 
+- **Enterprise Features:**
   - Unlimited custom parsing rules
   - Anomaly detection powered by machine learning
   - Role-based access control
@@ -81,8 +93,8 @@ This tier represents the sweet spot for most production environments, especially
 The Enterprise tier offers technical capabilities critical for large organizations:
 
 <KeyPointCallout title="Enterprise Custom Parsing Example">
-Custom parsing allows extraction of fields from non-standard logs using regular expressions:
-custom_derived_field = /status_code=(\d{3}).*response_time=(\d+)ms/
+  Custom parsing allows extraction of fields from non-standard logs using regular expressions:
+  custom_derived_field = /status_code=(\d{3}).*response_time=(\d+)ms/
 </KeyPointCallout>
 
 For high-compliance industries or organizations with complex log analysis needs, these advanced features justify the premium pricing.
@@ -108,10 +120,10 @@ This policy means no surprise bills, but potentially critical log data might be
 Each plan has a fixed retention period that cannot be extended without upgrading:
 
 <KeyPointCallout title="Retention Cost Comparison">
-Retention cost comparison for 5 GB/day volume: <br />
-30-day retention on Pro: ~\$250/month <br />
-90-day retention on Enterprise: ~\$500/month <br />
-Difference: ~\$250/month (\$3,000/year) for the same log volume
+  Retention cost comparison for 5 GB/day volume: <br />
+  30-day retention on Pro: ~\$250/month <br />
+  90-day retention on Enterprise: ~\$500/month <br />
+  Difference: ~\$250/month (\$3,000/year) for the same log volume
 </KeyPointCallout>
 
 For organizations with long-term retention requirements, archiving to S3 becomes mandatory, adding both storage costs and potential complexity in searching historical logs.
@@ -145,8 +157,8 @@ This architecture choice makes Loggly excellent for searching and exploring logs
 3. Custom parsing rules are limited on lower tiers
 
 <KeyPointCallout title="Indexing Impact">
-1 GB raw logs typically requires 1.5-2.5 GB of index storage <br />
-Plus computational resources for indexing and query processing 
+  1 GB raw logs typically requires 1.5-2.5 GB of index storage <br />
+  Plus computational resources for indexing and query processing
 </KeyPointCallout>
 
 ### Loggly's Native Features vs. Add-ons
@@ -171,11 +183,8 @@ Instead of indiscriminately sending all logs to Loggly, filter at the source:
 // Example: Winston logger configuration to filter debug logs in production
 const logger = winston.createLogger({
   level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
-  transports: [
-    new winston.transports.Console(),
-    new winston.transports.Loggly(logglyConfig)
-  ]
-});
+  transports: [new winston.transports.Console(), new winston.transports.Loggly(logglyConfig)],
+})
 ```
 
 This approach can reduce log volume by 40-70% in typical applications.
@@ -192,6 +201,7 @@ if (isHighVolumeEndpoint && Math.random() < 0.1) { // 10% sampling
 ```
 
 Sampling is particularly effective for:
+
 - Health check endpoints
 - Static asset requests
 - Frequent background jobs
@@ -231,9 +241,9 @@ This strategy can reduce retention costs by 60-80% for organizations with long-t
 Create dashboards and alerts to track log volume across sources:
 
 <KeyPointCallout title="Alert Threshold Calculation">
-Alert threshold calculation for Standard plan: <br />
-Set alert at 80% of daily limit: 800 <br />
-Alert trigger: Hourly rate exceeding 33 MB/hour <br />
+  Alert threshold calculation for Standard plan: <br />
+  Set alert at 80% of daily limit: 800 <br />
+  Alert trigger: Hourly rate exceeding 33 MB/hour <br />
 </KeyPointCallout>
 
 Early detection of volume spikes allows for targeted remediation before hitting caps.
@@ -244,15 +254,15 @@ SigNoz offers a fundamentally different approach to observability, combining log
 
 ### Technical Architecture Comparison
 
-| Feature | Loggly | SigNoz |
-|---------|--------|--------|
-| **Core Technology** | Proprietary stack (likely Elasticsearch-based) | Open source (ClickHouse for storage, Kafka for ingestion) |
-| **Deployment Model** | SaaS only | Self-hosted or SaaS |
-| **Observability Scope** | Logs only | Logs, metrics, and distributed traces |
-| **Data Model** | Document-based | Column-oriented storage |
-| **Query Performance** | Optimized for text search | Optimized for analytics and aggregations |
-| **Storage Efficiency** | Moderate (index overhead) | High (columnar compression) |
-| **Integration Model** | Agent-less with HTTP/syslog endpoints | OpenTelemetry-based instrumentation |
+| Feature                 | Loggly                                         | SigNoz                                                    |
+| ----------------------- | ---------------------------------------------- | --------------------------------------------------------- |
+| **Core Technology**     | Proprietary stack (likely Elasticsearch-based) | Open source (ClickHouse for storage, Kafka for ingestion) |
+| **Deployment Model**    | SaaS only                                      | Self-hosted or SaaS                                       |
+| **Observability Scope** | Logs only                                      | Logs, metrics, and distributed traces                     |
+| **Data Model**          | Document-based                                 | Column-oriented storage                                   |
+| **Query Performance**   | Optimized for text search                      | Optimized for analytics and aggregations                  |
+| **Storage Efficiency**  | Moderate (index overhead)                      | High (columnar compression)                               |
+| **Integration Model**   | Agent-less with HTTP/syslog endpoints          | OpenTelemetry-based instrumentation                       |
 
 This architectural difference translates into significant cost and capability differences.
 
@@ -261,12 +271,14 @@ This architectural difference translates into significant cost and capability di
 SigNoz offers two distinct pricing approaches:
 
 **1. Self-Hosted (Open Source)**
+
 - **Software Cost:** Free (Apache 2.0 license)
 - **Infrastructure Cost:** Varies based on deployment size
 - **Control:** Complete ownership of data and infrastructure
 - **Scalability:** Limited only by your infrastructure investment
 
 **2. SigNoz Cloud**
+
 - **Starting Price:** ~\$49/month.
 - **Pricing Model:** Usage-based at approximately ~\$0.30/GB
 - **Additional Fees:** None for users or hosts
@@ -275,10 +287,10 @@ SigNoz offers two distinct pricing approaches:
 For high-volume scenarios, the cost difference becomes substantial:
 
 <KeyPointCallout title="Cost Comparison">
-Cost comparison for 250 GB/day with 30-day retention: <br />
-Loggly Enterprise: ~\$97,000/year (based on reseller pricing) <br />
-SigNoz Cloud: ~\$27,000/year (\$0.30/GB × 250 GB × 30 days × 12 months) <br />
-SigNoz Self-Hosted: ~\$15,000/year (estimated infrastructure cost) <br />
+  Cost comparison for 250 GB/day with 30-day retention: <br />
+  Loggly Enterprise: ~\$97,000/year (based on reseller pricing) <br />
+  SigNoz Cloud: ~\$27,000/year (\$0.30/GB × 250 GB × 30 days × 12 months) <br />
+  SigNoz Self-Hosted: ~\$15,000/year (estimated infrastructure cost) <br />
 </KeyPointCallout>
 
 The cost advantage of SigNoz increases with volume, making it particularly compelling for data-intensive applications.
@@ -288,11 +300,13 @@ The cost advantage of SigNoz increases with volume, making it particularly compe
 SigNoz's integrated approach offers technical advantages that directly impact troubleshooting efficiency:
 
 **Log Management:**
+
 - Similar search capabilities to Loggly
 - Direct correlation with traces and metrics
 - Support for structured and unstructured logs
 
 **Unique Capabilities:**
+
 - **[Distributed Tracing](https://signoz.io/distributed-tracing/):** Track requests across microservices with flame graphs
 - **Metrics:** Monitor application and infrastructure performance metrics
 - **Root Cause Analysis:** Correlate logs with traces to identify failure points
@@ -300,17 +314,16 @@ SigNoz's integrated approach offers technical advantages that directly impact tr
 This integration provides context that Loggly alone cannot:
 
 <KeyPointCallout title="Example Troubleshooting Workflow">
-1. Alert triggers on high API error rate (metrics)
-2. View distributed trace showing slow database query (tracing)
-3. Examine database logs at the exact timestamp (logs)
-4. Fix identified connection pool configuration issue
+  1. Alert triggers on high API error rate (metrics) 2. View distributed trace showing slow database
+  query (tracing) 3. Examine database logs at the exact timestamp (logs) 4. Fix identified
+  connection pool configuration issue
 </KeyPointCallout>
 
 <div className="overflow-hidden rounded-xl shadow-2xl">
-    <video autoPlay muted loop className="lg:w-[120%]">
+  <video autoPlay muted loop className="lg:w-[120%]">
     <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
     Your browser does not support the video tag.
-    </video>
+  </video>
 </div>
 
 Without this integration, the same investigation might require multiple tools and manual correlation.
@@ -318,12 +331,14 @@ Without this integration, the same investigation might require multiple tools an
 ### When to Choose SigNoz vs. Loggly
 
 **Technical Considerations for Loggly:**
+
 - You need a specialized log management solution with minimal setup
 - Your team prefers a fully managed service without infrastructure concerns
 - Log search and alerting are your primary requirements
 - You have moderate log volumes (under 50 GB/day)
 
 **Technical Considerations for SigNoz:**
+
 - You need comprehensive observability (logs, metrics, and traces)
 - You have technical resources to self-host or prefer usage-based pricing
 - Your applications use or plan to use [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) instrumentation
@@ -395,6 +410,7 @@ Implement a consistent structured logging approach:
 ```
 
 Structured logs are:
+
 - More efficient to store and query
 - Easier to analyze programmatically
 - Better for automated alerting and anomaly detection
@@ -412,7 +428,9 @@ span_id=00f067aa0ba902b7
 This practice allows efficient troubleshooting regardless of platform choice.
 
 <KeyPointCallout title="Technical Decision Framework">
-When evaluating log management solutions, prioritize these factors: daily ingest volumes, required retention periods, analysis capabilities needed, integration with your existing stack, and total cost of ownership over a 3-year period.
+  When evaluating log management solutions, prioritize these factors: daily ingest volumes, required
+  retention periods, analysis capabilities needed, integration with your existing stack, and total
+  cost of ownership over a 3-year period.
 </KeyPointCallout>
 
 ## Getting Started with SigNoz
@@ -428,16 +446,19 @@ If you're considering SigNoz as an alternative to Loggly, you can:
 ## Key Takeaways
 
 1. **Loggly's Pricing Structure**
+
    - Tiered based on daily ingest volume and fixed retention periods
    - No overage charges but strict caps that drop data when exceeded
    - Higher tiers required for advanced features like anomaly detection
 
 2. **Hidden Cost Factors**
+
    - Data loss during volume spikes on lower tiers
    - Limited retention forcing archive strategies
    - Feature-based tier lock-in for essential capabilities
 
 3. **Technical Optimization Strategies**
+
    - Filter logs at source based on environment and severity
    - Implement sampling for high-volume, low-value logs
    - Use [structured logging](https://signoz.io/blog/structured-logs/) with context IDs
@@ -451,21 +472,21 @@ If you're considering SigNoz as an alternative to Loggly, you can:
 ## FAQs
 
 ### What happens when I exceed my daily log volume in Loggly?
-   
-   On Standard tier and below, logs beyond your daily limit are dropped until the next day. Pro and Enterprise plans include Peak Overage Protection that allows up to 2× your limit for 3 days per month, after which excess logs are dropped.
+
+On Standard tier and below, logs beyond your daily limit are dropped until the next day. Pro and Enterprise plans include Peak Overage Protection that allows up to 2× your limit for 3 days per month, after which excess logs are dropped.
 
 ### Can I extend retention beyond my plan's limits in Loggly?
-   
-   You cannot extend retention within Loggly's platform without upgrading tiers. However, Pro and Enterprise plans offer S3 archiving for long-term storage, which provides a cost-effective alternative for retention compliance.
+
+You cannot extend retention within Loggly's platform without upgrading tiers. However, Pro and Enterprise plans offer S3 archiving for long-term storage, which provides a cost-effective alternative for retention compliance.
 
 ### How does Loggly's pricing compare to Splunk for large enterprises?
-   
-   Loggly is typically more cost-effective than Splunk, especially at moderate volumes. For example, 10 GB/day might cost around $5,000/year with Loggly but $15,000+ with Splunk. However, Splunk offers more advanced analytics capabilities that may justify the premium for some use cases.
+
+Loggly is typically more cost-effective than Splunk, especially at moderate volumes. For example, 10 GB/day might cost around $5,000/year with Loggly but $15,000+ with Splunk. However, Splunk offers more advanced analytics capabilities that may justify the premium for some use cases.
 
 ### Is SigNoz a direct replacement for Loggly?
-   
-   SigNoz is more than a replacement—it's an expansion. It provides log management similar to Loggly but adds distributed tracing and metrics monitoring in the same platform. For teams using Loggly solely for logs, SigNoz represents an opportunity to unify observability while potentially reducing costs, especially at higher volumes.
+
+SigNoz is more than a replacement—it's an expansion. It provides log management similar to Loggly but adds distributed tracing and metrics monitoring in the same platform. For teams using Loggly solely for logs, SigNoz represents an opportunity to unify observability while potentially reducing costs, especially at higher volumes.
 
 ### What's the most cost-effective approach for regulated industries with multi-year retention requirements?
-   
-   For long-term compliance needs, the most cost-effective approach is typically a tiered strategy: use a log management platform like Loggly or SigNoz for recent logs (15-30 days), archive to S3 Standard for medium-term retention (30-90 days), and move to S3 Glacier or similar cold storage for multi-year retention. This approach can reduce costs by 70-90% compared to keeping all logs in a primary observability platform. 
\ No newline at end of file
+
+For long-term compliance needs, the most cost-effective approach is typically a tiered strategy: use a log management platform like Loggly or SigNoz for recent logs (15-30 days), archive to S3 Standard for medium-term retention (30-90 days), and move to S3 Glacier or similar cold storage for multi-year retention. This approach can reduce costs by 70-90% compared to keeping all logs in a primary observability platform.
diff --git a/data/guides/logrotate-linux.mdx b/data/guides/logrotate-linux.mdx
index 3936a9913..e8061c66b 100644
--- a/data/guides/logrotate-linux.mdx
+++ b/data/guides/logrotate-linux.mdx
@@ -1,6 +1,5 @@
 ---
 title: How to Setup and Manage Log Rotation Using logrotate in Linux
-slug: logrotate-linux
 date: 2024-07-11
 tags: [logging]
 authors: [simran_kumari]
@@ -9,148 +8,153 @@ keywords: [logs, logrotate, logrotate linux]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "How to Setup and Manage Log Rotation Using logrotate in Linux",
-  "alternativeHeadline": "A comprehensive guide to configuring and managing log rotation in Linux systems",
-  "image": "https://signoz.io/img/blog/2024/07/logrotate-linux-cover.webp",
-  "author": {
-    "@type": "Person",
-    "name": "Simran Kumari"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-11T00:00:00Z",
-  "dateModified": "2024-07-11T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/logrotate-linux/"
-  },
-  "description": "Learn to manage log rotation in Linux with logrotate, configuring schedules, compression, and actions in /etc/logrotate.d/ for efficient log management.",
-  "keywords": "logs, logrotate, logrotate linux",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Logrotate",
-      "description": "A utility for managing log files in Linux systems"
-    },
-    {
-      "@type": "Thing",
-      "name": "Log Management",
-      "description": "The process of handling log files to maintain system performance and security"
-    },
-    {
-      "@type": "Thing",
-      "name": "Linux",
-      "description": "An open-source operating system kernel"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Monitoring Software"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What is logrotate in Linux?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "logrotate in Linux is a vital utility used to manage log files by automating the processes of rotation, compression, and deletion. It helps prevent log files from growing too large, thereby optimizing disk space and system performance."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I run logrotate command?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To run the logrotate command manually in Linux, use the following syntax: logrotate -vf /etc/logrotate.conf. Replace /etc/logrotate.conf with the path to the specific logrotate configuration file you want to execute."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Does logrotate run automatically?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, logrotate is typically configured to run automatically through cron jobs. These jobs trigger log rotation based on predefined schedules specified in the logrotate configuration files."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Why do we need logrotate?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "logrotate is essential in Linux to manage log files efficiently. It prevents log files from filling up disk space, ensures logs are organized and archived, and helps maintain system performance by managing log size."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the purpose of log rotation?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "The primary purpose of log rotation is to manage log files systematically. It involves rotating logs periodically, compressing older logs to save disk space, and deleting outdated logs. This process ensures that logs remain manageable and accessible for system administrators."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Setup and Use Logrotate in Linux",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install Logrotate",
-        "text": "Install logrotate using your distribution's package manager (e.g., apt for Ubuntu, yum for CentOS)."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Logrotate",
-        "text": "Edit the global configuration file (/etc/logrotate.conf) or create specific configurations in /etc/logrotate.d/."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Define Log Rotation Rules",
-        "text": "Specify log files to rotate, rotation frequency, compression options, and other parameters in the configuration files."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Test Configuration",
-        "text": "Use 'logrotate -d' to test your configuration without actually rotating logs."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Run Logrotate",
-        "text": "Execute logrotate manually or set up a cron job for automated execution."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Monitor Log Rotation",
-        "text": "Use tools like SigNoz to monitor log rotation activities and set up alerts for any issues."
-      }
-    ]
-  }
-}) }}
-  /> 
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'How to Setup and Manage Log Rotation Using logrotate in Linux',
+        alternativeHeadline:
+          'A comprehensive guide to configuring and managing log rotation in Linux systems',
+        image: 'https://signoz.io/img/blog/2024/07/logrotate-linux-cover.webp',
+        author: {
+          '@type': 'Person',
+          name: 'Simran Kumari',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-11T00:00:00Z',
+        dateModified: '2024-07-11T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/logrotate-linux/',
+        },
+        description:
+          'Learn to manage log rotation in Linux with logrotate, configuring schedules, compression, and actions in /etc/logrotate.d/ for efficient log management.',
+        keywords: 'logs, logrotate, logrotate linux',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Logrotate',
+            description: 'A utility for managing log files in Linux systems',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log Management',
+            description:
+              'The process of handling log files to maintain system performance and security',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Linux',
+            description: 'An open-source operating system kernel',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Monitoring Software',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is logrotate in Linux?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'logrotate in Linux is a vital utility used to manage log files by automating the processes of rotation, compression, and deletion. It helps prevent log files from growing too large, thereby optimizing disk space and system performance.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I run logrotate command?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To run the logrotate command manually in Linux, use the following syntax: logrotate -vf /etc/logrotate.conf. Replace /etc/logrotate.conf with the path to the specific logrotate configuration file you want to execute.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Does logrotate run automatically?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, logrotate is typically configured to run automatically through cron jobs. These jobs trigger log rotation based on predefined schedules specified in the logrotate configuration files.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Why do we need logrotate?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'logrotate is essential in Linux to manage log files efficiently. It prevents log files from filling up disk space, ensures logs are organized and archived, and helps maintain system performance by managing log size.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the purpose of log rotation?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The primary purpose of log rotation is to manage log files systematically. It involves rotating logs periodically, compressing older logs to save disk space, and deleting outdated logs. This process ensures that logs remain manageable and accessible for system administrators.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Setup and Use Logrotate in Linux',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Logrotate',
+              text: "Install logrotate using your distribution's package manager (e.g., apt for Ubuntu, yum for CentOS).",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Logrotate',
+              text: 'Edit the global configuration file (/etc/logrotate.conf) or create specific configurations in /etc/logrotate.d/.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Define Log Rotation Rules',
+              text: 'Specify log files to rotate, rotation frequency, compression options, and other parameters in the configuration files.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Test Configuration',
+              text: "Use 'logrotate -d' to test your configuration without actually rotating logs.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Run Logrotate',
+              text: 'Execute logrotate manually or set up a cron job for automated execution.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Monitor Log Rotation',
+              text: 'Use tools like SigNoz to monitor log rotation activities and set up alerts for any issues.',
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
 Effective log management in Linux is crucial for maintaining system health, performance, and security. Logs are invaluable records of system events, application behavior, and security incidents. However, these logs can quickly grow out of control without proper management, consuming valuable disk space and leading to potential system issues. This is where log rotation comes into play. Regularly rotating logs ensures they are archived systematically, preventing disk space exhaustion and enhancing overall system performance.
@@ -579,7 +583,10 @@ use version 0.116.0, which is the latest at the time of writing. To verify and d
 current version, visit the <a
   href="https://github.com/open-telemetry/opentelemetry-collector-releases"
   rel="noopener noreferrer nofollow"
-  target="_blank">OpenTelemetry Collector Releases</a> page.
+  target="_blank"
+>
+  OpenTelemetry Collector Releases
+</a> page.
 
 - Create the OpenTelemetry configuration file, `config.yaml` in the folder otelcol-contrib with the below content in it.
 
diff --git a/data/guides/loguru.mdx b/data/guides/loguru.mdx
index 4cf75d663..494ed2b40 100644
--- a/data/guides/loguru.mdx
+++ b/data/guides/loguru.mdx
@@ -1,6 +1,5 @@
 ---
 title: Loguru Python - Complete Guide to Logging
-slug: loguru
 date: 2024-07-09
 tags: [logging]
 authors: [soumya_gupta]
@@ -9,146 +8,150 @@ keywords: [loguru, python, loguru python, loguru vs logging, logging in python,
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Loguru Python - Complete Guide to Logging",
-  "alternativeHeadline": "Comprehensive Guide on Using Loguru for Efficient Logging in Python",
-  "author": {
-    "@type": "Person",
-    "name": "Soumya Gupta"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-09T00:00:00Z",
-  "dateModified": "2024-07-09T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/loguru/"
-  },
-  "description": "This tutorial provides comprehensive guidance on using Loguru for logging in Python. It covers the necessity and benefits of Loguru, fundamental usage, practical techniques, and a detailed, step-by-step guide on sending Loguru logs to Signoz.",
-  "keywords": "loguru, python, loguru python, loguru vs logging, logging in python, logs, SigNoz",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Loguru",
-      "description": "A Python logging library that aims to bring enjoyable logging in Python"
-    },
-    {
-      "@type": "Thing",
-      "name": "Logging",
-      "description": "The process of recording messages from software applications"
-    },
-    {
-      "@type": "Thing",
-      "name": "SigNoz",
-      "description": "An open-source observability platform for monitoring applications"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Python",
-      "applicationCategory": "ProgrammingLanguage"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What does Loguru do?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Loguru is a logging library for Python that offers a simple yet powerful interface for logging. It provides features such as structured logging, automatic pretty formatting, and asynchronous logging capabilities. Loguru aims to simplify and streamline logging for Python developers."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the process of logging?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Logging involves recording information from a software application during its execution. This process includes steps like creating a logger instance (Initialization), defining severity levels (Log Levels), outputting messages with relevant information (Log Messages), directing log output to specified destinations such as files, consoles etc. (Handlers) and customizing the format of log messages for readability and analysis (Formatting)."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Is the Loguru Python thread safe?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes! Loguru is designed to handle logging operations safely across multiple threads. So, whether your application is running with a handful of threads or a complex multi-threaded setup, you can trust that Loguru will manage your logs without worrying about data conflicts."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the function of a sink in Loguru?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "In Loguru, sinks are the destinations where your log messages are directed, such as files, consoles, or databases. They function as the behind-the-scenes organizers that ensure your logs reach their intended locations, enabling you to track and troubleshoot the events occurring within your application efficiently."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What does 'logger' mean?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "A logger is your trusty tool for logging messages. It's the go-to interface that lets you record what's happening in your code. With a logger, you can capture errors, track events, and keep an eye on the performance of your application."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Use Loguru for Logging in Python",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install Loguru",
-        "text": "Install Loguru using pip: pip install loguru"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Import Loguru",
-        "text": "Import the logger from Loguru: from loguru import logger"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Basic Logging",
-        "text": "Use logger methods to log messages at different levels: logger.debug('Debug message'), logger.info('Info message'), etc."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Logging",
-        "text": "Use logger.add() to configure logging destinations and formats"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Advanced Features",
-        "text": "Explore advanced features like structured logging, exception catching, and custom log levels"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Integrate with SigNoz",
-        "text": "Set up SigNoz and configure Loguru to send logs to SigNoz for centralized monitoring"
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Loguru Python - Complete Guide to Logging',
+        alternativeHeadline: 'Comprehensive Guide on Using Loguru for Efficient Logging in Python',
+        author: {
+          '@type': 'Person',
+          name: 'Soumya Gupta',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-09T00:00:00Z',
+        dateModified: '2024-07-09T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/loguru/',
+        },
+        description:
+          'This tutorial provides comprehensive guidance on using Loguru for logging in Python. It covers the necessity and benefits of Loguru, fundamental usage, practical techniques, and a detailed, step-by-step guide on sending Loguru logs to Signoz.',
+        keywords:
+          'loguru, python, loguru python, loguru vs logging, logging in python, logs, SigNoz',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Loguru',
+            description: 'A Python logging library that aims to bring enjoyable logging in Python',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logging',
+            description: 'The process of recording messages from software applications',
+          },
+          {
+            '@type': 'Thing',
+            name: 'SigNoz',
+            description: 'An open-source observability platform for monitoring applications',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Python',
+            applicationCategory: 'ProgrammingLanguage',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What does Loguru do?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Loguru is a logging library for Python that offers a simple yet powerful interface for logging. It provides features such as structured logging, automatic pretty formatting, and asynchronous logging capabilities. Loguru aims to simplify and streamline logging for Python developers.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the process of logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Logging involves recording information from a software application during its execution. This process includes steps like creating a logger instance (Initialization), defining severity levels (Log Levels), outputting messages with relevant information (Log Messages), directing log output to specified destinations such as files, consoles etc. (Handlers) and customizing the format of log messages for readability and analysis (Formatting).',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is the Loguru Python thread safe?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes! Loguru is designed to handle logging operations safely across multiple threads. So, whether your application is running with a handful of threads or a complex multi-threaded setup, you can trust that Loguru will manage your logs without worrying about data conflicts.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the function of a sink in Loguru?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'In Loguru, sinks are the destinations where your log messages are directed, such as files, consoles, or databases. They function as the behind-the-scenes organizers that ensure your logs reach their intended locations, enabling you to track and troubleshoot the events occurring within your application efficiently.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What does 'logger' mean?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "A logger is your trusty tool for logging messages. It's the go-to interface that lets you record what's happening in your code. With a logger, you can capture errors, track events, and keep an eye on the performance of your application.",
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Loguru for Logging in Python',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Loguru',
+              text: 'Install Loguru using pip: pip install loguru',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Import Loguru',
+              text: 'Import the logger from Loguru: from loguru import logger',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Basic Logging',
+              text: "Use logger methods to log messages at different levels: logger.debug('Debug message'), logger.info('Info message'), etc.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Logging',
+              text: 'Use logger.add() to configure logging destinations and formats',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Advanced Features',
+              text: 'Explore advanced features like structured logging, exception catching, and custom log levels',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with SigNoz',
+              text: 'Set up SigNoz and configure Loguru to send logs to SigNoz for centralized monitoring',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
diff --git a/data/guides/loki-json-logs-filter-by-detected-fields-from-grafana.mdx b/data/guides/loki-json-logs-filter-by-detected-fields-from-grafana.mdx
index c9b1fe305..98623bbb4 100644
--- a/data/guides/loki-json-logs-filter-by-detected-fields-from-grafana.mdx
+++ b/data/guides/loki-json-logs-filter-by-detected-fields-from-grafana.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How to Filter Loki JSON Logs in Grafana - A Step-by-Step Guide
-slug: loki-json-logs-filter-by-detected-fields-from-grafana
 date: 2024-10-03
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Learn how to filter Loki JSON logs using detected fields in Grafana. This comprehensive guide covers everything from basics to advanced techniques.
 keywords: [Loki, Grafana, JSON logs, log filtering, LogQL, log analysis, observability, SigNoz]
-
 ---
 
 As logs become more complex, especially with the rise of microservices and distributed systems, managing and analyzing them efficiently is critical. Loki and Grafana provide an effective log management and visualization solution, and when combined with JSON logs, they offer a powerful way to search, filter, and analyze log data. This guide will walk you through filtering Loki JSON logs in Grafana, from the basics to more advanced techniques.
@@ -39,7 +36,7 @@ Here's an example of a [JSON log](https://signoz.io/blog/json-logs/) entry that
   },
   "transaction": {
     "id": "txn_456789",
-    "amount": 100.50,
+    "amount": 100.5,
     "currency": "USD"
   },
   "http": {
@@ -60,7 +57,11 @@ The combination of Loki's efficient log storage and Grafana's powerful querying
 - Set up alerts based on log patterns or thresholds
 - Perform real-time log analysis
 
-<Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image.webp" alt="Grafana-Loki log analysis" caption="Grafana-Loki log analysis" />
+<Figure
+  src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image.webp"
+  alt="Grafana-Loki log analysis"
+  caption="Grafana-Loki log analysis"
+/>
 
 ## How Grafana Detects Fields in JSON Logs
 
@@ -71,7 +72,11 @@ Grafana automatically detects fields in JSON-formatted logs, simplifying the pro
 3. Data type inference: Grafana attempts to determine the data type of each field (e.g., string, number, boolean).
 4. Field mapping: Detected fields are mapped to queryable attributes in Grafana's interface.
 
-<Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%201.webp" alt="How Grafana Detects Fields in JSON Logs" caption="How Grafana Detects Fields in JSON Logs" />
+<Figure
+  src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%201.webp"
+  alt="How Grafana Detects Fields in JSON Logs"
+  caption="How Grafana Detects Fields in JSON Logs"
+/>
 
 Common types of fields detected in JSON logs include:
 
@@ -95,119 +100,148 @@ To begin filtering logs, you need to access the Explore section in Grafana. This
 
 1. In Grafana’s left-hand menu, click on Explore.
 2. Select Loki as your data source from the dropdown menu.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%202.webp" alt="Select Loki as your data source" caption="Select Loki as your data source" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%202.webp"
+     alt="Select Loki as your data source"
+     caption="Select Loki as your data source"
+   />
+
 3. Enter your basic query to retrieve logs (for example, `{job="your-job-name"}`).
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%203.webp" alt="Retrieve logs" caption="Retrieve logs" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%203.webp"
+     alt="Retrieve logs"
+     caption="Retrieve logs"
+   />
 
 ### Using LogQL for Advanced Filtering
 
 Once you’ve retrieved your logs, you can start using LogQL to filter specific fields from JSON logs.
 
 1. Extract JSON fields
-    
-    LogQL includes powerful filtering capabilities for JSON logs. A key operator for parsing JSON fields is the `| json` operator, which allows you to extract and filter fields from JSON logs.
-    
-    Example:
-    
-    ```arduino
-    {job="python-server"} | json
-    ```
-    
-    This command extracts all JSON fields from the logs for the selected job.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%204.webp" alt="Extract JSON fields using LogQL" caption="Extract JSON fields using LogQL" />
-    
+
+   LogQL includes powerful filtering capabilities for JSON logs. A key operator for parsing JSON fields is the `| json` operator, which allows you to extract and filter fields from JSON logs.
+
+   Example:
+
+   ```arduino
+   {job="python-server"} | json
+   ```
+
+   This command extracts all JSON fields from the logs for the selected job.
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%204.webp"
+     alt="Extract JSON fields using LogQL"
+     caption="Extract JSON fields using LogQL"
+   />
+
 2. Extracting Specific Fields
-    
-    To filter a specific field, you can modify the query as follows:
-    
-    ```arduino
-    {job="python-server"} | json | level="error"
-    ```
-    
-    In this example, the query filters logs with the `job="python-server"` label and extracts logs where the `level` field is set to `"error"`.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%205.webp" alt="Extract Specific Fields using LogQL" caption="Extract Specific Fields using LogQL" />
-    
+
+   To filter a specific field, you can modify the query as follows:
+
+   ```arduino
+   {job="python-server"} | json | level="error"
+   ```
+
+   In this example, the query filters logs with the `job="python-server"` label and extracts logs where the `level` field is set to `"error"`.
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%205.webp"
+     alt="Extract Specific Fields using LogQL"
+     caption="Extract Specific Fields using LogQL"
+   />
+
 3. Combining Multiple Filters
-    
-    For more advanced use cases, you can combine multiple filters to narrow down your results:
-    
-    ```sql
-    {job="python-server"} | json | level="error" | method="POST"
-    ```
-    
-    This query filters for logs where the `level` is `"error"` and the HTTP method is `POST`.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%206.webp" alt="Combining Multiple Filters on JSON fields" caption="Combining Multiple Filters on JSON fields" />
-    
+
+   For more advanced use cases, you can combine multiple filters to narrow down your results:
+
+   ```sql
+   {job="python-server"} | json | level="error" | method="POST"
+   ```
+
+   This query filters for logs where the `level` is `"error"` and the HTTP method is `POST`.
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%206.webp"
+     alt="Combining Multiple Filters on JSON fields"
+     caption="Combining Multiple Filters on JSON fields"
+   />
 
 ## Advanced Techniques for JSON Log Filtering
 
 Once you've mastered basic filtering techniques, you can explore more advanced methods to refine your log queries and work with complex structures.
 
 1. Using Regular Expressions for Flexible Field Matching
-    
-    Sometimes you may need to filter logs based on patterns in a specific field rather than exact values. In such cases, you can use regular expressions (regex) in LogQL to match fields dynamically.
-    
-    For example, to filter logs where the `message` field contains any log related to `Home` page, you can use the following query:
-    
-    ```arduino
-    {job="python-server"} | json | message =~ "Home.*"
-    ```
-    
-    The `=~` operator matches logs where the `message` field follows the given regex pattern, making it a flexible tool for complex log analysis.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%207.webp" alt="Using Regular Expressions for Flexible Field Matching" caption="Using Regular Expressions for Flexible Field Matching" /> 
-    
+
+   Sometimes you may need to filter logs based on patterns in a specific field rather than exact values. In such cases, you can use regular expressions (regex) in LogQL to match fields dynamically.
+
+   For example, to filter logs where the `message` field contains any log related to `Home` page, you can use the following query:
+
+   ```arduino
+   {job="python-server"} | json | message =~ "Home.*"
+   ```
+
+   The `=~` operator matches logs where the `message` field follows the given regex pattern, making it a flexible tool for complex log analysis.
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%207.webp"
+     alt="Using Regular Expressions for Flexible Field Matching"
+     caption="Using Regular Expressions for Flexible Field Matching"
+   />{' '}
+
 2. Implementing Dynamic Field Filtering with Variables
-    
-    Grafana provides the ability to define variables in dashboards, which can be used dynamically in log queries. This enables you to change the filtering criteria based on user input without modifying the query manually each time.
-    
-    Check the documentation <a href="https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/" rel="noopener noreferrer nofollow" target="_blank">here</a> to create variables in the Grafana Dashboard
-    
-    For example, you could create a variable to dynamically filter logs by the `method` field (e.g., `GET`, `POST`). After creating the variable in your dashboard, you can reference it in your LogQL query like this:
-    
-    ```bash
-    {job="python-server"} | json | method="$httpMethod"
-    ```
-    
-    Here, `$httpMethod` is the variable representing the selected HTTP method, allowing users to filter logs interactively via dropdowns or other UI controls.
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%208.webp" alt="Implementing Dynamic Field Filtering with Variables" caption="Implementing Dynamic Field Filtering with Variables" />
-    
+
+   Grafana provides the ability to define variables in dashboards, which can be used dynamically in log queries. This enables you to change the filtering criteria based on user input without modifying the query manually each time.
+
+   Check the documentation <a href="https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/" rel="noopener noreferrer nofollow" target="_blank">here</a> to create variables in the Grafana Dashboard
+
+   For example, you could create a variable to dynamically filter logs by the `method` field (e.g., `GET`, `POST`). After creating the variable in your dashboard, you can reference it in your LogQL query like this:
+
+   ```bash
+   {job="python-server"} | json | method="$httpMethod"
+   ```
+
+   Here, `$httpMethod` is the variable representing the selected HTTP method, allowing users to filter logs interactively via dropdowns or other UI controls.
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%208.webp"
+     alt="Implementing Dynamic Field Filtering with Variables"
+     caption="Implementing Dynamic Field Filtering with Variables"
+   />
+
 3. Leveraging Derived Fields for Enhanced Filtering
-    
-    Derived fields allow you to enrich your log data by adding new fields based on the content of existing log messages. You can define custom parsing rules in Grafana to extract additional fields from your logs.
-    
-    For example, you can extract specific fields directly from your JSON logs with a simple query like this:
-    
-    ```json
-    {job="python-server"}
-    | json
-    | line_format "{{ .asctime }} | {{ .levelname }} | {{ .method }} | {{ .message }}"
-    ```
-    
-    Output Explanation:
-    
-    - `{{ .asctime }}`: Displays the timestamp of the log entry.
-    - `{{ .levelname }}`: Displays the log level (INFO, WARNING, etc.).
-    - `{{ .method }}`: Displays the HTTP method (GET, POST, etc.).
-    
-    Example Log Output:
-    
-    If you run the above query, you should see an output that looks something like this:
-    
-    ```sql
-    2024-09-25 20:37:44,275 | INFO | GET | Home page accessed .... 
-    ```
-    
-    <Figure src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%209.webp" alt="Leveraging Derived Fields for Enhanced Filtering" caption="Leveraging Derived Fields for Enhanced Filtering" />
-    
+
+   Derived fields allow you to enrich your log data by adding new fields based on the content of existing log messages. You can define custom parsing rules in Grafana to extract additional fields from your logs.
+
+   For example, you can extract specific fields directly from your JSON logs with a simple query like this:
+
+   ```json
+   {job="python-server"}
+   | json
+   | line_format "{{ .asctime }} | {{ .levelname }} | {{ .method }} | {{ .message }}"
+   ```
+
+   Output Explanation:
+
+   - `{{ .asctime }}`: Displays the timestamp of the log entry.
+   - `{{ .levelname }}`: Displays the log level (INFO, WARNING, etc.).
+   - `{{ .method }}`: Displays the HTTP method (GET, POST, etc.).
+
+   Example Log Output:
+
+   If you run the above query, you should see an output that looks something like this:
+
+   ```sql
+   2024-09-25 20:37:44,275 | INFO | GET | Home page accessed ....
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/loki-json-logs-filter-by-detected-fields-from-grafana-image%209.webp"
+     alt="Leveraging Derived Fields for Enhanced Filtering"
+     caption="Leveraging Derived Fields for Enhanced Filtering"
+   />
 
 ## Best Practices for Efficient JSON Log Filtering in Grafana
 
@@ -224,17 +258,17 @@ When working with JSON logs in Loki and Grafana, you may encounter these common
 
 1. Inconsistent JSON structures: Ensure all logs follow a consistent JSON format.
 2. Nested JSON objects: Use dot notation to access nested fields:
-    
-    ```arduino
-    {app="myapp"} | json | error.code == 500
-    ```
-    
+
+   ```arduino
+   {app="myapp"} | json | error.code == 500
+   ```
+
 3. Field detection issues: Verify JSON validity and use explicit parsing when needed:
-    
-    ```arduino
-    {app="myapp"} | json field="message"
-    ```
-    
+
+   ```arduino
+   {app="myapp"} | json field="message"
+   ```
+
 4. Slow query performance: Optimize queries by using appropriate label filters and time ranges.
 
 ## Enhancing Log Analysis with SigNoz
@@ -288,4 +322,4 @@ To improve performance:
 1. Use appropriate label filters to narrow down log streams
 2. Limit time ranges in your queries
 3. Avoid parsing large log volumes without necessary filters
-4. Use indexing and caching strategies in Loki configuration
\ No newline at end of file
+4. Use indexing and caching strategies in Loki configuration
diff --git a/data/guides/managed-prometheus.mdx b/data/guides/managed-prometheus.mdx
index bd58ea680..85b92253e 100644
--- a/data/guides/managed-prometheus.mdx
+++ b/data/guides/managed-prometheus.mdx
@@ -1,16 +1,21 @@
 ---
-
 title: Managed Prometheus - Simplifying Cloud-Native Monitoring
-slug: managed-prometheus
 date: 2024-10-14
 tags: [prometheus]
 authors: [nitin_gouda]
 description: Discover how Managed Prometheus simplifies cloud-native monitoring, its key features, top offerings, and implementation best practices for optimal observability.
-keywords: [managed prometheus, cloud-native monitoring, observability, prometheus, cloud monitoring, kubernetes monitoring]
-
+keywords:
+  [
+    managed prometheus,
+    cloud-native monitoring,
+    observability,
+    prometheus,
+    cloud monitoring,
+    kubernetes monitoring,
+  ]
 ---
 
-Cloud-native applications have revolutionized business operations, but they've also introduced new challenges in monitoring and observability. Traditional monitoring tools often struggle to keep pace with the dynamic nature of containerized and microservices architectures. 
+Cloud-native applications have revolutionized business operations, but they've also introduced new challenges in monitoring and observability. Traditional monitoring tools often struggle to keep pace with the dynamic nature of containerized and microservices architectures.
 
 Managed Prometheus, a cloud-based solution, provides a streamlined approach to monitoring these complex environments. By handling the technical complexities, Managed Prometheus lets you focus on understanding your systems and ensuring optimal performance.
 
@@ -25,31 +30,34 @@ Managed Prometheus is a cloud-based service designed to simplify monitoring for
 Some of the differences between using self-hosted Prometheus and managed services include:
 
 1. Infrastructure management
-    
-    With self-hosted Prometheus, you're responsible for managing the entire infrastructure—provisioning servers, configuring storage, ensuring network connectivity, and handling system updates. This requires significant time, resources, and expertise, especially as your system grows.
-    
-    Managed Prometheus, on the other hand, offloads these responsibilities to the cloud provider. The service automatically provisions resources, scales with demand, and keeps systems up to date. This reduces the operational overhead and allows your team to focus on improving application performance and tackling business-critical tasks instead of managing infrastructure.
-    
+
+   With self-hosted Prometheus, you're responsible for managing the entire infrastructure—provisioning servers, configuring storage, ensuring network connectivity, and handling system updates. This requires significant time, resources, and expertise, especially as your system grows.
+
+   Managed Prometheus, on the other hand, offloads these responsibilities to the cloud provider. The service automatically provisions resources, scales with demand, and keeps systems up to date. This reduces the operational overhead and allows your team to focus on improving application performance and tackling business-critical tasks instead of managing infrastructure.
+
 2. High availability
-    
-    In a self-hosted setup, ensuring high availability involves configuring complex redundancy, replication, and failover mechanisms. You need to manage multiple Prometheus instances and load balancers to avoid downtime, which adds to the complexity.
-    
-    Managed Prometheus simplifies this by providing built-in redundancy and failover capabilities. These features ensure uninterrupted monitoring even in the face of infrastructure failures, allowing your system to stay operational with minimal intervention.
-    
-    <Figure src="/img/guides/2024/10/managed-prometheus-HA.webp" alt="High Availability Setup" caption="High Availability Setup" />
-    
+
+   In a self-hosted setup, ensuring high availability involves configuring complex redundancy, replication, and failover mechanisms. You need to manage multiple Prometheus instances and load balancers to avoid downtime, which adds to the complexity.
+
+   Managed Prometheus simplifies this by providing built-in redundancy and failover capabilities. These features ensure uninterrupted monitoring even in the face of infrastructure failures, allowing your system to stay operational with minimal intervention.
+
+   <Figure
+     src="/img/guides/2024/10/managed-prometheus-HA.webp"
+     alt="High Availability Setup"
+     caption="High Availability Setup"
+   />
+
 3. Long-term storage
-    
-    Prometheus, by default, has limited data retention. To store metrics long-term, you need to set up and manage external storage systems, adding complexity and operational burden.
-    
-    Managed Prometheus typically includes long-term storage as part of the service. It handles data retention automatically, allowing you to analyze historical trends, such as performance and resource usage, without worrying about managing or losing older metrics.
-    
+
+   Prometheus, by default, has limited data retention. To store metrics long-term, you need to set up and manage external storage systems, adding complexity and operational burden.
+
+   Managed Prometheus typically includes long-term storage as part of the service. It handles data retention automatically, allowing you to analyze historical trends, such as performance and resource usage, without worrying about managing or losing older metrics.
+
 4. Integration
-    
-    Self-hosted Prometheus often requires custom configurations and extra effort to integrate with other services like logging, alerting, or visualization tools. Building a complete monitoring solution requires manual setup for each integration.
-    
-    Managed Prometheus simplifies this process by offering native integration with cloud ecosystems like AWS, Google Cloud, and Microsoft Azure, as well as with tools like Grafana for visualization and Alertmanager for notifications. This out-of-the-box compatibility streamlines your monitoring stack, allowing you to easily build a fully integrated observability system.
-    
+
+   Self-hosted Prometheus often requires custom configurations and extra effort to integrate with other services like logging, alerting, or visualization tools. Building a complete monitoring solution requires manual setup for each integration.
+
+   Managed Prometheus simplifies this process by offering native integration with cloud ecosystems like AWS, Google Cloud, and Microsoft Azure, as well as with tools like Grafana for visualization and Alertmanager for notifications. This out-of-the-box compatibility streamlines your monitoring stack, allowing you to easily build a fully integrated observability system.
 
 ### Benefits of using a Managed Service for Prometheus
 
@@ -63,13 +71,13 @@ Some of the differences between using self-hosted Prometheus and managed service
 Traditional monitoring tools were designed for stable, monolithic applications running on dedicated servers. However, with the rise of cloud-native architectures—comprising microservices, containers, and serverless functions—monitoring has become more complex. These environments are dynamic and distributed, introducing several key challenges:
 
 1. Ephemeral resources
-In cloud-native environments, resources like containers and serverless functions are ephemeral, meaning they can be created and destroyed rapidly. This makes traditional monitoring approaches, which expect long-running services, less effective, as the monitoring system must quickly adapt to the changing environment.
+   In cloud-native environments, resources like containers and serverless functions are ephemeral, meaning they can be created and destroyed rapidly. This makes traditional monitoring approaches, which expect long-running services, less effective, as the monitoring system must quickly adapt to the changing environment.
 2. Service discovery
-Cloud-native applications often consist of many microservices that are deployed, scaled, and updated independently. As services come and go, it becomes a challenge to discover and track all these services in real-time. Effective monitoring requires a system that can automatically detect these services as they are created, modified, or removed.
+   Cloud-native applications often consist of many microservices that are deployed, scaled, and updated independently. As services come and go, it becomes a challenge to discover and track all these services in real-time. Effective monitoring requires a system that can automatically detect these services as they are created, modified, or removed.
 3. [High cardinality](https://signoz.io/blog/high-cardinality-data/)
-Microservices architecture generates a large number of unique metrics, a phenomenon known as high cardinality. Each container, service, or function may produce multiple metrics, leading to an explosion in the amount of data being collected. Traditional monitoring tools can struggle to handle this volume efficiently, especially at scale.
+   Microservices architecture generates a large number of unique metrics, a phenomenon known as high cardinality. Each container, service, or function may produce multiple metrics, leading to an explosion in the amount of data being collected. Traditional monitoring tools can struggle to handle this volume efficiently, especially at scale.
 4. Resource utilization
-Monitoring at scale requires efficient use of computing and storage resources. Collecting and storing high volumes of metrics can quickly become resource-intensive, leading to concerns about resource utilization. A monitoring solution must be designed to manage these resources effectively, without causing a significant performance hit.
+   Monitoring at scale requires efficient use of computing and storage resources. Collecting and storing high volumes of metrics can quickly become resource-intensive, leading to concerns about resource utilization. A monitoring solution must be designed to manage these resources effectively, without causing a significant performance hit.
 
 ### Prometheus as a Solution
 
@@ -85,17 +93,17 @@ Prometheus emerged as a popular tool for monitoring cloud-native environments, a
 As organizations expanded their cloud-native infrastructures and the number of services increased, the original setup of Prometheus, while powerful, started to present some new challenges. The growth in scale and complexity of modern applications required organizations to rethink how they manage and maintain their monitoring systems. Key challenges included:
 
 1. Scaling
-    
-    One of the primary challenges was ensuring that Prometheus could scale effectively as the volume of metrics increased. In larger environments, where microservices, containers, and instances multiply rapidly, the sheer amount of data Prometheus needed to collect, process, and store began to strain the system
-    
+
+   One of the primary challenges was ensuring that Prometheus could scale effectively as the volume of metrics increased. In larger environments, where microservices, containers, and instances multiply rapidly, the sheer amount of data Prometheus needed to collect, process, and store began to strain the system
+
 2. High availability
-    
-    High availability is essential for mission-critical applications, where downtime or gaps in monitoring can lead to serious issues, including missing important alerts or performance problems. In a self-hosted Prometheus setup, achieving high availability is difficult. Prometheus was not natively designed to handle redundancy and failover out of the box, which means teams need to manually configure multiple Prometheus instances to avoid single points of failure
-    
+
+   High availability is essential for mission-critical applications, where downtime or gaps in monitoring can lead to serious issues, including missing important alerts or performance problems. In a self-hosted Prometheus setup, achieving high availability is difficult. Prometheus was not natively designed to handle redundancy and failover out of the box, which means teams need to manually configure multiple Prometheus instances to avoid single points of failure
+
 3. Long-term storage
-By default, Prometheus is designed for short-term data storage. It stores recent metrics data efficiently, which is fine for real-time monitoring, but many organizations require long-term storage for historical analysis and data retention. This is important for identifying trends over weeks or months, understanding how performance changes over time, and meeting regulatory or compliance requirements for data retention. 
+   By default, Prometheus is designed for short-term data storage. It stores recent metrics data efficiently, which is fine for real-time monitoring, but many organizations require long-term storage for historical analysis and data retention. This is important for identifying trends over weeks or months, understanding how performance changes over time, and meeting regulatory or compliance requirements for data retention.
 4. Operational complexity
-Running and maintaining Prometheus at scale introduces significant operational complexity. A self-hosted Prometheus environment requires ongoing maintenance, including regular software upgrades, patching, scaling adjustments, and managing storage capacity. As deployments grow, the number of Prometheus instances increases, adding more complexity to the system. Keeping Prometheus up-to-date and optimized becomes resource-intensive, and any mistakes during upgrades or configuration changes can lead to service disruptions.
+   Running and maintaining Prometheus at scale introduces significant operational complexity. A self-hosted Prometheus environment requires ongoing maintenance, including regular software upgrades, patching, scaling adjustments, and managing storage capacity. As deployments grow, the number of Prometheus instances increases, adding more complexity to the system. Keeping Prometheus up-to-date and optimized becomes resource-intensive, and any mistakes during upgrades or configuration changes can lead to service disruptions.
 
 These challenges paved the way for managed Prometheus services, which address scaling and maintenance issues while preserving the benefits of Prometheus.
 
@@ -104,26 +112,26 @@ These challenges paved the way for managed Prometheus services, which address sc
 Managed Prometheus services provide a range of features designed to streamline and enhance cloud-native monitoring. These features address common challenges associated with self-hosted Prometheus setups and offer significant benefits for organizations. Here’s a closer look at the key features:
 
 1. Automated setup and configuration
-Managed Prometheus services simplify deployment through automated setup and configuration. This means that you can quickly get started with monitoring without the need for manual setup. The service provider handles the configuration of Prometheus instances, applying industry best practices to ensure optimal performance and reliability from the start. This automation reduces the time and effort required to deploy monitoring solutions, allowing teams to focus on other critical tasks.
+   Managed Prometheus services simplify deployment through automated setup and configuration. This means that you can quickly get started with monitoring without the need for manual setup. The service provider handles the configuration of Prometheus instances, applying industry best practices to ensure optimal performance and reliability from the start. This automation reduces the time and effort required to deploy monitoring solutions, allowing teams to focus on other critical tasks.
 2. Scalability and high availability
-One of the most notable features of managed services is their ability to provide scalability and high availability. Managed Prometheus services automatically scale to accommodate increasing volumes of metrics data. Whether your application grows or the number of services expands, the service adjusts resources accordingly to handle the load. Additionally, these services come with built-in redundancy and failover mechanisms, ensuring that monitoring remains uninterrupted even if there are infrastructure issues. This guarantees that data collection and alerting continue seamlessly, without the risk of downtime or data loss.
-3. Built-in security and compliance 
-Managed Prometheus services offer strong security and compliance capabilities to safeguard your monitoring information. These services often contain strong security mechanisms like `encryption`, `authentication`, and `access control` to protect data from unauthorized access. In addition, these services adhere to a variety of regulatory and industry requirements, including `GDPR` and `SOC 2`. This indicates that the service meets stringent data management and privacy standards, simplifying your compliance processes and lowering the chance of data breaches or legal concerns.
+   One of the most notable features of managed services is their ability to provide scalability and high availability. Managed Prometheus services automatically scale to accommodate increasing volumes of metrics data. Whether your application grows or the number of services expands, the service adjusts resources accordingly to handle the load. Additionally, these services come with built-in redundancy and failover mechanisms, ensuring that monitoring remains uninterrupted even if there are infrastructure issues. This guarantees that data collection and alerting continue seamlessly, without the risk of downtime or data loss.
+3. Built-in security and compliance
+   Managed Prometheus services offer strong security and compliance capabilities to safeguard your monitoring information. These services often contain strong security mechanisms like `encryption`, `authentication`, and `access control` to protect data from unauthorized access. In addition, these services adhere to a variety of regulatory and industry requirements, including `GDPR` and `SOC 2`. This indicates that the service meets stringent data management and privacy standards, simplifying your compliance processes and lowering the chance of data breaches or legal concerns.
 4. Integration with cloud ecosystems
-Integration with cloud ecosystems is another significant advantage of managed Prometheus services. These services are designed to work seamlessly with other cloud-based tools and services within your cloud provider’s ecosystem. This connectivity enables easy integration with additional monitoring, logging, and analytics tools, as well as with cloud-native infrastructure components like Kubernetes, serverless functions, and more. This seamless integration enhances the overall monitoring experience, providing a more cohesive view of your application’s performance and simplifying the management of your cloud-native environment.
+   Integration with cloud ecosystems is another significant advantage of managed Prometheus services. These services are designed to work seamlessly with other cloud-based tools and services within your cloud provider’s ecosystem. This connectivity enables easy integration with additional monitoring, logging, and analytics tools, as well as with cloud-native infrastructure components like Kubernetes, serverless functions, and more. This seamless integration enhances the overall monitoring experience, providing a more cohesive view of your application’s performance and simplifying the management of your cloud-native environment.
 
 ### Data Collection and Storage
 
 Understanding how managed Prometheus handles data is crucial:
 
 1. Prometheus data model:
-Managed Prometheus uses a time-series data model. This means that data is organized and stored based on time. Each piece of data, or metric, is associated with a metric name (like `http_requests_total`) and key-value pairs (such as `method="GET"`). This structure allows Prometheus to efficiently track and analyze how metrics change over time, providing a detailed view of performance and behavior.
-2. Metric ingestion: 
-Prometheus collects metrics using several methods. The primary method is `pull-based scraping`, where Prometheus actively queries your services at regular intervals to gather metric data. This approach is effective in dynamic environments because Prometheus can adapt to changes in the monitored services. Additionally, Prometheus supports push gateways for metrics that are not easily scraped, allowing you to push data to Prometheus from services that cannot be directly scraped.
+   Managed Prometheus uses a time-series data model. This means that data is organized and stored based on time. Each piece of data, or metric, is associated with a metric name (like `http_requests_total`) and key-value pairs (such as `method="GET"`). This structure allows Prometheus to efficiently track and analyze how metrics change over time, providing a detailed view of performance and behavior.
+2. Metric ingestion:
+   Prometheus collects metrics using several methods. The primary method is `pull-based scraping`, where Prometheus actively queries your services at regular intervals to gather metric data. This approach is effective in dynamic environments because Prometheus can adapt to changes in the monitored services. Additionally, Prometheus supports push gateways for metrics that are not easily scraped, allowing you to push data to Prometheus from services that cannot be directly scraped.
 3. Long-term storage:
-Managed Prometheus services offer solutions for `long-term storage` of metrics. While Prometheus itself is optimized for short-term data retention, managed services often provide extended retention options. This might include tiered storage, where data is stored in different layers based on age and access frequency. For example, recent data might be kept in high-performance storage for quick access, while older data is moved to more cost-effective storage solutions. This approach helps manage large volumes of historical data efficiently.
+   Managed Prometheus services offer solutions for `long-term storage` of metrics. While Prometheus itself is optimized for short-term data retention, managed services often provide extended retention options. This might include tiered storage, where data is stored in different layers based on age and access frequency. For example, recent data might be kept in high-performance storage for quick access, while older data is moved to more cost-effective storage solutions. This approach helps manage large volumes of historical data efficiently.
 4. Query performance:
-To support quick and efficient data analysis, managed Prometheus services are optimized for `query performance`. The system is designed to retrieve and analyze large datasets rapidly, allowing users to run complex queries and generate insights without delays. This optimization ensures that you can get timely answers to questions about your metrics, such as trends, anomalies, or performance bottlenecks, even as the amount of data grows.
+   To support quick and efficient data analysis, managed Prometheus services are optimized for `query performance`. The system is designed to retrieve and analyze large datasets rapidly, allowing users to run complex queries and generate insights without delays. This optimization ensures that you can get timely answers to questions about your metrics, such as trends, anomalies, or performance bottlenecks, even as the amount of data grows.
 
 Different managed Prometheus services might handle data storage and retention in various ways. For example, `AWS for Prometheus` uses a purpose-built time-series database tailored for handling large volumes of metric data efficiently. In contrast, other services might use object storage solutions for long-term retention, providing flexibility in how data is stored and accessed.
 
@@ -132,69 +140,99 @@ Different managed Prometheus services might handle data storage and retention in
 Several cloud providers and specialized services offer managed Prometheus solutions:
 
 1. Amazon Managed Service for Prometheus (<a href="https://aws.amazon.com/prometheus/" rel="noopener noreferrer nofollow" target="_blank">AMP</a>):
-    - Fully Managed and Prometheus-Compatible: Amazon AMP is a fully managed service that is compatible with Prometheus, meaning it supports Prometheus metrics collection and querying without needing extensive setup.
-    - Seamless Integration with AWS Services: It integrates smoothly with Amazon EKS (Elastic Kubernetes Service) and other AWS services, making it easy to monitor applications running in AWS environments.
-    - PromQL API: Provides a PromQL-compatible API for querying metrics, allowing you to leverage the same powerful query language used in traditional Prometheus setups.
-        
-        <Figure src="/img/guides/2024/10/managed-prometheus-image.webp" alt="AWS Managed Prometheus ~ Image Credits [AWS]" caption="AWS Managed Prometheus ~ Image Credits [AWS]" />
-    
-        
-2. <a href="https://learn.microsoft.com/en-us/azure/azure-monitor/essentials/prometheus-metrics-overview" rel="noopener noreferrer nofollow" target="_blank">Azure Monitor Managed Service for Prometheus</a>:
-    - Part of Azure Monitor for Containers: This service is integrated into Azure Monitor, specifically designed for containerized applications running in the Azure ecosystem.
-    - Prometheus-Compatible Endpoint: It offers an endpoint compatible with Prometheus, enabling you to collect and monitor metrics from your applications seamlessly.
-    - Integration with Azure Kubernetes Service (AKS): The service integrates with Azure Kubernetes Service, simplifying the monitoring of Kubernetes clusters and workloads in Azure.
-        
-        <Figure src="/img/guides/2024/10/managed-prometheus-Screenshot_2024-09-23_at_10.33.29_PM.webp" alt="Azure Managed Prometheus" caption="Azure Managed Prometheus" />
-        
-3. <a href="https://cloud.google.com/managed-prometheus?hl=en" rel="noopener noreferrer nofollow" target="_blank">Google Cloud Managed Service for Prometheus:</a>
-    - Integrated with Google Kubernetes Engine (GKE): This managed service is designed to work well with Google Kubernetes Engine, providing a robust monitoring solution for applications running in Google Cloud.
-    - Long-Term Storage and PromQL-Compatible API: It offers long-term storage options and supports the PromQL query language, allowing for detailed analysis and historical data retention.
-    - Seamless Integration with Google Cloud Operations Suite: Provides easy integration with other Google Cloud tools and services, enhancing overall observability and management.
-    
-    <Figure src="/img/guides/2024/10/managed-prometheus-image 1.webp" alt="Google Cloud Managed Service for Prometheus ~ Image Credits ~ [GCP]" caption="Google Cloud Managed Service for Prometheus ~ Image Credits ~ [GCP]" />
-    
-4. <a href="https://grafana.com/products/cloud/" rel="noopener noreferrer nofollow" target="_blank">Grafana Cloud:</a>
-    - Managed Prometheus in a Broader Observability Platform: Grafana Cloud offers managed Prometheus as part of its comprehensive observability platform, which includes features beyond just metrics collection.
-    - Additional Features: Includes advanced features like alerting, dashboarding, and data visualization, which help in gaining deeper insights into your metrics.
-    - Support for Multi-Cloud and Hybrid Environments: Grafana Cloud supports a variety of environments, including multi-cloud and hybrid setups, making it a versatile choice for organizations with diverse infrastructure.
-        
-        <Figure src="/img/guides/2024/10/managed-prometheus-image 2.webp" alt="Grafana Cloud ~ Image Credits ~ [Grafana]" caption="Grafana Cloud ~ Image Credits ~ [Grafana]" />
-        
+   - Fully Managed and Prometheus-Compatible: Amazon AMP is a fully managed service that is compatible with Prometheus, meaning it supports Prometheus metrics collection and querying without needing extensive setup.
+   - Seamless Integration with AWS Services: It integrates smoothly with Amazon EKS (Elastic Kubernetes Service) and other AWS services, making it easy to monitor applications running in AWS environments.
+   - PromQL API: Provides a PromQL-compatible API for querying metrics, allowing you to leverage the same powerful query language used in traditional Prometheus setups.
+     {' '}
+     <Figure
+       src="/img/guides/2024/10/managed-prometheus-image.webp"
+       alt="AWS Managed Prometheus ~ Image Credits [AWS]"
+       caption="AWS Managed Prometheus ~ Image Credits [AWS]"
+     />
+2. <a
+     href="https://learn.microsoft.com/en-us/azure/azure-monitor/essentials/prometheus-metrics-overview"
+     rel="noopener noreferrer nofollow"
+     target="_blank"
+   >
+     Azure Monitor Managed Service for Prometheus
+   </a>
+   : - Part of Azure Monitor for Containers: This service is integrated into Azure Monitor,
+   specifically designed for containerized applications running in the Azure ecosystem. -
+   Prometheus-Compatible Endpoint: It offers an endpoint compatible with Prometheus, enabling you to
+   collect and monitor metrics from your applications seamlessly. - Integration with Azure
+   Kubernetes Service (AKS): The service integrates with Azure Kubernetes Service, simplifying the
+   monitoring of Kubernetes clusters and workloads in Azure.
+   <Figure
+     src="/img/guides/2024/10/managed-prometheus-Screenshot_2024-09-23_at_10.33.29_PM.webp"
+     alt="Azure Managed Prometheus"
+     caption="Azure Managed Prometheus"
+   />
+3. <a
+     href="https://cloud.google.com/managed-prometheus?hl=en"
+     rel="noopener noreferrer nofollow"
+     target="_blank"
+   >
+     Google Cloud Managed Service for Prometheus:
+   </a>
+   - Integrated with Google Kubernetes Engine (GKE): This managed service is designed to work well
+   with Google Kubernetes Engine, providing a robust monitoring solution for applications running in
+   Google Cloud. - Long-Term Storage and PromQL-Compatible API: It offers long-term storage options
+   and supports the PromQL query language, allowing for detailed analysis and historical data
+   retention. - Seamless Integration with Google Cloud Operations Suite: Provides easy integration
+   with other Google Cloud tools and services, enhancing overall observability and management.
+
+   <Figure
+     src="/img/guides/2024/10/managed-prometheus-image 1.webp"
+     alt="Google Cloud Managed Service for Prometheus ~ Image Credits ~ [GCP]"
+     caption="Google Cloud Managed Service for Prometheus ~ Image Credits ~ [GCP]"
+   />
+
+4. <a href="https://grafana.com/products/cloud/" rel="noopener noreferrer nofollow" target="_blank">
+     Grafana Cloud:
+   </a>
+   - Managed Prometheus in a Broader Observability Platform: Grafana Cloud offers managed Prometheus
+   as part of its comprehensive observability platform, which includes features beyond just metrics
+   collection. - Additional Features: Includes advanced features like alerting, dashboarding, and
+   data visualization, which help in gaining deeper insights into your metrics. - Support for
+   Multi-Cloud and Hybrid Environments: Grafana Cloud supports a variety of environments, including
+   multi-cloud and hybrid setups, making it a versatile choice for organizations with diverse
+   infrastructure.
+   <Figure
+     src="/img/guides/2024/10/managed-prometheus-image 2.webp"
+     alt="Grafana Cloud ~ Image Credits ~ [Grafana]"
+     caption="Grafana Cloud ~ Image Credits ~ [Grafana]"
+   />
 
 ### Choosing the Right Managed Prometheus Service
 
 When selecting a managed Prometheus service, consider the following factors:
 
 1. Compatibility
-Ensure the managed Prometheus service is compatible with your current infrastructure, tools, and applications. This includes checking whether it supports the metrics you’re already collecting and integrates well with your existing systems, such as cloud providers, container orchestration platforms (like Kubernetes), and other monitoring tools. Seamless compatibility will reduce the complexity of migrating to the service.
+   Ensure the managed Prometheus service is compatible with your current infrastructure, tools, and applications. This includes checking whether it supports the metrics you’re already collecting and integrates well with your existing systems, such as cloud providers, container orchestration platforms (like Kubernetes), and other monitoring tools. Seamless compatibility will reduce the complexity of migrating to the service.
 2. Scalability
-It's essential to choose a service that can grow with your needs. Evaluate its ability to handle increasing volumes of metrics as your application scales. Some services may limit the amount of data they can process or store, while others provide automatic scaling to handle higher loads. Ensure the service can scale both horizontally (across multiple instances) and vertically (within a single instance) to meet your long-term requirements.
+   It's essential to choose a service that can grow with your needs. Evaluate its ability to handle increasing volumes of metrics as your application scales. Some services may limit the amount of data they can process or store, while others provide automatic scaling to handle higher loads. Ensure the service can scale both horizontally (across multiple instances) and vertically (within a single instance) to meet your long-term requirements.
 3. Cost
-Managed Prometheus services often have different pricing models, so it’s important to understand the costs involved. Pay attention to how pricing is calculated typically based on factors like the rate of data ingestion (how much data is being collected), storage retention (how long data is stored), and the number of queries performed. Make sure you choose a service that matches your budget and has a clear price structure with no hidden fees.
+   Managed Prometheus services often have different pricing models, so it’s important to understand the costs involved. Pay attention to how pricing is calculated typically based on factors like the rate of data ingestion (how much data is being collected), storage retention (how long data is stored), and the number of queries performed. Make sure you choose a service that matches your budget and has a clear price structure with no hidden fees.
 4. Features
-Beyond basic monitoring, many managed Prometheus services offer additional features that can enhance your [observability stack](https://signoz.io/guides/observability-stack/). Look for capabilities like alerting, advanced visualization tools (for creating customized dashboards), and integrations with other services such as logging platforms or cloud-native monitoring solutions. The appropriate set of features can help you streamline your monitoring operations and gain deeper insights into your system's performance.
+   Beyond basic monitoring, many managed Prometheus services offer additional features that can enhance your [observability stack](https://signoz.io/guides/observability-stack/). Look for capabilities like alerting, advanced visualization tools (for creating customized dashboards), and integrations with other services such as logging platforms or cloud-native monitoring solutions. The appropriate set of features can help you streamline your monitoring operations and gain deeper insights into your system's performance.
 5. Support
-The quality of support can be a critical factor, especially if you're new to Prometheus or have complex monitoring needs. Consider the availability and responsiveness of vendor support, the quality of their documentation, and whether they offer additional resources like training or a strong user community. Services with good support can help resolve issues quickly and provide guidance on best practices for setting up and optimizing your monitoring environment.
+   The quality of support can be a critical factor, especially if you're new to Prometheus or have complex monitoring needs. Consider the availability and responsiveness of vendor support, the quality of their documentation, and whether they offer additional resources like training or a strong user community. Services with good support can help resolve issues quickly and provide guidance on best practices for setting up and optimizing your monitoring environment.
 
 ## Implementing Managed Prometheus in Your Stack
 
 To get started with a managed Prometheus service:
 
 1. Choose a provider
-The first step is to select a managed [Prometheus service](https://signoz.io/guides/cannot-start-prometheus-by-using-systemd/) provider that fits your organization’s needs. Managed Prometheus providers handle the underlying infrastructure, allowing you to focus on monitoring your applications without worrying about maintenance, scaling, or upgrades. When choosing a provider, consider.
-    - Scalability: Ensure the provider can scale to support your growing data needs.
-    - Integration: Check if the service integrates easily with your current tech stack, such as Kubernetes or other cloud services.
-    - Cost: Evaluate pricing based on your expected data volume and retention period.
-    - Support: Look for a provider that offers strong customer support and documentation.
+   The first step is to select a managed [Prometheus service](https://signoz.io/guides/cannot-start-prometheus-by-using-systemd/) provider that fits your organization’s needs. Managed Prometheus providers handle the underlying infrastructure, allowing you to focus on monitoring your applications without worrying about maintenance, scaling, or upgrades. When choosing a provider, consider. - Scalability: Ensure the provider can scale to support your growing data needs. - Integration: Check if the service integrates easily with your current tech stack, such as Kubernetes or other cloud services. - Cost: Evaluate pricing based on your expected data volume and retention period. - Support: Look for a provider that offers strong customer support and documentation.
 2. Set up the service
-Once you've selected a provider, follow their setup instructions. This typically involves creating a Prometheus instance via the provider's user interface or API, specifying storage and retention settings, and setting up any necessary authentication or authorization. Providers usually offer step-by-step tutorials to guide you through the setup process. Follow these closely to ensure proper configuration.
+   Once you've selected a provider, follow their setup instructions. This typically involves creating a Prometheus instance via the provider's user interface or API, specifying storage and retention settings, and setting up any necessary authentication or authorization. Providers usually offer step-by-step tutorials to guide you through the setup process. Follow these closely to ensure proper configuration.
 3. Configure data sources
-To start collecting metrics, you'll need to configure Prometheus to scrape data from your applications and infrastructure. Use Prometheus exporters (or agents) to collect metrics from various systems (e.g., Node Exporter for system metrics or application-specific exporters).
-Many managed services offer integrations with popular systems, reducing the need for manual configuration.
+   To start collecting metrics, you'll need to configure Prometheus to scrape data from your applications and infrastructure. Use Prometheus exporters (or agents) to collect metrics from various systems (e.g., Node Exporter for system metrics or application-specific exporters).
+   Many managed services offer integrations with popular systems, reducing the need for manual configuration.
 4. Migrate existing data
-If you're transitioning from a self-hosted Prometheus setup, migrating historical data can ensure continuity. Some managed services provide tools for data migration, or you can use Prometheus’s remote write capabilities to push data to the new service. Start with a limited migration to test the new setup and verify data integrity before moving all your data.
+   If you're transitioning from a self-hosted Prometheus setup, migrating historical data can ensure continuity. Some managed services provide tools for data migration, or you can use Prometheus’s remote write capabilities to push data to the new service. Start with a limited migration to test the new setup and verify data integrity before moving all your data.
 5. Set up dashboards and alerts
-After collecting metrics, you’ll want to visualize them and set up alerts. Most managed Prometheus services integrate with Grafana for dashboards, where you can create custom views of your data. Set alerting rules based on critical metrics to notify your team of potential issues. Start with pre-built dashboards offered by your service provider and customize them as you become more familiar with your monitoring needs.
+   After collecting metrics, you’ll want to visualize them and set up alerts. Most managed Prometheus services integrate with Grafana for dashboards, where you can create custom views of your data. Set alerting rules based on critical metrics to notify your team of potential issues. Start with pre-built dashboards offered by your service provider and customize them as you become more familiar with your monitoring needs.
 
 ### Best Practices for Migration
 
@@ -209,16 +247,16 @@ To successfully migrate your existing Prometheus setup, follow these best practi
 
 Managed Prometheus services often provide APIs and integrations to work with popular observability tools:
 
-1. PromQL: 
-Managed Prometheus fully supports `PromQL`, allowing you to reuse queries developed for self-hosted Prometheus, ensuring continuity in your metric analysis. You can perform complex queries for aggregating data, setting up alerts, and visualizing trends without additional configuration. SigNoz also supports PromQL, offering features like distributed tracing and real-time monitoring, providing deeper insights into your application performance.
-2. Grafana: 
-Grafana, widely known for its powerful visual dashboards, integrates smoothly with managed Prometheus. This enables real-time visualization of metrics from your infrastructure and applications. You can monitor system health, identify trends, and set up custom alerts. Managed Prometheus uses the same data format as self-hosted instances, meaning your existing Grafana dashboards work with minimal changes. SigNoz can also be integrated with Grafana for added flexibility in visualization.
-3. Alertmanager: 
-Managed Prometheus services often integrate with Prometheus Alertmanager or other alerting systems, enabling you to define custom alert rules and receive notifications via email, SMS, or other communication platforms. These alerts help streamline operational efficiency by automating incident responses and routing alerts to the right on-call teams.
+1. PromQL:
+   Managed Prometheus fully supports `PromQL`, allowing you to reuse queries developed for self-hosted Prometheus, ensuring continuity in your metric analysis. You can perform complex queries for aggregating data, setting up alerts, and visualizing trends without additional configuration. SigNoz also supports PromQL, offering features like distributed tracing and real-time monitoring, providing deeper insights into your application performance.
+2. Grafana:
+   Grafana, widely known for its powerful visual dashboards, integrates smoothly with managed Prometheus. This enables real-time visualization of metrics from your infrastructure and applications. You can monitor system health, identify trends, and set up custom alerts. Managed Prometheus uses the same data format as self-hosted instances, meaning your existing Grafana dashboards work with minimal changes. SigNoz can also be integrated with Grafana for added flexibility in visualization.
+3. Alertmanager:
+   Managed Prometheus services often integrate with Prometheus Alertmanager or other alerting systems, enabling you to define custom alert rules and receive notifications via email, SMS, or other communication platforms. These alerts help streamline operational efficiency by automating incident responses and routing alerts to the right on-call teams.
 4. Logging and tracing:
-Observability isn't complete without a combination of metrics, logs, and traces. Managed Prometheus integrates with logging systems like Loki and [tracing tools](https://signoz.io/blog/distributed-tracing-tools/) like Jaeger and Zipkin to give you a comprehensive understanding of system performance. This allows you to track issues at different levels, from high-level metrics to specific traces, making it easier to pinpoint root causes. SigNoz also offers an integrated view of logs, metrics, and traces, giving you a unified platform for observability.
+   Observability isn't complete without a combination of metrics, logs, and traces. Managed Prometheus integrates with logging systems like Loki and [tracing tools](https://signoz.io/blog/distributed-tracing-tools/) like Jaeger and Zipkin to give you a comprehensive understanding of system performance. This allows you to track issues at different levels, from high-level metrics to specific traces, making it easier to pinpoint root causes. SigNoz also offers an integrated view of logs, metrics, and traces, giving you a unified platform for observability.
 5. SigNoz:
-SigNoz is an open-source alternative to traditional monitoring tools, providing integrated monitoring for metrics, logs, and distributed tracing. Like Prometheus, SigNoz supports `PromQL`, allowing you to query your metrics easily. It offers powerful features like distributed tracing, helping you trace requests across microservices, and provides a unified platform for monitoring application performance in real-time. This makes troubleshooting more efficient and provides deeper insights into system behavior across different layers.
+   SigNoz is an open-source alternative to traditional monitoring tools, providing integrated monitoring for metrics, logs, and distributed tracing. Like Prometheus, SigNoz supports `PromQL`, allowing you to query your metrics easily. It offers powerful features like distributed tracing, helping you trace requests across microservices, and provides a unified platform for monitoring application performance in real-time. This makes troubleshooting more efficient and provides deeper insights into system behavior across different layers.
 
 ## Optimizing Your Monitoring Strategy with SigNoz
 
@@ -228,7 +266,7 @@ Built on OpenTelemetry—the emerging industry standard for telemetry data—Sig
 
 1. Extend [Prometheus Monitoring](https://signoz.io/guides/what-is-prometheus-for-monitoring/): Retain your existing Prometheus setup while enhancing it with tracing and logging capabilities.
 2. Faster Troubleshooting: Correlate metrics with traces and logs to quickly identify and resolve performance issues.
-3. Flexible Data Analysis: Use both PromQL and SigNoz's advanced [query builder](https://signoz.io/blog/query-builder-v5/) for versatile data exploration and analysis. 
+3. Flexible Data Analysis: Use both PromQL and SigNoz's advanced [query builder](https://signoz.io/blog/query-builder-v5/) for versatile data exploration and analysis.
 4. Unified Dashboards: Build custom dashboards that bring together metrics, traces, and logs, helping you monitor key performance indicators and identify trends effectively.
 
 For more information on integrating Prometheus metrics with SigNoz, check out the [OpenTelemetry Collector Prometheus Receiver guide](https://signoz.io/blog/opentelemetry-collector-prometheus-receiver/).
@@ -248,30 +286,30 @@ In addition to extending Prometheus monitoring, SigNoz offers the following bene
 As cloud-native applications scale, maintaining optimal performance in a managed Prometheus environment becomes crucial. Managed services handle much of the complexity behind the scenes, but there are still important performance and scalability factors to consider. Here’s an in-depth look at key considerations:
 
 1. High-volume metric ingestion: As your system grows, the number of metrics collected can increase exponentially. Properly managing high-volume metric ingestion is essential to prevent performance bottlenecks.
-    - Use Service Discovery: In dynamic environments, where containers and services are frequently spun up and down, Prometheus' service discovery feature can automatically find and scrape new targets. This minimizes manual configuration and ensures that you always have up-to-date metrics, even in rapidly changing environments.
-    - Implement [Metric Aggregation](https://signoz.io/docs/metrics-management/types-and-aggregation/) and Pre-Processing: When dealing with large amounts of raw metrics, consider using aggregation techniques to reduce data volume. Aggregating at the source (e.g., summarizing data at specific intervals) can reduce the load on Prometheus and improve query performance, especially when fine-grained detail isn’t necessary.
-    - Leverage Push Gateways: For applications that cannot be scraped directly (e.g., batch jobs), using a Prometheus push gateway allows metrics to be sent in batches. This reduces the need for frequent scrapes and can improve efficiency in environments with intermittent workloads.
+   - Use Service Discovery: In dynamic environments, where containers and services are frequently spun up and down, Prometheus' service discovery feature can automatically find and scrape new targets. This minimizes manual configuration and ensures that you always have up-to-date metrics, even in rapidly changing environments.
+   - Implement [Metric Aggregation](https://signoz.io/docs/metrics-management/types-and-aggregation/) and Pre-Processing: When dealing with large amounts of raw metrics, consider using aggregation techniques to reduce data volume. Aggregating at the source (e.g., summarizing data at specific intervals) can reduce the load on Prometheus and improve query performance, especially when fine-grained detail isn’t necessary.
+   - Leverage Push Gateways: For applications that cannot be scraped directly (e.g., batch jobs), using a Prometheus push gateway allows metrics to be sent in batches. This reduces the need for frequent scrapes and can improve efficiency in environments with intermittent workloads.
 2. Query performance optimization: As your dataset grows, Prometheus queries (especially complex PromQL queries) can become resource-intensive. Optimizing query performance ensures that your monitoring dashboards remain responsive, even with large-scale deployments.
-    - Use Efficient PromQL Queries: Avoid overly complex queries that require heavy processing, especially for real-time monitoring. Simplify queries where possible by reducing the number of time series analyzed. Additionally, avoid using functions that require large amounts of data, such as `rate()` or `histogram_quantile()` over long time ranges.
-    - Implement Caching for Frequently Accessed Dashboards: Many managed services allow you to cache query results for frequently used dashboards. Caching ensures that users don’t repeatedly query the same data, reducing load on your Prometheus instance and improving response times.
-    - Query Federation for Large-Scale Deployments: In very large environments, splitting your Prometheus instances into multiple smaller, federated instances can help distribute the query load. Query federation allows you to run global queries across these instances while keeping query times manageable.
+   - Use Efficient PromQL Queries: Avoid overly complex queries that require heavy processing, especially for real-time monitoring. Simplify queries where possible by reducing the number of time series analyzed. Additionally, avoid using functions that require large amounts of data, such as `rate()` or `histogram_quantile()` over long time ranges.
+   - Implement Caching for Frequently Accessed Dashboards: Many managed services allow you to cache query results for frequently used dashboards. Caching ensures that users don’t repeatedly query the same data, reducing load on your Prometheus instance and improving response times.
+   - Query Federation for Large-Scale Deployments: In very large environments, splitting your Prometheus instances into multiple smaller, federated instances can help distribute the query load. Query federation allows you to run global queries across these instances while keeping query times manageable.
 3. Cost management: Managed Prometheus services can accumulate costs based on the volume of data ingested and retained, as well as the query resources consumed. Managing these aspects proactively can help you avoid unexpected expenses.
-    - Monitor Metric Volume and Adjust Retention Policies: Regularly review the number of metrics being ingested and adjust retention policies to balance the need for historical data with storage costs. Keeping metrics for too long can increase costs unnecessarily, especially if you don’t need to analyze older data.
-    - Use Metric Relabeling: Reduce unnecessary data by relabeling metrics at the collection stage. Prometheus allows you to drop unneeded labels or rename them to optimize storage. This can significantly reduce data volume, especially in environments where similar metrics are collected from multiple sources.
-    - Leverage Cloud Provider Cost Optimization Tools: Many cloud providers offer cost management tools that can help monitor and optimize usage. These tools can provide insights into where your monitoring infrastructure is consuming resources and recommend adjustments to save costs. For instance, you may identify opportunities to reduce storage costs by compressing old metrics or lowering data retention times.
+   - Monitor Metric Volume and Adjust Retention Policies: Regularly review the number of metrics being ingested and adjust retention policies to balance the need for historical data with storage costs. Keeping metrics for too long can increase costs unnecessarily, especially if you don’t need to analyze older data.
+   - Use Metric Relabeling: Reduce unnecessary data by relabeling metrics at the collection stage. Prometheus allows you to drop unneeded labels or rename them to optimize storage. This can significantly reduce data volume, especially in environments where similar metrics are collected from multiple sources.
+   - Leverage Cloud Provider Cost Optimization Tools: Many cloud providers offer cost management tools that can help monitor and optimize usage. These tools can provide insights into where your monitoring infrastructure is consuming resources and recommend adjustments to save costs. For instance, you may identify opportunities to reduce storage costs by compressing old metrics or lowering data retention times.
 
 ## Security and Compliance in Managed Prometheus
 
 Managed Prometheus services often provide enhanced security features:
 
-1. Data encryption: 
-Managed Prometheus services normally encrypt your metric data at rest and in transit to prevent unauthorized access during storage and transmission. This assures that even if data is intercepted, it will be illegible without the encryption keys.
-2. Access control: 
-Many systems use fine-grained access controls, which allow administrators to assign precise roles and permissions to users. This reduces vulnerability by ensuring that only authorized workers may view or manage metrics.
-3. Audit logging: 
-Managed services typically offer detailed audit logs, tracking who accessed the system, what changes were made, and when these actions occurred. This provides transparency and is essential for both security monitoring and compliance reporting.
-4. Compliance certifications: 
-Many managed Prometheus providers adhere to industry-standard security and compliance frameworks like SOC 2, HIPAA, or GDPR. These certifications ensure that the service meets strict regulatory requirements for data handling and privacy.
+1. Data encryption:
+   Managed Prometheus services normally encrypt your metric data at rest and in transit to prevent unauthorized access during storage and transmission. This assures that even if data is intercepted, it will be illegible without the encryption keys.
+2. Access control:
+   Many systems use fine-grained access controls, which allow administrators to assign precise roles and permissions to users. This reduces vulnerability by ensuring that only authorized workers may view or manage metrics.
+3. Audit logging:
+   Managed services typically offer detailed audit logs, tracking who accessed the system, what changes were made, and when these actions occurred. This provides transparency and is essential for both security monitoring and compliance reporting.
+4. Compliance certifications:
+   Many managed Prometheus providers adhere to industry-standard security and compliance frameworks like SOC 2, HIPAA, or GDPR. These certifications ensure that the service meets strict regulatory requirements for data handling and privacy.
 
 Best practices for securing your monitoring infrastructure:
 
@@ -284,16 +322,16 @@ Best practices for securing your monitoring infrastructure:
 
 The field of cloud-native monitoring is rapidly evolving:
 
-1. AI-powered anomaly detection: 
-Artificial intelligence (AI) and machine learning (ML) are becoming increasingly important in monitoring. AI-powered anomaly detection uses machine learning algorithms to automatically identify unusual patterns in metrics that may indicate problems. This reduces the reliance on manual thresholds or static alerts, allowing systems to detect issues faster and more accurately, even in complex, dynamic environments. As AI becomes more sophisticated, this technology will help teams proactively manage performance and prevent outages before they escalate.
+1. AI-powered anomaly detection:
+   Artificial intelligence (AI) and machine learning (ML) are becoming increasingly important in monitoring. AI-powered anomaly detection uses machine learning algorithms to automatically identify unusual patterns in metrics that may indicate problems. This reduces the reliance on manual thresholds or static alerts, allowing systems to detect issues faster and more accurately, even in complex, dynamic environments. As AI becomes more sophisticated, this technology will help teams proactively manage performance and prevent outages before they escalate.
 2. Automated root cause analysis: (x)
-Finding the root cause of an issue in cloud-native applications can be challenging due to the sheer volume of data from metrics, logs, and traces. Automated root cause analysis uses intelligent systems to correlate data across these sources and quickly identify the underlying cause of an issue. This trend is set to revolutionize troubleshooting by significantly reducing the time it takes to resolve incidents and helping teams make data-driven decisions to improve system reliability.
+   Finding the root cause of an issue in cloud-native applications can be challenging due to the sheer volume of data from metrics, logs, and traces. Automated root cause analysis uses intelligent systems to correlate data across these sources and quickly identify the underlying cause of an issue. This trend is set to revolutionize troubleshooting by significantly reducing the time it takes to resolve incidents and helping teams make data-driven decisions to improve system reliability.
 3. [Edge monitoring](https://signoz.io/guides/edge-observability/):
-As more firms use edge computing, in which data is processed closer to the source rather than centralized in the cloud, there is a greater demand for effective edge monitoring. This involves extending observability to edge environments, ensuring that even remote or distributed systems are monitored effectively. Edge monitoring allows organizations to gain insights into performance, security, and reliability at the edge, making it an essential trend for future cloud-native applications.
-4. eBPF-based monitoring: 
-Extended Berkeley Packet Filter (eBPF) technology is emerging as a powerful tool for understanding system behavior. eBPF allows you to safely run custom monitoring programs directly in the Linux kernel, capturing high-fidelity data without the overhead typically associated with traditional monitoring agents. This approach enables more granular monitoring of system-level events, network traffic, and application performance, providing a more detailed understanding of system operations.
-5. Unified observability platforms: 
-The future of monitoring is moving towards unified observability platforms that combine metrics, logs, and traces into a single, integrated solution. This convergence streamlines the monitoring process by offering a comprehensive view of the complete system in a single platform, removing the need to manage several tools. Unified platforms make it easier to understand how different aspects of the system are interconnected, improving both troubleshooting and optimization efforts.
+   As more firms use edge computing, in which data is processed closer to the source rather than centralized in the cloud, there is a greater demand for effective edge monitoring. This involves extending observability to edge environments, ensuring that even remote or distributed systems are monitored effectively. Edge monitoring allows organizations to gain insights into performance, security, and reliability at the edge, making it an essential trend for future cloud-native applications.
+4. eBPF-based monitoring:
+   Extended Berkeley Packet Filter (eBPF) technology is emerging as a powerful tool for understanding system behavior. eBPF allows you to safely run custom monitoring programs directly in the Linux kernel, capturing high-fidelity data without the overhead typically associated with traditional monitoring agents. This approach enables more granular monitoring of system-level events, network traffic, and application performance, providing a more detailed understanding of system operations.
+5. Unified observability platforms:
+   The future of monitoring is moving towards unified observability platforms that combine metrics, logs, and traces into a single, integrated solution. This convergence streamlines the monitoring process by offering a comprehensive view of the complete system in a single platform, removing the need to manage several tools. Unified platforms make it easier to understand how different aspects of the system are interconnected, improving both troubleshooting and optimization efforts.
 
 As these trends develop, managed Prometheus services will likely adapt to incorporate new capabilities and address emerging challenges in cloud-native environments.
 
@@ -314,17 +352,17 @@ As these trends develop, managed Prometheus services will likely adapt to incorp
 Managed Prometheus and self-hosted Prometheus differ in several key ways:
 
 - Infrastructure Management:
-    - Managed Prometheus services handle all aspects of infrastructure management, including server setup, scaling, and maintenance. This reduces the burden on your team and ensures that the system is always up-to-date and performing optimally.
-    - In contrast, self-hosted Prometheus requires you to manage these tasks yourself, which can be resource-intensive and complex.
+  - Managed Prometheus services handle all aspects of infrastructure management, including server setup, scaling, and maintenance. This reduces the burden on your team and ensures that the system is always up-to-date and performing optimally.
+  - In contrast, self-hosted Prometheus requires you to manage these tasks yourself, which can be resource-intensive and complex.
 - Scalability and High Availability:
-    - Managed Prometheus services come with built-in scalability and high availability features. They automatically adjust resources to handle increased metric volumes and include redundancy and failover mechanisms to prevent downtime.
-    - Self-hosted Prometheus requires manual configuration for scaling and high availability, which can be challenging to implement and maintain effectively.
+  - Managed Prometheus services come with built-in scalability and high availability features. They automatically adjust resources to handle increased metric volumes and include redundancy and failover mechanisms to prevent downtime.
+  - Self-hosted Prometheus requires manual configuration for scaling and high availability, which can be challenging to implement and maintain effectively.
 - Security Features:
-    - Managed services often provide enhanced security features such as encryption, access controls, and compliance with industry standards. This is handled by the service provider, ensuring that your data is protected.
-    - With self-hosted Prometheus, you need to implement and manage these security measures yourself, which requires additional expertise and effort.
+  - Managed services often provide enhanced security features such as encryption, access controls, and compliance with industry standards. This is handled by the service provider, ensuring that your data is protected.
+  - With self-hosted Prometheus, you need to implement and manage these security measures yourself, which requires additional expertise and effort.
 - Customization:
-    - Self-hosted Prometheus allows for greater customization in terms of configuration and integration with other systems. If your monitoring needs require specific adjustments or integrations, self-hosted Prometheus offers more flexibility.
-    - Managed Prometheus services, while convenient, may have limitations on customization compared to a self-hosted setup.
+  - Self-hosted Prometheus allows for greater customization in terms of configuration and integration with other systems. If your monitoring needs require specific adjustments or integrations, self-hosted Prometheus offers more flexibility.
+  - Managed Prometheus services, while convenient, may have limitations on customization compared to a self-hosted setup.
 
 ### How does managed Prometheus handle data retention and long-term storage?
 
@@ -345,4 +383,4 @@ Managed Prometheus services ensure high availability and disaster recovery throu
 - Automatic Failover Mechanisms: These services have built-in failover mechanisms that automatically switch to backup systems or instances if the primary system fails. This ensures that monitoring continues without interruptions.
 - Regular Backups: Managed services perform regular backups of data to protect against data loss. In case of infrastructure failures or other issues, these backups can be used to restore data and resume normal operations.
 
-By leveraging these features, managed Prometheus services provide robust solutions for maintaining [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) capabilities and safeguarding against data loss.
\ No newline at end of file
+By leveraging these features, managed Prometheus services provide robust solutions for maintaining [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) capabilities and safeguarding against data loss.
diff --git a/data/guides/metrics-migration-cloud-users.mdx b/data/guides/metrics-migration-cloud-users.mdx
index 17e9c6c28..79c634966 100644
--- a/data/guides/metrics-migration-cloud-users.mdx
+++ b/data/guides/metrics-migration-cloud-users.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: Cloud Metrics Migration Guide
-slug: cloud-dot-metrics-migrations
 date: 2025-05-07
 tags: []
 authors: [aniket_agarwal]
 description: Step-by-Step guide to help in metrics migration for cloud users
 keywords: []
-
 ---
 
 # 📌 Overview
@@ -41,4 +38,3 @@ From next week onwards, we will roll out the final migration. You will begin to
 ## ✅ What You Need to Do
 
 If you're using API keys to query metrics directly, you may need to update your integrations to reflect the new metric and label formats. For all other users, absolutely nothing — the migration is fully managed by our team, and your dashboards, alerts, and queries will continue to operate without any changes.
-
diff --git a/data/guides/metrics-migration.mdx b/data/guides/metrics-migration.mdx
index 883f50140..86e4c463f 100644
--- a/data/guides/metrics-migration.mdx
+++ b/data/guides/metrics-migration.mdx
@@ -1,16 +1,12 @@
 ---
-
 title: Metrics Migration Guide
-slug: dot-metrics-migrations
 date: 2025-05-06
 tags: []
 authors: [aniket_agarwal]
 description: Step-by-Step guide to help in metrics migration
 keywords: []
-
 ---
 
-
 # 📌 Overview
 
 This is a step-by-step guide to help you migrate from normalized, underscore-based metric names (e.g., `system_memory_usage`) to unnormalized naming conventions (e.g., `system.memory.usage`). This change aligns with the OpenTelemetry semantic conventions and enables better namespacing, and cross-signal compatibility.
@@ -46,10 +42,11 @@ We will also offer community support and documentation to assist with this proce
 Once the data for both naming formats has existed in your system for at least one full default retention cycle, we will deprecate and remove the old exporter.
 
 At this point:
+
 - Underscore-based metric names will be deprecated.
 - Only the `signozclickhousemetrics` exporter will be supported moving forward.
 - All dashboards, alerts, and custom queries should use the unnormalized exclusively.
-- For those community users who have higher retention in metrics data, we will help with the scripts to converts the old (_) data to new non normalized data.
+- For those community users who have higher retention in metrics data, we will help with the scripts to converts the old (\_) data to new non normalized data.
 
 ## ⚙️ Resource Impact
 
diff --git a/data/guides/microservices-monitoring.mdx b/data/guides/microservices-monitoring.mdx
index e88b99f6f..90d9200fa 100644
--- a/data/guides/microservices-monitoring.mdx
+++ b/data/guides/microservices-monitoring.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: Essential Guide to Microservices Monitoring in 2025
-slug: microservices-monitoring
 date: 2025-01-02
 tags: [monitoring]
 authors: [eromosele]
 description: Discover essential strategies and tools for effective microservices monitoring in 2024. Learn how to optimize performance and reliability in complex distributed systems.
-keywords: [microservices monitoring, observability, distributed tracing, performance metrics, monitoring tools, DevOps]
-
+keywords:
+  [
+    microservices monitoring,
+    observability,
+    distributed tracing,
+    performance metrics,
+    monitoring tools,
+    DevOps,
+  ]
 ---
 
 Microservices architecture has revolutionized software development, enabling scalability and flexibility. However, they also introduce new challenges in monitoring and maintaining system health. As organizations increasingly adopt microservices, the need for robust monitoring solutions becomes critical. This guide explores the essentials of microservices monitoring in 2024, equipping you with the knowledge to ensure optimal performance and reliability in your distributed systems.
@@ -61,10 +66,13 @@ Key roles of a Load Balancer in a microservices architecture:
 
 Due to the inherent complexity and dynamic nature of microservices architecture, several challenges can be faced when monitoring these microservices. Here's a look at some of the challenges that can be encountered:
 
-<Figure src="/img/guides/2024/08/microservices-monitoring-image%201.webp" alt="" caption="" />- Increased Number of Components: With more services, there are more potential points where things can go wrong.
-- Dynamic Environments: Services can scale up or down frequently, making it harder to keep track of everything in real-time.
-- Polyglot Architectures: Different services may be built using different programming languages and technologies, complicating the monitoring process.
-- Distributed Transactions: A single user request often touches multiple services, making it challenging to monitor and trace the entire transaction flow.
+<Figure src="/img/guides/2024/08/microservices-monitoring-image%201.webp" alt="" caption="" />-
+Increased Number of Components: With more services, there are more potential points where things can
+go wrong. - Dynamic Environments: Services can scale up or down frequently, making it harder to keep
+track of everything in real-time. - Polyglot Architectures: Different services may be built using
+different programming languages and technologies, complicating the monitoring process. - Distributed
+Transactions: A single user request often touches multiple services, making it challenging to
+monitor and trace the entire transaction flow.
 
 ## Why is Microservices Monitoring Critical in 2024?
 
@@ -94,16 +102,21 @@ Effective microservices monitoring helps you maintain system reliability, optimi
 
 To effectively monitor your microservices architecture, you need to track a variety of metrics across different levels of your system. Here are the key categories of metrics you should focus on:
 
-<Figure src="/img/guides/2024/08/microservices-monitoring-CleanShot_2024-08-30_at_14.42.292x.webp" alt="" caption="" />### 1. Service-Level Metrics
+<Figure
+  src="/img/guides/2024/08/microservices-monitoring-CleanShot_2024-08-30_at_14.42.292x.webp"
+  alt=""
+  caption=""
+/>
+### 1. Service-Level Metrics
 
 These metrics provide insights into the performance and behavior of individual microservices:
 
 - Response Time: Measures how long your service takes to process requests.
-    - Focus on average response time, 95th percentile (to capture slower responses), and maximum response times to understand service efficiency.
+  - Focus on average response time, 95th percentile (to capture slower responses), and maximum response times to understand service efficiency.
 - Throughput: Indicates how many requests your service can handle.
-    - Track requests per second or transactions per minute to gauge service capacity.
+  - Track requests per second or transactions per minute to gauge service capacity.
 - Error Rate: Tracks how often your service encounters failures.
-    - Measure the percentage of requests that result in errors, and categorize the types of errors to identify common issues.
+  - Measure the percentage of requests that result in errors, and categorize the types of errors to identify common issues.
 
 ### 2. Infrastructure Metrics
 
@@ -139,9 +152,9 @@ Selecting the most relevant metrics for your microservices requires careful cons
 3. Balance granularity and actionability: Collect enough detail to be useful, but avoid overwhelming your team with unnecessary data.
 4. Evolve your metrics: As your system grows and changes, regularly review and update your monitored metrics to ensure they remain relevant.
 5. Use the RED method: For each service, track:
-    - Rate (requests per second)
-    - Errors (number of failed requests)
-    - Duration (amount of time each request takes)
+   - Rate (requests per second)
+   - Errors (number of failed requests)
+   - Duration (amount of time each request takes)
 
 By carefully selecting and monitoring these essential metrics, you'll gain a comprehensive view of your microservices ecosystem, enabling you to maintain peak performance and quickly address any issues that arise.
 
@@ -158,21 +171,21 @@ To effectively monitor your microservices architecture, you'll need a combinatio
 
 ### Cloud-Native Monitoring Solutions
 
-| Feature | Amazon CloudWatch | Cloud Monitoring |
-| --- | --- | --- |
-| Service Provider | Amazon Web Services (AWS) | Google Cloud Platform (GCP) |
-| Primary Purpose | Monitoring AWS cloud resources and applications | Monitoring Google Cloud cloud resources and applications |
-| Supported Resources | AWS-specific resources (e.g., EC2, S3, Lambda), custom metrics | GCP-specific resources, resources across multiple cloud platforms (e.g., AWS, Azure) and on-premises |
-| Data Collection | Collects metrics, logs, and events specific to AWS | Collects metrics, logs, and events from various cloud platforms and environments |
-| Alerts and Notifications | Set alarms and notifications based on AWS metric thresholds | Configurable alerts and notifications for metrics across various environments |
-| Integration with Other Services | Deep integration with AWS services (e.g., AWS Lambda, ECS) | Integration with multiple cloud services, on-premises systems, and third-party tools |
-| Dashboards | Customizable dashboards, focused on AWS resources | Highly customizable dashboards, often with support for multiple cloud providers and systems |
-| Logging | Integrated with AWS CloudTrail, CloudWatch Logs for application logs | Centralized logging solutions that can aggregate logs from multiple environments |
-| Pricing Model | Pay-per-use based on metrics, log volume, and alarms | Varies by tool; often includes a subscription model or pay-per-use based on volume and features |
-| Multi-Cloud Support | Primarily focused on AWS, with limited support for other environments | Designed to support multiple cloud platforms and hybrid environments |
-| Data Retention | Default retention for metrics is 15 months | Varies by tool, often configurable with retention based on user needs and cost considerations |
-| API and Automation | Extensive AWS-specific APIs for monitoring, alerting, and managing resources | APIs and automation tools that are platform-agnostic, often supporting multiple cloud environments |
-| User Interface | AWS Management Console with a dedicated CloudWatch console | Varies by tool, typically offering a unified interface to monitor resources across different platforms |
+| Feature                         | Amazon CloudWatch                                                            | Cloud Monitoring                                                                                       |
+| ------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| Service Provider                | Amazon Web Services (AWS)                                                    | Google Cloud Platform (GCP)                                                                            |
+| Primary Purpose                 | Monitoring AWS cloud resources and applications                              | Monitoring Google Cloud cloud resources and applications                                               |
+| Supported Resources             | AWS-specific resources (e.g., EC2, S3, Lambda), custom metrics               | GCP-specific resources, resources across multiple cloud platforms (e.g., AWS, Azure) and on-premises   |
+| Data Collection                 | Collects metrics, logs, and events specific to AWS                           | Collects metrics, logs, and events from various cloud platforms and environments                       |
+| Alerts and Notifications        | Set alarms and notifications based on AWS metric thresholds                  | Configurable alerts and notifications for metrics across various environments                          |
+| Integration with Other Services | Deep integration with AWS services (e.g., AWS Lambda, ECS)                   | Integration with multiple cloud services, on-premises systems, and third-party tools                   |
+| Dashboards                      | Customizable dashboards, focused on AWS resources                            | Highly customizable dashboards, often with support for multiple cloud providers and systems            |
+| Logging                         | Integrated with AWS CloudTrail, CloudWatch Logs for application logs         | Centralized logging solutions that can aggregate logs from multiple environments                       |
+| Pricing Model                   | Pay-per-use based on metrics, log volume, and alarms                         | Varies by tool; often includes a subscription model or pay-per-use based on volume and features        |
+| Multi-Cloud Support             | Primarily focused on AWS, with limited support for other environments        | Designed to support multiple cloud platforms and hybrid environments                                   |
+| Data Retention                  | Default retention for metrics is 15 months                                   | Varies by tool, often configurable with retention based on user needs and cost considerations          |
+| API and Automation              | Extensive AWS-specific APIs for monitoring, alerting, and managing resources | APIs and automation tools that are platform-agnostic, often supporting multiple cloud environments     |
+| User Interface                  | AWS Management Console with a dedicated CloudWatch console                   | Varies by tool, typically offering a unified interface to monitor resources across different platforms |
 
 ### Commercial Observability Platforms
 
@@ -236,8 +249,8 @@ Developing an effective monitoring strategy for your microservices architecture
 
 - Define thresholds for critical metrics
 - Implement a tiered alerting system:
-    - Warning alerts for potential issues
-    - Critical alerts for immediate action
+  - Warning alerts for potential issues
+  - Critical alerts for immediate action
 - Use tools like PagerDuty or OpsGenie for on-call management
 
 ### 3. Implement Distributed Tracing
@@ -261,26 +274,26 @@ Developing an effective monitoring strategy for your microservices architecture
 ### Best Practices for Microservices Observability
 
 1. Adopt a Culture of Observability:
-    - Encourage developers to think about monitoring from the start
-    - Include observability requirements in service design
+   - Encourage developers to think about monitoring from the start
+   - Include observability requirements in service design
 2. Implement Automated Instrumentation:
-    - Use libraries and agents for automatic metric collection
-    - Reduce the burden on developers to add monitoring code
+   - Use libraries and agents for automatic metric collection
+   - Reduce the burden on developers to add monitoring code
 3. Utilize Service Mesh for Enhanced Visibility:
-    - Gain detailed insights into service-to-service communication
-    - Implement consistent observability across all services
+   - Gain detailed insights into service-to-service communication
+   - Implement consistent observability across all services
 4. Regularly Review and Refine Monitoring Strategies:
-    - Conduct post-incident reviews to identify monitoring gaps
-    - Update alerting thresholds based on system changes and growth
+   - Conduct post-incident reviews to identify monitoring gaps
+   - Update alerting thresholds based on system changes and growth
 5. Implement [Contextual Logging](https://signoz.io/guides/structlog/):
-    - Include relevant context in log messages (e.g., request IDs, user information)
-    - Enable easy correlation between logs, traces, and metrics
+   - Include relevant context in log messages (e.g., request IDs, user information)
+   - Enable easy correlation between logs, traces, and metrics
 6. Use Health Checks and Readiness Probes:
-    - Implement /health and /ready endpoints for each service
-    - Enable orchestration tools to make informed decisions about service availability
+   - Implement /health and /ready endpoints for each service
+   - Enable orchestration tools to make informed decisions about service availability
 7. Monitor Both Internal and External Dependencies:
-    - Track the performance of external APIs and services
-    - Implement circuit breakers to handle dependency failures gracefully
+   - Track the performance of external APIs and services
+   - Implement circuit breakers to handle dependency failures gracefully
 
 ## Overcoming Common Microservices Monitoring Challenges
 
@@ -365,20 +378,20 @@ In the landscape of microservices monitoring tools, [SigNoz](https://signoz.io)
 ### Key Features of SigNoz
 
 1. End-to-End Tracing:
-    - Follow requests across multiple services
-    - Visualize service dependencies and identify bottlenecks
+   - Follow requests across multiple services
+   - Visualize service dependencies and identify bottlenecks
 2. Metrics Monitoring:
-    - Track custom and standard metrics
-    - Create detailed dashboards for system-wide visibility
+   - Track custom and standard metrics
+   - Create detailed dashboards for system-wide visibility
 3. Log Management:
-    - Centralize logs from all services
-    - Correlate logs with traces and metrics for faster troubleshooting
+   - Centralize logs from all services
+   - Correlate logs with traces and metrics for faster troubleshooting
 4. Anomaly Detection:
-    - Leverage machine learning to identify unusual patterns
-    - Set up alerts for proactive issue resolution
+   - Leverage machine learning to identify unusual patterns
+   - Set up alerts for proactive issue resolution
 5. Service-Level Objectives (SLOs):
-    - Define and track SLOs for critical services
-    - Monitor error budgets to maintain service reliability
+   - Define and track SLOs for critical services
+   - Monitor error budgets to maintain service reliability
 
 ### Advantages of Using SigNoz for Microservices Architectures
 
@@ -392,13 +405,13 @@ In the landscape of microservices monitoring tools, [SigNoz](https://signoz.io)
 SigNoz offers both [cloud-hosted](https://signoz.io/docs/cloud/) and [self-hosted](https://signoz.io/docs/install) options:
 
 1. SigNoz Cloud:
-    - Managed solution with automatic updates and scaling
-    - Reduced operational overhead
-    - Pay-as-you-go pricing model
+   - Managed solution with automatic updates and scaling
+   - Reduced operational overhead
+   - Pay-as-you-go pricing model
 2. SigNoz Open-Source:
-    - Full control over your monitoring infrastructure
-    - Ability to customize and extend functionality
-    - Suitable for organizations with strict data privacy requirements
+   - Full control over your monitoring infrastructure
+   - Ability to customize and extend functionality
+   - Suitable for organizations with strict data privacy requirements
 
 Choose the option that best aligns with your organization's needs and resources.
 
@@ -479,12 +492,12 @@ Monitoring focuses on collecting and analyzing predefined sets of metrics and lo
 You should review your microservices monitoring strategy regularly, with a recommended frequency of:
 
 1. Quarterly reviews: Conduct thorough assessments of your monitoring setup, including:
-    - Evaluating the relevance of current metrics and alerts
-    - Identifying gaps in coverage
-    - Assessing the effectiveness of your tools and processes
+   - Evaluating the relevance of current metrics and alerts
+   - Identifying gaps in coverage
+   - Assessing the effectiveness of your tools and processes
 2. Monthly check-ins: Have shorter, focused sessions to:
-    - Address any immediate concerns or pain points
-    - Discuss recent incidents and how monitoring could be improved
+   - Address any immediate concerns or pain points
+   - Discuss recent incidents and how monitoring could be improved
 3. Continuous improvement: Encourage ongoing feedback from your team to make incremental enhancements.
 
 Additionally, trigger reviews after significant events such as:
@@ -509,26 +522,26 @@ Yes, microservices monitoring plays a crucial role in capacity planning. Here's
 Security is a critical aspect of microservices monitoring. Here are key considerations:
 
 1. Data protection:
-    - Encrypt monitoring data in transit and at rest
-    - Implement access controls to restrict who can view sensitive monitoring information
+   - Encrypt monitoring data in transit and at rest
+   - Implement access controls to restrict who can view sensitive monitoring information
 2. Authentication and authorization:
-    - Use strong authentication mechanisms for accessing monitoring tools
-    - Implement role-based access control (RBAC) to limit access based on user roles
+   - Use strong authentication mechanisms for accessing monitoring tools
+   - Implement role-based access control (RBAC) to limit access based on user roles
 3. Network security:
-    - Secure the communication channels used for collecting monitoring data
-    - Use VPNs or private networks to isolate monitoring traffic
+   - Secure the communication channels used for collecting monitoring data
+   - Use VPNs or private networks to isolate monitoring traffic
 4. Compliance:
-    - Ensure your monitoring practices comply with relevant regulations (e.g., GDPR, HIPAA)
-    - Implement data retention and deletion policies in line with compliance requirements
+   - Ensure your monitoring practices comply with relevant regulations (e.g., GDPR, HIPAA)
+   - Implement data retention and deletion policies in line with compliance requirements
 5. Vulnerability monitoring:
-    - Use monitoring tools to detect and alert on potential security threats
-    - Integrate with security information and event management (SIEM) systems
+   - Use monitoring tools to detect and alert on potential security threats
+   - Integrate with security information and event management (SIEM) systems
 6. Audit logging:
-    - Maintain logs of all access to monitoring systems and data
-    - Regularly review audit logs for suspicious activities
+   - Maintain logs of all access to monitoring systems and data
+   - Regularly review audit logs for suspicious activities
 7. Secure instrumentation:
-    - Ensure that adding monitoring capabilities doesn't introduce security vulnerabilities
-    - Review and secure any third-party monitoring agents or libraries
+   - Ensure that adding monitoring capabilities doesn't introduce security vulnerabilities
+   - Review and secure any third-party monitoring agents or libraries
 8. Privacy considerations:
-    - Be cautious about collecting and storing personally identifiable information (PII) in logs or metrics
-    - Implement data anonymization techniques where necessary
+   - Be cautious about collecting and storing personally identifiable information (PII) in logs or metrics
+   - Implement data anonymization techniques where necessary
diff --git a/data/guides/model-monitoring.mdx b/data/guides/model-monitoring.mdx
index e236291bf..c46d99a7f 100644
--- a/data/guides/model-monitoring.mdx
+++ b/data/guides/model-monitoring.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: A Comprehensive Guide to Model Monitoring in ML Production
-slug: model-monitoring
 date: 2024-08-07
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Learn essential strategies for effective model monitoring in machine learning production environments to ensure optimal performance and reliability.
-keywords: [model monitoring, machine learning, ML production, data drift, model performance, AI observability]
-
+keywords:
+  [
+    model monitoring,
+    machine learning,
+    ML production,
+    data drift,
+    model performance,
+    AI observability,
+  ]
 ---
 
 In machine learning, ensuring that your models remain reliable and precise is just as important as keeping a well-oiled machine. Consider a self-driving automobile that gradually begins to incorrectly interpret road signs when traffic patterns or weather conditions change. Consider an e-commerce recommendation system that is unable to keep up with changing user preferences, resulting in irrelevant suggestions. Your machine learning models, like these systems, require regular maintenance to function properly.
@@ -36,12 +41,12 @@ Track computational resources, such as CPU and memory usage, as well as latency
 
 Model monitoring differs from general system monitoring as it specifically focuses on ML model behaviour and performance rather than just infrastructure health. This distinction is a must-know for maintaining the integrity and reliability of ML systems in production.
 
-|  | Model Monitoring | Generic Monitoring |
-| --- | --- | --- |
-| Focus | - ML model behavior and performance | - Infrastructure health and performance |
-| Key Metrics | - Prediction accuracy<br />- Drift detection<br />- Latency in prediction<br />- Feature importance changes<br />- Model explainability | - CPU usage<br />- Memory usage<br />- Network traffic<br />- Disk I/O<br />- Uptime/downtime |
-| Examples | - Monitoring fraud detection model<br />- Tracking the distribution of input features over time | - Monitoring CPU and memory usage of a web server<br />- Tracking network traffic to identify bottlenecks |
-| Tools | - SigNoz with Custom Metrics <br /> - Prometheus with custom metrics<br />- Seldon Core<br />- Evidently AI<br />- WhyLogs | - SigNoz <br /> - Prometheus<br />- Grafana<br />- Nagios<br />- New Relic |
+|             | Model Monitoring                                                                                                                        | Generic Monitoring                                                                                        |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Focus       | - ML model behavior and performance                                                                                                     | - Infrastructure health and performance                                                                   |
+| Key Metrics | - Prediction accuracy<br />- Drift detection<br />- Latency in prediction<br />- Feature importance changes<br />- Model explainability | - CPU usage<br />- Memory usage<br />- Network traffic<br />- Disk I/O<br />- Uptime/downtime             |
+| Examples    | - Monitoring fraud detection model<br />- Tracking the distribution of input features over time                                         | - Monitoring CPU and memory usage of a web server<br />- Tracking network traffic to identify bottlenecks |
+| Tools       | - SigNoz with Custom Metrics <br /> - Prometheus with custom metrics<br />- Seldon Core<br />- Evidently AI<br />- WhyLogs              | - SigNoz <br /> - Prometheus<br />- Grafana<br />- Nagios<br />- New Relic                                |
 
 ### Example: Implementing Basic Model Monitoring
 
@@ -123,7 +128,11 @@ In our code, we have logged accuracy metrics which helps in understanding how we
 
 Sample Output:
 
-<Figure src="/img/guides/2024/08/model-monitoring-Untitled.webp" alt="Output Example" caption="Output Example" />
+<Figure
+  src="/img/guides/2024/08/model-monitoring-Untitled.webp"
+  alt="Output Example"
+  caption="Output Example"
+/>
 
 The above example shows how to set a basic monitoring framework that logs accuracy and checks data for quality issues. It is just a foundational step towards more complex monitoring in production environments. This output indicates that the model's predictions are 48% accurate which means that the model has correctly predicted 48% of the labels in the test data. Since, the model is making random predictions, an accuracy close to 50% is expected in a binary classification problem, as random guessing would ideally result in an accuracy of around 50%.
 
@@ -145,23 +154,23 @@ import numpy as np
 from scipy.stats import ks_2samp
 
 # Generate simulated training data
-X_train = np.random.rand(1000, 10)  
+X_train = np.random.rand(1000, 10)
 # 1000 samples, each with 10 features
 
 # Generate simulated test data with slight drift introduced
-X_test = np.random.rand(1000, 10) * 1.1  
+X_test = np.random.rand(1000, 10) * 1.1
 # Scaling to introduce slight drift
 
 # Function to detect data drift using the Kolmogorov-Smirnov (KS) test
 def detect_data_drift(X_train, X_test):
-    p_values = []  
+    p_values = []
     # List to store p-values for each feature
     for i in range(X_train.shape[1]):
         # Perform KS test for each feature in the training and test datasets
         _, p_value = ks_2samp(X_train[:, i], X_test[:, i])
-        p_values.append(p_value)  
+        p_values.append(p_value)
         # Append the p-value to the list
-    return np.array(p_values)  
+    return np.array(p_values)
     # Return the list of p-values as a numpy array
 
 # Detecting data drift by comparing the training and test data distributions
@@ -193,226 +202,231 @@ Data drift detected
 This example demonstrates how statistical tests can be used to monitor data drift, which is important for maintaining model performance. By identifying the features where data drift occurs, you can take necessary actions such as retraining the model or adjusting data preprocessing steps to ensure the model remains effective and accurate over time. In this example, the distributions of each feature in the training and test datasets are compared using the Kolmogorov-Smirnov (KS) test. Data drift is identified if substantial differences are discovered (shown by p-values less than 0.05). If the p-value for a feature is less than 0.05 the distribution of that feature has significantly changed between the training and test datasets. This suggests data drift, which could impact model performance. On the other hand, if the p-value is greater than or equal to 0.05, it suggests that there is no significant change in the distribution of that feature, indicating no data drift.
 
 - Note
-    
-    The Kolmogorov-Smirnov (KS) test is a non-parametric test which is used to compare the distributions of two independent samples. This test evaluates the null hypothesis that the two samples are drawn from the same distribution. 
-    
+  The Kolmogorov-Smirnov (KS) test is a non-parametric test which is used to compare the distributions of two independent samples. This test evaluates the null hypothesis that the two samples are drawn from the same distribution.
 
 ## How to Implement Effective Model Monitoring Strategies
 
 To set up robust model monitoring, follow these steps:
 
 1. Establish Baseline Metrics: Set performance thresholds based on the initial model validation. This covers measurements like accuracy, precision, recall, and F1 score. Baseline measurements serve as a reference point for detecting deviations in model performance.
-    
-    Example:
-    
-    ```python
-    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
-    
-    def calculate_baseline_metrics(y_true, y_pred):
-        """
-        Calculate baseline metrics for model evaluation.
-    
-        y_true (list or array): True labels.
-        y_pred (list or array): Predicted labels.
-    
-        Returns a dictionary containing accuracy, precision, recall, f1_score
-        """
-        metrics = {
-            'accuracy': accuracy_score(y_true, y_pred),
-            'precision': precision_score(y_true, y_pred, average='weighted'),
-            'recall': recall_score(y_true, y_pred, average='weighted'),
-            'f1_score': f1_score(y_true, y_pred, average='weighted')
-        }
-        return metrics
-    
-    # Sample data for true labels and predictions
-    y_true = [0, 1, 2, 2, 1, 0]  # True labels
-    y_pred = [0, 0, 2, 2, 1, 1]  # Predicted labels
-    
-    # Calculate baseline metrics
-    baseline_metrics = calculate_baseline_metrics(y_true, y_pred)
-    
-    # Print the calculated metrics
-    print(baseline_metrics)
-    ```
-    
-    Explanation:
-    
-    - Importing the required Libraries: `accuracy_score`, `precision_score`, `recall_score`, and `f1_score` from `sklearn.metrics`.
-    - The `calculate_baseline_metrics` function takes `y_true` (true labels) and `y_pred` (predicted labels) as inputs. It calculates four evaluation metrics: accuracy, precision, recall, and F1 score. Finally, it returns these metrics in a dictionary.
-    
-    Sample Output:
-    
-    ```bash
-    {
-        'accuracy': 0.6666666666666666,
-        'precision': 0.7333333333333333,
-        'recall': 0.6666666666666666,
-        'f1_score': 0.6333333333333333
-    }
-    ```
-    
-2. Implement Data Quality Checks: Set up automated tests to ensure data integrity and consistency. Ensuring that the input data fulfils the requirements is critical for model performance. 
-    
-    Example:
-    
-    ```python
-    import pandas as pd
-    
-    def check_data_quality(data):
-    	  # .values converts the DataFrame to a NumPy array
-    	  # data.dtypes returns a Series with the data type of each column.
-        assert not data.isnull().values.any(), "Data contains null values"
-        assert data.dtypes.isin([int, float]).all(), "Data types are not consistent"
-        print("Data quality checks passed")
-    
-    # Assuming df is your DataFrame
-    df = pd.DataFrame({
-        'feature1': [1, 2, 3],
-        'feature2': [4.0, 5.0, 6.0]
-    })
-    check_data_quality(df)
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Data quality checks passed
-    ```
-    
+
+   Example:
+
+   ```python
+   from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+   def calculate_baseline_metrics(y_true, y_pred):
+       """
+       Calculate baseline metrics for model evaluation.
+
+       y_true (list or array): True labels.
+       y_pred (list or array): Predicted labels.
+
+       Returns a dictionary containing accuracy, precision, recall, f1_score
+       """
+       metrics = {
+           'accuracy': accuracy_score(y_true, y_pred),
+           'precision': precision_score(y_true, y_pred, average='weighted'),
+           'recall': recall_score(y_true, y_pred, average='weighted'),
+           'f1_score': f1_score(y_true, y_pred, average='weighted')
+       }
+       return metrics
+
+   # Sample data for true labels and predictions
+   y_true = [0, 1, 2, 2, 1, 0]  # True labels
+   y_pred = [0, 0, 2, 2, 1, 1]  # Predicted labels
+
+   # Calculate baseline metrics
+   baseline_metrics = calculate_baseline_metrics(y_true, y_pred)
+
+   # Print the calculated metrics
+   print(baseline_metrics)
+   ```
+
+   Explanation:
+
+   - Importing the required Libraries: `accuracy_score`, `precision_score`, `recall_score`, and `f1_score` from `sklearn.metrics`.
+   - The `calculate_baseline_metrics` function takes `y_true` (true labels) and `y_pred` (predicted labels) as inputs. It calculates four evaluation metrics: accuracy, precision, recall, and F1 score. Finally, it returns these metrics in a dictionary.
+
+   Sample Output:
+
+   ```bash
+   {
+       'accuracy': 0.6666666666666666,
+       'precision': 0.7333333333333333,
+       'recall': 0.6666666666666666,
+       'f1_score': 0.6333333333333333
+   }
+   ```
+
+2. Implement Data Quality Checks: Set up automated tests to ensure data integrity and consistency. Ensuring that the input data fulfils the requirements is critical for model performance.
+
+   Example:
+
+   ```python
+   import pandas as pd
+
+   def check_data_quality(data):
+   	  # .values converts the DataFrame to a NumPy array
+   	  # data.dtypes returns a Series with the data type of each column.
+       assert not data.isnull().values.any(), "Data contains null values"
+       assert data.dtypes.isin([int, float]).all(), "Data types are not consistent"
+       print("Data quality checks passed")
+
+   # Assuming df is your DataFrame
+   df = pd.DataFrame({
+       'feature1': [1, 2, 3],
+       'feature2': [4.0, 5.0, 6.0]
+   })
+   check_data_quality(df)
+   ```
+
+   Sample Output:
+
+   ```bash
+   Data quality checks passed
+   ```
+
 3. Monitor Model Inputs and Outputs: Track feature distributions and prediction trends to identify anomalies. Monitoring both inputs and outputs aids in detecting issues like data drift and model performance decline.
-    
-    Example:
-    
-    ```python
-    import numpy as np
-    import matplotlib.pyplot as plt
-    
-    def monitor_feature_distribution(data):
-        """
-        Plot the distribution of a feature
-        data (array-like): The feature data to plot
-        """
-        # Plot histogram of the data with 30 bins
-        plt.hist(data, bins=30)
-        plt.title("Feature Distribution")
-        plt.xlabel("Feature Values")
-        plt.ylabel("Frequency")
-        plt.show()
-    
-    # Generate sample feature data
-    feature_data = np.random.randn(1000)  
-    # Normally distributed data
-    # Monitor the feature distribution
-    monitor_feature_distribution(feature_data)
-    
-    def monitor_predictions(predictions):
-        """
-        Plot the distribution of predictions
-        predictions (array-like): The predictions to plot
-        """
-        # Plot histogram of the predictions with 30 bins
-        plt.hist(predictions, bins=30)
-        plt.title("Predictions Distribution")
-        plt.xlabel("Prediction Values")
-        plt.ylabel("Frequency")
-        plt.show()
-    
-    # Generate sample predictions data
-    predictions = np.random.randint(0, 2, size=1000)  
-    # Binary predictions
-    # Monitor the predictions distribution
-    monitor_predictions(predictions)
-    ```
-    
-    Explanation:
-    
-    - Importing the required libraries: `numpy` for generating sample data and `matplotlib.pyplot` for plotting histograms.
-    - The `monitor_feature_distribution(data)` and `monitor_predictions(predictions)` function plots a histogram of the provided feature data.
-    - The `feature_data` has normally distributed data with 1000 samples.
-    - The `predictions` contain binary predictions (0 or 1) with 1000 samples.
-    - Calling the `monitor_feature_distribution` with the generated feature data to plot its distribution.
-    - Calling `monitor_predictions` with the generated predictions to plot their distribution.
-    
-    Sample Output:
-    
-    Two histograms will be displayed according to your data set:
-    
-    Histogram of `feature_data`
-    
-    <Figure src="/img/guides/2024/08/model-monitoring-Untitled%201.webp" alt="Histogram of feature_data" caption="Histogram of feature_data" />
-    
-    Histogram of `predictions`
-    
-    <Figure src="/img/guides/2024/08/model-monitoring-Untitled%202.webp" alt="Histogram of predictions" caption="Histogram of predictions" />
-    
-
-1. Set Up Alerting Mechanisms: Generate automated warnings for performance degradation or anomalies. Alerts ensure that you are instantly aware of significant changes in model performance. You can use Python’s `email.mime` for this purpose. For more details, please refer to the official Python documentation.
+
+   Example:
+
+   ```python
+   import numpy as np
+   import matplotlib.pyplot as plt
+
+   def monitor_feature_distribution(data):
+       """
+       Plot the distribution of a feature
+       data (array-like): The feature data to plot
+       """
+       # Plot histogram of the data with 30 bins
+       plt.hist(data, bins=30)
+       plt.title("Feature Distribution")
+       plt.xlabel("Feature Values")
+       plt.ylabel("Frequency")
+       plt.show()
+
+   # Generate sample feature data
+   feature_data = np.random.randn(1000)
+   # Normally distributed data
+   # Monitor the feature distribution
+   monitor_feature_distribution(feature_data)
+
+   def monitor_predictions(predictions):
+       """
+       Plot the distribution of predictions
+       predictions (array-like): The predictions to plot
+       """
+       # Plot histogram of the predictions with 30 bins
+       plt.hist(predictions, bins=30)
+       plt.title("Predictions Distribution")
+       plt.xlabel("Prediction Values")
+       plt.ylabel("Frequency")
+       plt.show()
+
+   # Generate sample predictions data
+   predictions = np.random.randint(0, 2, size=1000)
+   # Binary predictions
+   # Monitor the predictions distribution
+   monitor_predictions(predictions)
+   ```
+
+   Explanation:
+
+   - Importing the required libraries: `numpy` for generating sample data and `matplotlib.pyplot` for plotting histograms.
+   - The `monitor_feature_distribution(data)` and `monitor_predictions(predictions)` function plots a histogram of the provided feature data.
+   - The `feature_data` has normally distributed data with 1000 samples.
+   - The `predictions` contain binary predictions (0 or 1) with 1000 samples.
+   - Calling the `monitor_feature_distribution` with the generated feature data to plot its distribution.
+   - Calling `monitor_predictions` with the generated predictions to plot their distribution.
+
+   Sample Output:
+
+   Two histograms will be displayed according to your data set:
+
+   Histogram of `feature_data`
+
+   <Figure
+     src="/img/guides/2024/08/model-monitoring-Untitled%201.webp"
+     alt="Histogram of feature_data"
+     caption="Histogram of feature_data"
+   />
+
+   Histogram of `predictions`
+
+   <Figure
+     src="/img/guides/2024/08/model-monitoring-Untitled%202.webp"
+     alt="Histogram of predictions"
+     caption="Histogram of predictions"
+   />
+
+4. Set Up Alerting Mechanisms: Generate automated warnings for performance degradation or anomalies. Alerts ensure that you are instantly aware of significant changes in model performance. You can use Python’s `email.mime` for this purpose. For more details, please refer to the official Python documentation.
 
 ### Common Challenges in ML Model Monitoring
 
 Implementing effective model monitoring comes with its share of challenges:
 
 1. High-dimensional data: Completely monitoring complex models with a large number of features might be challenging. So, to prevent the overload of information (features) in the data, it can be necessary to use advanced approaches while monitoring all features and their interactions. Information overload can occur when the number of features is so large that it becomes difficult to identify which ones are most important to monitor.
-    
-    Sample Solution: To concentrate on the most important components, apply dimensionality reduction strategies such as Principal Component Analysis (PCA). PCA helps by transforming the data into a set of principal components, retaining the most significant information while reducing the number of features.
-    
-    ```python
-    from sklearn.decomposition import PCA
-    import numpy as np
-    
-    # Assuming X is your high-dimensional dataset
-    X = np.random.rand(100, 50)  
-    # High-dimensional data example
-    pca = PCA(n_components=2)
-    X_reduced = pca.fit_transform(X)
-    print(X_reduced)
-    ```
-    
-    Explanation:
-    
-    By applying PCA, we reduce the dimensionality of the dataset from 50 features to 2 principal components. This reduction helps in focusing on the most important components and thus it lowered the risk of information overload.
-    
-    Sample Output:
-    
-    ```bash
-    [[-0.09784562 -0.05306694]
-     [-0.15915395  0.08565201]
-     [ 0.03284712 -0.22509111]
-     ...
-     [ 0.09221238 -0.14241958]
-     [ 0.12828239 -0.11862985]
-     [ 0.18943509 -0.04983527]]
-    ```
-    
-2. Delayed feedback: The lack of instant access to ground truth labels in some applications makes it challenging to evaluate model performance in real time. Ground truth labels are the actual correct outputs used to train and validate the model. In real-time applications, obtaining these labels immediately may not be possible which can lead to delays in performance evaluation. 
+
+   Sample Solution: To concentrate on the most important components, apply dimensionality reduction strategies such as Principal Component Analysis (PCA). PCA helps by transforming the data into a set of principal components, retaining the most significant information while reducing the number of features.
+
+   ```python
+   from sklearn.decomposition import PCA
+   import numpy as np
+
+   # Assuming X is your high-dimensional dataset
+   X = np.random.rand(100, 50)
+   # High-dimensional data example
+   pca = PCA(n_components=2)
+   X_reduced = pca.fit_transform(X)
+   print(X_reduced)
+   ```
+
+   Explanation:
+
+   By applying PCA, we reduce the dimensionality of the dataset from 50 features to 2 principal components. This reduction helps in focusing on the most important components and thus it lowered the risk of information overload.
+
+   Sample Output:
+
+   ```bash
+   [[-0.09784562 -0.05306694]
+    [-0.15915395  0.08565201]
+    [ 0.03284712 -0.22509111]
+    ...
+    [ 0.09221238 -0.14241958]
+    [ 0.12828239 -0.11862985]
+    [ 0.18943509 -0.04983527]]
+   ```
+
+2. Delayed feedback: The lack of instant access to ground truth labels in some applications makes it challenging to evaluate model performance in real time. Ground truth labels are the actual correct outputs used to train and validate the model. In real-time applications, obtaining these labels immediately may not be possible which can lead to delays in performance evaluation.
 
 Proxy Metrics are alternative metrics that are used to estimate performance when ground truth labels are not available. They can provide a quick, though less accurate, indication of model performance. Delayed Batch Evaluations involve collecting a batch of predictions and their corresponding delayed ground truth labels to evaluate the model's performance after some time.
-    
-    Example Solution: Let’s implement proxy metrics or use delayed batch evaluations to approximate real-time performance. 
-    
+
+    Example Solution: Let’s implement proxy metrics or use delayed batch evaluations to approximate real-time performance.
+
     ```python
     # Example of using delayed feedback with a proxy metric
     def calculate_proxy_metric(predictions, true_labels):
         proxy_metric = sum(predictions == true_labels) / len(true_labels)
         return proxy_metric
-    
+
     # Simulated delayed feedback
     delayed_true_labels = [0, 1, 0, 1, 1]
     predictions = [0, 1, 1, 1, 0]
     proxy_metric = calculate_proxy_metric(predictions, delayed_true_labels)
     print(f'Proxy Metric: {proxy_metric}')
     ```
-    
+
     Explanation:
     We simulate delayed feedback by calculating a proxy metric, which is the accuracy of the model's predictions compared to the delayed true labels. Although this does not provide real-time evaluation, it approximates the model's performance, helping to maintain oversight.
-    
+
     Sample Output:
-    
+
     ```bash
     Proxy Metric: 0.6
     ```
-    
+
 3. Scalability issues: With the growth in the production number of models in, monitoring systems must scale accordingly. This requires robust infrastructure and efficient algorithms to handle increased load.
 
 ### Key Metrics for Model Monitoring
@@ -421,85 +435,83 @@ Focus on these key variables to assess model health and guarantee consistent per
 
 1. Predictive Performance: Monitor standard performance indicators to determine how well the model predicts. These are accuracy, F1-score, AUC-ROC, precision, and recall. The F1-score is a measure of the accuracy of a model. It considers both precision and recall. The F1-score is the harmonic mean of precision and recall thus it provides a balance between the two metrics. AUC-ROC stands for the Area Under the Receiver Operating Characteristic Curve. The ROC curve is a graphical representation of a model's diagnostic ability, plotting the true positive rate (recall) against the false positive rate (1-specificity).
 
-    
-    Example:
-    
-    ```python
-    from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
-    import numpy as np
-    
-    def calculate_performance_metrics(y_true, y_pred, y_prob):
-        """
-        Calculates the performance metrics for the model.
-    
-        y_true (array-like): True labels.
-        y_pred (array-like): Predicted labels.
-        y_prob (array-like): Predicted probabilities for the positive class.
-        
-        Returns a dictionary containing accuracy, F1-score, and AUC-ROC.
-        """
-        metrics = {
-            'accuracy': accuracy_score(y_true, y_pred),
-            'f1_score': f1_score(y_true, y_pred, average='weighted'),
-            'auc_roc': roc_auc_score(y_true, y_prob)
-        }
-        return metrics
-    
-    # Generate sample data for demonstration
-    np.random.seed(0)
-    y_true = np.random.randint(0, 2, size=100)  # True labels
-    y_pred = np.random.randint(0, 2, size=100)  # Predicted labels
-    y_prob = np.random.rand(100)  
-    # Predicted probabilities for the positive class
-    
-    # Calculate performance metrics
-    performance_metrics = calculate_performance_metrics(y_true, y_pred, y_prob)
-    print(performance_metrics)
-    ```
-    
-    Explanation:
-    
-    - Importing the necessary functions `accuracy_score`, `f1_score`, and `roc_auc_score` are imported from `sklearn.metrics`.
-    - The `calculate_performance_metrics` function takes three arguments: `y_true` (true labels), `y_pred` (predicted labels), and `y_prob`. Inside the function, a dictionary `metrics` is created to store the computed metrics:
-        - `accuracy` is calculated using `accuracy_score`.
-        - `f1_score` is calculated using `f1_score` with a weighted average to account for class imbalance.
-        - `auc_roc` is calculated using `roc_auc_score`.
-    - The function `calculate_performance_metrics` is called with the sample data, and the resulting metrics are printed.
-    
-    Sample Output:
-    
-    ```bash
-    {
-        'accuracy': 0.44,
-        'f1_score': 0.457209104928158,
-        'auc_roc': 0.5654444444444444
-    }
-    ```
-    
+   Example:
+
+   ```python
+   from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
+   import numpy as np
+
+   def calculate_performance_metrics(y_true, y_pred, y_prob):
+       """
+       Calculates the performance metrics for the model.
+
+       y_true (array-like): True labels.
+       y_pred (array-like): Predicted labels.
+       y_prob (array-like): Predicted probabilities for the positive class.
+
+       Returns a dictionary containing accuracy, F1-score, and AUC-ROC.
+       """
+       metrics = {
+           'accuracy': accuracy_score(y_true, y_pred),
+           'f1_score': f1_score(y_true, y_pred, average='weighted'),
+           'auc_roc': roc_auc_score(y_true, y_prob)
+       }
+       return metrics
+
+   # Generate sample data for demonstration
+   np.random.seed(0)
+   y_true = np.random.randint(0, 2, size=100)  # True labels
+   y_pred = np.random.randint(0, 2, size=100)  # Predicted labels
+   y_prob = np.random.rand(100)
+   # Predicted probabilities for the positive class
+
+   # Calculate performance metrics
+   performance_metrics = calculate_performance_metrics(y_true, y_pred, y_prob)
+   print(performance_metrics)
+   ```
+
+   Explanation:
+
+   - Importing the necessary functions `accuracy_score`, `f1_score`, and `roc_auc_score` are imported from `sklearn.metrics`.
+   - The `calculate_performance_metrics` function takes three arguments: `y_true` (true labels), `y_pred` (predicted labels), and `y_prob`. Inside the function, a dictionary `metrics` is created to store the computed metrics:
+     - `accuracy` is calculated using `accuracy_score`.
+     - `f1_score` is calculated using `f1_score` with a weighted average to account for class imbalance.
+     - `auc_roc` is calculated using `roc_auc_score`.
+   - The function `calculate_performance_metrics` is called with the sample data, and the resulting metrics are printed.
+
+   Sample Output:
+
+   ```bash
+   {
+       'accuracy': 0.44,
+       'f1_score': 0.457209104928158,
+       'auc_roc': 0.5654444444444444
+   }
+   ```
+
 2. Business Impact Metrics: Assess the impact of your model on business-specific KPIs such as conversion rates, client retention, and revenue. These measurements let you understand your model's real-world effectiveness.
-    
-    Example:
-    
-    ```python
-    def calculate_conversion_rate(predictions, actuals):
-        conversions = sum((predictions == 1) & (actuals == 1))
-        total_positives = sum(actuals == 1)
-        conversion_rate = conversions / total_positives if total_positives > 0 else 0
-        return conversion_rate
-    
-    # Assuming predictions and actuals are your model's predictions and actual outcomes
-    predictions = [1, 0, 1, 1]
-    actuals = [1, 1, 1, 0]
-    conversion_rate = calculate_conversion_rate(predictions, actuals)
-    print(f'Conversion Rate: {conversion_rate:.2%}')
-    ```
-    
-    Sample Output:
-    
-    ```bash
-    Conversion Rate: 66.67%
-    ```
-    
+
+   Example:
+
+   ```python
+   def calculate_conversion_rate(predictions, actuals):
+       conversions = sum((predictions == 1) & (actuals == 1))
+       total_positives = sum(actuals == 1)
+       conversion_rate = conversions / total_positives if total_positives > 0 else 0
+       return conversion_rate
+
+   # Assuming predictions and actuals are your model's predictions and actual outcomes
+   predictions = [1, 0, 1, 1]
+   actuals = [1, 1, 1, 0]
+   conversion_rate = calculate_conversion_rate(predictions, actuals)
+   print(f'Conversion Rate: {conversion_rate:.2%}')
+   ```
+
+   Sample Output:
+
+   ```bash
+   Conversion Rate: 66.67%
+   ```
 
 ## Monitoring Unstructured Data Models
 
@@ -546,11 +558,11 @@ Example:
 from sklearn.metrics import accuracy_score
 
 # True labels for the test images
-ground_truth = [1, 0, 1, 1]  
+ground_truth = [1, 0, 1, 1]
 # 1 for cat, 0 for dog
 
 # Model's predictions for the test images
-predictions = [1, 0, 1, 0]  
+predictions = [1, 0, 1, 0]
 # Example predictions from the model
 
 # Calculate and print accuracy
@@ -576,7 +588,7 @@ Example:
 import numpy as np
 
 # Sample user engagement data in seconds
-view_durations = [120, 90, 150, 200]  
+view_durations = [120, 90, 150, 200]
 
 # Calculate average view duration
 average_duration = np.mean(view_durations)
@@ -720,8 +732,8 @@ Explanation: By continuously retraining the model with new data, you can ensure
 ### 3. Implement Comprehensive Monitoring
 
 - Monitor at both functional and operational levels:
-    - Functional: Input data, model performance, and output predictions
-    - Operational: System performance, pipelines, and costs
+  - Functional: Input data, model performance, and output predictions
+  - Operational: System performance, pipelines, and costs
 - Use a combination of tools to cover all aspects (e.g., Prometheus, Grafana, Evidently AI).
 
 ### 4. Set Up Automated Alerts
diff --git a/data/guides/monitoring-and-troubleshooting-java-applications-in-docker-containers.mdx b/data/guides/monitoring-and-troubleshooting-java-applications-in-docker-containers.mdx
index 713253642..9294c0918 100644
--- a/data/guides/monitoring-and-troubleshooting-java-applications-in-docker-containers.mdx
+++ b/data/guides/monitoring-and-troubleshooting-java-applications-in-docker-containers.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Mastering Java App Monitoring in Docker - A Practical Guide
-slug: monitoring-and-troubleshooting-java-applications-in-docker-containers
 date: 2024-08-08
 tags: [apm]
 authors: [niyati_thakkar]
 description: Learn essential techniques for monitoring and troubleshooting Java applications in Docker containers. Optimize performance and solve common issues effectively.
-keywords: [Java monitoring, Docker containers, application troubleshooting, performance optimization, containerized Java apps]
-
+keywords:
+  [
+    Java monitoring,
+    Docker containers,
+    application troubleshooting,
+    performance optimization,
+    containerized Java apps,
+  ]
 ---
 
 Java applications in Docker containers offer powerful benefits, but they also present unique monitoring challenges as containerization becomes increasingly popular, understanding how to monitor and troubleshoot Java apps in this environment effectively is crucial. This guide will equip you with the knowledge and tools to master Java app monitoring in Docker, ensuring optimal performance and quick issue resolution.
@@ -37,19 +41,19 @@ Benefits of Running Java Apps in a Docker Environment:
 To effectively monitor Java applications in Docker, you need a combination of [container monitoring tools](https://signoz.io/guides/container-monitoring/) and Java-specific utilities. Here are some essential tools to consider:
 
 1. Container Monitoring Tools:
-    - cAdvisor: Provides container-level resource usage and performance data.
-    - Prometheus: A powerful metrics collection and alerting system.
-    - Grafana: Creates visualizations and dashboards for your metrics.
-    - SigNoz: An open-source APM tool with robust support for containerized environments.
+   - cAdvisor: Provides container-level resource usage and performance data.
+   - Prometheus: A powerful metrics collection and alerting system.
+   - Grafana: Creates visualizations and dashboards for your metrics.
+   - SigNoz: An open-source APM tool with robust support for containerized environments.
 2. Java-Specific Monitoring Tools:
-    - JConsole: A built-in Java monitoring tool compatible with Docker.
-    - VisualVM: Offers detailed analysis of JVM performance and thread states.
+   - JConsole: A built-in Java monitoring tool compatible with Docker.
+   - VisualVM: Offers detailed analysis of JVM performance and thread states.
 3. [Log Aggregation Tools](https://signoz.io/comparisons/log-aggregation-tools/):
-    - ELK Stack (Elasticsearch, Logstash, Kibana): Collects and analyzes logs from multiple containers.
-    - Fluentd: A flexible log collector that integrates well with Docker.
+   - ELK Stack (Elasticsearch, Logstash, Kibana): Collects and analyzes logs from multiple containers.
+   - Fluentd: A flexible log collector that integrates well with Docker.
 4. APM Solutions:
-    - SigNoz: Provides end-to-end tracing and performance monitoring for Java apps.
-    - Dynatrace: Offers AI-powered, full-stack monitoring capabilities.
+   - SigNoz: Provides end-to-end tracing and performance monitoring for Java apps.
+   - Dynatrace: Offers AI-powered, full-stack monitoring capabilities.
 
 ### Setting Up Basic Monitoring Infrastructure
 
@@ -61,8 +65,8 @@ To effectively monitor Java applications in Docker, you need a combination of [c
 ### Steps Involved
 
 1. Docker Initialization and Metrics Exposure
-Run `docker init` in your project's root directory to set up basic Docker configurations or environment variables.
-Add the following configuration to your [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration file, typically found at:
+   Run `docker init` in your project's root directory to set up basic Docker configurations or environment variables.
+   Add the following configuration to your [Docker daemon](https://signoz.io/guides/docker-daemon-logs/) configuration file, typically found at:
 
 - Windows: `C:\ProgramData\Docker\config\daemon.json`
 - Linux: `/etc/docker/daemon.json`
@@ -70,8 +74,8 @@ Add the following configuration to your [Docker daemon](https://signoz.io/guides
 
 ```json
 {
-  "metrics-addr" : "127.0.0.1:9323",
-  "experimental" : true
+  "metrics-addr": "127.0.0.1:9323",
+  "experimental": true
 }
 ```
 
@@ -91,7 +95,7 @@ scrape_configs:
       - targets: ['localhost:9323']
 ```
 
-This configuration instructs Prometheus to collect metrics from the Docker daemon every 15 seconds by accessing the endpoint at `localhost:9323`. 
+This configuration instructs Prometheus to collect metrics from the Docker daemon every 15 seconds by accessing the endpoint at `localhost:9323`.
 
 Note: Prometheus’ Image can also be pulled from Docker CLI using the command:
 
@@ -99,7 +103,7 @@ Note: Prometheus’ Image can also be pulled from Docker CLI using the command:
 docker pull prom/prometheus:latest
 ```
 
-In that case we are not required to locate `prometheus.yml` and modify it for default variables like [localhost](http://localhost) or scrape interval. These can be easily modified in the Docker UI when we run its container. 
+In that case we are not required to locate `prometheus.yml` and modify it for default variables like [localhost](http://localhost) or scrape interval. These can be easily modified in the Docker UI when we run its container.
 
 3. Setting Up [Centralized Logging](https://signoz.io/blog/centralized-logging/) (Fluentd)
 
@@ -108,22 +112,21 @@ To centralize and manage container logs, use Fluentd as the logging driver for D
 This setup directs container logs to a Fluentd instance running on `localhost:24224`. You can pull the Fluentd image and run it in Docker, adjusting variables like `fluentd-address` as needed when starting the container.
 
 - Pull the Fluentd Image: If you haven't already pulled the Fluentd image, you can do so using the `docker pull` command.
-    
-    ```
-    docker pull fluent/fluentd
-    ```
-    
+  ```
+  docker pull fluent/fluentd
+  ```
 - Run the Fluentd Container: Start the Fluentd container without specifying a custom configuration file. The default configuration will be used.
-    
-    ```
-    docker run -d -p 24224:24224 fluent/fluentd
-    ```
-    
-    The above command instructs docker to start a new container in `d` i.e. detached mode(in background). The `p 24224:24224` tells it to map port 24224 on the host to port 24224 in the container. This allows Fluentd to receive logs on this port. Lastly, `fluent/fluentd` specifies the Fluentd image to use.
-    
+  ```
+  docker run -d -p 24224:24224 fluent/fluentd
+  ```
+  The above command instructs docker to start a new container in `d` i.e. detached mode(in background). The `p 24224:24224` tells it to map port 24224 on the host to port 24224 in the container. This allows Fluentd to receive logs on this port. Lastly, `fluent/fluentd` specifies the Fluentd image to use.
 - This directs container logs to a Fluentd instance running on localhost:24224.
 
-<Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled.webp" alt="Adding Port Number in Fluentd" caption="Adding Port Number in Fluentd" />
+<Figure
+  src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled.webp"
+  alt="Adding Port Number in Fluentd"
+  caption="Adding Port Number in Fluentd"
+/>
 
 To perform the same using the `fluent.conf` file in `/fluentd/etc/fluent.conf` we can add the code below:
 
@@ -136,7 +139,11 @@ logging:
 
 This is the screen you will see on running the container.
 
-<Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%201.webp" alt="Running Java application in Docker Container." caption="Running Java application in Docker Container." />
+<Figure
+  src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%201.webp"
+  alt="Running Java application in Docker Container."
+  caption="Running Java application in Docker Container."
+/>
 
 4. Establishing Alerting (Optional)
 
@@ -147,19 +154,19 @@ For alerting, you can set up Prometheus Alertmanager or integrate with third-par
 To ensure optimal performance of your Java application in Docker, focus on these key metrics:
 
 1. CPU Usage and Throttling:
-    - Monitor container CPU usage and any throttling events.
-    - Track JVM CPU consumption within the container.
+   - Monitor container CPU usage and any throttling events.
+   - Track JVM CPU consumption within the container.
 2. Memory Utilization:
-    - Observe container memory usage and limits.
-    - Monitor JVM heap usage and garbage collection metrics.
+   - Observe container memory usage and limits.
+   - Monitor JVM heap usage and garbage collection metrics.
 3. Network I/O:
-    - Track network traffic in and out of the container.
-    - Monitor connection pool statistics for database or service connections.
+   - Track network traffic in and out of the container.
+   - Monitor connection pool statistics for database or service connections.
 4. Container-Specific Metrics:
-    - Restart count: Indicates stability issues.
-    - Uptime: Helps identify unexpected restarts or crashes.
+   - Restart count: Indicates stability issues.
+   - Uptime: Helps identify unexpected restarts or crashes.
 
-Prometheus can be used to monitor stats. Docker provides a tab to view the stats as well, and we also open the website locally on the local host server for the UI. 
+Prometheus can be used to monitor stats. Docker provides a tab to view the stats as well, and we also open the website locally on the local host server for the UI.
 
 Prometheus can be configured to collect and visualize metrics from Docker containers, Java applications, and other services. It provides:
 
@@ -170,46 +177,54 @@ Prometheus can be configured to collect and visualize metrics from Docker contai
 To access the Prometheus UI:
 
 - Navigate to `http://localhost:<localhost portnumber>` in your web browser or view it in Docker stats. By default the port number is `9090:9090.`
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%202.webp" alt="link to prometheus local host" caption="link to prometheus local host" />
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%203.webp" alt="Prometheus Browser page" caption="Prometheus Browser page" />
-    
-    As we can see it provides various options for us like Graphs, Alerts, Status, etc.
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%202.webp"
+    alt="link to prometheus local host"
+    caption="link to prometheus local host"
+  />
+  <Figure
+    src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%203.webp"
+    alt="Prometheus Browser page"
+    caption="Prometheus Browser page"
+  />
+  As we can see it provides various options for us like Graphs, Alerts, Status, etc.
 - Use PromQL to query metrics and visualize them.
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-0e38c5de-d0ef-4c3d-ab33-a385a505021c.webp" alt="Visualizing Prometheus Stats" caption="Visualizing Prometheus Stats" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-0e38c5de-d0ef-4c3d-ab33-a385a505021c.webp"
+    alt="Visualizing Prometheus Stats"
+    caption="Visualizing Prometheus Stats"
+  />
 
-We can also use SigNoz with the Docker to monitor and analyze our Java Applicaiton. To instrument your Java application to send metrics to SigNoz. You can use [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) for this purpose. 
+We can also use SigNoz with the Docker to monitor and analyze our Java Applicaiton. To instrument your Java application to send metrics to SigNoz. You can use [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) for this purpose.
 
 ### Setting Up SigNoz with Docker
 
 To install SigNoz and monitor your applications, follow these steps:
 
 1. Clone the SigNoz Repository:
-    
-    ```
-    git clone -b main https://github.com/SigNoz/signoz.git && cd signoz/deploy/
-    ```
-    
+
+   ```
+   git clone -b main https://github.com/SigNoz/signoz.git && cd signoz/deploy/
+   ```
+
 2. Run SigNoz Using Docker Compose:
-    
-    ```
-    docker compose -f docker/clickhouse-setup/docker-compose.yaml up -d
-    ```
-    
+
+   ```
+   docker compose -f docker/clickhouse-setup/docker-compose.yaml up -d
+   ```
+
 3. Verify Installation:
-    
-    ```
-    docker ps
-    ```
-    
-    Ensure all containers are running correctly.
-    
+
+   ```
+   docker ps
+   ```
+
+   Ensure all containers are running correctly.
+
 4. Access the Dashboard:
-    - Open your browser and navigate to `http://localhost:3301/`.
+   - Open your browser and navigate to `http://localhost:3301/`.
 
 For detailed installation steps and additional options, refer to the [SigNoz Docker Installation Guide](https://signoz.io/docs/install/docker/).
 
@@ -218,23 +233,25 @@ For detailed installation steps and additional options, refer to the [SigNoz Doc
 Understanding Java metrics in a containerized environment requires special consideration:
 
 - JVM Heap Usage: Container memory limits can affect JVM memory allocation. Ensure your JVM settings align with container resources.
-    
-    Run the command to list the running containers
-    
-    ```java
-    docker ps
-    ```
-    
-    Run the command with the container ID to print the JVM heap usage.
-    
-    ```java
-    java -XX:+PrintFlagsFinal -version | grep HeapSize
-    ```
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%204.webp" alt="JVM heap usage in Docker" caption="JVM heap usage in Docker" />
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%205.webp" alt="CPU, memory usage and other stats" caption="CPU, memory usage and other stats" /> 
-    
+  Run the command to list the running containers
+  ```java
+  docker ps
+  ```
+  Run the command with the container ID to print the JVM heap usage.
+  ```java
+  java -XX:+PrintFlagsFinal -version | grep HeapSize
+  ```
+  {' '}
+  <Figure
+    src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%204.webp"
+    alt="JVM heap usage in Docker"
+    caption="JVM heap usage in Docker"
+  />
+  <Figure
+    src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%205.webp"
+    alt="CPU, memory usage and other stats"
+    caption="CPU, memory usage and other stats"
+  />
 - Garbage Collection: Analyze GC patterns to optimize memory usage and reduce performance impact.
 - Memory Leaks: Identify potential leaks by monitoring long-term memory usage trends.
 - Thread States: Correlate Java thread states with container resource usage to pinpoint performance bottlenecks.
@@ -244,106 +261,97 @@ Understanding Java metrics in a containerized environment requires special consi
 When issues arise in your containerized Java application, consider these common problems and their solutions:
 
 1. Java OutOfMemoryErrors:
-    - Cause: Insufficient memory allocation or memory leaks.
-    
-    The error may look something like this in the terminal
-    
-    <Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%206.webp" alt="Java out of memory error" caption="Java out of memory error" />
-    
-    - Possible Solutions:
-        
-        Adjust container memory limits and JVM heap settings as follows:
-        
-        - Increase Heap Size
-        
-        ```java
-        java -Xms512m -Xmx2048m -jar your-app.jar 
-        ```
-        
-        - Identify and Fix memory leaks
-        
-        ```java
-        java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/dumps -jar your-app.jar 
-        ```
-        
-        - Optimize JVM settings for frequent Garbage collections
-        
-        ```java
-        java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar your-app.jar
-        ```
-        
-        - Restarting the container can also sometimes solve the issue.
+
+   - Cause: Insufficient memory allocation or memory leaks.
+
+   The error may look something like this in the terminal
+
+   <Figure
+     src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%206.webp"
+     alt="Java out of memory error"
+     caption="Java out of memory error"
+   />
+
+   - Possible Solutions:
+     Adjust container memory limits and JVM heap settings as follows:
+     - Increase Heap Size
+     ```java
+     java -Xms512m -Xmx2048m -jar your-app.jar
+     ```
+     - Identify and Fix memory leaks
+     ```java
+     java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/dumps -jar your-app.jar
+     ```
+     - Optimize JVM settings for frequent Garbage collections
+     ```java
+     java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar your-app.jar
+     ```
+     - Restarting the container can also sometimes solve the issue.
+
 2. CPU Throttling:
-    - Cause: Container CPU limits are too restrictive.
-    - Possible Solutions:
-        - Increase CPU limits or optimize Java code for better CPU utilization. The `docker update` command can be useful to increase the limits of the CPU.
-            
-            ```java
-            docker update --cpu-shares 5120 -m 3000M ml-tm
-            ```
-            
-        - Continuously monitor CPU utilization to identify trends and potential issues.
+   - Cause: Container CPU limits are too restrictive.
+   - Possible Solutions:
+     - Increase CPU limits or optimize Java code for better CPU utilization. The `docker update` command can be useful to increase the limits of the CPU.
+       ```java
+       docker update --cpu-shares 5120 -m 3000M ml-tm
+       ```
+     - Continuously monitor CPU utilization to identify trends and potential issues.
 3. Network-Related Issues:
-    - Cause: Misconfigured network settings or connection pool exhaustion.
-    - Possible Solutions:
-        - Verify Docker network configuration; optimize connection pool settings.
-        - Always close connections in a final block or use try-with-resources to automatically close connections. Unused open connections until not collected by the garbage collector occupy the space.
-        - Implement mechanisms to detect and log connection leaks. Some connection pool libraries, like HikariCP, provide built-in leak detection features.
+   - Cause: Misconfigured network settings or connection pool exhaustion.
+   - Possible Solutions:
+     - Verify Docker network configuration; optimize connection pool settings.
+     - Always close connections in a final block or use try-with-resources to automatically close connections. Unused open connections until not collected by the garbage collector occupy the space.
+     - Implement mechanisms to detect and log connection leaks. Some connection pool libraries, like HikariCP, provide built-in leak detection features.
 4. Classpath and Dependency Problems:
-    - Cause: Incorrect JAR file inclusion or version conflicts.
-    - Possible Solutions:
-        - Review the Docker image build process; use dependency management tools like Maven or Gradle.
-        - Make sure to use the latest stable versions only, but if there are still some dependency issues, different classloaders can be used. This might be complicated to implement and give unexpected problems which need to be addressed.
-        - Maven can be customized to run with different jar files of the same plugin. The `<executions>` and `<executions>` tags are used.
+   - Cause: Incorrect JAR file inclusion or version conflicts.
+   - Possible Solutions:
+     - Review the Docker image build process; use dependency management tools like Maven or Gradle.
+     - Make sure to use the latest stable versions only, but if there are still some dependency issues, different classloaders can be used. This might be complicated to implement and give unexpected problems which need to be addressed.
+     - Maven can be customized to run with different jar files of the same plugin. The `<executions>` and `<executions>` tags are used.
 
 ### Advanced Debugging Techniques
 
 For complex issues, employ these advanced debugging methods:
 
 1. Remote Debugging:
-    - Enable remote debugging in your Docker container:
-        
-        ```
-        ENV JAVA_TOOL_OPTIONS -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
-        ```
-        
-        Configures the JVM to start a remote debugging server that listens on port 5005. `transport=dt_socket` specifies socket transport, `server=y` means the JVM acts as the debug server, `suspend=n` means the JVM won't wait for a debugger to connect before starting, and `address=*` allows connections from any IP.
-        
+   - Enable remote debugging in your Docker container:
+     ```
+     ENV JAVA_TOOL_OPTIONS -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
+     ```
+     Configures the JVM to start a remote debugging server that listens on port 5005. `transport=dt_socket` specifies socket transport, `server=y` means the JVM acts as the debug server, `suspend=n` means the JVM won't wait for a debugger to connect before starting, and `address=*` allows connections from any IP.
 2. JVM Flight Recorder:
-    - JVM Flight Recorder (JFR) is a feature of the Java Virtual Machine (JVM) that provides a comprehensive and low-overhead way to collect detailed performance data and diagnostic information.
-        
-        ```bash
-        docker exec -it <container_id> jcmd <pid> JFR.start
-        ```
-        
-        Starts Java Flight Recorder for the JVM process with the given PID, capturing detailed runtime information for performance analysis. You can also specify options like recording duration and file output.
-        
+   - JVM Flight Recorder (JFR) is a feature of the Java Virtual Machine (JVM) that provides a comprehensive and low-overhead way to collect detailed performance data and diagnostic information.
+     ```bash
+     docker exec -it <container_id> jcmd <pid> JFR.start
+     ```
+     Starts Java Flight Recorder for the JVM process with the given PID, capturing detailed runtime information for performance analysis. You can also specify options like recording duration and file output.
 3. [Distributed Tracing](https://signoz.io/blog/distributed-tracing/):
-    - Implement OpenTelemetry for end-to-end request tracing across microservices. To learn more about OpenTelemetry [visit](https://signoz.io/blog/opentelemetry-distributed-tracing-part-1/).
-4. Thread Dumps and Heap Analysis: 
-    - Generate thread dumps, useful for diagnosing thread-related issues such as deadlocks or performance bottlenecks.:
-        
-        ```bash
-        docker exec -it <container_id> jcmd <pid> Thread.print
-        ```
-        
-        Outputs the state of all threads in the JVM process with the given PID, including their stack traces. 
-        
-    - Perform heap analysis using tools like jmap and MAT (Memory Analyzer Tool).
+   - Implement OpenTelemetry for end-to-end request tracing across microservices. To learn more about OpenTelemetry [visit](https://signoz.io/blog/opentelemetry-distributed-tracing-part-1/).
+4. Thread Dumps and Heap Analysis:
+   - Generate thread dumps, useful for diagnosing thread-related issues such as deadlocks or performance bottlenecks.:
+     ```bash
+     docker exec -it <container_id> jcmd <pid> Thread.print
+     ```
+     Outputs the state of all threads in the JVM process with the given PID, including their stack traces.
+   - Perform heap analysis using tools like jmap and MAT (Memory Analyzer Tool).
 
 ## Monitoring Java App with SigNoz
 
-SigNoz provides a comprehensive solution for monitoring Java applications in Docker containers. 
+SigNoz provides a comprehensive solution for monitoring Java applications in Docker containers.
 
 1. SetUp SigNoz
-    
-    <GetStartedSigNoz />
-    
+
+   <GetStartedSigNoz />
+
 2. Instrument your Java application with OpenTelemetry.
 3. Configure the [OpenTelemetry agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) to send data to SigNoz.
 4. View metrics, traces, and logs in the SigNoz dashboard.
 
-<Figure src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%207.webp" alt="Signoz Dashboard" caption="Signoz Dashboard" />
+<Figure
+  src="/img/guides/2024/08/monitoring-and-troubleshooting-java-applications-in-docker-containers-Untitled%207.webp"
+  alt="Signoz Dashboard"
+  caption="Signoz Dashboard"
+/>
 
 For detailed instructions, refer to the [SigNoz Java monitoring guide](https://signoz.io/blog/opentelemetry-java/).
 
@@ -352,17 +360,17 @@ For detailed instructions, refer to the [SigNoz Java monitoring guide](https://s
 Follow these best practices to optimize your Java app monitoring in Docker:
 
 1. Implement proper resource limits and requests:
-    - Set appropriate CPU and memory limits for your containers.
-    - Use resource requests to ensure minimum required resources.
+   - Set appropriate CPU and memory limits for your containers.
+   - Use resource requests to ensure minimum required resources.
 2. Optimize JVM settings for containerized environments:
-    - Use the `XX:+UseContainerSupport` flag for better resource awareness.
-    - Set appropriate heap size limits based on container memory.
+   - Use the `XX:+UseContainerSupport` flag for better resource awareness.
+   - Set appropriate heap size limits based on container memory.
 3. Design effective logging strategies:
-    - Use [structured logging](https://signoz.io/blog/structured-logs/) formats (e.g., JSON) for easier parsing.
-    - Implement log rotation to manage log file sizes.
+   - Use [structured logging](https://signoz.io/blog/structured-logs/) formats (e.g., JSON) for easier parsing.
+   - Implement log rotation to manage log file sizes.
 4. Implement health checks and readiness probes:
-    - Add Docker health checks to monitor application status.
-    - Use Kubernetes readiness probes for proper service discovery.
+   - Add Docker health checks to monitor application status.
+   - Use Kubernetes readiness probes for proper service discovery.
 
 ## Key Takeaways
 
@@ -389,4 +397,4 @@ Use JVM heap analysis tools in conjunction with container memory metrics. Monito
 
 Key settings include `-XX:+UseContainerSupport`, appropriate heap size limits, and garbage collection tuning. Adjust these based on your container's resource limits and application requirements.
 
-Starts Java Flight Recorder for the JVM process with the given PID, capturing detailed runtime information for performance analysis. You can also specify options like recording duration and file output.
\ No newline at end of file
+Starts Java Flight Recorder for the JVM process with the given PID, capturing detailed runtime information for performance analysis. You can also specify options like recording duration and file output.
diff --git a/data/guides/monitoring-java-applications.mdx b/data/guides/monitoring-java-applications.mdx
index 1686883cb..6178fc861 100644
--- a/data/guides/monitoring-java-applications.mdx
+++ b/data/guides/monitoring-java-applications.mdx
@@ -1,6 +1,5 @@
 ---
 title: Java Application Monitoring - How to & Top 10 Tools
-slug: monitoring-java-applications
 date: 2024-08-20
 tags: [monitoring, apm]
 authors: [niyati_thakkar]
diff --git a/data/guides/network-observability.mdx b/data/guides/network-observability.mdx
index 0759b7c7a..016ae2d97 100644
--- a/data/guides/network-observability.mdx
+++ b/data/guides/network-observability.mdx
@@ -1,61 +1,82 @@
 ---
-
 title: Network Observability - Key to Modern IT Performance
-slug: network-observability
 date: 2024-09-24
 tags: [observability]
 authors: [manjunath_irukulla]
 description: Discover how network observability revolutionizes IT performance. Learn key components, implementation strategies, and future trends in this comprehensive guide.
-keywords: [network observability, IT performance, network monitoring, cloud computing, AIOps, network management, DevOps, SigNoz]
-
+keywords:
+  [
+    network observability,
+    IT performance,
+    network monitoring,
+    cloud computing,
+    AIOps,
+    network management,
+    DevOps,
+    SigNoz,
+  ]
 ---
 
-Network observability goes beyond merely collecting data on network performance, it provides a comprehensive, it provides a comprehensive understanding of the entire network ecosystem. By leveraging telemetry data from routers, switches, firewalls, servers, and applications, observability tools allow organizations to visualize the intricate interactions within their networks. 
+Network observability goes beyond merely collecting data on network performance, it provides a comprehensive, it provides a comprehensive understanding of the entire network ecosystem. By leveraging telemetry data from routers, switches, firewalls, servers, and applications, observability tools allow organizations to visualize the intricate interactions within their networks.
 
-This holistic view enables IT professionals to quickly identify and resolve issues before they impact service quality. 
+This holistic view enables IT professionals to quickly identify and resolve issues before they impact service quality.
 
 ## What is Network Observability?
 
 Network observability is the ability to gain comprehensive visibility into the internal state of your network by analyzing its outputs. Unlike traditional network monitoring, which limits itself to predefined metrics and alerts, observability takes a more holistic approach.
 
-Network observability enables network administrators and engineers to ask open-ended questions, explore unknown issues, and gain insights that weren’t previously obvious. 
+Network observability enables network administrators and engineers to ask open-ended questions, explore unknown issues, and gain insights that weren’t previously obvious.
 
 ### Key components of network observability include:
 
-<Figure src="/img/guides/2024/09/network-observability-key_components_of_Network_Monitoring.webp" alt="" caption="" />- Data Collection: Gathering telemetry from various sources, including routers, switches, firewalls, servers, and cloud infrastructure. This comprises network logs, metrics, traces, and events.
+<Figure
+  src="/img/guides/2024/09/network-observability-key_components_of_Network_Monitoring.webp"
+  alt=""
+  caption=""
+/>
+- Data Collection: Gathering telemetry from various sources, including routers, switches, firewalls,
+servers, and cloud infrastructure. This comprises network logs, metrics, traces, and events.
 
-<Figure src="/img/guides/2024/09/network-observability-Data_Collection_-_2.webp" alt="Collecting Telemetry Data from Devices." caption="Collecting Telemetry Data from Devices." /> 
+<Figure
+  src="/img/guides/2024/09/network-observability-Data_Collection_-_2.webp"
+  alt="Collecting Telemetry Data from Devices."
+  caption="Collecting Telemetry Data from Devices."
+/>{' '}
 
 - Analysis: The collected data is processed, correlated, and analyzed to uncover patterns and identify root causes of performance issues. This often involves the use of advanced analytics to detect anomalies.
 - Visualization: Dashboards and visual tools are critical for understanding the health of your network at a glance. Well-designed visualisations highlight important trends and issues, making it easier for teams to quickly grasp network conditions.
 
-Artificial Intelligence (AI) and Machine Learning (ML) play crucial roles in network observability. These technologies enable automated analysis of vast amounts of data, detecting patterns that humans might miss. AI and ML algorithms can predict potential issues, allowing teams to resolve problems before they escalate, thereby reducing downtime and optimizing network performance.  
+Artificial Intelligence (AI) and Machine Learning (ML) play crucial roles in network observability. These technologies enable automated analysis of vast amounts of data, detecting patterns that humans might miss. AI and ML algorithms can predict potential issues, allowing teams to resolve problems before they escalate, thereby reducing downtime and optimizing network performance.
 
 ### The Evolution of Network Management
 
-The journey from basic network management to modern network observability reflects the increasing complexity of today’s IT infrastructure. Let’s take a brief look at how management has evolved. 
+The journey from basic network management to modern network observability reflects the increasing complexity of today’s IT infrastructure. Let’s take a brief look at how management has evolved.
 
-| Aspect | Early Network Management | Traditional Monitoring | Modern Network Observability |
-| --- | --- | --- | --- |
-| Primary Focus | Basic connectivity checks | Monitoring predefined metrics (e.g., bandwidth, CPU) | Real-time insights and comprehensive visibility |
-| Technology Used  | Ping tests, basic traffic monitoring | SNMP-based tools | Advanced tools with AI/ML for deeper analysis |
-| Metric Scope | Limited to connectivity | Bandwidth, CPU, packet loss | Network behaviour, performance, dependencies |
-| Data Insights | Simple, minimal insights | Predefined, lacks contextual data | Correlated, contextual insights across distributed systems |
-| Environment Type | Basic local networks | Local networks and data centers | Cloud-native, microservices, hybrid cloud environments |
-| Issue Detection | Reactive (based on device failure or downtime) | Reactive (altered after threshold breach) | Proactive 0predictive, real-time issue detection) |
-| Scalability  | Not scalable | Scales to larger networks but with limitations | Scales to handle complex, distributed environments |
-| Real-Time Analysis | Not available  | Limited | Real-time, with predictive analytics and anomaly detection |
-| Example Use Case | Checking if devices are connected | Monitoring bandwidth usage across routers | Monitoring cloud-based microservices and infrastructure.  |
+| Aspect             | Early Network Management                       | Traditional Monitoring                               | Modern Network Observability                               |
+| ------------------ | ---------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------- |
+| Primary Focus      | Basic connectivity checks                      | Monitoring predefined metrics (e.g., bandwidth, CPU) | Real-time insights and comprehensive visibility            |
+| Technology Used    | Ping tests, basic traffic monitoring           | SNMP-based tools                                     | Advanced tools with AI/ML for deeper analysis              |
+| Metric Scope       | Limited to connectivity                        | Bandwidth, CPU, packet loss                          | Network behaviour, performance, dependencies               |
+| Data Insights      | Simple, minimal insights                       | Predefined, lacks contextual data                    | Correlated, contextual insights across distributed systems |
+| Environment Type   | Basic local networks                           | Local networks and data centers                      | Cloud-native, microservices, hybrid cloud environments     |
+| Issue Detection    | Reactive (based on device failure or downtime) | Reactive (altered after threshold breach)            | Proactive 0predictive, real-time issue detection)          |
+| Scalability        | Not scalable                                   | Scales to larger networks but with limitations       | Scales to handle complex, distributed environments         |
+| Real-Time Analysis | Not available                                  | Limited                                              | Real-time, with predictive analytics and anomaly detection |
+| Example Use Case   | Checking if devices are connected              | Monitoring bandwidth usage across routers            | Monitoring cloud-based microservices and infrastructure.   |
 
 ## Why Network Observability is Crucial for Modern IT
 
 In the rapidly evolving IT landscape, the complexity of infrastructure has reached unprecedented levels. Organizations are increasingly adopting hybrid cloud and multi-cloud environments, leveraging containerized applications and microservices architectures to stay agile and competitive.
 
-This shift, while offering flexibility and scalability, also introduces a tangled web of interdependencies and challenges that make traditional monitoring tools insufficient. 
+This shift, while offering flexibility and scalability, also introduces a tangled web of interdependencies and challenges that make traditional monitoring tools insufficient.
 
-Network observability emerges as a vital solution, offering comprehensive visibility across your entire infrastructure. Here’s why it is essential for modern IT operations: 
+Network observability emerges as a vital solution, offering comprehensive visibility across your entire infrastructure. Here’s why it is essential for modern IT operations:
 
-<Figure src="/img/guides/2024/09/network-observability-f0ebfa79-08d4-4cce-bbf4-8d66e560025c.webp" alt="Benefits of Network Observability" caption="Benefits of Network Observability" />
+<Figure
+  src="/img/guides/2024/09/network-observability-f0ebfa79-08d4-4cce-bbf4-8d66e560025c.webp"
+  alt="Benefits of Network Observability"
+  caption="Benefits of Network Observability"
+/>
 
 - Faster Troubleshooting: In complex environments, identifying the root cause of issues can be daunting. Network observability enhances your ability to detect and diagnose problems swiftly, significantly reducing Mean Time to Resolution (MTTR). With actionable insights, IT teams can quickly pinpoint the origins of slowdowns or outages, effectively minimizing downtime.
 - Proactive Performance Management: By continuously monitoring network performance, observability enables organizations to identify potential issues before they affect users. This proactive approach helps maintain optimal service levels and enhances overall user satisfaction.
@@ -65,87 +86,95 @@ Network observability emerges as a vital solution, offering comprehensive visibi
 
 ## Key Components of Network Observability
 
-<Figure src="/img/guides/2024/09/network-observability-napkin-selection.webp" alt="Key Components of Network Observability" caption="Key Components of Network Observability" />
+<Figure
+  src="/img/guides/2024/09/network-observability-napkin-selection.webp"
+  alt="Key Components of Network Observability"
+  caption="Key Components of Network Observability"
+/>
 
-Understanding the key components of network observability is essential for organizations aiming to enhance their IT infrastructure performance and reliability. By leveraging these components, businesses can gain comprehensive insights into their network operations, enabling proactive management and optimization. Here are the fundamental elements of network observability. 
+Understanding the key components of network observability is essential for organizations aiming to enhance their IT infrastructure performance and reliability. By leveraging these components, businesses can gain comprehensive insights into their network operations, enabling proactive management and optimization. Here are the fundamental elements of network observability.
 
 - Telemetry Data Collection:
-    - Packets: Capture detailed data about network traffic, providing insights into individual data transmissions.
-    - Flows: Aggregated traffic information that summarizes data movement across the network, helping identify patterns and trends.
-    - Logs: Record events from network devices and applications, offering a historical view that aids in troubleshooting and compliance.
-    - Metrics: Provided quantitative network performance measurements, such as latency, bandwidth utilization, and error rates, essential for assessing overall health.
+  - Packets: Capture detailed data about network traffic, providing insights into individual data transmissions.
+  - Flows: Aggregated traffic information that summarizes data movement across the network, helping identify patterns and trends.
+  - Logs: Record events from network devices and applications, offering a historical view that aids in troubleshooting and compliance.
+  - Metrics: Provided quantitative network performance measurements, such as latency, bandwidth utilization, and error rates, essential for assessing overall health.
 - Real-time Analytics:
-    - Data Collection: Integrates information from various sources to create a cohesive understanding of network behaviour.
-    - Anomaly Detection: Utilizes AI and ML algorithms to identify unusual patterns that may indicate performance issues or security threats.
-    - Root Cause Analysis: Facilitates quick identification of underlying issues, allowing IT teams to address problems efficiently.
+  - Data Collection: Integrates information from various sources to create a cohesive understanding of network behaviour.
+  - Anomaly Detection: Utilizes AI and ML algorithms to identify unusual patterns that may indicate performance issues or security threats.
+  - Root Cause Analysis: Facilitates quick identification of underlying issues, allowing IT teams to address problems efficiently.
 - Visualization Tools:
-    - Customizable Dashboards: Tailor visual interfaces for different stakeholders, ensuring relevant information is easily accessible.
-    - Real-Time Updates: Provide immediate insights into network status and performance metrics, aiding in timely decision-making.
-    - Drill-Down Capabilities: Allow users to explore data in detail, enhancing the ability to diagnose specific issues.
+  - Customizable Dashboards: Tailor visual interfaces for different stakeholders, ensuring relevant information is easily accessible.
+  - Real-Time Updates: Provide immediate insights into network status and performance metrics, aiding in timely decision-making.
+  - Drill-Down Capabilities: Allow users to explore data in detail, enhancing the ability to diagnose specific issues.
 - Automated Anomaly Detection:
-    - AI-Powered Systems: Learn normal behaviour patterns within the network, enabling rapid identification of derivations.
-    - Alert Mechanisms: Trigger notifications for any anomalies detected, ensuring that IT teams can respond swiftly to potential issues.
-    - Predictive Analysis: Forecast future problems based on historical data trends, allowing for proactive adjustments before issues escalate.
+  - AI-Powered Systems: Learn normal behaviour patterns within the network, enabling rapid identification of derivations.
+  - Alert Mechanisms: Trigger notifications for any anomalies detected, ensuring that IT teams can respond swiftly to potential issues.
+  - Predictive Analysis: Forecast future problems based on historical data trends, allowing for proactive adjustments before issues escalate.
 
 ## How to Implement Network Observability
 
-<Figure src="/img/guides/2024/09/network-observability-napkin-selection%201.webp" alt="How to implement Network Observability" caption="How to implement Network Observability" />
+<Figure
+  src="/img/guides/2024/09/network-observability-napkin-selection%201.webp"
+  alt="How to implement Network Observability"
+  caption="How to implement Network Observability"
+/>
 
-Implementing network observability is essential for organizations aiming to enhance their network performance and reliability. Here’s a streamlined, step-by-step guide to effectively implement network observability: 
+Implementing network observability is essential for organizations aiming to enhance their network performance and reliability. Here’s a streamlined, step-by-step guide to effectively implement network observability:
 
 - Assess Current Capabilities: To effectively implement network observability, organizations must first assess their current capabilities. This involves:
-    - Evaluate Existing Tools: Conduct a thorough audit of your current monitoring and observability tools. Assess their effectiveness in providing visibility across your network.
-    - Identify Gaps: Look for areas lacking visibility, such as blind spots in network traffic, under-monitored applications, or sufficient data collection methods. This assessment will help you understand where improvements are necessary.
+  - Evaluate Existing Tools: Conduct a thorough audit of your current monitoring and observability tools. Assess their effectiveness in providing visibility across your network.
+  - Identify Gaps: Look for areas lacking visibility, such as blind spots in network traffic, under-monitored applications, or sufficient data collection methods. This assessment will help you understand where improvements are necessary.
 - Define Objectives: Once the current capabilities are assessed, organizations should define clear objectives for their network observability efforts.
-    - Determine Insights Needed: Clearly outline the specific insights you require from your network observability efforts. This could include performance metrics, user experience indicators, or security threat detection.
-    - Set Clear Goals: Establish measurable objectives, such as reducing Mean Time to Resolution (MTTR) by a certain percentage, improving application response times, or enhancing overall user satisfaction.
+  - Determine Insights Needed: Clearly outline the specific insights you require from your network observability efforts. This could include performance metrics, user experience indicators, or security threat detection.
+  - Set Clear Goals: Establish measurable objectives, such as reducing Mean Time to Resolution (MTTR) by a certain percentage, improving application response times, or enhancing overall user satisfaction.
 - Select Appropriate Tools: The right tools are critical for effective network observability.
-    - Choose the Right Platforms: Research and select observability tools that fit your organization’s needs. Look for platforms that offer compatibility with your existing technology stack and can scale as your infrastructure grows.
-    - Consider Features: Evaluate features such as data visualization capabilities, real-time analytics, machine learning for anomaly detection, and ease of integration with other systems.
+  - Choose the Right Platforms: Research and select observability tools that fit your organization’s needs. Look for platforms that offer compatibility with your existing technology stack and can scale as your infrastructure grows.
+  - Consider Features: Evaluate features such as data visualization capabilities, real-time analytics, machine learning for anomaly detection, and ease of integration with other systems.
 - Implement Data Collection: Effective data collection is foundational to successful observability.
-    - Deploy Agents and Collectors: Install agents on critical devices and applications to gather telemetry data effectively. Ensure that data collection covers all aspects of your network, including cloud environments, on-premises systems, and hybrid setups.
-    - Ensure Comprehensive Coverage: Map out all critical systems and services to ensure no essential components are left unmonitored.
+  - Deploy Agents and Collectors: Install agents on critical devices and applications to gather telemetry data effectively. Ensure that data collection covers all aspects of your network, including cloud environments, on-premises systems, and hybrid setups.
+  - Ensure Comprehensive Coverage: Map out all critical systems and services to ensure no essential components are left unmonitored.
 - Configure Analytics and Alerting: Setting up analytics and alerting mechanisms is vital for proactive network management.
-    - Set Up Dashboards: Create customizable dashboards tailored to different teams (e.g., IT operations, security, development) to provide relevant insights at a glance. Dashboards should facilitate quick decision-making based on real-time data.
-    - Define Alert Thresholds: Establish clear thresholds for alerts based on historical performance data and business priorities. Implement escalation procedures to ensure timely responses to critical issues.
+  - Set Up Dashboards: Create customizable dashboards tailored to different teams (e.g., IT operations, security, development) to provide relevant insights at a glance. Dashboards should facilitate quick decision-making based on real-time data.
+  - Define Alert Thresholds: Establish clear thresholds for alerts based on historical performance data and business priorities. Implement escalation procedures to ensure timely responses to critical issues.
 - Train Your Team: A well-trained team is essential for maximizing the benefits of observability tools.
-    - Provide Training Sessions: Organize training workshops for IT staff to familiarize them with the observability tools and best practices for data analysis.
-    - Encourage a Data-Driven Culture: Promote an organizational culture that values data-driven decision-making by sharing success stories and insights gained from observability efforts.
+  - Provide Training Sessions: Organize training workshops for IT staff to familiarize them with the observability tools and best practices for data analysis.
+  - Encourage a Data-Driven Culture: Promote an organizational culture that values data-driven decision-making by sharing success stories and insights gained from observability efforts.
 - Continuously Refine: Finally, organizations should commit to continuously refining their observability strategy
-    - Regularly Review Strategy: Schedule periodic reviews of your observability strategy to assess its effectiveness. Gather feedback from stakeholders and make necessary adjustments based on evolving business needs.
-    - Stay Updated: Keep abreast of new features, industry trends, and best practices in network observability to continuously enhance your approach.
+  - Regularly Review Strategy: Schedule periodic reviews of your observability strategy to assess its effectiveness. Gather feedback from stakeholders and make necessary adjustments based on evolving business needs.
+  - Stay Updated: Keep abreast of new features, industry trends, and best practices in network observability to continuously enhance your approach.
 
 ### Overcoming Common Implementation Challenges
 
 Implementing network observability isn't without its hurdles. Here are some common challenges and strategies to overcome them:
 
 - Data Volume Management: The sheer volume of telemetry data generated by network devices can overwhelm storage and processing capabilities, making it difficult to extract meaningful insights.
-    - Implement Efficient Storage Solutions: Use scalable storage solutions that can handle large volumes of telemetry data without compromising performance.
-    - Establish Retention Policies: Define retention policies that balance the need for historical data with storage costs.
+  - Implement Efficient Storage Solutions: Use scalable storage solutions that can handle large volumes of telemetry data without compromising performance.
+  - Establish Retention Policies: Define retention policies that balance the need for historical data with storage costs.
 - Integration Difficulties: Integrating new observability tools with existing IT systems can be complex, leading to compatibility and operational disruptions.
-    - Select Tools with Robust APIs: Choose observability platforms that offer strong APIs and pre-built integrations with other tools in your tech stack to facilitate seamless connectivity.
-    - Conduct Pilot Tests: Run pilot tests for new tools before full-scale implementation to identify integration challenges early on.
+  - Select Tools with Robust APIs: Choose observability platforms that offer strong APIs and pre-built integrations with other tools in your tech stack to facilitate seamless connectivity.
+  - Conduct Pilot Tests: Run pilot tests for new tools before full-scale implementation to identify integration challenges early on.
 - Addressing Privacy Concerns: Collecting and analyzing telemetry data raises privacy and compliance issues, particularly regarding sensitive information.
-    - Enforce Data Governance Policies: Develop comprehensive data governance policies that outline how telemetry data will be collected, stored, and used while ensuring compliance with regulations (e.g., GDPR).
-    - Utilize Anonymization Techniques: Run pilot tests for new tools before full-scale implementation to identify integration challenges early on.
+  - Enforce Data Governance Policies: Develop comprehensive data governance policies that outline how telemetry data will be collected, stored, and used while ensuring compliance with regulations (e.g., GDPR).
+  - Utilize Anonymization Techniques: Run pilot tests for new tools before full-scale implementation to identify integration challenges early on.
 - Cultural Resistance: Resistance from team members who are accustomed to traditional monitoring methods can hinder the adoption of new observability practices.
-    - Demonstrate Quick Wins: Showcase early successes from observability initiatives to build confidence among stakeholders.
-    - Communicate ROI Clearly: Present clear metrics demonstrating the return on investment from improved network performance and reduced downtime.
+  - Demonstrate Quick Wins: Showcase early successes from observability initiatives to build confidence among stakeholders.
+  - Communicate ROI Clearly: Present clear metrics demonstrating the return on investment from improved network performance and reduced downtime.
 
 ## Leveraging SigNoz for Network Observability
 
-SigNoz, an open-source observability platform, offers a powerful solution for gaining comprehensive insights into your network’s performance, security, and overall health. By integrating SigNoz into your IT infrastructure, you can unlock a wealth of benefits that will transform the way you manage and optimize your network. 
+SigNoz, an open-source observability platform, offers a powerful solution for gaining comprehensive insights into your network’s performance, security, and overall health. By integrating SigNoz into your IT infrastructure, you can unlock a wealth of benefits that will transform the way you manage and optimize your network.
 
-### Key Features for Network Observability: 
+### Key Features for Network Observability:
 
 - End-to-End Tracing: SigNoz provides powerful [distributed tracing](https://signoz.io/blog/distributed-tracing/) capabilities that allow you to follow the path of requests as they flow through your network.
-    - This end-to-end visibility helps you identify bottlenecks, understand dependencies between services, and quickly pinpoint the root cause of performance issues.
+  - This end-to-end visibility helps you identify bottlenecks, understand dependencies between services, and quickly pinpoint the root cause of performance issues.
 - Metrics collection and visualization: SigNoz collects a wide range of network metrics, including throughput, latency, error rates, and more.
-    - The platform offers customizable dashboards and visualisations that make it easy to monitor critical performance indicators and spot trends or anomalies.
+  - The platform offers customizable dashboards and visualisations that make it easy to monitor critical performance indicators and spot trends or anomalies.
 - Log Management and Analysis: SigNoz integrates log management functionality, enabling you to collect, store, and analyze logs from various network devices and applications.
-    - The advanced log querying capabilities allow you to quickly filter, search, and correlate log data to troubleshoot problems and gain deeper insights.
+  - The advanced log querying capabilities allow you to quickly filter, search, and correlate log data to troubleshoot problems and gain deeper insights.
 - AI-Powered Anomaly Detection: SigNoz leverages machine learning algorithms to automatically detect anomalies in network behaviour.
-    - The platform establishes baselines for normal performance and sends alerts when deviations occur, allowing you to proactively address potential issues before they impact users or services.
+  - The platform establishes baselines for normal performance and sends alerts when deviations occur, allowing you to proactively address potential issues before they impact users or services.
 
 ### Benefits of Using SigNoz for Network Observability:
 
@@ -156,26 +185,26 @@ SigNoz, an open-source observability platform, offers a powerful solution for ga
 
 <GetStartedSigNoz />
 
-Whether you choose the cloud or self-hosted option, SigNoz provides the tools you need to gain deep insights into your network's behaviour. SigNoz is a comprehensive choice for organizations looking to enhance their network observability capabilities and drive better business outcomes. 
+Whether you choose the cloud or self-hosted option, SigNoz provides the tools you need to gain deep insights into your network's behaviour. SigNoz is a comprehensive choice for organizations looking to enhance their network observability capabilities and drive better business outcomes.
 
 ## Future Trends in Network Observability
 
-The field of network observability is undergoing rapid transformation, driven by technological advancements and evolving business needs. Here are some key trends to watch for as we move forward: 
+The field of network observability is undergoing rapid transformation, driven by technological advancements and evolving business needs. Here are some key trends to watch for as we move forward:
 
 - AIOps Integration: The integration of Artificial Intelligence for IT Operations (AIOps) will become increasingly prevalent.
-    - This trend will enable predictive insights, automated remediation of issues, and enhanced decision-making processes, allowing organizations to respond to network anomalies with greater speed and efficiency.
+  - This trend will enable predictive insights, automated remediation of issues, and enhanced decision-making processes, allowing organizations to respond to network anomalies with greater speed and efficiency.
 - Intent-Based Networking (IBN): Intent-Based Networking (IBN) is a modern approach to network management that leverages artificial intelligence (AI), machine learning (ML), and orchestration to automate the configuration and management of networks based on high-level business intents.
-    - By automating routine tasks and configurations, IBM reduces the workload on network administrators, allowing them to focus on strategic initiatives rather than manual management.
-    - Insights gained from continuous analytics help organizations make informed decisions about network performance and resource allocation.
+  - By automating routine tasks and configurations, IBM reduces the workload on network administrators, allowing them to focus on strategic initiatives rather than manual management.
+  - Insights gained from continuous analytics help organizations make informed decisions about network performance and resource allocation.
 - Edge Computing Observability: As edge computing grows, observability solutions will expand their capabilities to monitor these distributed environments effectively.
-    - This includes providing visibility into devices and applications located at the network edge, which is critical for real-time data processing and decision-making.
+  - This includes providing visibility into devices and applications located at the network edge, which is critical for real-time data processing and decision-making.
 - [Unified Observability](https://signoz.io/unified-observability/): There will be a significant shift towards unified observability platforms that integrate network, application, and [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/). This trend aims to provide a comprehensive view of the entire IT ecosystem, enabling organizations to correlate data across different domains for better insights and faster troubleshooting.
 - Open Standards: Initiatives like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) will drive the adoption of open standards in observability data collection and analysis.
-    - This trend will facilitate interoperability between different observability tools and promote a more collaborative ecosystem, allowing organizations to choose best-of-breed solutions without vendor lock-in.
+  - This trend will facilitate interoperability between different observability tools and promote a more collaborative ecosystem, allowing organizations to choose best-of-breed solutions without vendor lock-in.
 - Proactive Performance Management: Organizations will adopt more proactive strategies for performance management, and utilize observability insights to anticipate issues before they escalate into significant problems.
-    - This trend emphasizes the importance of [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and analysis in maintaining optimal network performance.
+  - This trend emphasizes the importance of [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and analysis in maintaining optimal network performance.
 - Expansion of Multi-Cloud Observability: As organizations adopt multi-cloud strategies, there will be a growing need for observability solutions that provide visibility across various cloud platforms.
-    - This trend will help organizations manage complex cloud environments effectively while ensuring consistent performance and security.
+  - This trend will help organizations manage complex cloud environments effectively while ensuring consistent performance and security.
 
 ## Key Takeaways
 
@@ -189,13 +218,13 @@ The field of network observability is undergoing rapid transformation, driven by
 
 ### What's the difference between network monitoring and network observability?
 
-| Aspect | Network Monitoring | Network Observability |
-| --- | --- | --- |
-| Focus | Narrow, specific metrics and device health | Wide, comprehensive view of network health and behaviour |
-| Data Collected | Basic, uptime, bandwidth, device availability | Comprehensive, logs, metrics, traces, flows and telemetry |
-| Alerts | Predefined rules based on thresholds | Predefined and AI-driven anomaly detection  |
-| Contextual Understanding | Limited context, often reactive | Holistic understanding of network state and performance |
-| Use Cases | Monitoring for uptime and performance metrics | Root cause analysis, performance optimization anomaly detection |
+| Aspect                   | Network Monitoring                            | Network Observability                                           |
+| ------------------------ | --------------------------------------------- | --------------------------------------------------------------- |
+| Focus                    | Narrow, specific metrics and device health    | Wide, comprehensive view of network health and behaviour        |
+| Data Collected           | Basic, uptime, bandwidth, device availability | Comprehensive, logs, metrics, traces, flows and telemetry       |
+| Alerts                   | Predefined rules based on thresholds          | Predefined and AI-driven anomaly detection                      |
+| Contextual Understanding | Limited context, often reactive               | Holistic understanding of network state and performance         |
+| Use Cases                | Monitoring for uptime and performance metrics | Root cause analysis, performance optimization anomaly detection |
 
 ### How does network observability improve IT performance?
 
@@ -216,4 +245,4 @@ The field of network observability is undergoing rapid transformation, driven by
 
 - Visibility During Migration: Observability tools provide insights into application dependencies and performance impacts, enabling cloud migration.
 - Monitoring Hybrid Environments: Ongoing visibility into cloud-based and on-premises infrastructure ensures optimal performance post-migration.
-- Compatibility with Cloud-Native Technologies: Observability solutions should support the monitoring of modern, dynamic cloud environments and architectures.
\ No newline at end of file
+- Compatibility with Cloud-Native Technologies: Observability solutions should support the monitoring of modern, dynamic cloud environments and architectures.
diff --git a/data/guides/new-qb-json-migration.mdx b/data/guides/new-qb-json-migration.mdx
index cd0181acd..b5697d099 100644
--- a/data/guides/new-qb-json-migration.mdx
+++ b/data/guides/new-qb-json-migration.mdx
@@ -1,7 +1,5 @@
 ---
 title: Query Builder Migration
-slug: new-qb-json-migration
-id: new-qb-json-migration
 date: 2025-08-14
 description: Guide to help in query builder migration
 authors: [srikanthccv]
@@ -22,6 +20,7 @@ In v5, `aggregateOperator` and `aggregateAttribute` are combined with `expressio
 #### For Traces/Logs
 
 **Before (v4)**:
+
 ```json
 {
   "builder": {
@@ -29,7 +28,7 @@ In v5, `aggregateOperator` and `aggregateAttribute` are combined with `expressio
       {
         "aggregateOperator": "avg",
         "aggregateAttribute": {
-            "key": "duration_nano"
+          "key": "duration_nano"
         }
       }
     ]
@@ -38,14 +37,17 @@ In v5, `aggregateOperator` and `aggregateAttribute` are combined with `expressio
 ```
 
 **After (v5)**:
+
 ```json
 {
   "builder": {
     "queryData": [
       {
-        "aggregations": [{
-          "expression": "avg(duration_nano)"
-        }]
+        "aggregations": [
+          {
+            "expression": "avg(duration_nano)"
+          }
+        ]
       }
     ]
   }
@@ -59,6 +61,7 @@ Currently, calculating max, min, and avg values for numeric attributes in logs/t
 #### For Metrics
 
 **Before (v4)**:
+
 ```json
 {
   "aggregateOperator": "p99",
@@ -70,17 +73,21 @@ Currently, calculating max, min, and avg values for numeric attributes in logs/t
 ```
 
 **After (v5)**:
+
 ```json
 {
-  "aggregations": [{
-    "metricName": "signoz_latency.bucket",
-    "spaceAggregation": "p99",
-    "reduceTo": "avg"
-  }]
+  "aggregations": [
+    {
+      "metricName": "signoz_latency.bucket",
+      "spaceAggregation": "p99",
+      "reduceTo": "avg"
+    }
+  ]
 }
 ```
 
 **Before (v4)**:
+
 ```json
 {
   "aggregateOperator": "p99",
@@ -93,14 +100,17 @@ Currently, calculating max, min, and avg values for numeric attributes in logs/t
 ```
 
 **After (v5)**:
+
 ```json
 {
-  "aggregations": [{
-    "metricName": "signoz_calls_total",
-    "spaceAggregation": "sum",
-    "timeAggregation": "rate",
-    "reduceTo": "avg"
-  }]
+  "aggregations": [
+    {
+      "metricName": "signoz_calls_total",
+      "spaceAggregation": "sum",
+      "timeAggregation": "rate",
+      "reduceTo": "avg"
+    }
+  ]
 }
 ```
 
@@ -113,6 +123,7 @@ Currently, multiple aggregations are available only for traces and logs. Support
 Filters change from structured objects to SQL-like expression:
 
 **Before (v4)**:
+
 ```json
 {
   "filters": {
@@ -147,6 +158,7 @@ Filters change from structured objects to SQL-like expression:
 ```
 
 **After (v5)**:
+
 ```json
 {
   "filter": {
@@ -167,22 +179,28 @@ Remains unchanged for dashboards.
 ### 4. Order By Changes
 
 **Before (v4)**:
+
 ```json
 {
-  "orderBy": [{
-    "columnName": "#SIGNOZ_VALUE",
-    "order": "desc"
-  }]
+  "orderBy": [
+    {
+      "columnName": "#SIGNOZ_VALUE",
+      "order": "desc"
+    }
+  ]
 }
 ```
 
 **After (v5)**:
+
 ```json
 {
-  "orderBy": [{
-    "columnName": "count()",
-    "order": "desc"
-  }]
+  "orderBy": [
+    {
+      "columnName": "count()",
+      "order": "desc"
+    }
+  ]
 }
 ```
 
@@ -205,6 +223,7 @@ Single naming scheme to work with variables across the product
 The having clause transforms from an array of conditions to a expression:
 
 **Before (v4)**:
+
 ```json
 {
   "having": [
@@ -223,6 +242,7 @@ The having clause transforms from an array of conditions to a expression:
 ```
 
 **After (v5)**:
+
 ```json
 {
   "having": {
@@ -240,6 +260,7 @@ This cryptic placeholder is only understandable to the original developer. We're
 Functions now use named argument format:
 
 **Before (v4)**:
+
 ```json
 {
   "functions": [
@@ -252,14 +273,13 @@ Functions now use named argument format:
 ```
 
 **After (v5)**:
+
 ```json
 {
   "functions": [
     {
       "name": "cutOffMin",
-      "args": [
-        {"name": "threshold", "value": 2}
-      ]
+      "args": [{ "name": "threshold", "value": 2 }]
     }
   ]
 }
@@ -268,28 +288,31 @@ Functions now use named argument format:
 ### 8. Dashboard Widget Example
 
 **HTTP Endpoint Monitoring Widget - Before (v4)**:
+
 ```json
 {
   "query": {
     "builder": {
-      "queryData": [{
-        "aggregateOperator": "count",
-        "dataSource": "traces",
-        "filters": {
-          "items": [
-            {"key": {"key": "serviceName"}, "op": "=", "value": "{{.service.name}}"},
-            {"key": {"key": "httpMethod"}, "op": "exists"},
-            {"key": {"key": "spanKind"}, "op": "=", "value": "Server"}
+      "queryData": [
+        {
+          "aggregateOperator": "count",
+          "dataSource": "traces",
+          "filters": {
+            "items": [
+              { "key": { "key": "serviceName" }, "op": "=", "value": "{{.service.name}}" },
+              { "key": { "key": "httpMethod" }, "op": "exists" },
+              { "key": { "key": "spanKind" }, "op": "=", "value": "Server" }
+            ],
+            "op": "AND"
+          },
+          "groupBy": [
+            { "key": "httpRoute", "type": "tag" },
+            { "key": "httpMethod", "type": "tag" }
           ],
-          "op": "AND"
-        },
-        "groupBy": [
-          {"key": "httpRoute", "type": "tag"},
-          {"key": "httpMethod", "type": "tag"}
-        ],
-        "orderBy": [{"columnName": "#SIGNOZ_VALUE", "order": "desc"}],
-        "queryName": "A"
-      }]
+          "orderBy": [{ "columnName": "#SIGNOZ_VALUE", "order": "desc" }],
+          "queryName": "A"
+        }
+      ]
     },
     "queryType": "builder"
   }
@@ -297,23 +320,23 @@ Functions now use named argument format:
 ```
 
 **After (v5)**:
+
 ```json
 {
   "query": {
     "builder": {
-      "queryData": [{
-        "aggregations": [{"expression": "count()"}],
-        "dataSource": "traces",
-        "filter": {
-          "expression": "(serviceName = $service.name AND httpMethod EXISTS AND spanKind = 'Server')"
-        },
-        "groupBy": [
-          {"key": "httpRoute"},
-          {"key": "httpMethod"}
-        ],
-        "orderBy": [{"columnName": "count()", "order": "desc"}],
-        "queryName": "A"
-      }]
+      "queryData": [
+        {
+          "aggregations": [{ "expression": "count()" }],
+          "dataSource": "traces",
+          "filter": {
+            "expression": "(serviceName = $service.name AND httpMethod EXISTS AND spanKind = 'Server')"
+          },
+          "groupBy": [{ "key": "httpRoute" }, { "key": "httpMethod" }],
+          "orderBy": [{ "columnName": "count()", "order": "desc" }],
+          "queryName": "A"
+        }
+      ]
     },
     "queryType": "builder"
   }
@@ -338,7 +361,7 @@ resource "signoz_alert" "error_rate_alert" {
   # All other fields remain unchanged
   ...
   version            = "v5"  # Required for v5 migration
-  
+
   # Only the condition field changes - use the new v5 format
   condition = jsonencode({
     "compositeQuery": {
@@ -380,7 +403,7 @@ resource "signoz_alert" "error_rate_alert" {
     "matchType": "1",
     "selectedQueryName": "F1"
   })
-  
+
   # All other fields remain unchanged
   ...
 }
@@ -393,12 +416,14 @@ resource "signoz_alert" "error_rate_alert" {
 The alerts is moving from separate query type objects to a unified `queries` array:
 
 #### Fields Removed in v5
+
 - `aggregateOperator` and `aggregateAttribute`
 - `filters` (replaced by `filter.expression`)
 - `builderQueries`, `promQueries`, `chQueries` (unified into `queries`)
 - `temporality`, `timeAggregation`, `spaceAggregation` (moved into aggregations for metrics)
 
 #### New Fields in v5
+
 - `queries` array containing all query types
 - `type` field to identify query type
 - `spec` object containing query specification
@@ -406,6 +431,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
 - `filter.expression` for SQL-like filter syntax
 
 **Before (v4)**:
+
 ```json
 {
   "condition": {
@@ -438,6 +464,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
 ```
 
 **After (v5)**:
+
 ```json
 {
   "condition": {
@@ -448,7 +475,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "spec": {
             "name": "A",
             "signal": "traces",
-            "aggregations": [{"expression": "count()"}],
+            "aggregations": [{ "expression": "count()" }],
             "filter": {}
           }
         },
@@ -457,7 +484,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "spec": {
             "name": "B",
             "signal": "traces",
-            "aggregations": [{"expression": "avg(durationNano)"}],
+            "aggregations": [{ "expression": "avg(durationNano)" }],
             "filter": {}
           }
         },
@@ -477,6 +504,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
 ### 2. Error Rate Alert Example
 
 **Before (v4)**:
+
 ```json
 {
   "condition": {
@@ -487,8 +515,8 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "dataSource": "traces",
           "filters": {
             "items": [
-              {"key": {"key": "serviceName"}, "op": "=", "value": "redis"},
-              {"key": {"key": "statusCode"}, "op": "=", "value": "STATUS_CODE_ERROR"}
+              { "key": { "key": "serviceName" }, "op": "=", "value": "redis" },
+              { "key": { "key": "statusCode" }, "op": "=", "value": "STATUS_CODE_ERROR" }
             ],
             "op": "AND"
           }
@@ -497,9 +525,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "aggregateOperator": "count",
           "dataSource": "traces",
           "filters": {
-            "items": [
-              {"key": {"key": "serviceName"}, "op": "=", "value": "redis"}
-            ]
+            "items": [{ "key": { "key": "serviceName" }, "op": "=", "value": "redis" }]
           }
         }
       },
@@ -515,6 +541,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
 ```
 
 **After (v5)**:
+
 ```json
 {
   "condition": {
@@ -525,7 +552,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "spec": {
             "name": "A",
             "signal": "traces",
-            "aggregations": [{"expression": "count()"}],
+            "aggregations": [{ "expression": "count()" }],
             "filter": {
               "expression": "serviceName = 'redis' AND statusCode = 'STATUS_CODE_ERROR'"
             }
@@ -536,7 +563,7 @@ The alerts is moving from separate query type objects to a unified `queries` arr
           "spec": {
             "name": "B",
             "signal": "traces",
-            "aggregations": [{"expression": "count()"}],
+            "aggregations": [{ "expression": "count()" }],
             "filter": {
               "expression": "serviceName = 'redis'"
             }
diff --git a/data/guides/new-relic-pricing.mdx b/data/guides/new-relic-pricing.mdx
index aa418c2ac..d9dd174b9 100644
--- a/data/guides/new-relic-pricing.mdx
+++ b/data/guides/new-relic-pricing.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: 💰 Unpacking New Relic's Pricing - Plans, Costs, and Optimization
-slug: new-relic-pricing
 date: 2025-02-18
 tags: [observability, pricing, monitoring]
 authors: [adil_shaikh]
 description: Discover New Relic's usage-based pricing model, compare plans, and learn cost optimization strategies for full-stack observability.
-keywords: [new relic pricing, observability costs, monitoring plans, usage-based pricing, data ingestion]
-
+keywords:
+  [new relic pricing, observability costs, monitoring plans, usage-based pricing, data ingestion]
 ---
 
 New Relic is a leading observability platform that has embraced a usage-based pricing model, making it distinct from traditional host-based pricing structures. Whether you're new to New Relic or looking to manage rising costs, this guide will break down its pricing model, help you estimate your expenses, and offer practical tips for optimizing your observability investment.
@@ -23,19 +21,19 @@ New Relic is a leading observability platform that has embraced a usage-based pr
 
 New Relic offers four distinct editions tailored to meet the varying needs of organizations, from small teams exploring observability to large enterprises managing complex workloads. Each edition provides a unique combination of features, support levels, and limits, enabling businesses to choose the plan that best aligns with their operational requirements.
 
-| Feature/Edition | Free | Standard | Pro | Enterprise |
-| --- | --- | --- | --- | --- |
-| **Data Ingestion** | 100 GB free | \$0.35/GB (Standard) | \$0.35/GB (Standard) | Custom |
-| **Data Plus (Optional)** | ❌ | \$0.55/GB | \$0.55/GB | Custom |
-| **Full Platform Users** | 1 free | \$10 (first user) | \$349/user (annual) | Custom |
-| **Extra Full Platform Users** | ❌ | \$99/user (max 5) | \$418.80/user (monthly) | Custom |
-| **Core Users** | Free | \$49/user | \$49/user | \$49/user |
-| **Basic Users** | Free (Unlimited) | Free (Unlimited) | Free (Unlimited) | Free (Unlimited) |
-| **Critical response SLA** | None | None | 2-hour SLA | 1-hour SLA |
-| **Support channels** | Community forum | Ticketed support | Ticketed support + In-app chat | In-app chat, email, Slack, phone |
-| **Synthetic Monitoring** | 500 checks/month | 10,000 checks/month | 10,000+ checks/month | 10,000+ checks/month |
-| **Data Plus Eligibility** | ❌ | No | Yes | Yes |
-| **Security Compliance** | No | No | No | FedRAMP & HIPAA eligible |
+| Feature/Edition               | Free             | Standard             | Pro                            | Enterprise                       |
+| ----------------------------- | ---------------- | -------------------- | ------------------------------ | -------------------------------- |
+| **Data Ingestion**            | 100 GB free      | \$0.35/GB (Standard) | \$0.35/GB (Standard)           | Custom                           |
+| **Data Plus (Optional)**      | ❌               | \$0.55/GB            | \$0.55/GB                      | Custom                           |
+| **Full Platform Users**       | 1 free           | \$10 (first user)    | \$349/user (annual)            | Custom                           |
+| **Extra Full Platform Users** | ❌               | \$99/user (max 5)    | \$418.80/user (monthly)        | Custom                           |
+| **Core Users**                | Free             | \$49/user            | \$49/user                      | \$49/user                        |
+| **Basic Users**               | Free (Unlimited) | Free (Unlimited)     | Free (Unlimited)               | Free (Unlimited)                 |
+| **Critical response SLA**     | None             | None                 | 2-hour SLA                     | 1-hour SLA                       |
+| **Support channels**          | Community forum  | Ticketed support     | Ticketed support + In-app chat | In-app chat, email, Slack, phone |
+| **Synthetic Monitoring**      | 500 checks/month | 10,000 checks/month  | 10,000+ checks/month           | 10,000+ checks/month             |
+| **Data Plus Eligibility**     | ❌               | No                   | Yes                            | Yes                              |
+| **Security Compliance**       | No               | No                   | No                             | FedRAMP & HIPAA eligible         |
 
 ### 1. Free Edition: A No-Cost Entry Point
 
@@ -45,13 +43,13 @@ The Free edition is perfect for individuals or small teams taking their first st
 
 - **Data Ingestion:** \$0.35/GB beyond the free 100 GB limit for additional data ingestion.
 - **Users:**
-    - 1 full platform user included.
-    - Unlimited basic and core users
+  - 1 full platform user included.
+  - Unlimited basic and core users
 
 **Key Features and Limits**
 
 - **Data Ingestion:** Up to 100 GB ingested per month free of charge.
-    - If you exceed the 100 GB limit in a calendar month, additional data ingestion is disabled until the next month. The ingestion resets at the start of each new month, though it may take up to 24 hours for the service to resume.
+  - If you exceed the 100 GB limit in a calendar month, additional data ingestion is disabled until the next month. The ingestion resets at the start of each new month, though it may take up to 24 hours for the service to resume.
 
 **Feature Restrictions**
 
@@ -71,15 +69,15 @@ The Standard edition is designed for small teams looking to go beyond the Free e
 - **Data Ingestion:** **\$0.35/GB** beyond 100 GB free limit.
 - **Data Plus (optional):** **\$0.55/GB**.
 - **Users:**
-    - First full platform user costs **\$10/month**.
-    - Additional full platform users cost **\$99/month**, up to a maximum of 5.
-    - Core users billed at **\$49/user/month**.
+  - First full platform user costs **\$10/month**.
+  - Additional full platform users cost **\$99/month**, up to a maximum of 5.
+  - Core users billed at **\$49/user/month**.
 
 **Key Features**
 
 - **Support:**
-    - Ticketed technical support included.
-    - 48-hour response SLA for support tickets.
+  - Ticketed technical support included.
+  - 48-hour response SLA for support tickets.
 - **Authentication:** Includes SAML single sign-on (SSO) for improved security and ease of access.
 
 The Standard edition is a cost-effective solution for teams that need moderate data ingestion capabilities and basic support for troubleshooting.
@@ -97,11 +95,11 @@ The Pro edition caters to organizations with larger teams and more complex opera
 **Key Features**
 
 - **Scalability:**
-    - Supports unlimited full platform users.
-    - Designed for teams with more than five engineers working across complex environments.
+  - Supports unlimited full platform users.
+  - Designed for teams with more than five engineers working across complex environments.
 - **Support:**
-    - Includes ticketed support with a 2-hour critical initial response SLA.
-    - Provides faster troubleshooting for urgent issues.
+  - Includes ticketed support with a 2-hour critical initial response SLA.
+  - Provides faster troubleshooting for urgent issues.
 - **Data Options:** Eligible for the Data Plus option, which enhances data retention, query limits, and cloud flexibility.
 - **Billing:** Requires a commitment contract, meaning pay-as-you-go billing is not available.
 
@@ -121,15 +119,19 @@ The Enterprise edition is designed for large-scale organizations with stringent
 **Key Features**
 
 - **Security and Compliance:**
-    - FedRAMP and HIPAA eligibility when paired with the Data Plus option.
+  - FedRAMP and HIPAA eligibility when paired with the Data Plus option.
 - **Support:**
-    - Includes Priority ticket routing for expedited issue resolution.
-    - Offers a 1-hour critical initial response SLA, ensuring immediate attention to high-priority issues.
+  - Includes Priority ticket routing for expedited issue resolution.
+  - Offers a 1-hour critical initial response SLA, ensuring immediate attention to high-priority issues.
 - **Scalability:** Ideal for organizations operating across multiple regions or with complex infrastructures.
 
 The Enterprise edition is perfect for organizations that prioritize compliance, security, and premium support while managing large-scale, distributed workloads.
 
-<Figure src="/img/guides/2025/02/new-relic-pricing-image.webp" alt="New Relic pricing tiers by Edition" caption="New Relic pricing tiers by Edition" />
+<Figure
+  src="/img/guides/2025/02/new-relic-pricing-image.webp"
+  alt="New Relic pricing tiers by Edition"
+  caption="New Relic pricing tiers by Edition"
+/>
 
 <NewRelicVsSigNoz />
 
@@ -137,7 +139,11 @@ The Enterprise edition is perfect for organizations that prioritize compliance,
 
 Understanding the nuances of New Relic's pricing model helps you optimize costs and maximize value. Let's explore the two main cost drivers in detail:
 
-<Figure src="/img/guides/2025/02/new-relic-pricing-New_Relic_Pricing_Model1.webp" alt="New Relic Pricing Model" caption="New Relic Pricing Model" />
+<Figure
+  src="/img/guides/2025/02/new-relic-pricing-New_Relic_Pricing_Model1.webp"
+  alt="New Relic Pricing Model"
+  caption="New Relic Pricing Model"
+/>
 
 ### 1. Data Ingestion
 
@@ -151,13 +157,16 @@ Data ingestion is the cornerstone of New Relic's pricing structure, determining
 **Data Plus Option**
 
 - \$0.55/GB: Offers advanced features and extended retention:
-    - **Retention Extension:** Adds up to 90 days of data retention, enabling deeper historical insights and long-term trend analysis.
-    - **Enhanced Security:** Features include advanced log obfuscation, vulnerability management (public preview), and compliance with HIPAA and FedRAMP standards for security-sensitive industries.
-    - **Query Capacity:** Allows up to 60 billion data points per minute and query durations of up to 10 minutes, a significant increase compared to the standard plan (20 billion data points/min and 1-minute query duration).
-    - **Cloud Flexibility:** Supports multiple cloud providers, enabling alignment with your deployment model and storage preferences.
-    
-    <Figure src="/img/guides/2025/02/new-relic-pricing-image%201.webp" alt="Data Ingest UI" caption="Data Ingest UI" />
-    
+  - **Retention Extension:** Adds up to 90 days of data retention, enabling deeper historical insights and long-term trend analysis.
+  - **Enhanced Security:** Features include advanced log obfuscation, vulnerability management (public preview), and compliance with HIPAA and FedRAMP standards for security-sensitive industries.
+  - **Query Capacity:** Allows up to 60 billion data points per minute and query durations of up to 10 minutes, a significant increase compared to the standard plan (20 billion data points/min and 1-minute query duration).
+  - **Cloud Flexibility:** Supports multiple cloud providers, enabling alignment with your deployment model and storage preferences.
+  {' '}
+  <Figure
+    src="/img/guides/2025/02/new-relic-pricing-image%201.webp"
+    alt="Data Ingest UI"
+    caption="Data Ingest UI"
+  />
 
 **No Hidden Costs**
 
@@ -173,42 +182,42 @@ Both options include egress and hydration at no additional charge, ensuring that
 New Relic categorizes users into three types—Basic, Core, and Full Platform users—based on the features they can access. Choosing the appropriate user type is crucial for managing costs and aligning access to organizational needs. Here's a breakdown of the types and their billing implications:
 
 - **Basic Users**
-    - **Cost:** Free
-    - **Features:** Access basic observability tools, create custom dashboards (data retention up to 7 days), run queries, configure alerts, and use some basic monitoring.
-    - **Billing Note:** Basic users are free, but they can drive costs for usage-based features like the Advanced Compute add-on (e.g., CodeStream CCU usage).
-    - **Ideal For:** Non-technical roles, C-suite executives, and team members involved in planning or using high-level analytics.
+  - **Cost:** Free
+  - **Features:** Access basic observability tools, create custom dashboards (data retention up to 7 days), run queries, configure alerts, and use some basic monitoring.
+  - **Billing Note:** Basic users are free, but they can drive costs for usage-based features like the Advanced Compute add-on (e.g., CodeStream CCU usage).
+  - **Ideal For:** Non-technical roles, C-suite executives, and team members involved in planning or using high-level analytics.
 - **Core Users**
-    - **Cost:** Billable (pricing depends on your New Relic subscription).
-    - **Features:** Access to more advanced developer tools, such as:
-        - New Relic CodeStream for IDE integration and debugging.
-        - Errors Inbox for centralized error tracking.
-        - [Logs UI](https://signoz.io/blog/logs-ui/) for advanced log analysis.
-    - **Billing Note:** Core users are billed for their subscription tier. CodeStream usage incurs CCU costs when tied to Advanced Compute.
-    - **Ideal For:** Developers focused on debugging, log analysis, and error tracking, without full platform access.
+  - **Cost:** Billable (pricing depends on your New Relic subscription).
+  - **Features:** Access to more advanced developer tools, such as:
+    - New Relic CodeStream for IDE integration and debugging.
+    - Errors Inbox for centralized error tracking.
+    - [Logs UI](https://signoz.io/blog/logs-ui/) for advanced log analysis.
+  - **Billing Note:** Core users are billed for their subscription tier. CodeStream usage incurs CCU costs when tied to Advanced Compute.
+  - **Ideal For:** Developers focused on debugging, log analysis, and error tracking, without full platform access.
 - **Full Platform Users**
-    - **Cost:** Billable (pricing depends on your New Relic subscription).
-    - **Features:** Full access to New Relic’s curated UI experiences and observability tools, such as:
-        - APM, browser, and mobile monitoring.
-        - Infrastructure monitoring and synthetic testing.
-        - Machine learning model performance tracking (MLOps) and Kubernetes monitoring.
-    - **Billing Note:** Full platform users are billed at the highest rate but gain unrestricted access to all New Relic features.
-    - **Ideal For:** DevOps engineers, site reliability engineers (SREs), and team members responsible for [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/), triaging workflows, and incident resolution.
+  - **Cost:** Billable (pricing depends on your New Relic subscription).
+  - **Features:** Full access to New Relic’s curated UI experiences and observability tools, such as:
+    - APM, browser, and mobile monitoring.
+    - Infrastructure monitoring and synthetic testing.
+    - Machine learning model performance tracking (MLOps) and Kubernetes monitoring.
+  - **Billing Note:** Full platform users are billed at the highest rate but gain unrestricted access to all New Relic features.
+  - **Ideal For:** DevOps engineers, site reliability engineers (SREs), and team members responsible for [end-to-end monitoring](https://signoz.io/comparisons/end-to-end-monitoring-tools/), triaging workflows, and incident resolution.
 
 Here's a brief summary of what each user type gets access to:
 
-| Feature/Access | Basic User | Core User | Full Platform User |
-| --- | --- | --- | --- |
-| Cost | Free | Billable (Advanced Compute usage billed by CCU) | Billable |
-| Custom Dashboard | Yes (quickstart dashboards, up to 7 days) | Yes | Yes |
-| Data Queries | Yes | Yes | Yes |
-| Alerts | Basic alerting features | Yes | Yes |
-| APM, Browser, Mobile Monitoring | No | No | Yes |
-| Infrastructure Monitoring | No | No | Yes |
-| Synthetic Monitoring | No | No | Yes |
-| Errors Inbox | No | Yes | Yes |
-| Log Management UI | No | Yes | Yes |
-| New Relic CodeStream | No | Yes (usage billed under Advanced Compute if enabled) | Yes (usage billed under Advanced Compute if enabled) |
-| Ideal For | Observability setup, basic analytics, and monitoring | Developers needing tools like CodeStream and logs UI without full platform access | DevOps engineers and users responsible for application reliability and management workflows |
+| Feature/Access                  | Basic User                                           | Core User                                                                         | Full Platform User                                                                          |
+| ------------------------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Cost                            | Free                                                 | Billable (Advanced Compute usage billed by CCU)                                   | Billable                                                                                    |
+| Custom Dashboard                | Yes (quickstart dashboards, up to 7 days)            | Yes                                                                               | Yes                                                                                         |
+| Data Queries                    | Yes                                                  | Yes                                                                               | Yes                                                                                         |
+| Alerts                          | Basic alerting features                              | Yes                                                                               | Yes                                                                                         |
+| APM, Browser, Mobile Monitoring | No                                                   | No                                                                                | Yes                                                                                         |
+| Infrastructure Monitoring       | No                                                   | No                                                                                | Yes                                                                                         |
+| Synthetic Monitoring            | No                                                   | No                                                                                | Yes                                                                                         |
+| Errors Inbox                    | No                                                   | Yes                                                                               | Yes                                                                                         |
+| Log Management UI               | No                                                   | Yes                                                                               | Yes                                                                                         |
+| New Relic CodeStream            | No                                                   | Yes (usage billed under Advanced Compute if enabled)                              | Yes (usage billed under Advanced Compute if enabled)                                        |
+| Ideal For                       | Observability setup, basic analytics, and monitoring | Developers needing tools like CodeStream and logs UI without full platform access | DevOps engineers and users responsible for application reliability and management workflows |
 
 ### Choosing the Right User Type
 
@@ -221,52 +230,52 @@ Here's a brief summary of what each user type gets access to:
 New Relic offers flexible pricing tailored to your data, user, and compute needs. To estimate your monthly costs effectively, you must evaluate several factors in detail:
 
 1. **Data Ingest Estimation**
-    - Data Costs (Monthly):
-        - Free Tier: 100 GB of data ingest is free each month.
-        - Beyond Free Limit:
-            - Standard Option: \$0.35/GB for additional data.
-            - Data Plus: \$0.55/GB for enhanced features like FedRAMP Moderate and HIPAA compliance.
-    - **Steps to Estimate Data Costs:**
-        - Analyze Current Data Volume: Review your current monitoring data volumes across logs, APM, infrastructure monitoring, and other telemetry sources.
-        - Plan for Growth and Spikes: Account for data growth trends and seasonal traffic spikes.
-        - Retention Settings:
-            - Standard retention (8 days) is sufficient for daily troubleshooting.
-            - Data Plus offers extended retention (up to 90 days), ideal for long-term analysis and compliance
+   - Data Costs (Monthly):
+     - Free Tier: 100 GB of data ingest is free each month.
+     - Beyond Free Limit:
+       - Standard Option: \$0.35/GB for additional data.
+       - Data Plus: \$0.55/GB for enhanced features like FedRAMP Moderate and HIPAA compliance.
+   - **Steps to Estimate Data Costs:**
+     - Analyze Current Data Volume: Review your current monitoring data volumes across logs, APM, infrastructure monitoring, and other telemetry sources.
+     - Plan for Growth and Spikes: Account for data growth trends and seasonal traffic spikes.
+     - Retention Settings:
+       - Standard retention (8 days) is sufficient for daily troubleshooting.
+       - Data Plus offers extended retention (up to 90 days), ideal for long-term analysis and compliance
 2. **User Requirements**
-    - User Types:
-        - Basic Users: Free, with view-only permissions.
-        - Core Users: \$49/user for core access and basic interaction capabilities.
-        - Full Platform Users:
-            - The free tier includes one free full platform user.
-            - Additional users:
-                - \$99/user (max 5) for Standard Edition.
-                - \$349/user (annual commitment) or \$418.80/user (monthly pay-as-you-go) for Pro Edition.
-    - Steps to Estimate User Costs:
-        - Identify Role Needs: Determine the number of team members needing advanced troubleshooting, such as developers and DevOps engineers.
-        - Edition-Specific Limits:
-            - Standard Edition is limited to 5 full platform users.
-            - Pro Edition allows unlimited full platform users.
+   - User Types:
+     - Basic Users: Free, with view-only permissions.
+     - Core Users: \$49/user for core access and basic interaction capabilities.
+     - Full Platform Users:
+       - The free tier includes one free full platform user.
+       - Additional users:
+         - \$99/user (max 5) for Standard Edition.
+         - \$349/user (annual commitment) or \$418.80/user (monthly pay-as-you-go) for Pro Edition.
+   - Steps to Estimate User Costs:
+     - Identify Role Needs: Determine the number of team members needing advanced troubleshooting, such as developers and DevOps engineers.
+     - Edition-Specific Limits:
+       - Standard Edition is limited to 5 full platform users.
+       - Pro Edition allows unlimited full platform users.
 3. **Compute Costs (Optional)**
-    - Compute Capacity Units (CCUs):
-        - Compute costs depend on usage of advanced features such as New Relic AI and Live Archives.
-        - Contact New Relic sales for pricing details and availability of this feature.
+   - Compute Capacity Units (CCUs):
+     - Compute costs depend on usage of advanced features such as New Relic AI and Live Archives.
+     - Contact New Relic sales for pricing details and availability of this feature.
 4. **Commitment Options**
-    - Choosing Between Monthly and Annual Plans:
-        - Annual plans offer discounted rates for full platform users compared to monthly pay-as-you-go pricing.
-        - Evaluate your expected usage growth over the commitment period to optimize costs.
+   - Choosing Between Monthly and Annual Plans:
+     - Annual plans offer discounted rates for full platform users compared to monthly pay-as-you-go pricing.
+     - Evaluate your expected usage growth over the commitment period to optimize costs.
 5. **Usage Monitoring and Alerts**
-    - Proactive Cost Management:
-        - Leverage New Relic’s usage dashboards to monitor data ingestion and user activity.
-        - Configure alerts to notify your team when nearing data or user thresholds, such as 85% of the monthly ingest limit.
+   - Proactive Cost Management:
+     - Leverage New Relic’s usage dashboards to monitor data ingestion and user activity.
+     - Configure alerts to notify your team when nearing data or user thresholds, such as 85% of the monthly ingest limit.
 
 ### 📌Example:
 
-| **Feature** | **Example Usage** | **Estimated Monthly Cost** |
-| --- | --- | --- |
-| **Data Ingestion** | 500GB | \$175 (Standard) / \$275 (Data Plus) |
-| **Full Platform Users** | 5 users | \$495 (Standard) / \$1,745 (Pro) |
-| **Synthetic Monitoring** | 10,000 checks | Included in paid plans |
-| **TOTAL** | **500GB + 5 users** | **\$670 (Standard) / \$2,020 (Pro)** |
+| **Feature**              | **Example Usage**   | **Estimated Monthly Cost**           |
+| ------------------------ | ------------------- | ------------------------------------ |
+| **Data Ingestion**       | 500GB               | \$175 (Standard) / \$275 (Data Plus) |
+| **Full Platform Users**  | 5 users             | \$495 (Standard) / \$1,745 (Pro)     |
+| **Synthetic Monitoring** | 10,000 checks       | Included in paid plans               |
+| **TOTAL**                | **500GB + 5 users** | **\$670 (Standard) / \$2,020 (Pro)** |
 
 ### Maximizing Value with Add-ons and Bundles
 
@@ -320,53 +329,57 @@ When evaluating observability solutions, it is crucial to understand how New Rel
 When evaluating observability solutions, engineering teams often weigh factors like cost, control, customization, and operational overhead. Here's a breakdown of key differences between [SigNoz](/product-comparison/signoz-vs-newrelic/) and New Relic, drawing from common considerations:
 
 1. 💰 **Cost and Pricing Model**
-    - SigNoz: SigNoz offers a cost-effective [alternative to New Relic](https://signoz.io/blog/open-source-newrelic-alternative/), especially for teams with high data volumes. With self-hosted deployments, you avoid per-GB ingestion fees, which can significantly reduce costs. You only pay for the infrastructure you manage, making expenses predictable and scalable.
-        - No user-based pricing: Unlike New Relic, SigNoz doesn’t charge per user seat, which can add up quickly for larger teams.
-        - Open-source option: The free, open-source community edition allows teams to get started without upfront costs.
-    - New Relic: Employs usage-based pricing, which includes costs for data ingestion and user seats. User-based pricing, in particular, can become a significant expense as teams grow, potentially leading to surprisingly high bills for large teams.
+   - SigNoz: SigNoz offers a cost-effective [alternative to New Relic](https://signoz.io/blog/open-source-newrelic-alternative/), especially for teams with high data volumes. With self-hosted deployments, you avoid per-GB ingestion fees, which can significantly reduce costs. You only pay for the infrastructure you manage, making expenses predictable and scalable.
+     - No user-based pricing: Unlike New Relic, SigNoz doesn’t charge per user seat, which can add up quickly for larger teams.
+     - Open-source option: The free, open-source community edition allows teams to get started without upfront costs.
+   - New Relic: Employs usage-based pricing, which includes costs for data ingestion and user seats. User-based pricing, in particular, can become a significant expense as teams grow, potentially leading to surprisingly high bills for large teams.
 2. 🔐 **Data Control and Privacy**
-    - SigNoz: SigNoz provides complete control over data storage, retention policies, and privacy. This makes it an ideal choice for organizations with strict compliance requirements or those handling sensitive data.
-        - Self-hosted and cloud options: Teams can choose between self-hosted deployments for full control or a managed cloud solution for convenience.
-        - No vendor lock-in: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-native support ensures compatibility with a wide range of tools and platforms.
-    - New Relic: As a SaaS platform, data storage is managed externally, potentially limiting flexibility. New Relic gives preference to its agent when ingesting data. If you want to do OpenTelemetry, SigNoz is the better choice
+   - SigNoz: SigNoz provides complete control over data storage, retention policies, and privacy. This makes it an ideal choice for organizations with strict compliance requirements or those handling sensitive data.
+     - Self-hosted and cloud options: Teams can choose between self-hosted deployments for full control or a managed cloud solution for convenience.
+     - No vendor lock-in: [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-native support ensures compatibility with a wide range of tools and platforms.
+   - New Relic: As a SaaS platform, data storage is managed externally, potentially limiting flexibility. New Relic gives preference to its agent when ingesting data. If you want to do OpenTelemetry, SigNoz is the better choice
 3. **🛠️ Customization and Querying Capabilities**
-    - SigNoz: SigNoz is built to be highly customizable, offering full access to its source code. This allows teams to tailor the platform to their unique requirements.
-        - OpenTelemetry-native: SigNoz is designed from the ground up to support OpenTelemetry, providing OTel-first documentation, visualizations, and features.
-        - Arbitrary attribute-based querying: Powered by ClickHouse, SigNoz enables complex aggregations and filtering on any attribute, making it easier to derive insights from observability data.
-    - New Relic: Provides standardized offerings that may be simpler to implement initially, but offer less flexibility. Requires NRQL to create queries that involves aggregations. NRQL has a steep learning curve and is complex to understand
+   - SigNoz: SigNoz is built to be highly customizable, offering full access to its source code. This allows teams to tailor the platform to their unique requirements.
+     - OpenTelemetry-native: SigNoz is designed from the ground up to support OpenTelemetry, providing OTel-first documentation, visualizations, and features.
+     - Arbitrary attribute-based querying: Powered by ClickHouse, SigNoz enables complex aggregations and filtering on any attribute, making it easier to derive insights from observability data.
+   - New Relic: Provides standardized offerings that may be simpler to implement initially, but offer less flexibility. Requires NRQL to create queries that involves aggregations. NRQL has a steep learning curve and is complex to understand
 4. ⚙️ **Infrastructure and Operational Overhead**
-    - SigNoz: SigNoz requires teams to manage their own infrastructure, including storage, compute, and network resources. While this adds some operational overhead, it also provides greater flexibility and control.
-        - Scalability: Teams can scale their observability infrastructure independently, ensuring it aligns with their specific needs.
-        - Optimized for OpenTelemetry: SigNoz’s architecture is designed to handle high-cardinality data efficiently, thanks to its use of ClickHouse.
-    - New Relic: A fully managed SaaS platform handles these operational tasks but limits the ability to customize configurations deeply.
+   - SigNoz: SigNoz requires teams to manage their own infrastructure, including storage, compute, and network resources. While this adds some operational overhead, it also provides greater flexibility and control.
+     - Scalability: Teams can scale their observability infrastructure independently, ensuring it aligns with their specific needs.
+     - Optimized for OpenTelemetry: SigNoz’s architecture is designed to handle high-cardinality data efficiently, thanks to its use of ClickHouse.
+   - New Relic: A fully managed SaaS platform handles these operational tasks but limits the ability to customize configurations deeply.
 
 ### New Relic vs. Datadog: Finding the Right Fit
 
 1. 🚀 **Pricing Model**
-    - New Relic: Usage-based pricing focused on data ingestion and user access. Advantageous for organizations with efficient data management, but requires close monitoring of ingestion volumes. User seat pricing impacts larger teams significantly.
-    - Datadog: Feature-based pricing with separate costs for different functionalities. More granular but potentially complex to predict total costs.
+
+   - New Relic: Usage-based pricing focused on data ingestion and user access. Advantageous for organizations with efficient data management, but requires close monitoring of ingestion volumes. User seat pricing impacts larger teams significantly.
+   - Datadog: Feature-based pricing with separate costs for different functionalities. More granular but potentially complex to predict total costs.
 
 2. **🔍 Cost Transparency**
-    - New Relic: Costs scale with data volume and users. While trackable, data spikes can cause significant cost variations.
-    - Datadog: Granular feature pricing provides control but requires careful planning to manage overall costs effectively.
+
+   - New Relic: Costs scale with data volume and users. While trackable, data spikes can cause significant cost variations.
+   - Datadog: Granular feature pricing provides control but requires careful planning to manage overall costs effectively.
 
 3. **📈 Scalability**
-    - New Relic: Flexible scaling based on data needs, but requires proactive data volume management.
-    - Datadog: Handles various deployment sizes well, with costs influenced by both infrastructure scale and feature usage.
+   - New Relic: Flexible scaling based on data needs, but requires proactive data volume management.
+   - Datadog: Handles various deployment sizes well, with costs influenced by both infrastructure scale and feature usage.
 
 ### New Relic vs. Dynatrace: The Battle for Enterprise Observability
 
 1. 🚀 **Pricing Model**
-    - New Relic: Usage-based model centered on data ingestion and user counts.
-    - Dynatrace: Host-unit based pricing model, with costs tied to monitored hosts and workloads. Generally less transparent pricing.
+
+   - New Relic: Usage-based model centered on data ingestion and user counts.
+   - Dynatrace: Host-unit based pricing model, with costs tied to monitored hosts and workloads. Generally less transparent pricing.
 
 2. **🔍 Cost Transparency**
-    - New Relic: Predictable pricing dependent on effective data and user management.
-    - Dynatrace: Comprehensive AI-driven features but complex pricing structure. Higher upfront costs typical.
+
+   - New Relic: Predictable pricing dependent on effective data and user management.
+   - Dynatrace: Comprehensive AI-driven features but complex pricing structure. Higher upfront costs typical.
 
 3. **📈 Scalability**
-    - New Relic: Well-suited for dynamic workloads with focus on data cost management.
-    - Dynatrace: Strong in enterprise environments needing AI automation, but higher costs require careful evaluation of ROI.
+   - New Relic: Well-suited for dynamic workloads with focus on data cost management.
+   - Dynatrace: Strong in enterprise environments needing AI automation, but higher costs require careful evaluation of ROI.
 
 <InterlinkCard title="Explore More New Relic Alternatives" href="/blog/new-relic-alternatives" />
 
@@ -387,21 +400,20 @@ By considering these factors, you can select a platform that balances cost, func
 ## Key Takeaways
 
 1. Flexible Pricing Model:
-    
-    New Relic’s pricing is based on usage, factoring in both data ingestion volumes and the number of users.
-    
+
+   New Relic’s pricing is based on usage, factoring in both data ingestion volumes and the number of users.
+
 2. Generous Free Tier:
-    
-    Includes 100 GB of monthly data ingest and unlimited Basic/Core users, making it accessible for teams of all sizes.
-    
+
+   Includes 100 GB of monthly data ingest and unlimited Basic/Core users, making it accessible for teams of all sizes.
+
 3. Enhanced Compliance and Security:
-    
-    The Data Plus tier offers advanced features tailored for organizations with stringent compliance and security requirements.
-    
+
+   The Data Plus tier offers advanced features tailored for organizations with stringent compliance and security requirements.
+
 4. Effective Cost Management:
-    
-    Optimize costs by closely monitoring data ingestion rates and strategically assigning user roles.
-    
+
+   Optimize costs by closely monitoring data ingestion rates and strategically assigning user roles.
 
 ## FAQs
 
@@ -443,4 +455,4 @@ New Relic consolidates over 30 capabilities into one platform, eliminating the n
 
 ### How does New Relic ensure data security compared to its competitors?
 
-New Relic provides advanced security options such as FedRAMP Moderate and HIPAA compliance for eligible accounts. With features like data obfuscation, vulnerability management, and encrypted data storage, New Relic offers superior security measures, often surpassing competitors’ default offerings.
\ No newline at end of file
+New Relic provides advanced security options such as FedRAMP Moderate and HIPAA compliance for eligible accounts. With features like data obfuscation, vulnerability management, and encrypted data storage, New Relic offers superior security measures, often surpassing competitors’ default offerings.
diff --git a/data/guides/observability-architecture.mdx b/data/guides/observability-architecture.mdx
index ddb0c1fe9..c32f05301 100644
--- a/data/guides/observability-architecture.mdx
+++ b/data/guides/observability-architecture.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Implementing Observability Architecture - A Practical Guide
-slug: observability-architecture
 date: 2024-08-14
 tags: [observability]
 authors: [eromosele]
 description: Learn how to implement observability architecture with this comprehensive guide. Discover key components, best practices, and practical strategies.
-keywords: [observability architecture, monitoring, distributed tracing, metrics, logs, DevOps, SRE, system reliability]
-
+keywords:
+  [
+    observability architecture,
+    monitoring,
+    distributed tracing,
+    metrics,
+    logs,
+    DevOps,
+    SRE,
+    system reliability,
+  ]
 ---
 
 Observability architecture is crucial for maintaining and optimizing modern, complex IT systems. As applications grow in scale and complexity, traditional monitoring approaches fall short. This guide will walk you through the process of implementing an effective observability architecture, from understanding its core concepts to practical implementation strategies.
@@ -59,7 +66,7 @@ To design an effective observability architecture, follow these steps:
 - Ease of Use: Design user-friendly interfaces and workflows that are easy for everyone to use. This helps teams across the organization quickly get on board and start using the tools without much hassle.
 - Automated Correlation: Set up systems that automatically connect and analyze logs from different sources. This makes it easier to spot and fix issues quickly, reducing downtime and keeping everything running smoothly.
 - Cloud-Native Approach: Leverage cloud services for scalability and flexibility in modern, distributed environments.
-- AI/ML Integration:  Integrate artificial intelligence and machine learning to provide advanced data analysis. This helps teams identify trends, predict problems before they happen, and make better decisions based on the insights gained.
+- AI/ML Integration: Integrate artificial intelligence and machine learning to provide advanced data analysis. This helps teams identify trends, predict problems before they happen, and make better decisions based on the insights gained.
 
 ## Building the Observability Pipeline
 
@@ -75,9 +82,9 @@ An effective [observability pipeline](https://signoz.io/guides/observability-pip
 [Distributed tracing](https://signoz.io/distributed-tracing/) is essential for gaining visibility into the flow of requests across complex, microservices-based systems. Here’s how to implement tracing effectively:
 
 1. Understand Key Concepts: Before diving into implementation, it's important to understand the fundamental concepts of distributed tracing. Key terms include:
-    - Spans: Individual units of work within a trace, representing specific operations or steps in a request’s journey through the system.
-    - Trace IDs: Unique identifiers that link all spans together, forming a complete trace that shows the end-to-end journey of a request.
-    - [Context Propagation](https://signoz.io/blog/opentelemetry-context-propagation/): The process of passing trace information (like trace IDs and span IDs) across service boundaries, ensuring that the entire trace is preserved as a request moves through different components.
+   - Spans: Individual units of work within a trace, representing specific operations or steps in a request’s journey through the system.
+   - Trace IDs: Unique identifiers that link all spans together, forming a complete trace that shows the end-to-end journey of a request.
+   - [Context Propagation](https://signoz.io/blog/opentelemetry-context-propagation/): The process of passing trace information (like trace IDs and span IDs) across service boundaries, ensuring that the entire trace is preserved as a request moves through different components.
 2. Instrument Applications: To capture traces, you need to add trace points to your application code. This is done by instrumenting your applications with tracing libraries or SDKs. OpenTelemetry is a widely used, vendor-neutral option that supports multiple programming languages and integrates well with various observability backends. By instrumenting your code, you ensure that each service in your system generates and reports spans, contributing to the overall trace.
 3. Correlate with Logs and Metrics: For a comprehensive view of your system’s performance, it’s crucial to link traces with related logs and metrics. This correlation allows you to see how a specific trace correlates with logs generated during its execution or how metrics like response times are affected by particular traces. Ensuring that your [tracing solution](https://signoz.io/blog/distributed-tracing-tools/) supports this integration will provide deeper insights and make troubleshooting more efficient.
 4. Implement Sampling: In high-volume systems, capturing every single trace can be overwhelming and resource-intensive. To manage this, implement sampling strategies that reduce the amount of tracing data while still capturing enough information to be useful. Intelligent sampling methods, such as retaining traces with errors or high latency, can help maintain a representative dataset without overloading your storage or processing resources.
@@ -98,11 +105,15 @@ Logs provide detailed context for system events. To extract maximum value from l
 1. Implement [structured logging](https://signoz.io/blog/structured-logs/): Use a consistent, structured format for your logs, such as JSON. Structured logs are easier to parse, search, and analyze because they follow a predictable pattern. This consistency allows you to automate the extraction of key fields, filter logs based on specific criteria, and perform more advanced queries, making your logs much more useful for troubleshooting and analysis.
 2. Centralize Log Management: Aggregate logs from all sources into a central repository for unified analysis. Tools like Elasticsearch, Logstash, and Kibana (the ELK stack) can help you achieve unified log management and analysis.
 3. Use Log Analytics: Utilize log analytics tools to gain insights from your log data. These tools can help you identify patterns, detect anomalies, and correlate events across your system. For example, you can use them to spot trends in [error logs](https://signoz.io/guides/error-log/), understand the sequence of events leading to an incident, or monitor application behavior over time.
-4. Balance Retention and Cost: Logs can grow rapidly in volume, leading to significant storage costs. To manage this, implement [log retention](https://signoz.io/guides/log-retention/) policies that balance the need to keep historical data for troubleshooting, auditing, or compliance purposes with the costs of storing that data. For instance, you might retain critical logs for a longer period while archiving or discarding less important logs after a shorter time. 
+4. Balance Retention and Cost: Logs can grow rapidly in volume, leading to significant storage costs. To manage this, implement [log retention](https://signoz.io/guides/log-retention/) policies that balance the need to keep historical data for troubleshooting, auditing, or compliance purposes with the costs of storing that data. For instance, you might retain critical logs for a longer period while archiving or discarding less important logs after a shorter time.
 
 ## Integrating SigNoz for Comprehensive Observability
 
-<Figure src="/img/guides/2024/08/observability-architecture-image.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/guides/2024/08/observability-architecture-image.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 [SigNoz](https://signoz.io) is an open-source observability platform that can significantly enhance your observability architecture. Here's how to leverage SigNoz:
 
@@ -162,4 +173,4 @@ To calculate ROI, consider factors such as:
 - Enhanced customer satisfaction due to better system performance
 - Optimized resource allocation and associated cost savings
 
-Compare these benefits against the costs of implementing and maintaining the [observability architecture](https://signoz.io/guides/observability-architecture/#designing-an-effective-observability-architecture).
\ No newline at end of file
+Compare these benefits against the costs of implementing and maintaining the [observability architecture](https://signoz.io/guides/observability-architecture/#designing-an-effective-observability-architecture).
diff --git a/data/guides/observability-as-code.mdx b/data/guides/observability-as-code.mdx
index 311d0a91b..f548b55a3 100644
--- a/data/guides/observability-as-code.mdx
+++ b/data/guides/observability-as-code.mdx
@@ -1,16 +1,23 @@
 ---
-
 title: Observability as Code - Streamline Your Monitoring Workflow
-slug: observability-as-code
 date: 2024-12-05
 tags: [Observability]
 authors: [simran_kumari]
 description: Discover how Observability as Code streamlines monitoring workflows, improves collaboration, and enhances system reliability. Learn implementation strategies and best practices.
-keywords: [observability as code, DevOps, monitoring, automation, SRE, infrastructure as code, observability tools, monitoring workflow]
-
+keywords:
+  [
+    observability as code,
+    DevOps,
+    monitoring,
+    automation,
+    SRE,
+    infrastructure as code,
+    observability tools,
+    monitoring workflow,
+  ]
 ---
 
-Monitoring complex systems is a challenge that grows with scale. As your infrastructure expands, manual configuration of monitoring tools becomes increasingly time-consuming and error-prone. This is where Observability as Code (OaC) comes in. 
+Monitoring complex systems is a challenge that grows with scale. As your infrastructure expands, manual configuration of monitoring tools becomes increasingly time-consuming and error-prone. This is where Observability as Code (OaC) comes in.
 
 OaC applies the principles of Infrastructure as Code to your monitoring setup, automating and standardizing how you track your systems' health and performance. But what exactly is OaC, and how can you use it to streamline your monitoring workflow? This article unpacks what OaC is, why it matters, and how to implement it for a streamlined monitoring workflow.
 
@@ -24,7 +31,11 @@ Key Components of OaC
 2. Logs: Detailed records of events within your system
 3. Traces: Information about request flows through distributed systems
 
-<Figure src="/img/guides/2024/12/observability-as-code-cb46b1e3-f82e-420d-8910-e61d3e5c807f.webp" alt="Key components of OaC" caption="Key components of OaC" /> 
+<Figure
+  src="/img/guides/2024/12/observability-as-code-cb46b1e3-f82e-420d-8910-e61d3e5c807f.webp"
+  alt="Key components of OaC"
+  caption="Key components of OaC"
+/>{' '}
 
 OaC vs Traditional Observability Methods
 
@@ -35,7 +46,11 @@ OaC differs from traditional observability methods in several ways:
 - Consistency: Ensures uniform monitoring across different environments
 - Scalability: Easily replicate monitoring setups across multiple services or applications
 
-<Figure src="/img/guides/2024/12/observability-as-code-image.webp" alt="OaC vs. Traditional Observability" caption="OaC vs. Traditional Observability" />
+<Figure
+  src="/img/guides/2024/12/observability-as-code-image.webp"
+  alt="OaC vs. Traditional Observability"
+  caption="OaC vs. Traditional Observability"
+/>
 
 ### Evolution from Infrastructure as Code to Observability as Code
 
@@ -69,7 +84,11 @@ The shift towards automated configuration of observability tools offers several
 
 Implementing OaC can significantly improve your monitoring workflow and overall system reliability. Here's why it's becoming increasingly important:
 
-<Figure src="/img/guides/2024/12/observability-as-code-image%201.webp" alt="Why is Observability as Code Important?" caption="Why is Observability as Code Important?" />
+<Figure
+  src="/img/guides/2024/12/observability-as-code-image%201.webp"
+  alt="Why is Observability as Code Important?"
+  caption="Why is Observability as Code Important?"
+/>
 
 1. Improved consistency and repeatability: With OaC, you define your monitoring setup once and can easily replicate it across multiple services or environments. This ensures consistent monitoring practices throughout your organization.
 2. Enhanced collaboration: By treating observability configurations as code, you enable better collaboration between development and operations teams. Developers can contribute to monitoring setups, while operations teams can review and approve changes.
@@ -85,23 +104,23 @@ Implementing OaC requires careful planning and the right tools. Here's a step-by
 2. Define your observability needs: Identify the key metrics, logs, and traces you need to monitor across your system.
 3. Create templates: Develop reusable templates for common monitoring configurations. These might include standard dashboard layouts or alert thresholds.
 4. Write your configurations: Use a declarative language like YAML or JSON to define your monitoring setup. Here's a simple example using YAML:
-    
-    ```yaml
-    dashboard:
-      name: "API Performance"
-      panels:
-        - title: "Request Rate"
-          metric: "http_requests_total"
-          type: "graph"
-        - title: "Response Time"
-          metric: "http_request_duration_seconds"
-          type: "heatmap"
-    alerts:
-      - name: "High Error Rate"
-        condition: "rate(http_errors_total[5m]) > 0.05"
-        severity: "critical"
-    ```
-    
+
+   ```yaml
+   dashboard:
+     name: 'API Performance'
+     panels:
+       - title: 'Request Rate'
+         metric: 'http_requests_total'
+         type: 'graph'
+       - title: 'Response Time'
+         metric: 'http_request_duration_seconds'
+         type: 'heatmap'
+   alerts:
+     - name: 'High Error Rate'
+       condition: 'rate(http_errors_total[5m]) > 0.05'
+       severity: 'critical'
+   ```
+
 5. Version control: Store your observability configurations in a version control system like Git.
 6. Integrate with CI/CD: Automate the deployment of your observability configurations as part of your CI/CD pipeline.
 7. Review and iterate: Regularly review your OaC setup and make improvements based on your evolving needs.
@@ -133,15 +152,15 @@ Key features of SigNoz that support OaC include:
 
 SigNoz offers two deployment models—SigNoz Cloud and SigNoz Open Source—to cater to diverse needs. Here's how they stack up:
 
-| Aspect | SigNoz Cloud | SigNoz Open Source |
-| --- | --- | --- |
-| Hosting | Fully managed by SigNoz | Self-hosted on your infrastructure |
-| Setup | Quick and easy with minimal effort | Requires technical expertise for setup |
-| Maintenance | Automated updates and monitoring | Requires manual maintenance and upgrades |
-| Privacy & Compliance | Data hosted on SigNoz servers | Data remains within your own environment |
-| Cost Model | Pay-as-you-go pricing | Free to use; infrastructure costs apply |
-| Customizability | Limited to provided features | Fully customizable for unique requirements |
-| Use Case | Ideal for startups and SMBs | Suitable for enterprises and privacy-focused teams |
+| Aspect               | SigNoz Cloud                       | SigNoz Open Source                                 |
+| -------------------- | ---------------------------------- | -------------------------------------------------- |
+| Hosting              | Fully managed by SigNoz            | Self-hosted on your infrastructure                 |
+| Setup                | Quick and easy with minimal effort | Requires technical expertise for setup             |
+| Maintenance          | Automated updates and monitoring   | Requires manual maintenance and upgrades           |
+| Privacy & Compliance | Data hosted on SigNoz servers      | Data remains within your own environment           |
+| Cost Model           | Pay-as-you-go pricing              | Free to use; infrastructure costs apply            |
+| Customizability      | Limited to provided features       | Fully customizable for unique requirements         |
+| Use Case             | Ideal for startups and SMBs        | Suitable for enterprises and privacy-focused teams |
 
 Choosing the Right Option
 
@@ -153,25 +172,25 @@ Choosing the Right Option
 Let's look at some real-world examples of how organizations can implement OaC:
 
 1. Scaling Microservices in E-commerce
-    - Scenario: An e-commerce platform running hundreds of microservices wants to monitor inventory, order processing, and customer activity during high-traffic events like Black Friday.
-    - OaC in Action: Developers define monitoring rules, alerts, and dashboards in configuration files stored in version control. These configurations are automatically deployed alongside application updates.
-    - Improvements:
-        - Scalability: Rapidly replicate observability setups for new services.
-        - Consistency: Ensure each service has identical monitoring standards.
-        - Speed: Automate incident detection, enabling faster response times.
+   - Scenario: An e-commerce platform running hundreds of microservices wants to monitor inventory, order processing, and customer activity during high-traffic events like Black Friday.
+   - OaC in Action: Developers define monitoring rules, alerts, and dashboards in configuration files stored in version control. These configurations are automatically deployed alongside application updates.
+   - Improvements:
+     - Scalability: Rapidly replicate observability setups for new services.
+     - Consistency: Ensure each service has identical monitoring standards.
+     - Speed: Automate incident detection, enabling faster response times.
 2. Incident Management for Fintech Applications
-    - Scenario: A fintech company needs to track API response times and detect unusual transaction patterns in real-time.
-    - OaC in Action: The team uses OaC to configure [distributed tracing](https://signoz.io/distributed-tracing/) and alert thresholds across all services handling payments and user authentication.
-    - Improvements:
-        - Faster Troubleshooting: Centralized and automated logging helps identify bottlenecks.
-        - Improved Collaboration: Developers and SREs can jointly iterate on monitoring configurations in Git.
+   - Scenario: A fintech company needs to track API response times and detect unusual transaction patterns in real-time.
+   - OaC in Action: The team uses OaC to configure [distributed tracing](https://signoz.io/distributed-tracing/) and alert thresholds across all services handling payments and user authentication.
+   - Improvements:
+     - Faster Troubleshooting: Centralized and automated logging helps identify bottlenecks.
+     - Improved Collaboration: Developers and SREs can jointly iterate on monitoring configurations in Git.
 3. Managing Cloud-Native Workloads
-    - Scenario: A company managing Kubernetes workloads across multiple clusters wants consistent observability for applications, pods, and nodes.
-    - OaC in Action: The team uses tools like Helm charts or Terraform to deploy Prometheus for metrics and Jaeger for tracing, with configurations stored in Git repositories.
-    - Improvements:
-        - Consistency: Uniform observability across clusters.
-        - Version Control: Audit changes to monitoring setups easily.
-        - Disaster Recovery: Recreate observability setups quickly in case of failures.
+   - Scenario: A company managing Kubernetes workloads across multiple clusters wants consistent observability for applications, pods, and nodes.
+   - OaC in Action: The team uses tools like Helm charts or Terraform to deploy Prometheus for metrics and Jaeger for tracing, with configurations stored in Git repositories.
+   - Improvements:
+     - Consistency: Uniform observability across clusters.
+     - Version Control: Audit changes to monitoring setups easily.
+     - Disaster Recovery: Recreate observability setups quickly in case of failures.
 
 ## Future Trends in Observability as Code
 
@@ -206,4 +225,4 @@ Common tools include Prometheus, Grafana, Terraform, and platforms like SigNoz t
 
 ### Can Observability as Code be implemented in legacy systems?
 
-Yes, OaC can be implemented in legacy systems, though it may require more effort. Start by identifying key metrics and gradually move towards automated, code-based configurations.
\ No newline at end of file
+Yes, OaC can be implemented in legacy systems, though it may require more effort. Start by identifying key metrics and gradually move towards automated, code-based configurations.
diff --git a/data/guides/observability-engineering.mdx b/data/guides/observability-engineering.mdx
index c57e82753..a8bcd0c3b 100644
--- a/data/guides/observability-engineering.mdx
+++ b/data/guides/observability-engineering.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Observability Engineering - A Practical Guide for Modern DevOps
-slug: observability-engineering
 date: 2024-08-27
 tags: [observability]
 authors: [soumya_gupta]
 description: Learn how observability engineering enhances DevOps practices, improves system reliability, and enables data-driven decision-making in complex software environments.
-keywords: [observability engineering, DevOps, monitoring, distributed tracing, SLIs, SLOs, incident response]
-
+keywords:
+  [
+    observability engineering,
+    DevOps,
+    monitoring,
+    distributed tracing,
+    SLIs,
+    SLOs,
+    incident response,
+  ]
 ---
 
 Observability engineering has become a critical practice in modern software development and operations. As systems grow more complex and distributed, traditional monitoring approaches fall short. Observability engineering provides the tools and techniques to gain deep insights into system behavior, enabling teams to quickly identify and resolve issues. This guide explores the principles, tools, and best practices of observability engineering, helping you improve system reliability and performance in your DevOps workflows.
@@ -24,7 +30,11 @@ Observability doesn’t replace monitoring; it just means monitoring is one piec
 
 The three pillars of observability are:
 
-<Figure src="/img/guides/2024/08/observability-engineering-Untitled.webp" alt="Three Pillars of Observability" caption="Three Pillars of Observability" />
+<Figure
+  src="/img/guides/2024/08/observability-engineering-Untitled.webp"
+  alt="Three Pillars of Observability"
+  caption="Three Pillars of Observability"
+/>
 
 1. Logs: Detailed records of events within your system.
 2. Metrics: Quantitative measurements of system performance and behavior.
@@ -34,7 +44,11 @@ The three pillars of observability are:
 
 At SigNoz, we envision observability as a mesh or network rather than a set of pillars since these signals alone don’t constitute observability, nor does simply analyzing them mean you’re truly practicing observability. Instead, you need to integrate these signals into a broader strategy that includes continuous profiling, business metrics, CI/CD pipeline performance, and customer feedback. Only by combining these elements can you effectively execute a comprehensive observability practice.
 
-<Figure src="/img/guides/2024/08/observability-engineering-image.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/guides/2024/08/observability-engineering-image.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 ### Why Observability Engineering Matters for DevOps
 
@@ -55,7 +69,11 @@ To implement effective observability, follow these core principles:
 2. Implement [distributed tracing](https://signoz.io/blog/distributed-tracing/): Use unique identifiers to track requests across services, enabling end-to-end visibility into system behavior. Distributed tracing visualizes the entire request journey, helping developers pinpoint performance issues and bottlenecks in complex microservices for easier troubleshooting.
 3. Design effective SLI, SLA and SLOs: Define measurable metrics that reflect user experience and set realistic targets for system performance. The goal is to ensure everyone including vendors and clients are aligned on system performance expectations. This includes how often your systems will be available, how quickly you'll respond to issues, and what speed and functionality promises you're making.
 
-   <Figure src="/img/guides/2024/08/observability-engineering-image%201.webp" alt="Measurable Metrics" caption="Measurable Metrics" />
+   <Figure
+     src="/img/guides/2024/08/observability-engineering-image%201.webp"
+     alt="Measurable Metrics"
+     caption="Measurable Metrics"
+   />
 
 4. Adopt a culture of observability: Encourage your team to embrace observability by integrating it into the development workflow. This means educating the team, choosing the right tools, setting clear metrics, and fostering collaboration. Observability is about understanding and troubleshooting any system state in real-time, without pre-defining debugging needs.
 
diff --git a/data/guides/observability-pipeline.mdx b/data/guides/observability-pipeline.mdx
index 86cefa24f..0285ab23f 100644
--- a/data/guides/observability-pipeline.mdx
+++ b/data/guides/observability-pipeline.mdx
@@ -1,26 +1,31 @@
 ---
-
 title: Understanding Observability Pipelines - A Practical Guide
-slug: observability-pipeline
 date: 2024-08-30
 tags: [observability]
 authors: [manjunath_irukulla]
 description: Discover how observability pipelines enhance system visibility, optimize data management, and improve troubleshooting in modern distributed systems.
-keywords: [observability pipeline, data processing, system monitoring, distributed tracing, log aggregation, metrics collection]
-
+keywords:
+  [
+    observability pipeline,
+    data processing,
+    system monitoring,
+    distributed tracing,
+    log aggregation,
+    metrics collection,
+  ]
 ---
 
-Observability pipelines are specialized systems that streamline the collection, processing, and analysis of telemetry data (such as logs, metrics, and traces), enabling organizations to gain deep insights into their application’s performance, security, and behavior. By centralizing data management, enhancing data quality, and optimizing costs, observability pipelines are indispensable for modern DevOps and Security teams. 
+Observability pipelines are specialized systems that streamline the collection, processing, and analysis of telemetry data (such as logs, metrics, and traces), enabling organizations to gain deep insights into their application’s performance, security, and behavior. By centralizing data management, enhancing data quality, and optimizing costs, observability pipelines are indispensable for modern DevOps and Security teams.
 
-This article delves into the key components, benefits, challenges, and best practices for implementing best practices, while also exploring future trends that are shaping their evolution. 
+This article delves into the key components, benefits, challenges, and best practices for implementing best practices, while also exploring future trends that are shaping their evolution.
 
 ## What is an Observability Pipeline?
 
-An observability pipeline, also known as a telemetry pipeline, manages, optimizes, and analyzes telemetry data(metrics, logs, traces) from several sources, ensuring that this data is processed and sent to the appropriate observability tools. 
+An observability pipeline, also known as a telemetry pipeline, manages, optimizes, and analyzes telemetry data(metrics, logs, traces) from several sources, ensuring that this data is processed and sent to the appropriate observability tools.
 
-Observability is the ability to understand and diagnose the behavior and performance of a system by examining its outputs. It entails gathering, monitoring, and analyzing telemetry data to acquire a thorough knowledge of system behavior, performance, and potential security risks. 
+Observability is the ability to understand and diagnose the behavior and performance of a system by examining its outputs. It entails gathering, monitoring, and analyzing telemetry data to acquire a thorough knowledge of system behavior, performance, and potential security risks.
 
-Observability pipelines parse and share data into the correct format, route it to the appropriate observability tools, optimize it by reducing low-value data, enrich it with additional context, and enable teams to make informed decisions while significantly reducing costs.  
+Observability pipelines parse and share data into the correct format, route it to the appropriate observability tools, optimize it by reducing low-value data, enrich it with additional context, and enable teams to make informed decisions while significantly reducing costs.
 
 ### Benefits of Implementing an Observability Pipeline
 
@@ -30,15 +35,19 @@ Observability pipelines parse and share data into the correct format, route it t
 - Efficient Troubleshooting: With organized and accessible data, observability pipelines enable faster identification and resolution of issues, reducing downtime.
 - Cost Optimization: By managing data efficiently, observability pipelines help reduce storage and processing costs, optimizing overall expenses.
 
-<Figure src="/img/guides/2024/08/observability-pipeline-benifits_of_observability.webp" alt="Benefits of implementing an observability pipeline" caption="Benefits of implementing an observability pipeline" />
+<Figure
+  src="/img/guides/2024/08/observability-pipeline-benifits_of_observability.webp"
+  alt="Benefits of implementing an observability pipeline"
+  caption="Benefits of implementing an observability pipeline"
+/>
 
 ## Why Observability Pipelines are Crucial for Modern Systems
 
 Modern distributed systems generate massive amounts of telemetry data from various sources. This data explosion presents several challenges:
 
-1. Data Volume and Variety: Logs, metrics, and traces are produced at an unprecedented scale, requiring methods to handle and analyze this data efficiently. 
+1. Data Volume and Variety: Logs, metrics, and traces are produced at an unprecedented scale, requiring methods to handle and analyze this data efficiently.
 2. Data Quality: Raw data is often noisy and inconsistent, making it difficult to extract meaningful insights without proper processing.
-3. System Complexity: Microservices, containerization, and cloud-native architectures introduce numerous components that must be monitored, increasing the complexity of the observability landscape. 
+3. System Complexity: Microservices, containerization, and cloud-native architectures introduce numerous components that must be monitored, increasing the complexity of the observability landscape.
 4. Cost Management: The storage and processing of large volumes of observability data can be prohibitively expensive if not managed efficiently.
 
 ## How Observability Pipelines Work:
@@ -46,15 +55,19 @@ Modern distributed systems generate massive amounts of telemetry data from vario
 Observability pipelines operate through a series of stages that ensure the efficient handling of data from collection to analysis:
 
 1. Data Ingestion: The pipeline begins with data collectors and agents, which gather data from various sources, including application logs, system metrics, and distributed traces.
-2. Data Transformation: Raw data undergoes transformation, where it is normalized, filtered, and enriched with additional context to make it actionable and relevant. 
-3. Data Routing: The Processed data is sent to appropriate destinations, such as time-series databases for metrics, log management systems for logs, and tracing backends for distributed traces. 
-4. Real-time Processing: Many observability pipelines support stream processing, allowing for immediate analysis and alerting on incoming data. This capability is essential for proactive monitoring and rapid response to issues. 
+2. Data Transformation: Raw data undergoes transformation, where it is normalized, filtered, and enriched with additional context to make it actionable and relevant.
+3. Data Routing: The Processed data is sent to appropriate destinations, such as time-series databases for metrics, log management systems for logs, and tracing backends for distributed traces.
+4. Real-time Processing: Many observability pipelines support stream processing, allowing for immediate analysis and alerting on incoming data. This capability is essential for proactive monitoring and rapid response to issues.
 
-<Figure src="/img/guides/2024/08/observability-pipeline-obsservability_pipeline.webp" alt="How observability pipelines work" caption="How observability pipelines work" />
+<Figure
+  src="/img/guides/2024/08/observability-pipeline-obsservability_pipeline.webp"
+  alt="How observability pipelines work"
+  caption="How observability pipelines work"
+/>
 
 ### Key Components of an Observability Pipeline
 
-1. Data Collectors and Agents: 
+1. Data Collectors and Agents:
 
 Data collectors and agents are essential for gathering observability data from various sources within an infrastructure or application. These include log collectors, metric collectors, and tracing agents. They capture metrics, logs, and traces, and ensure that this data is transmitted to the central processing layer.
 
@@ -79,14 +92,18 @@ Examples: SigNoz, Grafana, Kibana, Datadog.
 
 ## Implementing an Observability Pipeline: Best Practices
 
-Implementing an observability pipeline is a complex task that requires careful planning and execution. Here are some best practices to guide you through the process: 
+Implementing an observability pipeline is a complex task that requires careful planning and execution. Here are some best practices to guide you through the process:
 
-1. Define Clear Objectives: Identify what you want to achieve, such as reducing mean time to resolution (MTTR) for incidents or improving application performance. Clear objectives will guide your decisions throughout the implementation process. 
-2. Choose the Right Tools: Select technologies that align with your infrastructure and goals, considering factors like scalability, ease of integration, and community support. 
-3. Ensure Data Security and Compliance: Implement robust security measures to protect sensitive data. This includes using encryption for data in transit and at rest, implementing strict access controls, and ensuring compliance with relevant data protection regulations.  
-4. Plan for Scalability: Design your [observability pipeline](https://signoz.io/guides/observability-pipeline/#1-integration-complexity) to handle increasing data volumes as your system grows. Use distributed systems for data processing, implement data sampling techniques, and consider cloud-based solutions for elasticity and scalability. 
+1. Define Clear Objectives: Identify what you want to achieve, such as reducing mean time to resolution (MTTR) for incidents or improving application performance. Clear objectives will guide your decisions throughout the implementation process.
+2. Choose the Right Tools: Select technologies that align with your infrastructure and goals, considering factors like scalability, ease of integration, and community support.
+3. Ensure Data Security and Compliance: Implement robust security measures to protect sensitive data. This includes using encryption for data in transit and at rest, implementing strict access controls, and ensuring compliance with relevant data protection regulations.
+4. Plan for Scalability: Design your [observability pipeline](https://signoz.io/guides/observability-pipeline/#1-integration-complexity) to handle increasing data volumes as your system grows. Use distributed systems for data processing, implement data sampling techniques, and consider cloud-based solutions for elasticity and scalability.
 
-<Figure src="/img/guides/2024/08/observability-pipeline-b63d1cf5-0cc9-458c-ab88-5e4f9f5eda3a.webp" alt="Steps to implement an observability pipeline" caption="Steps to implement an observability pipeline" />
+<Figure
+  src="/img/guides/2024/08/observability-pipeline-b63d1cf5-0cc9-458c-ab88-5e4f9f5eda3a.webp"
+  alt="Steps to implement an observability pipeline"
+  caption="Steps to implement an observability pipeline"
+/>
 
 ## Common Challenges in Observability Pipeline Implementation
 
@@ -94,26 +111,26 @@ When implementing observability pipelines, you might encounter:
 
 ### 1. Integration Complexity:
 
-Integrating observability tools with existing systems, especially in a microservices architecture, can be complex. Different services may require different monitoring approaches, and ensuring data collection across the entire stack can be difficult. 
+Integrating observability tools with existing systems, especially in a microservices architecture, can be complex. Different services may require different monitoring approaches, and ensuring data collection across the entire stack can be difficult.
 
 Solution:
 
 - Standardized Instrumentation: Use standard libraries and frameworks for instrumentation across all services. This ensures consistency in how data is collected and reported.
 - Automated Deployment: Integrate observability tools into CI/CD pipelines to automate the deployment and configuration of observability across all services. You can implement this by following the steps.
-    - Choose an open-source tool for observability (monitoring, tracing, and logging) such as [SigNoz.](https://signoz.io/)
-    - Ensure that your application code is instrumented to generate the necessary telemetry data. This can be done by integrating SDKs or libraries specific to the tools you are using.
-    - Use automated scripts like Ansible playbooks to apply instrumentation across all services during the CI/CD process.
-    - Integrate observability as a stage in your CI/CD pipeline, alongside common stages such as
-        - Instrumentation Verification: Ensure that the code is properly instrumented before it is deployed.
-        - Monitoring Configuration: Automatically configure monitoring tools to start and track the new or updated services.
-        - Logging Setup: Set up [centralized logging](https://signoz.io/blog/centralized-logging/) configurations, such as sending logs to a [SigNoz cloud](https://signoz.io/).
-    - Add automated tests to verify that observability is correctly configured after deployment. This can include checking that all telemetry data is generated and flowing to the correct destinations.
+  - Choose an open-source tool for observability (monitoring, tracing, and logging) such as [SigNoz.](https://signoz.io/)
+  - Ensure that your application code is instrumented to generate the necessary telemetry data. This can be done by integrating SDKs or libraries specific to the tools you are using.
+  - Use automated scripts like Ansible playbooks to apply instrumentation across all services during the CI/CD process.
+  - Integrate observability as a stage in your CI/CD pipeline, alongside common stages such as
+    - Instrumentation Verification: Ensure that the code is properly instrumented before it is deployed.
+    - Monitoring Configuration: Automatically configure monitoring tools to start and track the new or updated services.
+    - Logging Setup: Set up [centralized logging](https://signoz.io/blog/centralized-logging/) configurations, such as sending logs to a [SigNoz cloud](https://signoz.io/).
+  - Add automated tests to verify that observability is correctly configured after deployment. This can include checking that all telemetry data is generated and flowing to the correct destinations.
 
 ### 2. Data Overload:
 
-With observability, you collect a large volume of logs, metrics, and traces. Managing and making sense of this vast amount of data can be overwhelming, leading to noise rather than actionable insights. 
+With observability, you collect a large volume of logs, metrics, and traces. Managing and making sense of this vast amount of data can be overwhelming, leading to noise rather than actionable insights.
 
-Solution: 
+Solution:
 
 - Prioritize Key Metrics: Collect and [analyze metrics](https://signoz.io/blog/metrics-explorer/) directly related to business outcomes and system performance.
 - Data Aggregation and Filtering: To reduce noise in your system’s logs, it’s important to use tools that enable data aggregation, filtering, and sampling. Setting appropriate log levels allows you to focus on capturing the most relevant information and avoid analyzing unnecessary information. For insights on effectively filtering and managing logs, consider exploring strategies discussed in our article on [syslog.](https://signoz.io/guides/syslog-levels/)
@@ -121,35 +138,35 @@ Solution:
 
 ### 3. Complex Infrastructure:
 
-As systems evolve to become more intricate, and distributed, traditional monitoring methods become insufficient. Particularly in microservice architecture systems, the complexity of tracking requests across multiple services and understanding their impact on overall performance can be daunting. 
+As systems evolve to become more intricate, and distributed, traditional monitoring methods become insufficient. Particularly in microservice architecture systems, the complexity of tracking requests across multiple services and understanding their impact on overall performance can be daunting.
 
-Solution: 
+Solution:
 
 - [Distributed Tracing](https://signoz.io/blog/distributed-tracing/): Implement distributed tracing to follow requests as they traverse through different services. This helps in understanding latency and pinpointing the root cause of issues.
 - Automated Correlation: Use tools like [SigNoz](https://signoz.io/) that automatically correlate logs, metrics, and traces, providing a comprehensive view of an incident or performance issue.
 
 ### 4. Security and Compliance
 
-Collecting and storing telemetry data can raise security and compliance concerns, especially in regulated industries. Sensitive information may inadvertently be captured in logs or traces. 
+Collecting and storing telemetry data can raise security and compliance concerns, especially in regulated industries. Sensitive information may inadvertently be captured in logs or traces.
 
 Solution:
 
-Access Controls: Apply strict access control to observability data, ensuring that only authorized personnel can view or modify it. 
+Access Controls: Apply strict access control to observability data, ensuring that only authorized personnel can view or modify it.
 
-Compliance Auditing: Use tools that provide auditing and reporting capabilities to ensure your observability implementation complies with industry regulations. 
+Compliance Auditing: Use tools that provide auditing and reporting capabilities to ensure your observability implementation complies with industry regulations.
 
 ## Optimizing your Observability Pipeline
 
 To get the most out of your observability pipeline:
 
-1. Implement Data Filtering and Sampling: To reduce the volume of data without losing critical information, implement dynamic sampling techniques based on the importance of requests and filter out noisy or redundant data early in the pipeline. 
-2. Develop Effective Data Retention Policies: Balance data availability with storage costs by keeping high-resolution data for short periods and aggregating or downsampling older data. 
-3. Leverage Machine Learning for Anomaly Detection: Use machine learning algorithms to identify unusual patterns in your data. Implement automated baseline creation and set up dynamic thresholds for alters, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and faster issue resolution. 
-4. Continuously Monitor and Refine: Treat your observability pipeline as a critical system that requires ongoing monitoring and optimization. Regularly review performance metrics and adjust your pipeline based on changing needs and evolving system requirements. 
+1. Implement Data Filtering and Sampling: To reduce the volume of data without losing critical information, implement dynamic sampling techniques based on the importance of requests and filter out noisy or redundant data early in the pipeline.
+2. Develop Effective Data Retention Policies: Balance data availability with storage costs by keeping high-resolution data for short periods and aggregating or downsampling older data.
+3. Leverage Machine Learning for Anomaly Detection: Use machine learning algorithms to identify unusual patterns in your data. Implement automated baseline creation and set up dynamic thresholds for alters, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) and faster issue resolution.
+4. Continuously Monitor and Refine: Treat your observability pipeline as a critical system that requires ongoing monitoring and optimization. Regularly review performance metrics and adjust your pipeline based on changing needs and evolving system requirements.
 
 ## SigNoz: A Modern Solution for Observability Pipelines
 
-SigNoz is an open-source observability platform that simplifies the setup and maintenance of observability pipelines. It integrates metrics, logs, and traces into a single platform, providing a comprehensive solution for current observability requirements. 
+SigNoz is an open-source observability platform that simplifies the setup and maintenance of observability pipelines. It integrates metrics, logs, and traces into a single platform, providing a comprehensive solution for current observability requirements.
 
 For a comprehensive guide on how to set up observability using SigNoz and [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), including detailed instructions and best practices, please refer to this article: [Achieving Observability with SigNoz and OpenTelemetry](https://signoz.io/blog/o11y/)
 
@@ -159,10 +176,10 @@ For a comprehensive guide on how to set up observability using SigNoz and [OpenT
 
 The field of observability is rapidly evolving. Here are key trends to watch:
 
-1. AI-Driven Analysis: Machine learning will play a larger role in automated root cause analysis, predictive alerting, and anomaly detection. These technologies will help operators identify and resolve issues more quickly and accurately. 
+1. AI-Driven Analysis: Machine learning will play a larger role in automated root cause analysis, predictive alerting, and anomaly detection. These technologies will help operators identify and resolve issues more quickly and accurately.
 2. Edge Computing: As more computing moves to the edge, observability pipelines will need to extend to these environments. This shift will enable local data processing, reduce latency for critical alerts, and improve data privacy by keeping sensitive information closer to its source.
-3. eBPF Integration: Extended Berkeley Packet Filter (eBPF) technology will enhance observability by providing deeper kernel-level insights and more efficient data collection. This technology allows for more granular monitoring and improved performance without the need for intrusive agents. 
-4. [Unified Observability](https://signoz.io/unified-observability/) Platforms: The trends towards unified observability platforms will continue, with increasingly converging to offer seamless integration of metrics, logs, and traces. These platforms will reduce cognitive load for operators, simplify tooling, and provide a more holistic view of system performance and health. 
+3. eBPF Integration: Extended Berkeley Packet Filter (eBPF) technology will enhance observability by providing deeper kernel-level insights and more efficient data collection. This technology allows for more granular monitoring and improved performance without the need for intrusive agents.
+4. [Unified Observability](https://signoz.io/unified-observability/) Platforms: The trends towards unified observability platforms will continue, with increasingly converging to offer seamless integration of metrics, logs, and traces. These platforms will reduce cognitive load for operators, simplify tooling, and provide a more holistic view of system performance and health.
 
 ## Key Takeaways
 
@@ -188,7 +205,7 @@ Observability pipelines can reduce storage costs by:
 
 ### Can observability pipelines handle both structured and unstructured data?
 
-Yes, observability pipelines are designed to handle diverse data types. They can process structured data like metrics, semi-structured data like [JSON logs](https://signoz.io/blog/json-logs/), and unstructured data like plain text logs. The pipeline’s transformation stage can normalize and enrich the data, making it more useful for analysis and decision-making. 
+Yes, observability pipelines are designed to handle diverse data types. They can process structured data like metrics, semi-structured data like [JSON logs](https://signoz.io/blog/json-logs/), and unstructured data like plain text logs. The pipeline’s transformation stage can normalize and enrich the data, making it more useful for analysis and decision-making.
 
 ### What are the security considerations when implementing an observability pipeline?
 
@@ -198,4 +215,4 @@ Key security considerations when implementing an observability pipeline include:
 - Implementing strong access controls and authentication mechanisms to ensure that only authorized personnel can access sensitive data.
 - Ensure compliance with data protection regulations, such as GDPR, or HIPPA, to avoid legal and financial penalties.
 - Regularly auditing and monitoring the pipeline itself to detect and address potential security issues.
-- Sanitizing sensitive information before it enters the pipeline to prevent accidental exposure or misuse of critical data.
\ No newline at end of file
+- Sanitizing sensitive information before it enters the pipeline to prevent accidental exposure or misuse of critical data.
diff --git a/data/guides/observability-stack.mdx b/data/guides/observability-stack.mdx
index 96c56a7cf..afe240dda 100644
--- a/data/guides/observability-stack.mdx
+++ b/data/guides/observability-stack.mdx
@@ -1,26 +1,23 @@
 ---
-
 title: Building Your Observability Stack - A Practical Guide
-slug: observability-stack
 date: 2025-01-07
 tags: [observability, monitoring, DevOps, microservices]
 authors: [manjunath_irukulla]
 description: Learn how to build a robust observability stack for your software systems. This guide covers key components, implementation strategies, and best practices.
 keywords: [observability stack, monitoring, logs, metrics, traces, OpenTelemetry, DevOps]
-
 ---
 
-Modern software systems are inherently complex, distributed, and dynamic. Managing this complexity requires more than just traditional monitoring it demands a robust observability stack. Observability goes beyond simply tracking metrics, logs, and traces. It integrates these signals to provide actionable insights into system behavior. 
+Modern software systems are inherently complex, distributed, and dynamic. Managing this complexity requires more than just traditional monitoring it demands a robust observability stack. Observability goes beyond simply tracking metrics, logs, and traces. It integrates these signals to provide actionable insights into system behavior.
 
-This guide explores how to build an effective observability stack, detailing its core components, advanced analytics, and strategies to address the challenges of modern software environments. By the end, you’ll understand  how to achieve seamless visibility and faster resolution of issues in your systems. 
+This guide explores how to build an effective observability stack, detailing its core components, advanced analytics, and strategies to address the challenges of modern software environments. By the end, you’ll understand how to achieve seamless visibility and faster resolution of issues in your systems.
 
 ## What Is an Observability Stack and Why Do You Need One?
 
-An observability stack is a suite of tools and practices with comprehensive insights into the behavior and performance of software systems. Unlike traditional monitoring, which focuses on predefined metrics, observability offers a deeper understanding by correlating data from diverse sources to reveal the underlying state of your systems.  
+An observability stack is a suite of tools and practices with comprehensive insights into the behavior and performance of software systems. Unlike traditional monitoring, which focuses on predefined metrics, observability offers a deeper understanding by correlating data from diverse sources to reveal the underlying state of your systems.
 
 ### Understanding Observability and Its Significance
 
-Observability refers to the ability to infer the internal state of a system based on its external outputs. In today’s complex, distributed systems, achieving observability is critical for several reasons: 
+Observability refers to the ability to infer the internal state of a system based on its external outputs. In today’s complex, distributed systems, achieving observability is critical for several reasons:
 
 - Faster Issue Resolution: Pinpoint and address problems quickly to minimize downtime.
 - Enhanced System Reliability: Maintain optimal performance by identifying potential failures early.
@@ -28,20 +25,24 @@ Observability refers to the ability to infer the internal state of a system base
 
 ### Core Components of an Observability Stack
 
-An effective observability stack is built on four key pillars, each contributing unique insights: 
+An effective observability stack is built on four key pillars, each contributing unique insights:
 
 - Logs: Sequential records that capture system events, aiding in detailed troubleshooting.
 - Metrics: Quantitative data points, such as CPU usage or response times, offer a snapshot of system health.
 - Traces: End-to-end details of requests as they traverse across distributed systems, illuminating bottlenecks and failures.
 - Events: Contextual information about significant system occurrences, such as deployments or configuration changes.
 
-These components provide a holistic view of system operations, enabling teams to identify issues and effectively uncover trends. 
+These components provide a holistic view of system operations, enabling teams to identify issues and effectively uncover trends.
 
 ### Why Your Organization Needs an Observability Stack
 
-Implementing a robust observability stack delivers tangible benefits that go beyond traditional monitoring: 
+Implementing a robust observability stack delivers tangible benefits that go beyond traditional monitoring:
 
-<Figure src="/img/guides/2025/01/observability-stack-Observability_Stack__Importance.webp" alt="Advantages of an Observability Stack" caption="Advantages of an Observability Stack" />
+<Figure
+  src="/img/guides/2025/01/observability-stack-Observability_Stack__Importance.webp"
+  alt="Advantages of an Observability Stack"
+  caption="Advantages of an Observability Stack"
+/>
 
 - Proactive Issue Resolution: Detect and address anomalies before they impact end users.
 - Comprehensive System Insights: Gain a unified perspective of performance across applications, infrastructure, and services.
@@ -51,13 +52,14 @@ Implementing a robust observability stack delivers tangible benefits that go bey
 
 To build a robust observability stack, you must understand how the different telemetry signals logs, metrics, traces, and events. Traditionally described as "pillars”, at SigNoz, you can view these signals as a tightly woven mesh rather than isolated components. We've covered this topic in greater detail in our blog - [Not 3 pillars but a single whole to help customers solve issues faster.](https://signoz.io/blog/observability-net/)
 
-<Figure src="/img/guides/2025/01/observability-stack-o11y-net-trans.webp" alt="" caption="" />*A better model where all signals come together to give insights to users*
+<Figure src="/img/guides/2025/01/observability-stack-o11y-net-trans.webp" alt="" caption="" />
+*A better model where all signals come together to give insights to users*
 
 ### Logs
 
-Logs record detailed events and state changes within your system, answering the “what” and “why” behind behaviors. 
+Logs record detailed events and state changes within your system, answering the “what” and “why” behind behaviors.
 
-Best Practices for Log Management: 
+Best Practices for Log Management:
 
 - [structured logging](https://signoz.io/blog/structured-logs/): Use formats like JSON for easier parsing.
 - Field Standardization: Include consistent fields like timestamps and severity levels.
@@ -65,9 +67,9 @@ Best Practices for Log Management:
 
 ### Metrics
 
-Metrics measure the health and performance of your system over time, helping identify trends and anomalies. 
+Metrics measure the health and performance of your system over time, helping identify trends and anomalies.
 
-Key Considerations: 
+Key Considerations:
 
 - Relevant KPIs: Focus on actionable metrics like latency and throughput.
 - Avoid Over-Collection: Prevent data overload by prioritizing key indicators.
@@ -75,9 +77,9 @@ Key Considerations:
 
 ### Traces
 
-Traces map the lifecycle of requests, providing end-to-end visibility in distributed systems. 
+Traces map the lifecycle of requests, providing end-to-end visibility in distributed systems.
 
-Important Aspects: 
+Important Aspects:
 
 - Unique Identifiers: Use TraceID and SpanID for correlation across microservices.
 - Sampling: Collect representative subsets to manage high trace volumes.
@@ -85,31 +87,31 @@ Important Aspects:
 
 ### Events
 
-Events capture significant occurrences, such as deployments and configuration changes, offering critical context for interpreting other signals. 
+Events capture significant occurrences, such as deployments and configuration changes, offering critical context for interpreting other signals.
 
-Effectiveness Event Management: 
+Effectiveness Event Management:
 
 - CI/CD Integration: Track deployments to correlate with system behaviour.
 - Annotate Data: Use events to enrich logs and metrics for deeper insights.
 - Standardized Schema: Ensure uniformity for seamless integration.
 
-The traditional model of observability as three or four independent pillars creates a false dichotomy. In reality, these signals overlap and enrich one another, forming a mesh of correlated insights. 
+The traditional model of observability as three or four independent pillars creates a false dichotomy. In reality, these signals overlap and enrich one another, forming a mesh of correlated insights.
 
-For instance: 
+For instance:
 
 - Metrics from Traces: Use trace span data to generate latency and error rate metrics.
 - Logs in Traces: Add log entries to specific spans for deeper context.
 - Events with Metrics: Annotate metrics with deployment events for faster issue resolution.
 
-Imagine a web application where users report slow checkout processes. Metrics like latency and error rates help identify that the payment service is slower than usual. Logs provide context, showing repeated timeout errors from a third-party API. Traces then pinpoint the exact step in the request lifecycle where delays occur, revealing that the issue lies with API response times. 
+Imagine a web application where users report slow checkout processes. Metrics like latency and error rates help identify that the payment service is slower than usual. Logs provide context, showing repeated timeout errors from a third-party API. Traces then pinpoint the exact step in the request lifecycle where delays occur, revealing that the issue lies with API response times.
 
 SigNoz uses this interconnected approach by leveraging a single data store for seamless correlation across signals. Observability isn't just about monitoring dashboards; it's about asking precise questions and getting answers quickly, enabling faster resolution of complex system issues.
 
-By thinking of observability as a mesh, you gain the flexibility and depth needed to pinpoint issues in complex systems efficiently. 
+By thinking of observability as a mesh, you gain the flexibility and depth needed to pinpoint issues in complex systems efficiently.
 
 ## Choosing the Right Tools for Each Pillar
 
-Building an effective observability stack starts with selecting the right tools. Here are key considerations to guide your decision-making process: 
+Building an effective observability stack starts with selecting the right tools. Here are key considerations to guide your decision-making process:
 
 ### Key Factors to Consider
 
@@ -119,36 +121,40 @@ Building an effective observability stack starts with selecting the right tools.
 
 ### Open-Source vs. Commercial Solutions
 
-Both open-source and commercial tools bring unique advantages to the table: 
+Both open-source and commercial tools bring unique advantages to the table:
 
 - Open-source tools
-    - Offer flexibility, transparency, and access to community support.
-    - Typically requires in-house expertise for setup, customization, and maintenance.
-    - Ideal for organizations seeking cost-effective, customizable solutions.
+  - Offer flexibility, transparency, and access to community support.
+  - Typically requires in-house expertise for setup, customization, and maintenance.
+  - Ideal for organizations seeking cost-effective, customizable solutions.
 - Commercial Solutions
-    - Provide enterprise-grade features, professional support, and robust documentation.
-    - Come at a higher cost but reduces the need for internal expertise.
-    - Best suited for organizations prioritization fast deployment and ongoing vendor support.
+  - Provide enterprise-grade features, professional support, and robust documentation.
+  - Come at a higher cost but reduces the need for internal expertise.
+  - Best suited for organizations prioritization fast deployment and ongoing vendor support.
 
 Choose the Right Fit: Assess your team's skillset, budget, and operational needs to balance flexibility and support.
 
 ### Integration and Compatibility
 
-To build a cohesive observability stack, ensure your tools work together seamlessly. Look for: 
+To build a cohesive observability stack, ensure your tools work together seamlessly. Look for:
 
 - Consistent Data Formats: Select tools that produce and consume compatible data formats across logs, metrics, traces, and events.
 - APIs and Plugins: Ensure the tools offer robust APIs or plugins for easy integration with other components in your stack.
 - Support for Standard Protocols: Favor solutions that adhere to open standards like OpenTelemetry for interoperability and future-proofing.
 
-<Figure src="/img/guides/2025/01/observability-stack-CleanShot_2025-01-03_at_15.50.332x.webp" alt="Popular Observability stacks and it’s comparisons." caption="Popular Observability stacks and it’s comparisons." /> 
+<Figure
+  src="/img/guides/2025/01/observability-stack-CleanShot_2025-01-03_at_15.50.332x.webp"
+  alt="Popular Observability stacks and it’s comparisons."
+  caption="Popular Observability stacks and it’s comparisons."
+/>{' '}
 
 ## How to Design Your Observability Stack Architecture
 
-Creating an effective observability stack architecture involves strategic planning to address your system’s unique requirements. Follow these steps to design a robust and scalable stack: 
+Creating an effective observability stack architecture involves strategic planning to address your system’s unique requirements. Follow these steps to design a robust and scalable stack:
 
 ### 1. Defining Goals and Requirements
 
-Establish clear objectives to align your observability stack with business and operational needs: 
+Establish clear objectives to align your observability stack with business and operational needs:
 
 - Service Level Agreements (SLAs): Identifying key performance and availability metrics you must meet.
 - Data Retention Needs: Determine how long historical data should be stored for analysis and compliance.
@@ -156,7 +162,7 @@ Establish clear objectives to align your observability stack with business and o
 
 ### 2. Map Data Flow and Collection Points
 
-Understand the lifecycle of your observability data to design an efficient flow: 
+Understand the lifecycle of your observability data to design an efficient flow:
 
 - Data Collection Points: Define where you’ll gather data, such as application code, infrastructure, and network layers.
 - Collection Methods: Choose suitable methods like agents, exporters, or sidecars for data collection.
@@ -164,7 +170,7 @@ Understand the lifecycle of your observability data to design an efficient flow:
 
 ### 3. Scalability and Performance Considerations
 
-Design your architecture to handle current workloads and future growth: 
+Design your architecture to handle current workloads and future growth:
 
 - Data Partitioning and Sharding: Distribute data across nodes for efficient storage and retrieval in high-volume scenarios.
 - Horizontal Scaling: Use multi-node clusters and load balancers to scale out your stack as demand increases.
@@ -172,7 +178,7 @@ Design your architecture to handle current workloads and future growth:
 
 ### 4. Security and Compliance
 
-Protect sensitive observability data and meet regulatory standards: 
+Protect sensitive observability data and meet regulatory standards:
 
 - Data Encryption: Secure data in transit and at rest using robust encryption protocols.
 - Role-Based Access Control (RBAC): Restrict data access to authorized users and systems.
@@ -182,11 +188,16 @@ Protect sensitive observability data and meet regulatory standards:
 
 Once you’ve designed your observability stack, it’s time to bring it to life with a structured implementation plan.
 
-<Figure src="/img/guides/2025/01/observability-stack-CleanShot_2025-01-03_at_15.41.062x.webp" alt="" caption="" />Follow these steps for a seamless setup: 
+<Figure
+  src="/img/guides/2025/01/observability-stack-CleanShot_2025-01-03_at_15.41.062x.webp"
+  alt=""
+  caption=""
+/>
+Follow these steps for a seamless setup:{' '}
 
 ### Instrumentation of Applications and Infrastructure
 
-Instrumentation is the foundation of your observability stack. Here’s how to approach it: 
+Instrumentation is the foundation of your observability stack. Here’s how to approach it:
 
 - Select Compatible Libraries: Use instrumentation libraries tailored to your tech stack (e.g., OpenTelemetry for polyglot environments).
 - Leverage Auto-Instrumentation: Automate where possible to minimize manual effort and reduce human error.
@@ -196,27 +207,27 @@ Pro Tip: Start with critical services and gradually expand instrumentation to th
 
 ### Set Up Data Collection and Storage
 
-Efficient data collection and storage are essential for long-term observability. 
+Efficient data collection and storage are essential for long-term observability.
 
 - Deploy Collection Agents: Install agents or exporters on your systems to gather telemetry data.
 - Configure Ingestion Pipelines: Use scalable solutions like Kafka for high-volume scenarios or direct ingestion for smaller setups.
-- Select Storage Solutions: Opt for robust tools like [SigNoz](https://signoz.io/docs/introduction/), which combines metrics, logs, and traces in one platform, or specialized databases such as Prometheus for time-series data and Elsaticsearch for logs. 
+- Select Storage Solutions: Opt for robust tools like [SigNoz](https://signoz.io/docs/introduction/), which combines metrics, logs, and traces in one platform, or specialized databases such as Prometheus for time-series data and Elsaticsearch for logs.
 
-Pro Tip: Plan for storage scalability early to avoid bottlenecks as data volumes grow. 
+Pro Tip: Plan for storage scalability early to avoid bottlenecks as data volumes grow.
 
 ### Implement Visualization and Alerting Tools
 
-Visualization and alerting bring your observability data to life, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/). 
+Visualization and alerting bring your observability data to life, enabling [proactive monitoring](https://signoz.io/guides/proactive-monitoring/).
 
 - Create Interactive Dashboards: Leverage tools like SigNoz, Grafana, or Kibana to visualize metrics, logs, and traces effectively.
 - Set Up Intelligent Alerts: Configure alerts in platforms like SigNoz based on key metrics and thresholds to reduce noise and improve incident response.
 - Integrate with Incident Management: Connect with tools like PagerDuty or OpsGenie for streamlined escalation and resolution workflows.
 
-Pro Tip: Focus on creating actionable dashboards, and avoid overwhelming teams with unnecessary data. 
+Pro Tip: Focus on creating actionable dashboards, and avoid overwhelming teams with unnecessary data.
 
 ### Establish Baseline Metrics and Thresholds
 
-Defining baselines ensures your alerting system reflects real-world conditions. 
+Defining baselines ensures your alerting system reflects real-world conditions.
 
 - Monitor to Determine Baselines: Observe normal system behaviour over a defined period to establish benchmarks.
 - Set Initial Thresholds: Use baseline data to define thresholds for alerts, ensuring they’re neither too sensitive nor too lax.
@@ -224,92 +235,92 @@ Defining baselines ensures your alerting system reflects real-world conditions.
 
 ## Best Practices for Data Collection and Instrumentation
 
-Ensuring the quality of observability data begins with effective data collection and instrumentation. The following best practices will help you create a robust foundation for monitoring and analyzing your systems. 
+Ensuring the quality of observability data begins with effective data collection and instrumentation. The following best practices will help you create a robust foundation for monitoring and analyzing your systems.
 
 ### 1. Leverage Automated Instrumentation
 
-Automated instrumentation simplifies collecting telemetry data and ensures consistency across your stack. use frameworks like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), a vendor-neutral standard that provides libraries and agents to instrument your applications seamlessly. 
+Automated instrumentation simplifies collecting telemetry data and ensures consistency across your stack. use frameworks like [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), a vendor-neutral standard that provides libraries and agents to instrument your applications seamlessly.
 
 - Why it’s important: Manual instrumentation is error-prone and time-consuming. Automating it ensures all critical events are captured.
 - How to implement: Integrate OpenTelemetry SDKs into your applications and configure them to export data to your observability platform.
 
 ### 2. Balance Data Granularity
 
-Collecting too much data can overwhelm your storage and slow down analysis, while too little data may leave you blind to critical issues. 
+Collecting too much data can overwhelm your storage and slow down analysis, while too little data may leave you blind to critical issues.
 
 - Optimal granularity: Focus on capturing detailed data for key services using sampling techniques for less critical components.
 
-Pro Tip: Start by monitoring critical paths, like request-response times for user-facing APIs, and adjust granularity as needed. 
+Pro Tip: Start by monitoring critical paths, like request-response times for user-facing APIs, and adjust granularity as needed.
 
 ### 3. Ensure Minimal Overhead with Lightweight Instrumentation
 
-Instrumentation should not significantly impact your application’s performance. 
+Instrumentation should not significantly impact your application’s performance.
 
 - Use efficient libraries and avoid excessive logging at high verbosity levels (e.g., DEBUG).
 - Implement sampling and rate limiting to reduce the load on storage and processing systems.
 
 ### 4. Prioritize High-Value Metrics and Traces
 
-Focus your data collection efforts on key metrics and spans that provide actionable insights. 
+Focus your data collection efforts on key metrics and spans that provide actionable insights.
 
 - Example: Instead of collecting all HTTP requests, prioritize failed requests, latency spikes, or high-volume endpoints.
 - Use dynamic filters to adjust what you monitor based on real-time conditions.
 
-SigNoz simplifies this process by enabling targeted data collection and dynamic filtering. Its powerful querying and visualization capabilities help teams focus on high-value metrics and traces without being overwhelmed by unnecessary data. 
+SigNoz simplifies this process by enabling targeted data collection and dynamic filtering. Its powerful querying and visualization capabilities help teams focus on high-value metrics and traces without being overwhelmed by unnecessary data.
 
-By correlating signals in a single data store, SigNoz ensures faster root cause analysis, reducing time to resolution and improving system reliability. 
+By correlating signals in a single data store, SigNoz ensures faster root cause analysis, reducing time to resolution and improving system reliability.
 
 ### 5. Enable Context Propagation Across Services
 
-Tracing requires propagating context information across distributed systems. Ensure that context headers are forwarded correctly to connect related spans. 
+Tracing requires propagating context information across distributed systems. Ensure that context headers are forwarded correctly to connect related spans.
 
 - Use trace IDs and span IDs for seamless request tracing across microservices.
 - Validate integration points regularly to prevent broken trace chains.
 
-SigNoz ensures smooth [context propagation](https://signoz.io/blog/opentelemetry-context-propagation/) by standardizing trace ID and [span ID](https://signoz.io/comparisons/opentelemetry-trace-id-vs-span-id/) handling across your distributed architecture. With its robust instrumentation and seamless integrations, SigNoz helps you maintain uninterrupted trace chains. 
+SigNoz ensures smooth [context propagation](https://signoz.io/blog/opentelemetry-context-propagation/) by standardizing trace ID and [span ID](https://signoz.io/comparisons/opentelemetry-trace-id-vs-span-id/) handling across your distributed architecture. With its robust instrumentation and seamless integrations, SigNoz helps you maintain uninterrupted trace chains.
 
-This helps for accurate correlation of events, making it easier to identify bottlenecks and optimize system performance effectively. 
+This helps for accurate correlation of events, making it easier to identify bottlenecks and optimize system performance effectively.
 
 ### 6. Incorporate Real-Time Data Validation
 
-Ensure the accuracy of collected data with validation mechanisms during ingestion. 
+Ensure the accuracy of collected data with validation mechanisms during ingestion.
 
 - Use schema validators to confirm that logs, metrics, and traces adhere to expected formats.
 - Monitor data pipelines to detect and resolve issues, such as missing fields or incorrect values.
 
 ### 7. Integrate Observability with CI/CD Pipelines
 
-Automate the validation of telemetry during deployments to catch potential issues early. 
+Automate the validation of telemetry during deployments to catch potential issues early.
 
 - Add smoke tests for critical observability signals in your CI/CD pipeline.
 - Example: After deploying a new service, ensure telemetry data from the service is being ingested correctly.
 
 ## Leveraging OpenTelemetry for a Unified Observability Approach
 
-OpenTelemetry standardizes telemetry data collection and export with key components: 
+OpenTelemetry standardizes telemetry data collection and export with key components:
 
 - SDKs for code instrumentation.
 - Collector for vendor-neutral data processing.
 - Protocols for standardized data transmission.
 
-Implementation Tips: 
+Implementation Tips:
 
 - Start small with a single service or data type (gradual migration).
 - Adopt OpenTelemetry for new projects (greenfield approach).
 
-Tool Integration: 
+Tool Integration:
 
-Export telemetry to popular backends like SigNoz, Prometheus, Jaeger, or Elasticsearch. SigNoz, in particular, stands out for its unified observability approach, enabling developers to monitor metrics, logs, and traces in a single interface. By centralizing observablity, SigNoz simplifies troubleshooting, accelerates debugging, and enhances overall system performance. 
+Export telemetry to popular backends like SigNoz, Prometheus, Jaeger, or Elasticsearch. SigNoz, in particular, stands out for its unified observability approach, enabling developers to monitor metrics, logs, and traces in a single interface. By centralizing observablity, SigNoz simplifies troubleshooting, accelerates debugging, and enhances overall system performance.
 
-Ready to streamline your observability? Explore how SigNoz’s [unified observability](https://signoz.io/unified-observability/) platform can transform your monitoring strategy. 
+Ready to streamline your observability? Explore how SigNoz’s [unified observability](https://signoz.io/unified-observability/) platform can transform your monitoring strategy.
 
 ## Visualizing and Analyzing Telemetry Data
 
-In observability, effective visualization transforms raw telemetry data into actionable insights, empowering teams to monitor performance, detect anomalies, and troubleshoot issues efficiently. 
+In observability, effective visualization transforms raw telemetry data into actionable insights, empowering teams to monitor performance, detect anomalies, and troubleshoot issues efficiently.
 
 ### Effective Visualization Techniques
 
-The choice of visualization can significantly impact how well the data is understood: 
+The choice of visualization can significantly impact how well the data is understood:
 
 - Heat Maps: Best suited for latency distributions, helping identify performance bottlenecks and patterns.
 - Line Charts: Ideal for tracking time-series metrics, such as CPU usage, memory consumption, or request rates over time.
@@ -317,7 +328,7 @@ The choice of visualization can significantly impact how well the data is unders
 
 ### Dashboard and Reporting
 
-Dashboards are essential for tailoring observability data to the needs of diverse stakeholders: 
+Dashboards are essential for tailoring observability data to the needs of diverse stakeholders:
 
 - Execute Overview: Highlight key performance indicators (KPIs), trends, and SLA adherence. Focus on summary metrics such as uptime, error rates, and cost optimization.
 - Operational Dashboards: Provide detailed, real-time metrics for ongoing monitoring and alerting. Include alerts and event logs to assist operations teams with immediate responses.
@@ -325,7 +336,7 @@ Dashboards are essential for tailoring observability data to the needs of divers
 
 ### Advanced Analytics and Anomaly Detection
 
-Modern observability systems leverage analytics and machine learning to enhance visibility: 
+Modern observability systems leverage analytics and machine learning to enhance visibility:
 
 - Anomaly Detection Algorithms: Identify derivations from normal patterns using statistical models (e.g., Z-Score) or ML techniques (e.g., Isolation Forests).
 - Correlation Analysis: Detect interdependencies between metrics, such as how CPU spikes correlate with increased API calls.
@@ -333,7 +344,7 @@ Modern observability systems leverage analytics and machine learning to enhance
 
 ### Cross-Pillar Correlation
 
-Integrating data from metrics, logs, and traces creates a unified observability framework. 
+Integrating data from metrics, logs, and traces creates a unified observability framework.
 
 - Link Trace IDs in Logs: Provide context by mapping logs to corresponding traces, enabling a complete view of request flows.
 - Annotate Metrics with Events: Mark metrics with deployment times, configuring changes, or incidents for better context.
@@ -341,37 +352,37 @@ Integrating data from metrics, logs, and traces creates a unified observability
 
 ## Observability in Action: Real-World Use Cases
 
-Observability is not just about monitoring, it’s about solving real-world challenges with actionable insights. Here’s how an observability stack can address common problems effectively. 
+Observability is not just about monitoring, it’s about solving real-world challenges with actionable insights. Here’s how an observability stack can address common problems effectively.
 
 ### Microservices Troubleshooting
 
-Scenario: Users report slow response times in your e-commerce app. 
+Scenario: Users report slow response times in your e-commerce app.
 
-Solution: 
+Solution:
 
 - [Distributed Tracing](https://signoz.io/distributed-tracing/): Use SigNoz to trace the full transaction path and pinpoint the slow-performing microservice. Its intuitive UI makes it easy to visualize request latencies across services.
 - Metrics Analysis: Dive into service-specific metrics like CPU, memory, and network usage using SigNoz’s built-in dashboards. Quickly identify resource bottlenecks affecting performance.
 - Log Review: Centralize logs within SigNoz to search for errors or warnings associated with the impacted service. This reduces context-switching between tools.
 - Event Correlation: Leverage SigNoz to correlate performance issues with recent deployment changes or configuration updates.
 
-Result: SigNoz reveals that a database query bottleneck caused by inefficient indexing was introduced in the latest release. With this insight, you swiftly optimize the query and restore system performance. 
+Result: SigNoz reveals that a database query bottleneck caused by inefficient indexing was introduced in the latest release. With this insight, you swiftly optimize the query and restore system performance.
 
 ### Cloud Resource Optimization
 
-Scenario: Your cloud costs are rising disproportionately to user growth. 
+Scenario: Your cloud costs are rising disproportionately to user growth.
 
-Solution: 
+Solution:
 
 - Utilization Metrics: Track resource usage trends (CPU, Memory, Storage) over time.
 - Load Correlation: Map resource consumption to user activity and application load.
 - Scaling Policy Review: Examine scaling events for inefficiencies in configuration.
 - Resource Assessment: Detect over-provisioned or idle instances and resize or terminate them.
 
-Result: By fine-tuning auto-scaling and rightsizing instances, you can achieve up to a 25% reduction in cloud costs without impacting performance. 
+Result: By fine-tuning auto-scaling and rightsizing instances, you can achieve up to a 25% reduction in cloud costs without impacting performance.
 
 ### Enhanced Security Posture
 
-Scenario: You need to strengthen threat detection and response capabilities. 
+Scenario: You need to strengthen threat detection and response capabilities.
 
 Solution:
 
@@ -379,11 +390,11 @@ Solution:
 - Proactive Alerts: Set up alerts for suspicious patterns, such as multiple failed login attempts or unauthorized access to sensitive resources.
 - Tracing user Actions: Connect security incidents with system metrics, logs, and recent changes for better context.
 
-Result: A coordinated view across logs, metrics, and traces allows you to detect and thwart a potential data exfiltration attempt within minutes. 
+Result: A coordinated view across logs, metrics, and traces allows you to detect and thwart a potential data exfiltration attempt within minutes.
 
 ### User Experience Improvements
 
-Scenario: You aim to reduce cart abandonment rates in your e-commerce application. 
+Scenario: You aim to reduce cart abandonment rates in your e-commerce application.
 
 Solution:
 
@@ -392,11 +403,11 @@ Solution:
 - Behaviour Correlation: Link performance metrics to user behaviour, such as drop-off rates at specific stages.
 - Component Optimization: Address bottlenecks like slow-loading components or high-latency API endpoints.
 
-Result: By reducing the average checkout time by 40%, you can achieve up to a 15% drop in cart abandonment, directly booting sales.  
+Result: By reducing the average checkout time by 40%, you can achieve up to a 15% drop in cart abandonment, directly booting sales.
 
 ## Overcoming Common Challenges in Observability Implementation
 
-Implementing an observability stack involves several hurdles. Here’s how to address them efficiently: 
+Implementing an observability stack involves several hurdles. Here’s how to address them efficiently:
 
 ### Managing Data Volume and Storage Costs
 
@@ -454,7 +465,7 @@ Stay ahead of the curve by keeping an eye on these emerging trends:
 
 SigNoz is an open-source, full-stack observability platform that can simplify your observability journey.
 
-SigNoz offers a unified platform for logs, metrics, and traces, delivering: 
+SigNoz offers a unified platform for logs, metrics, and traces, delivering:
 
 - A scalable backend for efficient data storage and processing.
 - An intuitive user interface for visualization and analysis.
@@ -464,20 +475,27 @@ SigNoz offers a unified platform for logs, metrics, and traces, delivering:
 
 - Unified dashboards for correlated insights across logs, metrics, and traces.
 
-<Figure src="/img/guides/2025/01/observability-stack-hostmetrics-dashboards.webp" alt="" caption="" />- Built-in alerting and anomaly detection to stay ahead of issues.
+<Figure
+  src="/img/guides/2025/01/observability-stack-hostmetrics-dashboards.webp"
+  alt=""
+  caption=""
+/>
+- Built-in alerting and anomaly detection to stay ahead of issues.
 
-<Figure src="/img/guides/2025/01/observability-stack-image.webp" alt="" caption="" />- Advanced analysis with a custom query language.
+<Figure src="/img/guides/2025/01/observability-stack-image.webp" alt="" caption="" />- Advanced
+analysis with a custom query language.
 
-<Figure src="/img/guides/2025/01/observability-stack-Query_Builder_SigNoz.webp" alt="" caption="" />- Role-based access control to enhance collaboration and security.
+<Figure src="/img/guides/2025/01/observability-stack-Query_Builder_SigNoz.webp" alt="" caption="" />
+- Role-based access control to enhance collaboration and security.
 
 ### Getting Started with SigNoz
 
 To begin using SigNoz:
 
-1. Deploy SigNoz using Docker Compose or Kubernetes (Helm). 
+1. Deploy SigNoz using Docker Compose or Kubernetes (Helm).
 2. Instrument your applications using OpenTelemetry SDKs.
 3. Configure the [OpenTelemetry Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) to route data to SigNoz.
-4. Access the SigNoz UI to visualize and analyze data. 
+4. Access the SigNoz UI to visualize and analyze data.
 
 ### Cloud vs. Open-Source
 
@@ -486,11 +504,11 @@ SigNoz offers both cloud-hosted and self-hosted options:
 - SigNoz Cloud: Managed solution with automatic updates and scaling.
 - Open-Source: Self-hosted for complete control and on-premise deployment.
 
-Select the option that best suits your expertise, budget, and compliance needs. 
+Select the option that best suits your expertise, budget, and compliance needs.
 
 ## Key Takeaways
 
-Creating an effective observability stack is essential for managing the complexities of modern software systems. Here are the core principles to guide your approach. 
+Creating an effective observability stack is essential for managing the complexities of modern software systems. Here are the core principles to guide your approach.
 
 - Ensure your stack incorporates all four pillars: Logs, metrics, traces, and events, for holistic system visibility.
 - Opt for tools that seamlessly integrate and scale with your evolving needs while avoiding tool sprawl.
@@ -500,7 +518,7 @@ Creating an effective observability stack is essential for managing the complexi
 - Address challenges like high data volumes and integration complexity with strategies such as intelligent sampling, tiered storage, and centralized platforms.
 - Keep pace with advancements like AI-driven analytics, eBPF-based tracing, and observability-driven development practices.
 
-By implementing these strategies, you’ll build an observability stack that delivers deep insights, accelerates troubleshooting, enhances performance, and supports strategic decision-making for modern, distributed systems. 
+By implementing these strategies, you’ll build an observability stack that delivers deep insights, accelerates troubleshooting, enhances performance, and supports strategic decision-making for modern, distributed systems.
 
 ## FAQs
 
@@ -517,23 +535,23 @@ Your decision depends on your unique needs:
 - Support Needs: Commercial tools provide dedicated customer support, open-source tools rely on community support.
 - Integration: Ensure the tool fits seamlessly into your existing tech stack.
 
-Evaluate your team’s skills, budget, and system requirements to make the right choice.  
+Evaluate your team’s skills, budget, and system requirements to make the right choice.
 
 ### Can I Implement an Observability Stack in a Legacy System?
 
-Yes, implementing observability in legacy systems is possible, but it may require extra effort. Steps to get started: 
+Yes, implementing observability in legacy systems is possible, but it may require extra effort. Steps to get started:
 
-1. Start Small: Begin with basic log analysis and [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/). 
-2. Gradual Instrumentation: Introduce metrics and tracing incrementally. 
-3. Standardization: Use OpenTelemetry libraries to collect consistent telemetry data across components. 
+1. Start Small: Begin with basic log analysis and [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/).
+2. Gradual Instrumentation: Introduce metrics and tracing incrementally.
+3. Standardization: Use OpenTelemetry libraries to collect consistent telemetry data across components.
 4. Use Sidecars or Agents: For systems that can’t be directly instrumented, leverage external helpers like Sidecars.
 
 ### How Does Observability Impact DevOps Practices?
 
-Observability is a game-changer for DevOps, enhancing key workflows: 
+Observability is a game-changer for DevOps, enhancing key workflows:
 
 - Faster Incident Response: Quickly detect, diagnose, and resolve issues.
 - Improved Collaboration: Foster shared visibility and understanding across development and operations teams.
 - Data-Driven Decisions: Leverage insights to make informed improvements.
 - Continuous Improvement: Iterate on system performance using real-world feedback.
-- Shift-Left Testing: Embed [observability principles](https://signoz.io/guides/observability-engineering/) early in the development lifecycle for proactive problem-solving.
\ No newline at end of file
+- Shift-Left Testing: Embed [observability principles](https://signoz.io/guides/observability-engineering/) early in the development lifecycle for proactive problem-solving.
diff --git a/data/guides/observability-vs-monitoring-vs-telemetry.mdx b/data/guides/observability-vs-monitoring-vs-telemetry.mdx
index d7c41246e..0244b2eb1 100644
--- a/data/guides/observability-vs-monitoring-vs-telemetry.mdx
+++ b/data/guides/observability-vs-monitoring-vs-telemetry.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: Observability vs Monitoring vs Telemetry - Key Differences
-slug: observability-vs-monitoring-vs-telemetry
 date: 2024-08-20
 tags: [observability, monitoring]
 authors: [vivek_goswami]
 description: Discover the key differences between observability, monitoring, and telemetry in IT operations. Learn how these concepts work together to enhance system insights.
 keywords: [observability, monitoring, telemetry, IT operations, system management, DevOps, SigNoz]
-
 ---
 
 The landscape of IT operations and system management is evolving rapidly. As systems become more complex, the need for comprehensive insights grows. Three key concepts — observability, monitoring, and telemetry — play crucial roles in modern IT environments. But what exactly are these concepts, and how do they differ? This article breaks down the distinctions and explores their interconnected roles in maintaining robust, efficient systems.
@@ -22,7 +19,11 @@ Before diving into the details, let's establish a quick overview of these three
 
 These concepts work together in modern IT environments to comprehensively view system performance and health. Telemetry feeds data to monitoring and observability tools, which then analyze this information to provide actionable insights.
 
-<Figure src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image.webp" alt="Monitoring vs Observability" caption="Monitoring vs Observability" />
+<Figure
+  src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image.webp"
+  alt="Monitoring vs Observability"
+  caption="Monitoring vs Observability"
+/>
 
 In the following sections, you will learn about the various aspects of these concepts in detail. So, let’s start right away.
 
@@ -36,11 +37,19 @@ The three pillars of observability on which the foundation of observability lies
 - Metrics: These are quantitative measurements of system performance. It provides data like response time or resource usage that are aggregated and analyzed over time.
 - Traces: These are records of requests as they flow through distributed systems.
 
-<Figure src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image%201.webp" alt="Tradional Approach to Observability" caption="Tradional Approach to Observability" />
+<Figure
+  src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image%201.webp"
+  alt="Tradional Approach to Observability"
+  caption="Tradional Approach to Observability"
+/>
 
 At SigNoz, we envision [observability as a mesh or network rather than a set of pillars](https://signoz.io/blog/observability-net/). This interconnected approach allows for more powerful correlations and faster problem-solving.
 
-<Figure src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image%202.webp" alt="SigNoz’s Approach to Observability" caption="SigNoz’s Approach to Observability" />
+<Figure
+  src="/img/guides/2024/08/observability-vs-monitoring-vs-telemetry-image%202.webp"
+  alt="SigNoz’s Approach to Observability"
+  caption="SigNoz’s Approach to Observability"
+/>
 
 ### How Observability Works
 
@@ -177,4 +186,4 @@ For comprehensive system oversight, especially in complex environments, implemen
 
 - [Three Pillars of Observability [And Beyond] - A Beginner's Guide](https://signoz.io/blog/three-pillars-of-observability/)
 - [Mastering Java App Monitoring in Docker - A Practical Guide](https://signoz.io/guides/monitoring-and-troubleshooting-java-applications-in-docker-containers/)
-- [Overview - Implementing OpenTelemetry in Python applications [Tutorial Series]](https://signoz.io/opentelemetry/python-overview/)
\ No newline at end of file
+- [Overview - Implementing OpenTelemetry in Python applications [Tutorial Series]](https://signoz.io/opentelemetry/python-overview/)
diff --git a/data/guides/observability-vs-visibility.mdx b/data/guides/observability-vs-visibility.mdx
index b065a1485..5c971d4ba 100644
--- a/data/guides/observability-vs-visibility.mdx
+++ b/data/guides/observability-vs-visibility.mdx
@@ -1,18 +1,25 @@
 ---
-
 title: Observability vs. Visibility - Key Differences and Why They Matter
-slug: observability-vs-visibility
 date: 2025-02-28
 tags: [observability, visibility, monitoring, cloud native]
 authors: [niyati_thakkar]
 description: Understand the key differences between observability and visibility, and why these concepts are crucial for effectively managing modern systems.
-keywords: [observability, visibility, monitoring, cloud native, troubleshooting, DevOps, SRE, observability vs visibility]
-
+keywords:
+  [
+    observability,
+    visibility,
+    monitoring,
+    cloud native,
+    troubleshooting,
+    DevOps,
+    SRE,
+    observability vs visibility,
+  ]
 ---
 
-Site Reliability Engineers (SREs) and developers need more than basic monitoring – they require deep insights into system behavior. This is where **observability** comes in. 
+Site Reliability Engineers (SREs) and developers need more than basic monitoring – they require deep insights into system behavior. This is where **observability** comes in.
 
-**Observability goes beyond traditional visibility** or monitoring by enabling teams to not only see that something is wrong, but **understand **why** and **where** it’s wrong in real time**. 
+**Observability goes beyond traditional visibility** or monitoring by enabling teams to not only see that something is wrong, but **understand **why** and **where** it’s wrong in real time**.
 
 In the sections below, we’ll explore what observability and visibility mean, how they differ, and why observability has become essential for ensuring reliability and performance in modern systems.
 
@@ -35,7 +42,7 @@ and enables active investigation of problems that were not predefined. In practi
 
 <KeyPointCallout>
 
-*A helpful analogy from industry compares monitoring/visibility to just **hearing** an alarm vs. observability to **listening** and understanding the full situation. Visibility gives a signal, while observability gives you the story.*
+_A helpful analogy from industry compares monitoring/visibility to just **hearing** an alarm vs. observability to **listening** and understanding the full situation. Visibility gives a signal, while observability gives you the story._
 
 </KeyPointCallout>
 
@@ -45,27 +52,27 @@ Both observability and traditional visibility rely on gathering data from system
 
 ### Metrics
 
-Numerical measurements that reflect the performance or health of a system over time. Metrics are typically time-series data points – for example, **CPU usage**, **request throughput**, **memory consumption**, **error rate**, etc. 
+Numerical measurements that reflect the performance or health of a system over time. Metrics are typically time-series data points – for example, **CPU usage**, **request throughput**, **memory consumption**, **error rate**, etc.
 
 Metrics are great for high-level monitoring and alerting (e.g. a spike in latency or error count). They provide a quantifiable pulse of your system at a glance. However, metrics alone may lack detail for root cause analysis (they show **that** a problem exists but not always the full context). **Metrics are the first clue that something might be wrong (e.g. high latency, increased error rate)**
 
-### Logs 
+### Logs
 
-Immutable, timestamped records of discrete events that happened in the system. Logs can be structured (like JSON events) or unstructured text, and they contain details about specific events or errors (stack traces, messages, user IDs, etc.). 
+Immutable, timestamped records of discrete events that happened in the system. Logs can be structured (like JSON events) or unstructured text, and they contain details about specific events or errors (stack traces, messages, user IDs, etc.).
 
-Logs are essential for drilling into what happened at a particular time – they answer the **“who, what, when, where”** of an event. Traditional visibility heavily relies on log files for troubleshooting after an incident. Logs provide rich context but can be voluminous and hard to analyze in isolation. *In context, logs help explain **why** something happened by providing error details or state information leading up to an issue.*
+Logs are essential for drilling into what happened at a particular time – they answer the **“who, what, when, where”** of an event. Traditional visibility heavily relies on log files for troubleshooting after an incident. Logs provide rich context but can be voluminous and hard to analyze in isolation. _In context, logs help explain **why** something happened by providing error details or state information leading up to an issue._
 
 ### Traces
 
-Traces represent the **end-to-end path of a single request or transaction** through a distributed system. A trace is composed of spans, each span representing a unit of work (e.g. a service call, a database query) along that request’s journey. 
+Traces represent the **end-to-end path of a single request or transaction** through a distributed system. A trace is composed of spans, each span representing a unit of work (e.g. a service call, a database query) along that request’s journey.
 
-[Distributed tracing](https://signoz.io/blog/distributed-tracing/) is key to observability in microservices and cloud-native architectures – it allows you to follow a user request as it hops through multiple services and see where delays or errors occur. Traces visualize the **flow** and timing across components, making it easier to pinpoint bottlenecks or failing interactions. Traditional monitoring usually lacked this cross-service visibility. *Traces tell you **where** a problem occurred across a workflow (e.g. which service or call in the chain is slow or failing)*
+[Distributed tracing](https://signoz.io/blog/distributed-tracing/) is key to observability in microservices and cloud-native architectures – it allows you to follow a user request as it hops through multiple services and see where delays or errors occur. Traces visualize the **flow** and timing across components, making it easier to pinpoint bottlenecks or failing interactions. Traditional monitoring usually lacked this cross-service visibility. _Traces tell you **where** a problem occurred across a workflow (e.g. which service or call in the chain is slow or failing)_
 
 ### Telemetry & Events
 
-The term **telemetry** encompasses all the data signals emitted by systems – metrics, logs, traces, and also events. 
+The term **telemetry** encompasses all the data signals emitted by systems – metrics, logs, traces, and also events.
 
-Events can include things like deploys, configuration changes, or security alerts. Modern observability often references **MELT** data: **M**etrics, **E**vents, **L**ogs, and **T**races​. 
+Events can include things like deploys, configuration changes, or security alerts. Modern observability often references **MELT** data: **M**etrics, **E**vents, **L**ogs, and **T**races​.
 These are the raw materials of observability. A robust observability setup will collect telemetry from across the stack (applications, infrastructure, network, etc.). The **key difference** is that observability platforms **correlate and analyze** this telemetry together, rather than examining each data type in a silo.
 
 ### Why combine these?
@@ -74,7 +81,7 @@ Because each of the three pillars offers a different viewpoint. When you layer t
 
 <KeyPointCallout>
 
-*Metrics indicate **that** there is an issue, traces show **where** in the system it is, and logs explain **why** it happened.*
+_Metrics indicate **that** there is an issue, traces show **where** in the system it is, and logs explain **why** it happened._
 
 </ KeyPointCallout>
 
@@ -84,36 +91,36 @@ To make this more concrete, let’s look at scenarios where observability provid
 
 ### Debugging Microservices in Production
 
-Imagine a user-facing application composed of dozens of microservices. 
+Imagine a user-facing application composed of dozens of microservices.
 
-A user action (like placing an order) might invoke a chain of service calls `(user service → order service → inventory service → payment service, etc.)`. 
-If the user’s order fails or is slow, traditional monitoring might show an error count increment on the front-end service or a generic “500 error” log. 
+A user action (like placing an order) might invoke a chain of service calls `(user service → order service → inventory service → payment service, etc.)`.
+If the user’s order fails or is slow, traditional monitoring might show an error count increment on the front-end service or a generic “500 error” log.
 
-But **which service in the chain caused it?** 
+But **which service in the chain caused it?**
 
-With observability, SREs can pull up a distributed trace for that request and **see the entire call graph**. 
-For instance, the trace might reveal that the **inventory service** took 3 seconds to respond, delaying the whole request. Drilling into inventory service logs could then show a **database timeout error.** 
+With observability, SREs can pull up a distributed trace for that request and **see the entire call graph**.
+For instance, the trace might reveal that the **inventory service** took 3 seconds to respond, delaying the whole request. Drilling into inventory service logs could then show a **database timeout error.**
 
-This end-to-end view drastically reduces debugging time. Teams at Netflix, Google, etc., rely on tracing to debug production issues that span multiple services – something basic metrics would not easily reveal. 
+This end-to-end view drastically reduces debugging time. Teams at Netflix, Google, etc., rely on tracing to debug production issues that span multiple services – something basic metrics would not easily reveal.
 
 ### Anomaly Detection and Outage Prevention
 
-Observability can catch anomalies that basic monitoring might overlook. 
+Observability can catch anomalies that basic monitoring might overlook.
 
-For example, suppose a new deployment causes one microservice to intermittently throw authentication errors downstream. 
-A traditional system might not trigger an alert if the error rate is below a fixed threshold, and the ops team might only notice when it becomes a major outage. 
+For example, suppose a new deployment causes one microservice to intermittently throw authentication errors downstream.
+A traditional system might not trigger an alert if the error rate is below a fixed threshold, and the ops team might only notice when it becomes a major outage.
 
-An observability platform with anomaly detection could recognize the unusual spike in error **percentage** for that service or correlate that the error coincided with a deploy event. 
+An observability platform with anomaly detection could recognize the unusual spike in error **percentage** for that service or correlate that the error coincided with a deploy event.
 
-Another scenario: anomaly detection might catch a memory leak early – e.g. if a service’s memory usage starts trending higher than its typical pattern, an AI-driven insight can flag it before the service actually crashes. 
+Another scenario: anomaly detection might catch a memory leak early – e.g. if a service’s memory usage starts trending higher than its typical pattern, an AI-driven insight can flag it before the service actually crashes.
 
 This proactive detection lets SREs fix issues **before** they escalate into outages. Basic visibility tools, reliant on human-set thresholds, often miss these subtle early warnings​.
 
 ### Performance Optimization and Bottleneck Identification
 
-Beyond firefighting outages, observability is invaluable for performance tuning. In complex systems, the slowest component determines the user experience. 
+Beyond firefighting outages, observability is invaluable for performance tuning. In complex systems, the slowest component determines the user experience.
 
-Observability data helps locate slownesses and inefficiencies. **For instance, consider a web page that is loading slowly.** Metrics might show the page load time is high (alerting you to the problem). With an observability approach, you could pull up a trace of a slow request and see which step took the longest – maybe a call to the **reviews service** is unusually slow. Then you check logs for that service around the same timestamp and find that a database query was sluggish (perhaps due to an inefficient query or lock contention). By correlating these signals, you’ve identified a specific bottleneck to fix. 
+Observability data helps locate slownesses and inefficiencies. **For instance, consider a web page that is loading slowly.** Metrics might show the page load time is high (alerting you to the problem). With an observability approach, you could pull up a trace of a slow request and see which step took the longest – maybe a call to the **reviews service** is unusually slow. Then you check logs for that service around the same timestamp and find that a database query was sluggish (perhaps due to an inefficient query or lock contention). By correlating these signals, you’ve identified a specific bottleneck to fix.
 
 <div className="bg-gray-900 p-4 rounded-lg shadow-lg my-4">
   <div className="flex flex-col space-y-3">
@@ -142,12 +149,11 @@ Observability data helps locate slownesses and inefficiencies. **For instance, c
         Slow query: SELECT * FROM reviews...
       </div>
     </div>
+
   </div>
 </div>
 
-
-As a general pattern: *metrics can **signal** high latency, traces will spotlight **which service** is the culprit, and logs provide the **detailed reason** (e.g. a slow SQL query)*​. This capability is especially useful in microservices and serverless architectures where performance issues can creep in at unexpected places. 
-
+As a general pattern: *metrics can **signal** high latency, traces will spotlight **which service** is the culprit, and logs provide the **detailed reason** (e.g. a slow SQL query)*​. This capability is especially useful in microservices and serverless architectures where performance issues can creep in at unexpected places.
 
 ### Complex Outage Resolution and Root Cause Analysis
 
@@ -160,7 +166,7 @@ When major incidents occur, observability helps resolve them quickly by:
 
 For example, in a chain reaction failure where Service A's crash triggers issues in Services B and C, observability platforms can show the exact sequence and timing of events. This turns a confusing set of alerts into a clear narrative, helping teams identify and fix the root cause faster.
 
-### Analytics and Business Insights 
+### Analytics and Business Insights
 
 Observability also connects technical metrics to business outcomes by enabling questions like:
 
@@ -187,7 +193,7 @@ While observability brings significant benefits, teams face several key challeng
 
 Observability generates massive amounts of telemetry data - often hundreds of gigabytes daily. This volume can overwhelm both tools and teams, making it difficult to extract meaningful insights. Teams must carefully balance data retention with analysis needs, while managing storage costs and query performance.
 
-### Tool Integration & Complexity 
+### Tool Integration & Complexity
 
 Implementing observability often requires integrating multiple specialized tools into a cohesive stack. Many organizations struggle with data silos between different monitoring systems. While standards like OpenTelemetry help, deploying and maintaining an observability platform requires significant engineering effort and expertise.
 
@@ -209,19 +215,20 @@ Despite these challenges, **organizations continue investing in observability be
 
 The landscape of tools for observability has expanded rapidly. Here we’ll compare popular **observability tools** with some traditional **visibility/monitoring tools**, highlighting their roles:
 
-### Observability Tools and Platforms 
+### Observability Tools and Platforms
 
 These are tools designed to gather **and** correlate metrics, logs, and traces, often across distributed systems:
 
-**OpenTelemetry (OTel) with SigNoz:** 
+**OpenTelemetry (OTel) with SigNoz:**
 
-[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is an open-source framework and collection of libraries for instrumenting applications and collecting telemetry data (metrics, logs, traces) in a standardized way​. It’s not a monitoring solution by itself, but rather the plumbing that enables observability – think of it as the unified client libraries and agents you add to your code to emit data. With OpenTelemetry, you can instrument your services to send data to backends of your choice. 
+[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) is an open-source framework and collection of libraries for instrumenting applications and collecting telemetry data (metrics, logs, traces) in a standardized way​. It’s not a monitoring solution by itself, but rather the plumbing that enables observability – think of it as the unified client libraries and agents you add to your code to emit data. With OpenTelemetry, you can instrument your services to send data to backends of your choice.
 
 The key benefit is vendor-neutrality and consistency: you use the same instrumentation for many backends. OpenTelemetry supports many languages and has autoinstrumentation for popular frameworks, making it easier for devs to produce telemetry. In an observability stack, [OTel](https://signoz.io/blog/what-is-opentelemetry/) might be used to collect data, which is then sent to a metrics system, a tracing backend, etc. (For example, you might use OTel libraries in your code, and point them to send traces to Jaeger and metrics to Prometheus or SigNoz for an all in one solution).
 
 SigNoz is an open-source APM and observability platform that provides a unified solution for metrics, traces, and logs. It's designed as a more cost-effective, self-hosted alternative to commercial observability platforms like Datadog or New Relic. SigNoz uses OpenTelemetry for data collection, making it vendor-neutral and future-proof.
 
 Key features of SigNoz include:
+
 - Application metrics monitoring with pre-built dashboards
 - Distributed tracing with flamegraphs and service dependency graphs
 - Log management with full-text search and correlation with traces
@@ -233,7 +240,6 @@ SigNoz is particularly appealing for teams that want full control over their obs
 
 <GetStartedSigNoz />
 
-
 **Grafana + Prometheus:**
 
 Prometheus is a popular open-source metrics monitoring system for cloud-native environments. It collects metrics from services via HTTP endpoints and stores them as time-series data. Key features include real-time metrics collection, powerful PromQL querying, Kubernetes integration, and alerting capabilities. It enables monitoring of CPU, memory, request rates, error rates, and other metrics with threshold-based alerts.
@@ -242,21 +248,21 @@ Prometheus handles the metrics pillar of observability, particularly for golden
 
 Grafana provides a unified interface for metrics, logs, and traces through its [LGTM](https://signoz.io/docs/migration/migrate-from-grafana-to-signoz/) stack (Loki, Grafana, Tempo, Mimir). This offers an open-source alternative for full observability. The ecosystem includes Prometheus Alertmanager for alerts and emerging tools for continuous profiling like Pyroscope/Parca. Organizations typically combine these tools based on their needs, unless opting for a SaaS solution.
 
-**Elastic Stack (ELK/Opensearch):** 
+**Elastic Stack (ELK/Opensearch):**
 
 A common approach for **logs** is the ELK stack – Elasticsearch, Logstash, Kibana – or its open-source fork OpenSearch/OpenSearch Dashboards. These systems store and index logs, and provide search and visualization capabilities. In terms of observability, Elasticsearch/OpenSearch can serve as the log management component: aggregating logs from many services and making them searchable in near real-time. Kibana (or OpenSearch Dashboards) can be used to set up log analytics and some basic correlations (for example, you can correlate logs with metrics if you ship metrics into Elasticsearch too, though that’s less common). Elastic has an “Observability” solution that ties together logs, metrics, and APM traces in their stack. So ELK/OpenSearch can be considered part of an observability toolkit (especially for the logging pillar). It’s a bit more DIY compared to all-in-one platforms; you need to run and scale the clusters. Many SRE teams set up [centralized logging](https://signoz.io/blog/centralized-logging/) this way to improve visibility over the old approach of SSHing into servers to read log files.
 
-**Datadog:** 
+**Datadog:**
 
-Datadog is a popular commercial **observability platform** (SaaS) that offers a one-stop solution for metrics, logs, traces, and more. It provides agents to collect data from hosts and applications, and a unified cloud platform to store, visualize, and analyze that data. 
+Datadog is a popular commercial **observability platform** (SaaS) that offers a one-stop solution for metrics, logs, traces, and more. It provides agents to collect data from hosts and applications, and a unified cloud platform to store, visualize, and analyze that data.
 
-One of the strengths of Datadog is correlation – in the Datadog UI, you can jump from an alerting metric directly to related logs or [APM traces](https://signoz.io/blog/apm-vs-distributed-tracing/) with a few clicks. Datadog’s APM (Application Performance Monitoring) features include distributed tracing similar to Jaeger, complete with service dependency maps and flame graphs of requests. It also has log management where you can tail and [search logs](https://signoz.io/docs/logs-management/logs-api/search-logs/), and a custom metrics database for all your app and infrastructure metrics. Additionally, Datadog includes **machine-learning based anomaly detection** and forecasting on metrics, and **RBAC and integrations** for a huge variety of technologies (AWS, Docker, MySQL, you name it)​​. 
+One of the strengths of Datadog is correlation – in the Datadog UI, you can jump from an alerting metric directly to related logs or [APM traces](https://signoz.io/blog/apm-vs-distributed-tracing/) with a few clicks. Datadog’s APM (Application Performance Monitoring) features include distributed tracing similar to Jaeger, complete with service dependency maps and flame graphs of requests. It also has log management where you can tail and [search logs](https://signoz.io/docs/logs-management/logs-api/search-logs/), and a custom metrics database for all your app and infrastructure metrics. Additionally, Datadog includes **machine-learning based anomaly detection** and forecasting on metrics, and **RBAC and integrations** for a huge variety of technologies (AWS, Docker, MySQL, you name it)​​.
 
-Essentially, Datadog aims to be an all-in-one visibility and observability solution – replacing the need to run separate Prometheus, ELK, Jaeger, etc. It’s very convenient but **[can be costly at scale](/blog/datadog-pricing/) (since it charges based on hosts, volumes of logs, etc.).** 
+Essentially, Datadog aims to be an all-in-one visibility and observability solution – replacing the need to run separate Prometheus, ELK, Jaeger, etc. It’s very convenient but **[can be costly at scale](/blog/datadog-pricing/) (since it charges based on hosts, volumes of logs, etc.).**
 
 Other notable commercial platforms in this space include **New Relic, Dynatrace, Splunk Observability, Grafana Cloud, Honeycomb.io,** and more – each with their own focus and strengths. For instance, **Honeycomb** is known for high-cardinality data exploration (great for debugging tricky problems with many dimensions), and **Dynatrace** has strong automated topology discovery and AI problem identification.
 
-### Traditional Visibility/Monitoring Tools 
+### Traditional Visibility/Monitoring Tools
 
 Prior to the modern observability movement, teams used a variety of simpler tools for monitoring and visibility. Some examples:
 
@@ -264,7 +270,7 @@ Prior to the modern observability movement, teams used a variety of simpler tool
 
 Tools like Nagios (very popular in the 2000s) focus on host and service monitoring. They perform checks (ping this server, test this port, check this process) and report status (often just **up/down** or OK/warning/critical). They can send alerts if something is offline or a basic metric exceeds a threshold. These are great for basic infrastructure visibility – e.g., “is the web server running? is the disk full?” – but they don’t understand application-level issues or complex dependencies. As noted earlier, Nagios-style health checks are limited to known failure conditions and don’t provide insight into why a service is unhealthy​. They also lack built-in log or trace analysis. Many organizations still use tools like Nagios or Icinga for system/network monitoring (e.g., verifying that all services are alive), but supplement them with observability tools for deeper insight.
 
-**Traditional Logging Systems:** 
+**Traditional Logging Systems:**
 
 In the past, “logging system” often meant a syslog server or simple log file aggregation. For example, using syslog protocol to collect logs from various servers into a central syslog server, or manually aggregating log files with scripts. Tools like the ELK stack improved on this by allowing search, but earlier on one might just use `grep` on combined logs or basic log rotation and retention schemes. Even today, some teams rely on cloud vendor logging solutions (like AWS CloudWatch Logs) which provide raw log access but minimal correlation. A “traditional” approach is to troubleshoot by logging into servers and reading logs – which is slow and doesn’t scale when you have hundreds of instances and ephemeral containers. Thus, moving to centralized log management was a huge step in visibility. Still, simply having all logs in one place (without linking to metrics/traces) is only part of observability. It’s often reactive (you go to the logs after an alert tells you something’s wrong).
 
@@ -274,10 +280,12 @@ Before “observability” became a buzzword, APM suites (like earlier versions
 
 **Network Monitoring Tools:**
 
-Visibility can also refer specifically to network-level visibility. Tools such as SolarWinds Network Performance Monitor, Wireshark, or even simple SNMP-based monitors give insight into network devices, traffic flows, and connectivity. For example, a network monitor might show that a link is saturated or a router interface is down (which is crucial info). However, these operate at the network layer and don’t tell you the impact on application transactions directly. They’re often used by ops teams to troubleshoot connectivity or bandwidth issues. 
+Visibility can also refer specifically to network-level visibility. Tools such as SolarWinds Network Performance Monitor, Wireshark, or even simple SNMP-based monitors give insight into network devices, traffic flows, and connectivity. For example, a network monitor might show that a link is saturated or a router interface is down (which is crucial info). However, these operate at the network layer and don’t tell you the impact on application transactions directly. They’re often used by ops teams to troubleshoot connectivity or bandwidth issues.
 
 <KeyPointCallout>
-In essence, older visibility tools are each good at a slice: uptime monitoring, resource metrics, logs, or network stats. They’re often not integrated and require human correlation. Modern observability tools aim to bring these slices together. 
+  In essence, older visibility tools are each good at a slice: uptime monitoring, resource metrics,
+  logs, or network stats. They’re often not integrated and require human correlation. Modern
+  observability tools aim to bring these slices together.
 </KeyPointCallout>
 
 It’s worth noting that many of the observability tools we listed (SigNoz, Prometheus, Jaeger, etc.) are open-source and can be used à la carte, whereas many traditional tools were also open-source (Nagios, etc.) or simple scripts. Organizations might build an observability solution by composing open-source tools, or they might opt for a commercial platform that packages them together.
@@ -286,19 +294,19 @@ It’s worth noting that many of the observability tools we listed (SigNoz, Prom
 
 While both observability and visibility aim to understand system behavior, they differ significantly in their approach and capabilities. Here’s a breakdown of the key distinctions:
 
-| **Feature** | **Observability** | **Visibility** |
-| --- | --- | --- |
-| **Focus** | Unknown, unexpected system behavior | Known, predefined issues |
-| **Approach** | Proactive, exploring system behavior in real-time | Reactive, monitoring predefined metrics/logs |
-| **Goal** | Understand **why** a system behaves a certain way | Know **what** is happening in a system at a given moment |
-| **Data Types** | Metrics, logs, and traces | Primarily metrics and logs |
-| **Data Correlation** | Seamless correlation between metrics, logs, and traces for faster root cause analysis | Correlation possible but often manual or limited |
-| **Troubleshooting** | Enables deep root cause analysis, even for unknown issues | Limited to known issues, struggles with complex interactions |
-| **Scalability** | Designed to scale with complex, dynamic systems | Challenges in scaling with complex systems |
-| **Key Limitation** | Requires more effort in instrumentation and data analysis | Difficulty diagnosing unexpected issues in complex systems |
+| **Feature**               | **Observability**                                                                              | **Visibility**                                                                 |
+| ------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| **Focus**                 | Unknown, unexpected system behavior                                                            | Known, predefined issues                                                       |
+| **Approach**              | Proactive, exploring system behavior in real-time                                              | Reactive, monitoring predefined metrics/logs                                   |
+| **Goal**                  | Understand **why** a system behaves a certain way                                              | Know **what** is happening in a system at a given moment                       |
+| **Data Types**            | Metrics, logs, and traces                                                                      | Primarily metrics and logs                                                     |
+| **Data Correlation**      | Seamless correlation between metrics, logs, and traces for faster root cause analysis          | Correlation possible but often manual or limited                               |
+| **Troubleshooting**       | Enables deep root cause analysis, even for unknown issues                                      | Limited to known issues, struggles with complex interactions                   |
+| **Scalability**           | Designed to scale with complex, dynamic systems                                                | Challenges in scaling with complex systems                                     |
+| **Key Limitation**        | Requires more effort in instrumentation and data analysis                                      | Difficulty diagnosing unexpected issues in complex systems                     |
 | **Performance Overheads** | Higher data ingestion and processing costs; optimized using trace sampling and log aggregation | Lower computational/storage footprint due to lightweight metric/log collection |
-| **AI-Driven Insights** | AI-assisted anomaly detection, automated root cause analysis, and predictive issue prevention | Limited or rule-based alerting |
-| **Tool Examples** | SigNoz, LGTM stack | Nagios, Zabbix |
+| **AI-Driven Insights**    | AI-assisted anomaly detection, automated root cause analysis, and predictive issue prevention  | Limited or rule-based alerting                                                 |
+| **Tool Examples**         | SigNoz, LGTM stack                                                                             | Nagios, Zabbix                                                                 |
 
 Observability is a **proactive** approach that helps understand **why** a system behaves a certain way by correlating **metrics, logs, and traces** for deep root cause analysis. It scales well with complex, dynamic systems but requires more instrumentation effort.
 
@@ -313,49 +321,70 @@ Visibility, on the other hand, is **reactive**, focusing on predefined **metrics
 SigNoz extends beyond traditional monitoring by offering deep visibility into system behavior, facilitating the understanding of complex interactions within distributed environments. It captures and correlates the three [pillars of observability](https://signoz.io/blog/three-pillars-of-observability/):
 
 - **Metrics:** SigNoz excels at collecting and visualizing key performance indicators (KPIs) relevant to SREs, including the crucial Four Golden Signals (latency, traffic, errors, and saturation). This is facilitated by features like:
-    - **Custom Dashboards:** Build personalized dashboards to monitor specific metrics, Service Level Objectives (SLOs), and Service Level Indicators (SLIs) in real-time.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image.webp" alt="Custom Dashboards in SigNoz" caption="Custom Dashboards in SigNoz" />
-        
-    - **Intelligent Alerting:** Define alerts based on metric thresholds, anomaly detection, or complex PromQL queries to identify performance issues proactively.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-20a1e0dc-6c4c-4ffe-859a-63b63c3734ca.webp" alt="Alerts in SigNoz" caption="Alerts in SigNoz" />
-        
-    - **PromQL Compatibility:** Fully compatible with [Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/) (PromQL), enabling users to leverage their existing Prometheus queries within SigNoz.
+  - **Custom Dashboards:** Build personalized dashboards to monitor specific metrics, Service Level Objectives (SLOs), and Service Level Indicators (SLIs) in real-time.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image.webp"
+      alt="Custom Dashboards in SigNoz"
+      caption="Custom Dashboards in SigNoz"
+    />
+  - **Intelligent Alerting:** Define alerts based on metric thresholds, anomaly detection, or complex PromQL queries to identify performance issues proactively.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-20a1e0dc-6c4c-4ffe-859a-63b63c3734ca.webp"
+      alt="Alerts in SigNoz"
+      caption="Alerts in SigNoz"
+    />
+  - **PromQL Compatibility:** Fully compatible with [Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/) (PromQL), enabling users to leverage their existing Prometheus queries within SigNoz.
 - **Logs:** SigNoz provides robust log management capabilities, enabling users to search, filter, and correlate logs with other observability data, providing valuable context during incident investigations. Key features include:
-    - **Powerful Log Querying:** Search, filter, and analyze logs using an intuitive query interface to quickly find relevant events.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image%201.webp" alt="Log Queries in SigNoz" caption="Log Queries in SigNoz" />
-        
-    - **Centralized Log Aggregation:** Collect logs from various services into a single, searchable repository, making debugging and auditing easier.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image%202.webp" alt="Centralized Log Aggregation in SigNoz" caption="Centralized Log Aggregation in SigNoz" />
-        
-    - **Live Tail Logging:** Monitor logs in real-time to instantly detect errors, anomalies, and performance issues as they occur.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image%203.webp" alt="Live Tail Logging in SigNoz" caption="Live Tail Logging in SigNoz" />
-        
+  - **Powerful Log Querying:** Search, filter, and analyze logs using an intuitive query interface to quickly find relevant events.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image%201.webp"
+      alt="Log Queries in SigNoz"
+      caption="Log Queries in SigNoz"
+    />
+  - **Centralized Log Aggregation:** Collect logs from various services into a single, searchable repository, making debugging and auditing easier.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image%202.webp"
+      alt="Centralized Log Aggregation in SigNoz"
+      caption="Centralized Log Aggregation in SigNoz"
+    />
+  - **Live Tail Logging:** Monitor logs in real-time to instantly detect errors, anomalies, and performance issues as they occur.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image%203.webp"
+      alt="Live Tail Logging in SigNoz"
+      caption="Live Tail Logging in SigNoz"
+    />
 - **Traces:** SigNoz’s tracing capabilities provide deep visibility into request flows across microservices, helping teams identify performance bottlenecks and understand complex service dependencies. This enables faster debugging and automated root cause analysis through features like:
-    - **Distributed Trace Visualization:** Gain a clear, end-to-end view of how requests travel across services using Gantt charts.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image%204.webp" alt="Distributed Trace Visualization in SigNoz" caption="Distributed Trace Visualization in SigNoz" />
-        
-    - **Trace Filtering and Analysis:** Quickly filter spans based on status codes, service names, operations, RPC methods, and more to isolate performance issues.
-        
-        <Figure src="/img/guides/2025/03/observability-vs-visibility-image%205.webp" alt="Trace Filtering and Analysis in SigNoz" caption="Trace Filtering and Analysis in SigNoz" />
-        
-    - **Correlation with Logs:** Link traces with logs to get deeper context during debugging, allowing you to track errors and anomalies across different observability signals.
-    - **Automated Root Cause Analysis:** By correlating traces, logs, and metrics, [SigNoz](https://signoz.io/blog/deeper-trace-analytics-root-and-entry-spans/) pinpoints the root cause of issues, reducing time spent on troubleshooting.
+  - **Distributed Trace Visualization:** Gain a clear, end-to-end view of how requests travel across services using Gantt charts.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image%204.webp"
+      alt="Distributed Trace Visualization in SigNoz"
+      caption="Distributed Trace Visualization in SigNoz"
+    />
+  - **Trace Filtering and Analysis:** Quickly filter spans based on status codes, service names, operations, RPC methods, and more to isolate performance issues.
+    {' '}
+    <Figure
+      src="/img/guides/2025/03/observability-vs-visibility-image%205.webp"
+      alt="Trace Filtering and Analysis in SigNoz"
+      caption="Trace Filtering and Analysis in SigNoz"
+    />
+  - **Correlation with Logs:** Link traces with logs to get deeper context during debugging, allowing you to track errors and anomalies across different observability signals.
+  - **Automated Root Cause Analysis:** By correlating traces, logs, and metrics, [SigNoz](https://signoz.io/blog/deeper-trace-analytics-root-and-entry-spans/) pinpoints the root cause of issues, reducing time spent on troubleshooting.
 
 By offering a unified view of these three crucial data types, and by providing these features, SigNoz empowers teams to move beyond reactive monitoring and embrace a proactive approach to maintaining system reliability.
 
-<GetStartedSigNoz/>
+<GetStartedSigNoz />
 
 Refer to the documentation to get more insights into observability with [SigNoz](https://signoz.io/docs/introduction/).
 
 ## **Key Takeaways**
 
-To put it succinctly, using traditional visibility focused monitoring is like having separate security cameras for each room – you can see what happened in one area. Using observability is like having a 360-degree view that stitches all cameras together – you get the full story of an intruder moving through the building, not just isolated snapshots. 
+To put it succinctly, using traditional visibility focused monitoring is like having separate security cameras for each room – you can see what happened in one area. Using observability is like having a 360-degree view that stitches all cameras together – you get the full story of an intruder moving through the building, not just isolated snapshots.
 
 - Visibility relies on predefined metrics to detect known issues ("What?"), while observability enables flexible querying to investigate unknowns ("Why?"), making it essential for proactive problem-solving.
 - Traditional monitoring focused on visibility struggles with complex systems, root cause analysis, and scaling high-cardinality metrics.
@@ -376,7 +405,7 @@ Traditional monitoring is reactive, relying on threshold-based alerts for predef
 
 ### **How does observability help with troubleshooting and root cause analysis in distributed systems?**
 
-Observability empowers engineers to trace requests across multiple services, identify bottlenecks, and understand the impact of failures.  It helps by:
+Observability empowers engineers to trace requests across multiple services, identify bottlenecks, and understand the impact of failures. It helps by:
 
 - Correlating data from different sources (metrics, logs, traces).
 - Visualizing complex interactions between services.
@@ -395,4 +424,4 @@ Organizations can implement observability by:
 - **Centralized Platform:** Using a centralized platform like **SigNoz** to ingest, store, and analyze this data.
 - **Data Analysis:** Analyzing the data to identify patterns, anomalies, and potential issues.
 - **Alerting and Dashboards:** Setting up alerts and dashboards to monitor key metrics and provide real-time insights.
-- **Continuous Improvement:** Continuously refining their observability practices based on the insights gained.
\ No newline at end of file
+- **Continuous Improvement:** Continuously refining their observability practices based on the insights gained.
diff --git a/data/guides/omit-labels-from-series-results-promql.mdx b/data/guides/omit-labels-from-series-results-promql.mdx
index cc1f90cc6..19b7590c6 100644
--- a/data/guides/omit-labels-from-series-results-promql.mdx
+++ b/data/guides/omit-labels-from-series-results-promql.mdx
@@ -1,22 +1,19 @@
 ---
-
 title: How to Omit Labels in PromQL Series Results
-slug: omit-labels-from-series-results-promql
 date: 2024-11-29
 tags: [prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to effectively omit labels from PromQL series results to optimize query performance and simplify data visualization in Prometheus monitoring.
 keywords: [PromQL, labels, Prometheus, monitoring, data visualization, query optimization, SigNoz]
-
 ---
 
-PromQL, Prometheus’s query language, uses labels to identify time series data. While labels are crucial for data organization, there are scenarios where you need to omit certain labels from your query results. This process can significantly improve query performance and simplify data visualization. 
+PromQL, Prometheus’s query language, uses labels to identify time series data. While labels are crucial for data organization, there are scenarios where you need to omit certain labels from your query results. This process can significantly improve query performance and simplify data visualization.
 
 In this guide, you'll learn various techniques to omit labels in PromQL, optimize your Grafana dashboards, and explore how modern monitoring solutions like SigNoz can streamline label management.
 
 ## Understanding PromQL Labels and their Importance
 
-PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) is the powerful query language used in Prometheus, a popular open-source monitoring and alerting system. At the heart of PromQL are labels—key-value pairs that uniquely identify time series. Labels in PromQL are key-value pairs attached to time series data. 
+PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) is the powerful query language used in Prometheus, a popular open-source monitoring and alerting system. At the heart of PromQL are labels—key-value pairs that uniquely identify time series. Labels in PromQL are key-value pairs attached to time series data.
 
 For example:
 
@@ -67,9 +64,17 @@ sum without (instance,job) (prometheus_http_requests_total)
 
 This query sums up all HTTP requests but removes the `instance` and `job` labels from the result.
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image.webp" alt="General metric filtering in PromQL" caption="General metric filtering in PromQL" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image.webp"
+  alt="General metric filtering in PromQL"
+  caption="General metric filtering in PromQL"
+/>
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%201.webp" alt="Using without clause to remove labels" caption="Using without clause to remove labels" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%201.webp"
+  alt="Using without clause to remove labels"
+  caption="Using without clause to remove labels"
+/>
 
 ### Leveraging the `by` Clause
 
@@ -89,7 +94,11 @@ sum by (code,handler) (prometheus_http_requests_total)
 
 This query retains only the `method` and `status_code` labels, effectively omitting all others.
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%202.webp" alt="Using by clause to keep labels" caption="Using by clause to keep labels" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%202.webp"
+  alt="Using by clause to keep labels"
+  caption="Using by clause to keep labels"
+/>
 
 ### Manipulating Labels with `label_replace`
 
@@ -118,16 +127,24 @@ What it does:
 - `up` - The input vector/metric to be modified
 - `"new_label"` - This specifies the name of the new label to be created (or replaced if it already exists)
 - `"$1"` - The value to assign to the `new_label`. Here, `$1` refers to the first (and only) captured group in the regular expression
-- `"instance"` -  The existing/source label from which the value is extracted. The operation looks at the `instance` label in the `up` metric for matching
+- `"instance"` - The existing/source label from which the value is extracted. The operation looks at the `instance` label in the `up` metric for matching
 - `"(.*)”` - A regular expression pattern used to match the value of the `instance` label
-    - `.*` matches the entire value of the label
-    - The parentheses `()` define a capture group, so the entire matched value becomes the first group (`$1`), which is used as the replacement value for `new_label`
+  - `.*` matches the entire value of the label
+  - The parentheses `()` define a capture group, so the entire matched value becomes the first group (`$1`), which is used as the replacement value for `new_label`
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%203.webp" alt="Query result without label replacement" caption="Query result without label replacement" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%203.webp"
+  alt="Query result without label replacement"
+  caption="Query result without label replacement"
+/>
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%204.webp" alt="Query result with new result" caption="Query result with new result" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%204.webp"
+  alt="Query result with new result"
+  caption="Query result with new result"
+/>
 
-Note: By default, `label_replace` adds a new label without removing the old one. 
+Note: By default, `label_replace` adds a new label without removing the old one.
 
 To remove the old label (`instance` in this example) after using `label_replace`, you can pair it with the `without` or `by` clauses to exclude unwanted labels.
 
@@ -140,7 +157,12 @@ sum without (instance) (label_replace(up, "new_label", "$1", "instance", "(.*)")
 - `label_replace(up, "new_label", "$1", "instance", "(.*)")`: Creates the new label `new_label` by copying the value from the `instance` label
 - `without (instance)`: Excludes the original `instance` label from the result
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%205.webp" alt="" caption="" />### Example: Omitting Instance and Pod Labels
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%205.webp"
+  alt=""
+  caption=""
+/>
+### Example: Omitting Instance and Pod Labels
 
 Let's walk through a practical example of omitting `instance` and `pod` labels from a Kubernetes deployment metric:
 
@@ -170,7 +192,11 @@ sum without (instance) (prometheus_http_requests_total{handler=~"/api/.*"})
 
 This query sums up HTTP requests for all handlers starting with "/api" and removes the `instance` label.
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%206.webp" alt="Regex-based Label Selection" caption="Regex-based Label Selection" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%206.webp"
+  alt="Regex-based Label Selection"
+  caption="Regex-based Label Selection"
+/>
 
 ### Label Joins for Combining labels
 
@@ -195,7 +221,11 @@ label_join(prometheus_http_requests_total, "endpoint", "/", "instance", "handler
 
 This query combines the `instance` and `handler` labels into a new `endpoint` label, separated by a `/`.
 
-<Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%207.webp" alt="Label Joins for Complex Data Relationships" caption="Label Joins for Complex Data Relationships" />
+<Figure
+  src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%207.webp"
+  alt="Label Joins for Complex Data Relationships"
+  caption="Label Joins for Complex Data Relationships"
+/>
 
 ### Best Practices for Label Omission
 
@@ -211,23 +241,34 @@ When omitting labels, keep these best practices in mind:
 Grafana, a popular visualization tool often used with Prometheus, can benefit greatly from strategic label omission:
 
 1. Streamline Legend Entries: Use PromQL to omit unnecessary labels, resulting in cleaner legends:
-    
-    ```
-    sum by (code) (rate(prometheus_http_requests_total[5m]))
-    ```
-    
-    This query shows request rates by status code, omitting other labels for a concise legend.
-    
-    <Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%208.webp" alt="Streamline Legend Entries" caption="Streamline Legend Entries" />
-    
+
+   ```
+   sum by (code) (rate(prometheus_http_requests_total[5m]))
+   ```
+
+   This query shows request rates by status code, omitting other labels for a concise legend.
+
+   <Figure
+     src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%208.webp"
+     alt="Streamline Legend Entries"
+     caption="Streamline Legend Entries"
+   />
+
 2. Utilize Grafana's Label Filters: Complement PromQL label omission with Grafana's built-in label filters for dynamic visualizations.
-    
-    <Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%209.webp" alt="Utilize Grafana's Label Filters" caption="Utilize Grafana's Label Filters" />
-    
-3. Create Template Variables: Use Grafana template variables to allow users to select which label values to include or exclude dynamically. Check out the <a href="https://grafana.com/docs/grafana/latest/dashboards/variables/" rel="noopener noreferrer nofollow" target="_blank">steps for creating a template variable in Grafana.</a>  
-    
-    <Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2010.webp" alt="Create Template Variables" caption="Create Template Variables" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%209.webp"
+     alt="Utilize Grafana's Label Filters"
+     caption="Utilize Grafana's Label Filters"
+   />
+
+3. Create Template Variables: Use Grafana template variables to allow users to select which label values to include or exclude dynamically. Check out the <a href="https://grafana.com/docs/grafana/latest/dashboards/variables/" rel="noopener noreferrer nofollow" target="_blank">steps for creating a template variable in Grafana.</a>
+
+   <Figure
+     src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2010.webp"
+     alt="Create Template Variables"
+     caption="Create Template Variables"
+   />
 
 ### Tips for Creating Clear and Concise Visualizations
 
@@ -239,21 +280,28 @@ When creating visualizations, the goal is to present data in a way that is both
 
 ## Monitoring with SigNoz: Simplified Label Management
 
-In traditional monitoring setups, Prometheus and Grafana are commonly used for collecting metrics and visualizing data. However, for more complex, distributed systems, managing labels in Prometheus can become cumbersome, especially when you have many different metrics across microservices. 
+In traditional monitoring setups, Prometheus and Grafana are commonly used for collecting metrics and visualizing data. However, for more complex, distributed systems, managing labels in Prometheus can become cumbersome, especially when you have many different metrics across microservices.
 
 [SigNoz](https://signoz.io) offers a modern alternative that simplifies label management, aggregation, and visualization of metrics, traces, and logs, making it a great choice for teams looking to streamline their [observability stack](https://signoz.io/guides/observability-stack/).
 
 SigNoz, a modern open-source monitoring solution, offers enhanced capabilities for label management in distributed systems:
 
 1. Automatic [Context Propagation](https://signoz.io/blog/opentelemetry-context-propagation/): SigNoz automatically propagates relevant labels across services, reducing the need for manual label management.
-    
-    <Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2011.webp" alt="Automatic Context Propagation: SigNoz" caption="Automatic Context Propagation: SigNoz" />
-    
-2. Intelligent Aggregation: SigNoz provides intelligent aggregation features by offering automatic grouping of metrics and traces based on common attributes (like service, region, etc.). 
+
+   <Figure
+     src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2011.webp"
+     alt="Automatic Context Propagation: SigNoz"
+     caption="Automatic Context Propagation: SigNoz"
+   />
+
+2. Intelligent Aggregation: SigNoz provides intelligent aggregation features by offering automatic grouping of metrics and traces based on common attributes (like service, region, etc.).
 3. Custom Attribute Mapping: SigNoz allows you to map custom attributes to labels, giving you fine-grained control over what information is included in your metrics.
-    
-    <Figure src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2012.webp" alt="Custom Attribute Mapping: SigNoz" caption="Custom Attribute Mapping: SigNoz" /> 
-    
+
+   <Figure
+     src="/img/guides/2024/11/omit-labels-from-series-results-promql-image%2012.webp"
+     alt="Custom Attribute Mapping: SigNoz"
+     caption="Custom Attribute Mapping: SigNoz"
+   />{' '}
 
 To get started with SigNoz and experience its simplified label management:
 
@@ -286,4 +334,4 @@ Label omission in alerting rules can impact which alerts are fired and how they
 
 ### Are there performance implications when using complex label manipulation in PromQL?
 
-Yes, complex label manipulations can impact query performance, especially on large datasets. Operations like regex-based label selection or extensive use of label join operations may increase query execution time. It's important to balance the need for label manipulation with performance considerations, particularly for frequently executed queries or those used in real-time dashboards.
\ No newline at end of file
+Yes, complex label manipulations can impact query performance, especially on large datasets. Operations like regex-based label selection or extensive use of label join operations may increase query execution time. It's important to balance the need for label manipulation with performance considerations, particularly for frequently executed queries or those used in real-time dashboards.
diff --git a/data/guides/open-ai-api-latency.mdx b/data/guides/open-ai-api-latency.mdx
index 7f7f8a85e..22e0e2ced 100644
--- a/data/guides/open-ai-api-latency.mdx
+++ b/data/guides/open-ai-api-latency.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: Optimizing OpenAI API Performance - Reducing Latency
-slug: open-ai-api-latency
 date: 2024-10-03
 tags: [monitoring]
 authors: [soumya_gupta]
 description: Learn how to optimize OpenAI API performance and reduce latency. Discover strategies for faster response times in AI-powered applications.
 keywords: [OpenAI API, latency optimization, API performance, response times, AI applications]
-
 ---
 
 OpenAI's powerful language models have revolutionized AI-powered applications, but their effectiveness hinges on one critical factor: latency. As a developer, you know that slow API response times can frustrate users and hinder your application's performance. How can you harness the full potential of OpenAI's API while ensuring lightning-fast responses? This guide will walk you through practical strategies to optimize your OpenAI API integration, focusing on reducing latency and improving overall performance.
@@ -16,139 +13,148 @@ OpenAI's powerful language models have revolutionized AI-powered applications, b
 
 API latency refers to the time it takes for the OpenAI API to process your request and return a response. High latency can significantly impact user experience, especially in real-time applications or chatbots. Several factors contribute to OpenAI API response times:
 
-<Figure src="/img/guides/2024/10/open-ai-api-latency-image.webp" alt="OpenAI API Latency Factors" caption="OpenAI API Latency Factors" />
+<Figure
+  src="/img/guides/2024/10/open-ai-api-latency-image.webp"
+  alt="OpenAI API Latency Factors"
+  caption="OpenAI API Latency Factors"
+/>
 
 1. Model complexity: When we talk about latency, the first thing that probably pops into your head is inference speed. This is all about how quickly the language model processes tokens, and it’s typically measured in tokens per minute (TPM) or tokens per second (TPS). One of the biggest factors affecting inference speed is the model size. Generally, smaller models tend to run faster and are more cost-effective. In fact, if you use them wisely, they can sometimes even outperform larger models like GPT-4!
-    
-    To keep the performance high with these smaller models, here are a few strategies you might consider:
-    
-    - Train Through Examples in Prompts: Including a few-shot example or two within your prompts helps the model better understand the desired output by providing concrete examples to follow.
-    - Fine-Tuning or Distillation: Fine-tuning a smaller model on your specific data can really help tailor its responses to your needs. Distillation, on the other hand, is a process where you train a smaller model to mimic the behavior of a larger one, capturing its strengths without the overhead.
-2. Input length: While it’s true that reducing the number of input tokens can lower latency, it’s often not a game changer. For example, trimming your prompt by 50% might only improve latency by around 1-5% (<a href="https://platform.openai.com/docs/guides/latency-optimization/3-use-fewer-input-tokens" rel="noopener noreferrer nofollow" target="_blank">ref</a>). Unless you're dealing with really massive contexts, like lengthy documents or complex images, it might be better to focus your energy on other optimization strategies. But what if you are working with those larger contexts or are determined to squeeze out every last bit of performance after trying everything else? 
-    
-    Here are some techniques to help you reduce input tokens:
-    
-    - Fine-Tune the Model: This can help eliminate the need for lengthy instructions or examples, making your prompts more concise while still getting great results.
-    - Filter Context Input: Clean up your context by pruning retrieval-augmented generation (RAG) results or stripping away unnecessary HTML. This can help streamline your inputs significantly.
-    - Maximize Shared Prompt Prefix: Put changing parts like RAG results or conversation history towards the end of the prompt. This way, the beginning of the prompt can be cached (stored for reuse) by many LLM providers, so the model doesn’t have to repeatedly process the same information. This helps reduce the number of tokens processed in each request, making everything faster.
-3. Output length: 
-    - For Natural Language: If you want more concise responses, try asking the model to keep it brief—something like “under 20 words” or “be concise” can work wonders. You can also use few-shot examples or fine-tune the model to encourage shorter replies.
-    - For Structured Output: In this case it’s all about minimizing syntax. Shorten function names, omit named arguments, and combine parameters whenever you can.
-    - Use `max_tokens` or `stop_tokens`: You can set these parameters to cut off generation early, saving both time and tokens.
-    
-    Note: Every output token you trim is a (milli)second gained!
-    
+
+   To keep the performance high with these smaller models, here are a few strategies you might consider:
+
+   - Train Through Examples in Prompts: Including a few-shot example or two within your prompts helps the model better understand the desired output by providing concrete examples to follow.
+   - Fine-Tuning or Distillation: Fine-tuning a smaller model on your specific data can really help tailor its responses to your needs. Distillation, on the other hand, is a process where you train a smaller model to mimic the behavior of a larger one, capturing its strengths without the overhead.
+
+2. Input length: While it’s true that reducing the number of input tokens can lower latency, it’s often not a game changer. For example, trimming your prompt by 50% might only improve latency by around 1-5% (<a href="https://platform.openai.com/docs/guides/latency-optimization/3-use-fewer-input-tokens" rel="noopener noreferrer nofollow" target="_blank">ref</a>). Unless you're dealing with really massive contexts, like lengthy documents or complex images, it might be better to focus your energy on other optimization strategies. But what if you are working with those larger contexts or are determined to squeeze out every last bit of performance after trying everything else?
+
+   Here are some techniques to help you reduce input tokens:
+
+   - Fine-Tune the Model: This can help eliminate the need for lengthy instructions or examples, making your prompts more concise while still getting great results.
+   - Filter Context Input: Clean up your context by pruning retrieval-augmented generation (RAG) results or stripping away unnecessary HTML. This can help streamline your inputs significantly.
+   - Maximize Shared Prompt Prefix: Put changing parts like RAG results or conversation history towards the end of the prompt. This way, the beginning of the prompt can be cached (stored for reuse) by many LLM providers, so the model doesn’t have to repeatedly process the same information. This helps reduce the number of tokens processed in each request, making everything faster.
+
+3. Output length:
+
+   - For Natural Language: If you want more concise responses, try asking the model to keep it brief—something like “under 20 words” or “be concise” can work wonders. You can also use few-shot examples or fine-tune the model to encourage shorter replies.
+   - For Structured Output: In this case it’s all about minimizing syntax. Shorten function names, omit named arguments, and combine parameters whenever you can.
+   - Use `max_tokens` or `stop_tokens`: You can set these parameters to cut off generation early, saving both time and tokens.
+
+   Note: Every output token you trim is a (milli)second gained!
+
 4. Server load: When you're dealing with API responses, server load can really play a significant role. High traffic can lead to slower responses, which is something you definitely want to avoid. One effective way to manage this is through load balancing. This technique helps distribute requests evenly across your available servers, preventing any one server from becoming a bottleneck. Placing a load balancer in front of your servers can automatically route incoming requests to the server with the least load. This helps ensure that no single server is overwhelmed.
 5. Network conditions: Your network conditions play a crucial role in how quickly data moves between your application and the API. If you have a strong, stable connection, you’ll enjoy faster response times and smoother interactions. On the flip side, a weak or unstable connection can lead to delays and interruptions, making your experience less enjoyable.
 
 ## Quick Guide: 5 Steps to Reduce OpenAI API Latency
 
-1. Optimize input tokens and prompt engineering: 
-    
-    To keep your API responses fast, it’s essential to craft concise and clear prompts, because when it comes to generating a lot of tokens, it can lead to increased latency. Here are some effective strategies to reduce that:
-    
-    - Lower `max_tokens`: If your requests are generating a similar number of tokens, setting a lower `max_tokens` parameter can help cut down on latency. It’s all about giving the model less to work with.
-    - Include Stop Sequences: Adding stop sequences can prevent the model from generating unnecessary tokens. For instance, if you want a list with a specific number of items, you could use `11`. as a stop sequence. This way, the generation stops once it hits `11`, giving you just the 10 items you want.
-    - Generate Fewer Completions: Lower the values of `n` and `best_of` whenever possible. Here, `n` refers to how many completions you want for each prompt, while `best_of` is about selecting the one with the highest log probability per token. If both are set to 1 (the default), the total number of generated tokens will be at most equal to your `max_tokens`.
-    
-    Note: If you set `n` or `best_of` to greater than 1, each request will produce multiple outputs. In this case, you can think of the total number of generated tokens as `[max_tokens * max(n, best_of)]`.
-    
+1. Optimize input tokens and prompt engineering:
+
+   To keep your API responses fast, it’s essential to craft concise and clear prompts, because when it comes to generating a lot of tokens, it can lead to increased latency. Here are some effective strategies to reduce that:
+
+   - Lower `max_tokens`: If your requests are generating a similar number of tokens, setting a lower `max_tokens` parameter can help cut down on latency. It’s all about giving the model less to work with.
+   - Include Stop Sequences: Adding stop sequences can prevent the model from generating unnecessary tokens. For instance, if you want a list with a specific number of items, you could use `11`. as a stop sequence. This way, the generation stops once it hits `11`, giving you just the 10 items you want.
+   - Generate Fewer Completions: Lower the values of `n` and `best_of` whenever possible. Here, `n` refers to how many completions you want for each prompt, while `best_of` is about selecting the one with the highest log probability per token. If both are set to 1 (the default), the total number of generated tokens will be at most equal to your `max_tokens`.
+
+   Note: If you set `n` or `best_of` to greater than 1, each request will produce multiple outputs. In this case, you can think of the total number of generated tokens as `[max_tokens * max(n, best_of)]`.
+
 2. Implement caching strategies: One great way to boost your response times is by implementing caching strategies. By storing and reusing responses for frequent or similar requests, you can save yourself from making repeated calls to the API. To make the most of caching, your application should be designed to pull from cached data whenever possible. Remember to invalidate that cache whenever new information comes in. There are different ways through which you could set this up:
+
 - Database Storage: If your application needs to handle larger datasets or requires persistent storage, consider using a database, as it is great for keeping data organized and easily accessible.
 - Filesystem Storage: For simpler applications, storing data in the filesystem might be a good fit. This approach is straightforward and can be useful for quick access to static files or logs.
 - In-Memory Cache: If speed is your priority, an in-memory cache is a fantastic choice. This method allows for rapid access to frequently used data, significantly reducing response times.
-1. Use efficient API calling patterns: To optimize your API usage, focus on efficient calling patterns. One key strategy is to batch requests and avoid unnecessary calls. 
-    
-    Batching is especially helpful when sending multiple requests to the same endpoint. Instead of making individual requests for each prompt, combine them into a single request, as the prompt parameter can accommodate up to 20 unique prompts. This reduces the number of calls but may increase the total tokens generated, potentially slowing response times.
-    
-    If instant responses aren’t critical, utilize the Batch API to submit large collections of requests without impacting your synchronous request limits, streamlining processing without sacrificing performance. For quicker responses, keep in mind the OpenAI API’s limits on requests and tokens per minute. If you're reaching the requests-per-minute cap but still have token capacity, batching multiple tasks can boost your throughput, especially with smaller models that manage larger batches effectively. When sending a batch, just pass a list of strings to the prompt parameter, making it a simple yet effective change that can bring significant benefits. 
-    
-    Before we see some examples, let’s see how to set the `API KEY` for Windows PowerShell:
-    
-    ```python
-    $env:OPENAI_API_KEY="your_api_key_here"
-    
-    ```
-    
-    Case 1: Program without Batching
-    
-    ```python
-    from openai import OpenAI
-    
-    client = OpenAI()
-    
-    num_stories = 10
-    prompt = "Once upon a time,"
-    
-    # Serial example, with one story completion per request
-    for _ in range(num_stories):
-        response = client.completions.create(
-            model="curie",
-            prompt=prompt,
-            max_tokens=20,
-        )
-        # Print story
-        print(prompt + response.choices[0].text.strip())  # Use .strip() to remove any leading/trailing whitespace
-    
-    ```
-    
-    - Execution: Each story is generated one at a time in a loop.
-    - API Calls: The code makes 10 separate API calls (one for each story).
-    - Output Handling: The output is printed immediately after each request, which can lead to slower performance due to the overhead of multiple requests.
-    
-    Possible Output :
-    
-    ```
-    Once upon a time, there was a brave knight who lived in a small village.
-    Once upon a time, a little girl found a magical forest behind her house.
-    Once upon a time, a mysterious dragon appeared in the kingdom, causing panic.
-    ...
-    ```
-    
-    Note that specific output might vary according to model’s response.
-    
-    Case 2: Program with batching
-    
-    ```python
-    from openai import OpenAI
-    # API key will be picked up from the environment variable
-    client = OpenAI()
-    
-    num_stories = 10
-    prompts = ["Once upon a time,"] * num_stories
-    
-    # Batched example, with 10 story completions per request
-    response = client.completions.create(
-        model="curie",
-        prompt=prompts,
-        max_tokens=20,
-    )
-    
-    # Match completions to prompts by index
-    stories = ["" for _ in prompts]
-     # Use enumerate to get index
-    for index, choice in enumerate(response.choices):
-        stories[index] = prompts[index] + choice.text.strip()
-    
-    # Print stories
-    for story in stories:
-        print(story)
-    
-    ```
-    
-    - Execution: All story prompts are sent to the API in a single request.
-    - API Calls: The code makes just one API call to generate all stories at once.
-    - Output Handling: The output is processed after the API call completes, which can be more efficient and faster for larger numbers of stories.
-2. Choose the right model: It’s all about picking the right model that fits your needs while keeping an eye on performance and speed. OpenAI’s API offers a range of models, each with its own strengths and complexities. If you’re looking for something that can handle intricate and varied responses, the advanced GPT-4 is your go-to. Just keep in mind that it may take a bit longer to process your requests. On the flip side, if you want quicker and more budget-friendly chat completions, you might consider models like GPT-4o-mini. While they’re faster and cheaper, they might not always hit the mark in terms of accuracy or relevance. 
+
+1. Use efficient API calling patterns: To optimize your API usage, focus on efficient calling patterns. One key strategy is to batch requests and avoid unnecessary calls.
+
+   Batching is especially helpful when sending multiple requests to the same endpoint. Instead of making individual requests for each prompt, combine them into a single request, as the prompt parameter can accommodate up to 20 unique prompts. This reduces the number of calls but may increase the total tokens generated, potentially slowing response times.
+
+   If instant responses aren’t critical, utilize the Batch API to submit large collections of requests without impacting your synchronous request limits, streamlining processing without sacrificing performance. For quicker responses, keep in mind the OpenAI API’s limits on requests and tokens per minute. If you're reaching the requests-per-minute cap but still have token capacity, batching multiple tasks can boost your throughput, especially with smaller models that manage larger batches effectively. When sending a batch, just pass a list of strings to the prompt parameter, making it a simple yet effective change that can bring significant benefits.
+
+   Before we see some examples, let’s see how to set the `API KEY` for Windows PowerShell:
+
+   ```python
+   $env:OPENAI_API_KEY="your_api_key_here"
+
+   ```
+
+   Case 1: Program without Batching
+
+   ```python
+   from openai import OpenAI
+
+   client = OpenAI()
+
+   num_stories = 10
+   prompt = "Once upon a time,"
+
+   # Serial example, with one story completion per request
+   for _ in range(num_stories):
+       response = client.completions.create(
+           model="curie",
+           prompt=prompt,
+           max_tokens=20,
+       )
+       # Print story
+       print(prompt + response.choices[0].text.strip())  # Use .strip() to remove any leading/trailing whitespace
+
+   ```
+
+   - Execution: Each story is generated one at a time in a loop.
+   - API Calls: The code makes 10 separate API calls (one for each story).
+   - Output Handling: The output is printed immediately after each request, which can lead to slower performance due to the overhead of multiple requests.
+
+   Possible Output :
+
+   ```
+   Once upon a time, there was a brave knight who lived in a small village.
+   Once upon a time, a little girl found a magical forest behind her house.
+   Once upon a time, a mysterious dragon appeared in the kingdom, causing panic.
+   ...
+   ```
+
+   Note that specific output might vary according to model’s response.
+
+   Case 2: Program with batching
+
+   ```python
+   from openai import OpenAI
+   # API key will be picked up from the environment variable
+   client = OpenAI()
+
+   num_stories = 10
+   prompts = ["Once upon a time,"] * num_stories
+
+   # Batched example, with 10 story completions per request
+   response = client.completions.create(
+       model="curie",
+       prompt=prompts,
+       max_tokens=20,
+   )
+
+   # Match completions to prompts by index
+   stories = ["" for _ in prompts]
+    # Use enumerate to get index
+   for index, choice in enumerate(response.choices):
+       stories[index] = prompts[index] + choice.text.strip()
+
+   # Print stories
+   for story in stories:
+       print(story)
+
+   ```
+
+   - Execution: All story prompts are sent to the API in a single request.
+   - API Calls: The code makes just one API call to generate all stories at once.
+   - Output Handling: The output is processed after the API call completes, which can be more efficient and faster for larger numbers of stories.
+
+2. Choose the right model: It’s all about picking the right model that fits your needs while keeping an eye on performance and speed. OpenAI’s API offers a range of models, each with its own strengths and complexities. If you’re looking for something that can handle intricate and varied responses, the advanced GPT-4 is your go-to. Just keep in mind that it may take a bit longer to process your requests. On the flip side, if you want quicker and more budget-friendly chat completions, you might consider models like GPT-4o-mini. While they’re faster and cheaper, they might not always hit the mark in terms of accuracy or relevance.
 3. Leverage parallel processing: Why not supercharge your API calls by using asynchronous programming to handle multiple requests at once? When working with a large language model (LLM), parallelization can be a game changer, especially if your tasks don’t depend on each other. Think of it this way: just like two shirts take the same time to dry as one, you can split your calls into parallel requests to save time. But what if your steps do need to happen in a certain order? You can still take advantage of speculative execution. This is especially handy for classification tasks where one outcome is more likely than others, like moderation. Let’s see a quick approach:
-    - Start step 1 (input moderation) and step 2 (story generation) at the same time.
-    - Check the result of step 1.
-    - If it’s not what you expected, you can cancel step 2 (and try again if needed).
-    - If your guess for step 1 is correct, you’ve effectively run it without any added delay!
+   - Start step 1 (input moderation) and step 2 (story generation) at the same time.
+   - Check the result of step 1.
+   - If it’s not what you expected, you can cancel step 2 (and try again if needed).
+   - If your guess for step 1 is correct, you’ve effectively run it without any added delay!
 4. Scaling: If you're looking to enhance your application's performance, consider scaling it out horizontally. This approach allows you to manage incoming requests from various sources by deploying extra servers or containers to share the workload. Just remember, if you choose this route, your architecture should be prepared to support multiple nodes, and you'll need effective load balancing mechanisms to distribute traffic evenly.
-    
-    On the other hand, you might think about vertical scaling, which means upgrading a single node's resources. This could involve boosting your server’s capabilities to handle more load. If you go this route, ensure your application is optimized to leverage these enhanced resources effectively. Both methods have their benefits, so pick the one that best fits your needs!
-    
+
+   On the other hand, you might think about vertical scaling, which means upgrading a single node's resources. This could involve boosting your server’s capabilities to handle more load. If you go this route, ensure your application is optimized to leverage these enhanced resources effectively. Both methods have their benefits, so pick the one that best fits your needs!
 
 ## Analyzing OpenAI API Response Times
 
@@ -163,7 +169,7 @@ Note: These times can vary based on input complexity and server load. GPT-3.5 mo
 To measure API latency accurately:
 
 1. Use Built-in Timing Functions: Most programming languages offer built-in functions to measure time. For instance, in Python, you can use `time.time()` or the `timeit` module. This allows you to capture the duration of API calls easily, giving you precise insights into how long each request takes.
-2. Implement Server-side Logging: Setting up logging for your API calls helps you capture more than just response times. By logging the request and response details along with timestamps, you can analyze performance over time, identify patterns, and pinpoint any anomalies or delays. 
+2. Implement Server-side Logging: Setting up logging for your API calls helps you capture more than just response times. By logging the request and response details along with timestamps, you can analyze performance over time, identify patterns, and pinpoint any anomalies or delays.
 3. Utilize [API Monitoring Tools](https://signoz.io/blog/api-monitoring-complete-guide/): Tools like [SigNoz](https://signoz.io/docs/introduction/) provide a comprehensive way to monitor your API performance. They can track metrics such as response times, error rates, and throughput, allowing you to visualize trends and identify bottlenecks in real-time. This [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps you react quickly to any performance issues that arise.
 
 ## Benchmarking OpenAI API Performance
@@ -180,6 +186,7 @@ Once you’ve gathered and analyzed your benchmarks, you can use this informatio
 1. Set Performance Baselines: Establish what "normal" performance looks like for your application. This will help you spot any anomalies quickly.
 2. Identify Areas for Optimization: By understanding where delays occur, you can target specific areas for improvement. This could mean tweaking your code, adjusting how you interact with the API, or even considering different models.
 3. Make Informed Decisions: Armed with your data, you can make better choices about model selection and API usage. For instance, you might find that a different model provides faster responses for specific tasks, which could enhance your application’s overall performance.
+
 - Identify areas for optimization
 - Make informed decisions about model selection and API usage
 
@@ -228,9 +235,8 @@ def api_call_with_retry(max_retries=3):
 
 1. Manage rate limits: Implement a queue system to control the rate of API calls and avoid hitting rate limits. Rate limits are like guardrails for OpenAI’s API, setting boundaries on how often a user or client can access the services within a given timeframe. These restrictions help ensure fair usage and maintain the performance and reliability of the system for everyone.
 2. Balance latency with cost: It’s crucial to weigh the benefits of faster, pricier models against slower, more budget-friendly alternatives. When transitioning your prototype into production, budgeting for operational costs becomes a key challenge. OpenAI uses a pay-as-you-go pricing model, where charges are based on the number of tokens processed—roughly 1,000 tokens are equivalent to about 750 words. To estimate your expenses, you’ll need to project your token usage by considering factors like traffic levels, user interaction frequency, and the volume of data being processed. A helpful way to think about cost management is to view it as a function of the number of tokens and the price per token. There are two main strategies to reduce costs:
-    - Lowering the Cost Per Token: This can be achieved by using smaller models for certain tasks, which can help you save money.
-    - Reducing Token Usage: You can decrease the number of tokens needed by using shorter prompts, fine-tuning your models, or caching frequently asked user queries to avoid repetitive processing.
-    
+   - Lowering the Cost Per Token: This can be achieved by using smaller models for certain tasks, which can help you save money.
+   - Reducing Token Usage: You can decrease the number of tokens needed by using shorter prompts, fine-tuning your models, or caching frequently asked user queries to avoid repetitive processing.
 
 Note: To assist with cost estimation, you can also try OpenAI’s interactive tokenizer tool. Additionally, the API and playground provide token counts in their responses. Once you have your application running smoothly with the most capable model, experiment with other models to see if they can deliver similar results with lower latency and costs.
 
@@ -287,4 +293,4 @@ Yes, fine-tuning can potentially reduce latency by creating a more specialized m
 
 ### What are the trade-offs between latency and cost when using OpenAI API?
 
-Faster models or more frequent API calls generally incur higher costs. You'll need to balance the need for speed with your budget constraints. Consider using smaller models or implementing caching strategies to optimize both latency and cost.
\ No newline at end of file
+Faster models or more frequent API calls generally incur higher costs. You'll need to balance the need for speed with your budget constraints. Consider using smaller models or implementing caching strategies to optimize both latency and cost.
diff --git a/data/guides/opentelemetry-collector-vs-exporter.mdx b/data/guides/opentelemetry-collector-vs-exporter.mdx
index 6bde5d92e..7bbe6cd9b 100644
--- a/data/guides/opentelemetry-collector-vs-exporter.mdx
+++ b/data/guides/opentelemetry-collector-vs-exporter.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: OpenTelemetry Collector vs Exporter - Key Differences Explained
-slug: opentelemetry-collector-vs-exporter
 date: 2024-12-19
 tags: [opentelemetry, observability, monitoring, devops]
 authors: [nitin_gouda]
 description: Learn the key differences between OpenTelemetry Collector and Exporter, their roles in telemetry data processing, and when to use each component for optimal observability.
-keywords: [opentelemetry collector vs exporter, opentelemetry collector, opentelemetry exporter, telemetry pipeline, observability, otel collector, otel exporter]
-
+keywords:
+  [
+    opentelemetry collector vs exporter,
+    opentelemetry collector,
+    opentelemetry exporter,
+    telemetry pipeline,
+    observability,
+    otel collector,
+    otel exporter,
+  ]
 ---
 
 When implementing OpenTelemetry in your applications, understanding its data pipeline components is essential. Among these, collectors and exporters often cause confusion due to their complementary but distinct roles. The decision to use a collector, an exporter, or both significantly influences the efficiency, scalability, and flexibility of your observability pipeline. Let’s explore how these components fit into the broader telemetry ecosystem and why the right choice matters.
@@ -16,45 +22,53 @@ When implementing OpenTelemetry in your applications, understanding its data pip
 
 When working with OpenTelemetry, understanding the difference between Collectors and Exporters is key to building an effective observability pipeline. Both components play critical roles but serve different purposes. Here's a quick comparison:
 
-| Aspect | Collector | Exporter |
-| --- | --- | --- |
-| Purpose | Aggregates, processes, and routes telemetry data from multiple sources to multiple destinations. | Sends telemetry data to a specific backend or observability platform. |
+| Aspect        | Collector                                                                                                    | Exporter                                                                                  |
+| ------------- | ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------- |
+| Purpose       | Aggregates, processes, and routes telemetry data from multiple sources to multiple destinations.             | Sends telemetry data to a specific backend or observability platform.                     |
 | Functionality | Acts as a central hub, performing operations like batching, filtering, sampling, and transformation of data. | Simply transfers data from the application or collector to the designated backend system. |
-| Deployment | Runs as a standalone service, typically deployed independently of the instrumented application. | Embedded within the application, Collector, or SDK to communicate with the backend. |
-| Flexibility | Supports complex pipelines, enabling data from various sources to be routed to multiple destinations. | Limited to handling a single destination per instance. |
-| Integration | Works with multiple protocols, receivers, and exporters to support diverse data sources and backends. | Specific to the backend being used (e.g., Prometheus, Elasticsearch, Jaeger). |
-| Use Case | Ideal for centralizing telemetry data collection and processing in distributed systems. | Used for direct communication between the application or collector and a backend system. |
-| Examples | OpenTelemetry Collector, Fluent Bit. | Prometheus Exporter, OTLP Exporter, Jaeger Exporter. |
+| Deployment    | Runs as a standalone service, typically deployed independently of the instrumented application.              | Embedded within the application, Collector, or SDK to communicate with the backend.       |
+| Flexibility   | Supports complex pipelines, enabling data from various sources to be routed to multiple destinations.        | Limited to handling a single destination per instance.                                    |
+| Integration   | Works with multiple protocols, receivers, and exporters to support diverse data sources and backends.        | Specific to the backend being used (e.g., Prometheus, Elasticsearch, Jaeger).             |
+| Use Case      | Ideal for centralizing telemetry data collection and processing in distributed systems.                      | Used for direct communication between the application or collector and a backend system.  |
+| Examples      | OpenTelemetry Collector, Fluent Bit.                                                                         | Prometheus Exporter, OTLP Exporter, Jaeger Exporter.                                      |
 
 As shown in the infographic below, Collectors act as a central processing hub that can handle multiple data sources and destinations, while Exporters specialize in efficiently transmitting data to specific backends. Together, these components form a flexible and scalable foundation for modern observability pipelines.
 
-<Figure src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-CleanShot_2024-12-19_at_15.25.542x.webp" alt="OpenTelemetry Collector vs. Exporter" caption="OpenTelemetry Collector vs. Exporter" />
+<Figure
+  src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-CleanShot_2024-12-19_at_15.25.542x.webp"
+  alt="OpenTelemetry Collector vs. Exporter"
+  caption="OpenTelemetry Collector vs. Exporter"
+/>
 
 ## Understanding OpenTelemetry Components
 
 Telemetry data refers to the collection of data points that provide insights into the performance, behavior, and health of software systems. In the context of observability, telemetry data typically falls into three categories:
 
 - Metrics:
-Metrics are quantitative metrics that provide different aspects of an application's performance in a numerical representation. They provide a high-level overview of the functionality and state of the system. Common metrics include resource utilization (CPU, memory, and disc usage), error rates (the frequency of errors occurring), and response times (the amount of time it takes for the program to react to a request).
-- Traces: 
-Traces provide detailed records of transactions as they flow through an application. They track the path of individual requests and show how they interact with various system components. Traces can show how a user request moves through different services, databases, and third-party APIs. They highlight the duration of each step, helping to identify slow or failing components.
-- Logs: 
-Logs are text-based records of events and errors within an application. They provide a chronological record of what has happened within the system. Logs can include error messages, debug information, and audit trails. They record events such as user logins, database queries, and application errors.
-
-<Figure src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-CleanShot_2024-08-08_at_15.25.292x.webp" alt="Venn Diagram of logs, metrics and traces" caption="Venn Diagram of logs, metrics and traces" />
+  Metrics are quantitative metrics that provide different aspects of an application's performance in a numerical representation. They provide a high-level overview of the functionality and state of the system. Common metrics include resource utilization (CPU, memory, and disc usage), error rates (the frequency of errors occurring), and response times (the amount of time it takes for the program to react to a request).
+- Traces:
+  Traces provide detailed records of transactions as they flow through an application. They track the path of individual requests and show how they interact with various system components. Traces can show how a user request moves through different services, databases, and third-party APIs. They highlight the duration of each step, helping to identify slow or failing components.
+- Logs:
+  Logs are text-based records of events and errors within an application. They provide a chronological record of what has happened within the system. Logs can include error messages, debug information, and audit trails. They record events such as user logins, database queries, and application errors.
+
+<Figure
+  src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-CleanShot_2024-08-08_at_15.25.292x.webp"
+  alt="Venn Diagram of logs, metrics and traces"
+  caption="Venn Diagram of logs, metrics and traces"
+/>
 
 ### Why Is Telemetry Data Important?
 
 Telemetry data plays a crucial role in modern software systems, offering insights into how applications and infrastructure perform. Here's why it matters:
 
-- Enhanced Visibility: 
-Telemetry data provides a continuous and real-time overview of a system's behavior and health. By monitoring this data, teams can detect potential problems before they escalate, ensuring systems remain stable and reliable.
-- Root Cause Analysis: 
-In complex distributed systems, identifying the cause of a failure or performance issue can be challenging. Telemetry data, such as logs and traces, helps pinpoint where and why a problem occurred, making it faster and easier to resolve issues.
-- Optimized Performance: 
-With access to detailed metrics and trends, organizations can make informed decisions to optimize system performance. This might include reallocating resources, fine-tuning application behavior, or improving user experiences.
-- Compliance and Auditing: 
-Logs and metrics serve as verifiable records for security, compliance, and regulatory needs. They ensure systems are operating within defined guidelines and provide a transparent trail for audits when needed.
+- Enhanced Visibility:
+  Telemetry data provides a continuous and real-time overview of a system's behavior and health. By monitoring this data, teams can detect potential problems before they escalate, ensuring systems remain stable and reliable.
+- Root Cause Analysis:
+  In complex distributed systems, identifying the cause of a failure or performance issue can be challenging. Telemetry data, such as logs and traces, helps pinpoint where and why a problem occurred, making it faster and easier to resolve issues.
+- Optimized Performance:
+  With access to detailed metrics and trends, organizations can make informed decisions to optimize system performance. This might include reallocating resources, fine-tuning application behavior, or improving user experiences.
+- Compliance and Auditing:
+  Logs and metrics serve as verifiable records for security, compliance, and regulatory needs. They ensure systems are operating within defined guidelines and provide a transparent trail for audits when needed.
 
 ### Overview of OpenTelemetry’s Architecture
 
@@ -62,18 +76,22 @@ OpenTelemetry is an open-source framework designed to standardize the collection
 
 OpenTelemetry's modular architecture is built to be flexible and extensible, ensuring it can fit into diverse observability pipelines. The core components of its architecture include:
 
-1. Instrumentation Libraries: 
-These are libraries added to applications to generate telemetry data such as traces, metrics, and logs. They can be integrated manually or automatically using agents. [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) SDKs provide the tools needed for this instrumentation process, making it easier to capture and monitor application behavior.
-2. SDKs & API: 
-OpenTelemetry provides SDKs and APIs that work together to collect, process, and export telemetry data. SDKs are libraries that manage data collection and send it to a backend or a Collector, while the API offers a consistent way to instrument applications across different programming languages.
-3. Collector: 
-The OpenTelemetry Collector is an independent service designed to receive telemetry data from multiple sources, process it, and export it to one or more observability platforms. It acts as a centralized hub for managing telemetry pipelines.
-4. Exporters: 
-Exporters are components that send telemetry data from applications or the Collector to specific observability backends, such as Prometheus, Jaeger, or Datadog. They ensure that data is formatted and transmitted in a way the backend can understand.
-5. OpenTelemetry Protocol (OTLP): 
-OTLP is an open-source, vendor-neutral protocol used to transfer telemetry data such as traces, metrics, and logs. It defines how data is structured, encoded, and transmitted across networks. The OTLP exporter is responsible for sending this data to backends for further analysis and visualization.
-
-<Figure src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-Screenshot_2024-11-22_at_11.56.38.webp" alt="OpenTelemetry’s Architecture" caption="OpenTelemetry’s Architecture" />
+1. Instrumentation Libraries:
+   These are libraries added to applications to generate telemetry data such as traces, metrics, and logs. They can be integrated manually or automatically using agents. [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) SDKs provide the tools needed for this instrumentation process, making it easier to capture and monitor application behavior.
+2. SDKs & API:
+   OpenTelemetry provides SDKs and APIs that work together to collect, process, and export telemetry data. SDKs are libraries that manage data collection and send it to a backend or a Collector, while the API offers a consistent way to instrument applications across different programming languages.
+3. Collector:
+   The OpenTelemetry Collector is an independent service designed to receive telemetry data from multiple sources, process it, and export it to one or more observability platforms. It acts as a centralized hub for managing telemetry pipelines.
+4. Exporters:
+   Exporters are components that send telemetry data from applications or the Collector to specific observability backends, such as Prometheus, Jaeger, or Datadog. They ensure that data is formatted and transmitted in a way the backend can understand.
+5. OpenTelemetry Protocol (OTLP):
+   OTLP is an open-source, vendor-neutral protocol used to transfer telemetry data such as traces, metrics, and logs. It defines how data is structured, encoded, and transmitted across networks. The OTLP exporter is responsible for sending this data to backends for further analysis and visualization.
+
+<Figure
+  src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-Screenshot_2024-11-22_at_11.56.38.webp"
+  alt="OpenTelemetry’s Architecture"
+  caption="OpenTelemetry’s Architecture"
+/>
 
 The modular design ensures interoperability and scalability, making OpenTelemetry adaptable to various environments.
 
@@ -86,7 +104,11 @@ OpenTelemetry simplifies telemetry management by breaking it into distinct roles
 3. Exporters: Responsible for sending telemetry data to a specific backend or storage system. Each backend (e.g., Prometheus, Elasticsearch) typically requires its corresponding Exporter.
 4. Collector: Functions as a central hub that combines the above components. It allows for complex pipelines, enabling data from various sources to be processed and routed to multiple destinations.
 
-<Figure src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-ab5a8de7-97f2-40d0-9343-b48938e23464.webp" alt="Data Flow Process" caption="Data Flow Process" />
+<Figure
+  src="/img/guides/2024/12/opentelemetry-collector-vs-exporter-ab5a8de7-97f2-40d0-9343-b48938e23464.webp"
+  alt="Data Flow Process"
+  caption="Data Flow Process"
+/>
 
 This separation of responsibilities ensures that the telemetry pipeline remains efficient, modular, and easy to manage.
 
@@ -95,11 +117,11 @@ This separation of responsibilities ensures that the telemetry pipeline remains
 Despite their distinct roles, collectors and exporters are often misunderstood. Here are a few common misconceptions:
 
 1. Misconception: Collectors are mandatory for OpenTelemetry setups.
-    - Reality: While Collectors are powerful and versatile, they are not required in simple setups. Applications can use Exporters directly to send telemetry data to backends.
+   - Reality: While Collectors are powerful and versatile, they are not required in simple setups. Applications can use Exporters directly to send telemetry data to backends.
 2. Misconception: Exporters can process and enrich telemetry data.
-    - Reality: Exporters are designed for data forwarding only. Processing tasks, such as filtering or enriching data, are handled by Collectors or application code.
+   - Reality: Exporters are designed for data forwarding only. Processing tasks, such as filtering or enriching data, are handled by Collectors or application code.
 3. Misconception: Collectors and Exporters are interchangeable.
-    - Reality: Collectors and Exporters complement each other. The Collector acts as a centralized processing hub, while Exporters serve as the final step to deliver data to specific backends.
+   - Reality: Collectors and Exporters complement each other. The Collector acts as a centralized processing hub, while Exporters serve as the final step to deliver data to specific backends.
 
 ## What is an OpenTelemetry Collector?
 
@@ -121,7 +143,7 @@ By offloading processing and export tasks from applications, the Collector reduc
 
 The OpenTelemetry Collector is designed with modularity and flexibility in mind. Key features include:
 
-1. Receivers: 
+1. Receivers:
 
 Receivers are the starting point of the OpenTelemetry Collector’s pipeline. They are responsible for ingesting telemetry data from various sources, such as applications, agents, or other collectors. With support for multiple protocols like gRPC, HTTP, Kafka, and OTLP, receivers enable the Collector to integrate with diverse systems. This flexibility ensures that the Collector can accommodate a wide range of telemetry formats and seamlessly connect with distributed applications.
 
@@ -200,13 +222,13 @@ To learn more about the OpenTelemetry Collector, check out our [OpenTelemetry Co
 The OpenTelemetry Collector can be deployed in two primary ways, depending on your system’s needs: Agent Deployment or Gateway Deployment.
 
 1. Agent Deployment:
-    
-    In the agent deployment model, the Collector runs alongside applications, typically as a sidecar container in environments like Kubernetes or as a local daemon on standalone systems. The primary purpose of this deployment is to act as a lightweight, localized telemetry collector that captures data generated by the application it accompanies. This model is ideal for scenarios where minimal latency is crucial, such as collecting telemetry data from a single microservice within a Kubernetes pod. By being colocated with the application, it simplifies telemetry collection and minimizes the overhead associated with data transmission.
-    
+
+   In the agent deployment model, the Collector runs alongside applications, typically as a sidecar container in environments like Kubernetes or as a local daemon on standalone systems. The primary purpose of this deployment is to act as a lightweight, localized telemetry collector that captures data generated by the application it accompanies. This model is ideal for scenarios where minimal latency is crucial, such as collecting telemetry data from a single microservice within a Kubernetes pod. By being colocated with the application, it simplifies telemetry collection and minimizes the overhead associated with data transmission.
+
 2. Gateway Deployment:
-    
-    In the gateway deployment model, the Collector operates as a centralized service that aggregates telemetry data from multiple sources across the infrastructure. Its purpose is to process, transform, and manage data from a range of applications and services before forwarding it to one or more observability backends. This deployment is particularly useful in distributed environments, such as Kubernetes clusters, where centralizing telemetry management simplifies data flow and improves scalability. For example, a gateway Collector can aggregate telemetry from an entire cluster and export it efficiently to platforms like Prometheus or Jaeger.
-    
+
+   In the gateway deployment model, the Collector operates as a centralized service that aggregates telemetry data from multiple sources across the infrastructure. Its purpose is to process, transform, and manage data from a range of applications and services before forwarding it to one or more observability backends. This deployment is particularly useful in distributed environments, such as Kubernetes clusters, where centralizing telemetry management simplifies data flow and improves scalability. For example, a gateway Collector can aggregate telemetry from an entire cluster and export it efficiently to platforms like Prometheus or Jaeger.
+
 ###Choosing a Model
 
 Deciding between agent and gateway deployment depends on the scale and complexity of your system. The agent deployment model is well-suited for lightweight setups or single-node applications, where the focus is on reducing resource usage and keeping telemetry collection close to the source. Conversely, the gateway deployment model is ideal for distributed systems, offering centralized processing and the flexibility to manage and route telemetry data to multiple destinations efficiently.
@@ -215,16 +237,16 @@ Deciding between agent and gateway deployment depends on the scale and complexit
 
 The OpenTelemetry Collector offers several benefits that enhance the flexibility, scalability, and efficiency of your observability pipeline, making it a cornerstone for modern monitoring strategies. They include:
 
-1. Vendor Neutrality: 
-The OpenTelemetry Collector enables a vendor-agnostic observability pipeline by decoupling telemetry data collection from specific backends. This means you can seamlessly switch or integrate with multiple observability tools, such as Prometheus, Jaeger, or Elasticsearch, without altering your instrumentation. This flexibility empowers organizations to adapt their observability strategy as requirements evolve.
-2. Centralized Processing: 
-By consolidating data collection, processing, and exporting in one component, the Collector simplifies telemetry management. Instead of configuring multiple agents or exporters for different applications, the Collector acts as a single hub to manage telemetry pipelines. This centralization not only reduces complexity but also ensures consistent processing rules across all data sources
-3. Scalability: 
-The Collector is built to handle large volumes of telemetry data efficiently. Its modular pipelines and batching capabilities allow it to scale with your infrastructure, accommodating growing workloads without compromising performance. Whether you're monitoring a single application or a distributed system with thousands of services, the Collector can be configured to manage the data effectively.
-4. Flexibility: 
-The Collector is highly configurable, supporting a variety of protocols (e.g., OTLP, HTTP, gRPC) and backend systems. It also allows for custom transformations and enrichment of telemetry data through processors, enabling you to tailor the pipeline to meet specific organizational or operational needs. This adaptability makes it a versatile tool for diverse observability setups.
-5. Reduced Overhead on Applications: 
-By offloading the processing and exporting of telemetry data to the Collector, applications are freed from the burden of managing these tasks. This improves application performance and ensures that telemetry responsibilities do not interfere with critical business processes. Developers can focus on building features, knowing that the Collector is handling the telemetry pipeline efficiently.
+1. Vendor Neutrality:
+   The OpenTelemetry Collector enables a vendor-agnostic observability pipeline by decoupling telemetry data collection from specific backends. This means you can seamlessly switch or integrate with multiple observability tools, such as Prometheus, Jaeger, or Elasticsearch, without altering your instrumentation. This flexibility empowers organizations to adapt their observability strategy as requirements evolve.
+2. Centralized Processing:
+   By consolidating data collection, processing, and exporting in one component, the Collector simplifies telemetry management. Instead of configuring multiple agents or exporters for different applications, the Collector acts as a single hub to manage telemetry pipelines. This centralization not only reduces complexity but also ensures consistent processing rules across all data sources
+3. Scalability:
+   The Collector is built to handle large volumes of telemetry data efficiently. Its modular pipelines and batching capabilities allow it to scale with your infrastructure, accommodating growing workloads without compromising performance. Whether you're monitoring a single application or a distributed system with thousands of services, the Collector can be configured to manage the data effectively.
+4. Flexibility:
+   The Collector is highly configurable, supporting a variety of protocols (e.g., OTLP, HTTP, gRPC) and backend systems. It also allows for custom transformations and enrichment of telemetry data through processors, enabling you to tailor the pipeline to meet specific organizational or operational needs. This adaptability makes it a versatile tool for diverse observability setups.
+5. Reduced Overhead on Applications:
+   By offloading the processing and exporting of telemetry data to the Collector, applications are freed from the burden of managing these tasks. This improves application performance and ensures that telemetry responsibilities do not interfere with critical business processes. Developers can focus on building features, knowing that the Collector is handling the telemetry pipeline efficiently.
 
 By leveraging these benefits, the OpenTelemetry Collector becomes a cornerstone of scalable and robust observability practices, suitable for both small-scale setups and complex, distributed systems.
 
@@ -235,44 +257,40 @@ An OpenTelemetry Exporter is a critical component in the [observability pipeline
 The Exporter’s main role is to:
 
 - Format Data:
-    
-    Exporters convert telemetry data into the required format (e.g., OTLP, Prometheus, or Jaeger) to ensure it is compatible with the backend.
-    
+  Exporters convert telemetry data into the required format (e.g., OTLP, Prometheus, or Jaeger) to ensure it is compatible with the backend.
 - Transmit Data:
-    
-    They handle communication protocols (e.g., gRPC, HTTP) to send data efficiently over the network.
-    
+  They handle communication protocols (e.g., gRPC, HTTP) to send data efficiently over the network.
 - Ensure Reliability:
-    
-    Many exporters implement batching, retries, and buffering to improve performance and prevent data loss.
-    
+  Many exporters implement batching, retries, and buffering to improve performance and prevent data loss.
 
 ### Types of Available Exporters
 
 1. OTLP Exporters
-    
-    The OpenTelemetry Protocol (OTLP) is the native protocol for OpenTelemetry, designed for maximum compatibility and performance. OTLP exporters are:
-    
-    - Supported by most observability platforms.
-    - Capable of handling logs, metrics, and traces seamlessly.
-    - Ideal for modern setups prioritizing interoperability and scalability.
+
+   The OpenTelemetry Protocol (OTLP) is the native protocol for OpenTelemetry, designed for maximum compatibility and performance. OTLP exporters are:
+
+   - Supported by most observability platforms.
+   - Capable of handling logs, metrics, and traces seamlessly.
+   - Ideal for modern setups prioritizing interoperability and scalability.
+
 2. Vendor-Specific Exporters
-    
-    These exporters are tailored to specific backend systems provided by observability vendors. They are:
-    
-    - Optimized for the unique features of the vendor’s platform.
-    - Often provided as part of the vendor’s [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) distribution.
-    - Examples include AWS X-Ray, Datadog, and New Relic exporters.
+
+   These exporters are tailored to specific backend systems provided by observability vendors. They are:
+
+   - Optimized for the unique features of the vendor’s platform.
+   - Often provided as part of the vendor’s [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) distribution.
+   - Examples include AWS X-Ray, Datadog, and New Relic exporters.
+
 3. Standard Protocol Exporters
-    
-    For legacy or established systems, exporters supporting protocols like Jaeger and Zipkin are widely used. These:
-    
-    - Ensure compatibility with existing observability setups.
-    - Are suitable for organizations transitioning to OpenTelemetry while retaining legacy systems.
+
+   For legacy or established systems, exporters supporting protocols like Jaeger and Zipkin are widely used. These:
+
+   - Ensure compatibility with existing observability setups.
+   - Are suitable for organizations transitioning to OpenTelemetry while retaining legacy systems.
 
 ### Configuration Options
 
-Configuring an exporter involves specifying the target backend, customizing connection settings, and enabling performance features like batching. 
+Configuring an exporter involves specifying the target backend, customizing connection settings, and enabling performance features like batching.
 
 Below is an example configuration in Python:
 
@@ -287,7 +305,7 @@ tracer_provider = TracerProvider()
 
 # Configure the OTLP Exporter
 otlp_exporter = OTLPSpanExporter(
-    endpoint="http://collector:4317"  
+    endpoint="http://collector:4317"
     # Replace with your collector's endpoint
 )
 
@@ -306,17 +324,16 @@ Key Points for Beginners:
 Batching is an essential aspect of exporter configuration, designed to improve efficiency and reliability in telemetry data transmission. By grouping multiple telemetry items into a single payload, batching minimizes the overhead associated with frequent small transmissions. This not only optimizes resource usage but also enhances network efficiency and reduces costs, making it a critical feature for high-volume telemetry pipelines.
 
 1. Batch Size Configuration:
-    
-    Adjust the batch size based on the telemetry volume and backend capacity. Larger batches enhance throughput but may increase memory usage, while smaller batches lower memory consumption but lead to more frequent transmissions.
-    
+
+   Adjust the batch size based on the telemetry volume and backend capacity. Larger batches enhance throughput but may increase memory usage, while smaller batches lower memory consumption but lead to more frequent transmissions.
+
 2. Timeout Settings:
-    
-    Configure appropriate timeouts to ensure the exporter does not hang if the backend is unresponsive. Moderate timeout values strike a balance between responsiveness and system reliability.
-    
+
+   Configure appropriate timeouts to ensure the exporter does not hang if the backend is unresponsive. Moderate timeout values strike a balance between responsiveness and system reliability.
+
 3. Retry Logic:
-    
-    Enable retry mechanisms to avoid data loss during temporary failures. Implementing exponential backoff strategies ensures that backend systems are not overwhelmed during outages, maintaining a steady flow of telemetry data.
-    
+
+   Enable retry mechanisms to avoid data loss during temporary failures. Implementing exponential backoff strategies ensures that backend systems are not overwhelmed during outages, maintaining a steady flow of telemetry data.
 
 To learn more about the OpenTelemetry Collector in detail, check out the blog [OpenTelemetry Exporters - Types and Configuration Steps](https://signoz.io/blog/opentelemetry-exporters/).
 
@@ -325,65 +342,55 @@ To learn more about the OpenTelemetry Collector in detail, check out the blog [O
 While both collectors and exporters are essential components of an OpenTelemetry pipeline, they serve distinct purposes and play different roles in managing and transmitting telemetry data. Understanding their differences is crucial for designing an efficient observability setup.
 
 1. Architectural Placement and Responsibility
+
 - Collectors
-    - Act as an intermediary between telemetry data sources (applications or SDKs) and backends.
-    - Serve as a standalone service capable of receiving, processing, and forwarding telemetry data.
-    - Can be deployed in various modes (agent or gateway) to suit specific environments.
-    
-    Responsibility: Collectors provide a flexible, centralized system for receiving, processing, and routing telemetry data across various sources and backends.
-    
+  - Act as an intermediary between telemetry data sources (applications or SDKs) and backends.
+  - Serve as a standalone service capable of receiving, processing, and forwarding telemetry data.
+  - Can be deployed in various modes (agent or gateway) to suit specific environments.
+  Responsibility: Collectors provide a flexible, centralized system for receiving, processing, and routing telemetry data across various sources and backends.
 - Exporters
-    - Embedded within SDKs or collectors to send telemetry data directly to a specific backend.
-    - Handle the formatting and transmission of data to match the requirements of the destination.
-    
-    Responsibility: Exporters are dedicated to delivering telemetry data to the final observability platform or storage system.
-    
+  - Embedded within SDKs or collectors to send telemetry data directly to a specific backend.
+  - Handle the formatting and transmission of data to match the requirements of the destination.
+  Responsibility: Exporters are dedicated to delivering telemetry data to the final observability platform or storage system.
 
 Example: In a typical setup, an application SDK generates telemetry data, which is then sent to a collector. The collector processes the data and uses an exporter to forward it to a backend like Prometheus or Jaeger.
 
 1. Data Handling Capabilities
+
 - Collectors
-    - Data Processing: Collectors can filter, transform, and enrich data before forwarding it. For example, they can add metadata (like environment tags) to all telemetry items.
-    - Aggregation: Useful for reducing telemetry data volume by summarizing metrics or combining similar traces.
-    - Data Routing: Collectors can send data to multiple backends simultaneously, making them ideal for multi-platform observability.
-    
-    Example Use Case: A collector could receive traces from various microservices, filter out non-critical traces, enrich the remaining ones with deployment details, and route them to both a tracing platform and a logging backend.
-    
+  - Data Processing: Collectors can filter, transform, and enrich data before forwarding it. For example, they can add metadata (like environment tags) to all telemetry items.
+  - Aggregation: Useful for reducing telemetry data volume by summarizing metrics or combining similar traces.
+  - Data Routing: Collectors can send data to multiple backends simultaneously, making them ideal for multi-platform observability.
+  Example Use Case: A collector could receive traces from various microservices, filter out non-critical traces, enrich the remaining ones with deployment details, and route them to both a tracing platform and a logging backend.
 - Exporters
-    - Direct Data Transfer: Exporters are optimized for efficiently transmitting data to a single backend.
-    - No Processing: Unlike collectors, exporters do not modify or enrich telemetry data. They simply package it in the format required by the target system.
-    
-    Example Use Case: An OTLP exporter sends unmodified telemetry data from a collector to an OpenTelemetry-compatible backend.
-    
+  - Direct Data Transfer: Exporters are optimized for efficiently transmitting data to a single backend.
+  - No Processing: Unlike collectors, exporters do not modify or enrich telemetry data. They simply package it in the format required by the target system.
+  Example Use Case: An OTLP exporter sends unmodified telemetry data from a collector to an OpenTelemetry-compatible backend.
+
 1. Scalability Aspects
+
 - Collectors
-    - Designed for scalability, especially in distributed systems.
-    - Can handle high volumes of telemetry data from multiple sources, making them ideal for large-scale environments.
-    - Provide buffering and retry mechanisms to ensure data is not lost during temporary outages.
-    
-    Scalability Tip: In a Kubernetes environment, deploy collectors as a DaemonSet (agent mode) for host-level monitoring or as a Deployment (gateway mode) for centralized telemetry processing.
-    
+  - Designed for scalability, especially in distributed systems.
+  - Can handle high volumes of telemetry data from multiple sources, making them ideal for large-scale environments.
+  - Provide buffering and retry mechanisms to ensure data is not lost during temporary outages.
+  Scalability Tip: In a Kubernetes environment, deploy collectors as a DaemonSet (agent mode) for host-level monitoring or as a Deployment (gateway mode) for centralized telemetry processing.
 - Exporters
-    - While efficient, exporters are limited in scalability due to their direct data transfer nature.
-    - Often rely on collectors to manage high-volume data and handle complex processing tasks before export.
-    
-    Scalability Tip: Use collectors to aggregate and process telemetry data, reducing the burden on exporters and enabling smoother backend integration.
-    
+  - While efficient, exporters are limited in scalability due to their direct data transfer nature.
+  - Often rely on collectors to manage high-volume data and handle complex processing tasks before export.
+  Scalability Tip: Use collectors to aggregate and process telemetry data, reducing the burden on exporters and enabling smoother backend integration.
+
 1. When to Use Which Component
+
 - Use Collectors When
-    - You need to process or transform telemetry data (e.g., filtering, sampling, or enrichment).
-    - Your setup involves routing data to multiple backends.
-    - You want a centralized point for telemetry data collection and processing in a distributed system.
-    
-    Example: In a multi-cloud environment, a collector can route metrics to Prometheus, traces to Jaeger, and logs to a cloud-native logging solution.
-    
+  - You need to process or transform telemetry data (e.g., filtering, sampling, or enrichment).
+  - Your setup involves routing data to multiple backends.
+  - You want a centralized point for telemetry data collection and processing in a distributed system.
+  Example: In a multi-cloud environment, a collector can route metrics to Prometheus, traces to Jaeger, and logs to a cloud-native logging solution.
 - Use Exporters When
-    - You need to send telemetry data directly from an application or collector to a single backend.
-    - Data processing or routing is not required.
-    - You are working in a small or simple environment where minimal components are preferred.
-    
-    Example: A Python application with the OTLP exporter configured in its SDK directly sends traces to an OpenTelemetry-compatible backend for analysis.
-    
+  - You need to send telemetry data directly from an application or collector to a single backend.
+  - Data processing or routing is not required.
+  - You are working in a small or simple environment where minimal components are preferred.
+  Example: A Python application with the OTLP exporter configured in its SDK directly sends traces to an OpenTelemetry-compatible backend for analysis.
 
 ## Implementing Telemetry with SigNoz
 
@@ -408,48 +415,51 @@ For more information on implementing Telemetry with SigNoz, check out the [Imple
 
 To effectively monitor modern applications and systems, it’s essential to choose the right observability solution that aligns with your organization’s goals and capabilities. Observability tools generally fall into two categories: Cloud-Based Solutions and Open-Source Software (OSS) Options. Each has unique advantages and trade-offs, making it important to understand their differences to make an informed decision.
 
-| Aspect | Cloud-Based Solutions | Open-Source Software (OSS) Options |
-| --- | --- | --- |
-| Setup and Maintenance | Minimal setup; managed by the provider, including upgrades and scaling. | Requires manual setup, configuration, and ongoing maintenance by the team. |
-| Scalability | Automatically scales to handle large data volumes. | Scalability depends on the team’s ability to manage infrastructure resources. |
-| Cost | Subscription-based; costs depend on usage, such as data volume or retention. | Free to use, but requires investment in infrastructure, time, and expertise. |
-| Flexibility | Limited to the features and customization options provided by the vendor. | Fully customizable; can be tailored to meet specific requirements. |
-| Vendor Lock-In | Data and workflows are tied to the service provider. | No vendor lock-in; full control over the pipeline and data. |
-| Features | Offers advanced features like AI-driven insights, integrated dashboards, and automated alerts. | Features depend on the specific OSS tools used (e.g., Prometheus, Grafana). |
-| Skill Requirements | Low; suitable for teams with little expertise in observability tools. | High; requires in-depth knowledge of observability tools and infrastructure. |
-| Examples | Datadog, New Relic, AWS CloudWatch, Microsoft Azure Monitor. | OpenTelemetry, SigNoz, Prometheus, Grafana. |
+| Aspect                | Cloud-Based Solutions                                                                          | Open-Source Software (OSS) Options                                            |
+| --------------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| Setup and Maintenance | Minimal setup; managed by the provider, including upgrades and scaling.                        | Requires manual setup, configuration, and ongoing maintenance by the team.    |
+| Scalability           | Automatically scales to handle large data volumes.                                             | Scalability depends on the team’s ability to manage infrastructure resources. |
+| Cost                  | Subscription-based; costs depend on usage, such as data volume or retention.                   | Free to use, but requires investment in infrastructure, time, and expertise.  |
+| Flexibility           | Limited to the features and customization options provided by the vendor.                      | Fully customizable; can be tailored to meet specific requirements.            |
+| Vendor Lock-In        | Data and workflows are tied to the service provider.                                           | No vendor lock-in; full control over the pipeline and data.                   |
+| Features              | Offers advanced features like AI-driven insights, integrated dashboards, and automated alerts. | Features depend on the specific OSS tools used (e.g., Prometheus, Grafana).   |
+| Skill Requirements    | Low; suitable for teams with little expertise in observability tools.                          | High; requires in-depth knowledge of observability tools and infrastructure.  |
+| Examples              | Datadog, New Relic, AWS CloudWatch, Microsoft Azure Monitor.                                   | OpenTelemetry, SigNoz, Prometheus, Grafana.                                   |
 
 ## Best Practices
 
 Implementing OpenTelemetry effectively requires careful consideration of deployment strategies, configuration optimization, and performance tuning. By following these best practices, you can ensure a scalable, efficient, and reliable observability pipeline for your applications.
 
 1. Collector Deployment Strategies
-    
-    Deploying the OpenTelemetry Collector correctly is essential for ensuring the smooth collection and processing of telemetry data. Choose the deployment model that best fits your environment:
-    
-    - Agent Deployment: For lightweight setups, deploy the collector as a sidecar or daemon on each host to monitor local applications. This setup reduces latency and simplifies telemetry collection in single-host or containerized environments like Kubernetes.
-    - Gateway Deployment: For centralized data processing, use the collector as a gateway to aggregate telemetry data from multiple sources or services. This approach is ideal for distributed systems or large-scale environments like microservices architectures.
-    - Secure Data Transmission: Always use TLS (Transport Layer Security) for secure data transmission to protect telemetry data from interception. Enable trusted certificates to simplify configuration and ensure secure communication.
+
+   Deploying the OpenTelemetry Collector correctly is essential for ensuring the smooth collection and processing of telemetry data. Choose the deployment model that best fits your environment:
+
+   - Agent Deployment: For lightweight setups, deploy the collector as a sidecar or daemon on each host to monitor local applications. This setup reduces latency and simplifies telemetry collection in single-host or containerized environments like Kubernetes.
+   - Gateway Deployment: For centralized data processing, use the collector as a gateway to aggregate telemetry data from multiple sources or services. This approach is ideal for distributed systems or large-scale environments like microservices architectures.
+   - Secure Data Transmission: Always use TLS (Transport Layer Security) for secure data transmission to protect telemetry data from interception. Enable trusted certificates to simplify configuration and ensure secure communication.
+
 2. Exporter Configuration Optimization
-    
-    Exporters play a crucial role in sending telemetry data to observability backends. Proper configuration of exporters ensures efficient data transmission and reliable delivery.
-    
-    - Batching Configuration: Configure batch sizes to balance throughput and memory usage. Larger batches are more efficient but require more memory, while smaller batches reduce memory usage but may result in more frequent transmissions.
-    - Timeout Settings: Set reasonable timeouts for data export operations to prevent long delays caused by unresponsive backends. Moderate timeouts strike a balance between reliability and responsiveness.
-    - Enable Retry Logic: Enable retries for transient failures, such as network disruptions or backend unavailability. Implementing exponential backoff prevents overwhelming the backend during temporary outages.
+
+   Exporters play a crucial role in sending telemetry data to observability backends. Proper configuration of exporters ensures efficient data transmission and reliable delivery.
+
+   - Batching Configuration: Configure batch sizes to balance throughput and memory usage. Larger batches are more efficient but require more memory, while smaller batches reduce memory usage but may result in more frequent transmissions.
+   - Timeout Settings: Set reasonable timeouts for data export operations to prevent long delays caused by unresponsive backends. Moderate timeouts strike a balance between reliability and responsiveness.
+   - Enable Retry Logic: Enable retries for transient failures, such as network disruptions or backend unavailability. Implementing exponential backoff prevents overwhelming the backend during temporary outages.
+
 3. Data Sampling Considerations
-    
-    Sampling helps control the volume of telemetry data without sacrificing visibility. It’s particularly useful in high-traffic environments to manage resource consumption and costs.
-    
-    - Sampling Strategy: Choose between head-based sampling (a fixed percentage of all data) for predictability or tail-based sampling (capturing significant traces like errors) for more relevant insights.
-    - Centralized Sampling: Apply sampling in the collector if your applications generate high volumes of telemetry. This centralizes the logic and reduces overhead on individual applications, improving overall efficiency.
+
+   Sampling helps control the volume of telemetry data without sacrificing visibility. It’s particularly useful in high-traffic environments to manage resource consumption and costs.
+
+   - Sampling Strategy: Choose between head-based sampling (a fixed percentage of all data) for predictability or tail-based sampling (capturing significant traces like errors) for more relevant insights.
+   - Centralized Sampling: Apply sampling in the collector if your applications generate high volumes of telemetry. This centralizes the logic and reduces overhead on individual applications, improving overall efficiency.
+
 4. Performance Tuning Tips
-    
-    Optimizing performance is crucial for maintaining a responsive and scalable observability pipeline.
-    
-    - Monitor Resource Usage: Regularly monitor the CPU and memory usage of collectors to avoid resource exhaustion. Use monitoring tools like Prometheus to track metrics such as CPU usage, memory consumption, and queue sizes.
-    - Adjust Batch Sizes Dynamically: Adjust batch sizes based on the telemetry load. During peak traffic, increase batch sizes for better throughput, and reduce them during off-peak hours to save resources.
-    - Use Sampling in High-Traffic Environments: Combine sampling with batch size adjustments in environments with very high telemetry volumes. This helps prevent resource overload while maintaining important data for analysis.
+
+   Optimizing performance is crucial for maintaining a responsive and scalable observability pipeline.
+
+   - Monitor Resource Usage: Regularly monitor the CPU and memory usage of collectors to avoid resource exhaustion. Use monitoring tools like Prometheus to track metrics such as CPU usage, memory consumption, and queue sizes.
+   - Adjust Batch Sizes Dynamically: Adjust batch sizes based on the telemetry load. During peak traffic, increase batch sizes for better throughput, and reduce them during off-peak hours to save resources.
+   - Use Sampling in High-Traffic Environments: Combine sampling with batch size adjustments in environments with very high telemetry volumes. This helps prevent resource overload while maintaining important data for analysis.
 
 By following these best practices for collector deployment, exporter configuration, data sampling, and performance tuning, you can ensure that your OpenTelemetry setup remains efficient, scalable, and reliable across different environments.
 
@@ -469,4 +479,4 @@ Collectors enhance telemetry data quality by providing capabilities such as filt
 
 ### Which exporters are most commonly used?
 
-The OpenTelemetry Protocol (OTLP) exporters are widely adopted due to their compatibility with modern observability platforms. Other commonly used exporters include Jaeger, for distributed tracing, and Prometheus, for metrics collection and monitoring in specific scenarios.
\ No newline at end of file
+The OpenTelemetry Protocol (OTLP) exporters are widely adopted due to their compatibility with modern observability platforms. Other commonly used exporters include Jaeger, for distributed tracing, and Prometheus, for metrics collection and monitoring in specific scenarios.
diff --git a/data/guides/optimize-cloud-costs.mdx b/data/guides/optimize-cloud-costs.mdx
index fe9601a68..e7fea2fcc 100644
--- a/data/guides/optimize-cloud-costs.mdx
+++ b/data/guides/optimize-cloud-costs.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: 10 Proven Strategies to Optimize Your Cloud Costs
-slug: optimize-cloud-costs
 date: 2024-12-26
 tags: [observability, monitoring]
 authors: [soumya_gupta]
 description: Discover 10 effective strategies to optimize your cloud costs, improve efficiency, and maximize ROI. Learn how to implement cost-saving measures for your cloud infrastructure.
-keywords: [cloud cost optimization, cloud spending, resource management, cost efficiency, cloud budgeting, cloud cost reduction, cloud cost monitoring, cloud cost analysis]
-
+keywords:
+  [
+    cloud cost optimization,
+    cloud spending,
+    resource management,
+    cost efficiency,
+    cloud budgeting,
+    cloud cost reduction,
+    cloud cost monitoring,
+    cloud cost analysis,
+  ]
 ---
 
 Cloud computing has revolutionized the way businesses operate, offering unparalleled scalability and flexibility. However, with these benefits comes the challenge of managing costs effectively. As cloud adoption continues to surge, organizations find themselves grappling with escalating expenses. How can you harness the power of the cloud without breaking the bank? This article presents 10 proven strategies to optimize your cloud costs, ensuring you maximize value while minimizing expenditure.
@@ -16,14 +23,20 @@ Cloud computing has revolutionized the way businesses operate, offering unparall
 
 Cloud cost optimization focuses on allocating the most efficient and cost-effective resources to workloads, balancing performance, cost, compliance, and security to ensure investments align with organizational needs. Since each workload is unique and evolves over time, optimization requires setting performance thresholds based on metrics and domain expertise to reduce costs without compromising performance. This dynamic process adapts to shifting application demands and cloud pricing options, relying on detailed analytics, metrics, and automation to navigate the complexity of cloud environments.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image.webp" alt="Key Components of Cloud Cost Analysis" caption="Key Components of Cloud Cost Analysis" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image.webp"
+  alt="Key Components of Cloud Cost Analysis"
+  caption="Key Components of Cloud Cost Analysis"
+/>
+
+Optimizing cloud costs may include the following steps:
+
+1. Resource Management: Efficient resource management ensures that cloud resources are allocated based on actual needs, avoiding overprovisioning or underutilization.
 
-Optimizing cloud costs may include the following steps: 
+   <Figure src="/img/guides/2024/12/optimize-cloud-costs-image%201.webp" alt="" caption="" />
+   This involves monitoring usage and adjusting resources dynamically to maintain efficiency and
+   minimize waste.
 
-1. Resource Management: Efficient resource management ensures that cloud resources are allocated based on actual needs, avoiding overprovisioning or underutilization. 
-    
-    <Figure src="/img/guides/2024/12/optimize-cloud-costs-image%201.webp" alt="" caption="" />This involves monitoring usage and adjusting resources dynamically to maintain efficiency and minimize waste.
-    
 2. Pricing Models: Cloud providers offer diverse pricing options, such as on-demand, reserved, and spot instances, to cater to different needs. Choosing the right pricing model based on workload requirements can significantly lower costs while maintaining service quality.
 3. Usage Patterns: Understanding how cloud services are consumed helps identify inefficiencies and areas for improvement. By analyzing usage trends, organizations can optimize workloads, eliminate redundancies, and plan for scaling during peak demand.
 
@@ -31,23 +44,27 @@ However, challenges such as complexity, lack of visibility, and rapid technologi
 
 ### Cloud Cost Optimization VS Cloud Cost Management
 
-As organizations increasingly rely on cloud services, managing and optimizing cloud expenses has become essential. However, understanding the difference between cloud cost management and cloud cost optimization is key to effective financial oversight. Cloud cost management refers to the broader practice of monitoring, analyzing, and controlling cloud spending to stay within budget and ensure accountability. It involves creating policies, setting budgets, and generating detailed cost reports. In contrast, cloud cost optimization focuses on refining how cloud resources are used to maximize efficiency and minimize waste. By introducing these concepts, businesses can develop a balanced approach that combines strategic cost control with practical efficiency improvements. 
+As organizations increasingly rely on cloud services, managing and optimizing cloud expenses has become essential. However, understanding the difference between cloud cost management and cloud cost optimization is key to effective financial oversight. Cloud cost management refers to the broader practice of monitoring, analyzing, and controlling cloud spending to stay within budget and ensure accountability. It involves creating policies, setting budgets, and generating detailed cost reports. In contrast, cloud cost optimization focuses on refining how cloud resources are used to maximize efficiency and minimize waste. By introducing these concepts, businesses can develop a balanced approach that combines strategic cost control with practical efficiency improvements.
 
-Let’s look at a tabular comparison of the same: 
+Let’s look at a tabular comparison of the same:
 
-| Factors | Cloud Cost Optimization | Cloud Cost Management |
-| --- | --- | --- |
-| Focus | Maximizing business value while minimizing costs. | Tracking, allocating, and analyzing cloud spend. |
-| Primary Goal | Align costs with business goals and drive profitability. | Monitor and control spending. |
-| Revenue Correlation | Higher costs are acceptable if they drive higher revenue or profitability. | Not necessarily linked to revenue generation. |
-| Key Requirement | Actionable cloud cost intelligence for proactive decision-making. | Detailed reports and spending insights. |
-| Outcome | Ensures costs are productive and lead to business growth. | Ensures controlled and transparent cloud expenditure. |
+| Factors             | Cloud Cost Optimization                                                    | Cloud Cost Management                                 |
+| ------------------- | -------------------------------------------------------------------------- | ----------------------------------------------------- |
+| Focus               | Maximizing business value while minimizing costs.                          | Tracking, allocating, and analyzing cloud spend.      |
+| Primary Goal        | Align costs with business goals and drive profitability.                   | Monitor and control spending.                         |
+| Revenue Correlation | Higher costs are acceptable if they drive higher revenue or profitability. | Not necessarily linked to revenue generation.         |
+| Key Requirement     | Actionable cloud cost intelligence for proactive decision-making.          | Detailed reports and spending insights.               |
+| Outcome             | Ensures costs are productive and lead to business growth.                  | Ensures controlled and transparent cloud expenditure. |
 
 ## Why Cloud Cost Optimization is Crucial for Businesses
 
 Cloud computing costs can vary widely across services and vendors. With on-demand resources, organizations can scale quickly, while automation enhances efficiency. However, managing these costs requires a clear understanding of the factors driving them, a strategic plan tailored to business needs, and continuous monitoring to optimize usage and billing. To support this, cloud vendors offer various pricing models and cost management tools.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%202.webp" alt="Cloud Cost Optimization Advantages for Businesses" caption="Cloud Cost Optimization Advantages for Businesses" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%202.webp"
+  alt="Cloud Cost Optimization Advantages for Businesses"
+  caption="Cloud Cost Optimization Advantages for Businesses"
+/>
 
 As cloud spending continues to grow rapidly, it’s becoming a major factor in business budgets. Gartner projects global end-user spending on public cloud services to hit $597.3 billion in 2023, emphasizing the need for effective cost control strategies.
 
@@ -60,7 +77,11 @@ Cloud cost optimization enhances financial performance, drives sustainability, a
 - Increased Return on Investment (ROI): Cloud cost optimization isn’t just about cutting expenses; it’s a strategic approach to maximizing the value of cloud investments. This involves reducing costs without compromising security, system performance, or development speed, ensuring cloud resources contribute directly to business goals and outcomes.
 - Reduced Security Risks: While not the core focus of security programs, cloud cost optimization can enhance security by eliminating overprovisioned and idle resources that expand the attack surface. Increased visibility from monitoring cloud usage helps identify potential vulnerabilities. Tools like autoscaling and infrastructure as code (IaC) ensure consistent enforcement of security controls and reduce risks from misconfigurations. This proactive approach supports both cost savings and stronger security postures.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%203.webp" alt="Effective Cloud Cost Optimization Strategies" caption="Effective Cloud Cost Optimization Strategies" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%203.webp"
+  alt="Effective Cloud Cost Optimization Strategies"
+  caption="Effective Cloud Cost Optimization Strategies"
+/>
 
 ## Strategy 1: Implement Comprehensive Cloud Cost Monitoring
 
@@ -167,7 +188,7 @@ Here’s an example to illustrate a lifecycle policy in AWS S3:
 }
 ```
 
-This JSON code sets up an S3 lifecycle policy to automatically manage the storage of your files. It starts by enabling the policy and then specifies how objects should be handled as they age. 
+This JSON code sets up an S3 lifecycle policy to automatically manage the storage of your files. It starts by enabling the policy and then specifies how objects should be handled as they age.
 
 - After 30 days: objects are moved to the STANDARD_IA storage class, which is cheaper for data that’s accessed less frequently.
 - After 60 days: they’re transitioned to GLACIER, a very low-cost storage option for data that needs to be archived.
@@ -214,8 +235,8 @@ In the above example, `SpotFleetRequestConfig` involves:
 - `AllocationStrategy`: The strategy chosen here is `capacityOptimized`. This means the Spot Fleet will prioritize instances from pools with the least chance of interruption, improving the likelihood that your instances will stay running without termination due to high demand in other pools.
 - `TargetCapacity`: The total number of Spot Instances you want to request is set to 10. This specifies the desired capacity for your Spot Fleet, which AWS will try to meet by launching instances.
 - `LaunchSpecifications`: This section lists the types of instances that AWS can use to fulfill the requested capacity. In this case, two instance types are specified:
-    - `c5.large`: A compute-optimized instance type, with a weighted capacity of 1. This means one `c5.large` instance counts as 1 towards the total capacity.
-    - `m5.large`: A general-purpose instance type, also with a weighted capacity of 1.
+  - `c5.large`: A compute-optimized instance type, with a weighted capacity of 1. This means one `c5.large` instance counts as 1 towards the total capacity.
+  - `m5.large`: A general-purpose instance type, also with a weighted capacity of 1.
 
 The Spot Fleet will try to meet the target capacity of 10 by selecting `c5.large` and `m5.large` instances, using them in any combination that adds up to the desired capacity. By specifying multiple instance types, you provide flexibility in instance selection, ensuring your Spot Fleet can efficiently scale depending on availability and cost.
 
@@ -243,24 +264,21 @@ Let’s take an example to see how we can define a tagging policy for managing c
         "Environment": ["Production", "Development", "Testing"],
         "Owner": "${aws:PrincipalTag/email}"
       },
-      "EnforceForResources": [
-        "AWS::EC2::Instance",
-        "AWS::RDS::DBInstance"
-      ]
+      "EnforceForResources": ["AWS::EC2::Instance", "AWS::RDS::DBInstance"]
     }
   ]
 }
 ```
 
-This policy automates and enforces consistent tagging practices, ensuring every tagged resource aligns with organizational standards. For example, a company can easily filter and track costs for all resources related to the `Development` environment or identify resource ownership via the `Owner` tag. Let’s understand this in-depth: 
+This policy automates and enforces consistent tagging practices, ensuring every tagged resource aligns with organizational standards. For example, a company can easily filter and track costs for all resources related to the `Development` environment or identify resource ownership via the `Owner` tag. Let’s understand this in-depth:
 
 - `Tagpolicy` specifies a set of tags to be applied to AWS resources.
-    - `Project`: Dynamically inherits the value from the AWS principal's tag (`aws:PrincipalTag/Project`), ensuring that resources are associated with a specific project.
-    - `Environment`: Restricts the environment tag to one of the predefined values—`Production`, `Development`, or `Testing`. This ensures consistency across different resource environments.
-    - `Owner`: Dynamically derives the email of the resource owner from the AWS principal's tag (`aws:PrincipalTag/email`), promoting accountability.
+  - `Project`: Dynamically inherits the value from the AWS principal's tag (`aws:PrincipalTag/Project`), ensuring that resources are associated with a specific project.
+  - `Environment`: Restricts the environment tag to one of the predefined values—`Production`, `Development`, or `Testing`. This ensures consistency across different resource environments.
+  - `Owner`: Dynamically derives the email of the resource owner from the AWS principal's tag (`aws:PrincipalTag/email`), promoting accountability.
 - `EnforceForResources` lists the specific resource types where the tagging policy must be enforced:
-    - `AWS::EC2::Instance`: Applies the policy to EC2 instances, which are commonly used virtual machines.
-    - `AWS::RDS::DBInstance`: Enforces tagging on RDS database instances, which manage relational database
+  - `AWS::EC2::Instance`: Applies the policy to EC2 instances, which are commonly used virtual machines.
+  - `AWS::RDS::DBInstance`: Enforces tagging on RDS database instances, which manage relational database
 
 ## Strategy 8: Optimize Network Usage and Data Transfer
 
@@ -306,7 +324,7 @@ Key aspects of continuous optimization include:
 
 This example showcases a Terraform configuration for an Auto Scaling Group (ASG) in AWS. The ASG adapts the number of EC2 instances based on demand, ensuring efficient resource use while keeping applications available. It’s also a great example of Infrastructure as Code (IaC), where infrastructure is defined in a clear, reusable way, making deployments consistent and easy to manage.
 
-Pre-requisites: 
+Pre-requisites:
 
 - Make sure that all referenced resources (`aws_subnet.private.*.id`, `aws_lb_target_group.web.arn`, and `aws_launch_template.web.id`) that are used in this example are defined elsewhere in your Terraform project.
 - Verify that the target group's health checks align with your application's requirements.
@@ -338,19 +356,19 @@ Key Components of this example:
 
 1. `resource "aws_autoscaling_group" "web_asg"` creates an Auto Scaling Group named `"web-asg"` to automatically scale EC2 instances.
 2. Attributes:
-    - `name`: Specifies the name of the Auto Scaling Group (`"web-asg"`).
-    - `vpc_zone_identifier`: Points to the private subnets where the instances will be launched. It refers to IDs from the `aws_subnet.private.*.id` resource.
-    - `target_group_arns`: Links the Auto Scaling Group to an Application Load Balancer (ALB) target `group (aws_lb_target_group.web.arn)` for load balancing and health checks.
-    - `health_check_type`: Defines the health check type as `"ELB"` (Elastic Load Balancer), ensuring instances are monitored through the ALB.
+   - `name`: Specifies the name of the Auto Scaling Group (`"web-asg"`).
+   - `vpc_zone_identifier`: Points to the private subnets where the instances will be launched. It refers to IDs from the `aws_subnet.private.*.id` resource.
+   - `target_group_arns`: Links the Auto Scaling Group to an Application Load Balancer (ALB) target `group (aws_lb_target_group.web.arn)` for load balancing and health checks.
+   - `health_check_type`: Defines the health check type as `"ELB"` (Elastic Load Balancer), ensuring instances are monitored through the ALB.
 3. Scaling Configuration:
-`min_size`: Ensures a minimum of 2 instances are always running for availability.
-`max_size`: Caps the group at 10 instances to control costs and avoid over-provisioning.
+   `min_size`: Ensures a minimum of 2 instances are always running for availability.
+   `max_size`: Caps the group at 10 instances to control costs and avoid over-provisioning.
 4. Launch Template: Specifies the configuration for launching EC2 instances.
-    - `id`: Refers to the ID of the AWS Launch Template (`aws_launch_template.web.id`), which contains instance details like AMI, instance type, and other parameters.
-    - `version`: Uses the latest version (`"$Latest"`) of the launch template.
+   - `id`: Refers to the ID of the AWS Launch Template (`aws_launch_template.web.id`), which contains instance details like AMI, instance type, and other parameters.
+   - `version`: Uses the latest version (`"$Latest"`) of the launch template.
 5. Tag: Automatically applies tags to instances created by the ASG.
-    - Key-Value Pair: `"Name"` tag is set to `"web-server"`.
-    - `propagate_at_launch`: Ensures tags are applied to all instances launched by the ASG.
+   - Key-Value Pair: `"Name"` tag is set to `"web-server"`.
+   - `propagate_at_launch`: Ensures tags are applied to all instances launched by the ASG.
 
 ## Strategy 10: Leverage Cloud Cost Optimization Tools
 
@@ -383,17 +401,22 @@ By providing deep insights into your application's behaviour, SigNoz enables you
 
 <GetStartedSigNoz />
 
-Let’s take a look at a practical demo of how we can optimize cloud costs with SigNoz, 
+Let’s take a look at a practical demo of how we can optimize cloud costs with SigNoz,
 
 ### Optimizing Cloud Costs with SigNoz: A Practical Example
 
-Let us give you a brief of what we’re doing here: 
+Let us give you a brief of what we’re doing here:
 
 1. Environment Setup: Before we begin, let's review the basic environment setup we need.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%204.webp" alt="Environment Setup" caption="Environment Setup" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%204.webp"
+  alt="Environment Setup"
+  caption="Environment Setup"
+/>
 
 1. Observability Components
+
 - Tracer Initialization: A tracer is set up to monitor spans of code execution. The spans are exported to SigNoz for visualization and analysis.
 - Metrics Initialization: A custom metric (`http_requests`) is created to count HTTP requests per endpoint.
 
@@ -414,47 +437,46 @@ Let us give you a brief of what we’re doing here:
 ### Pre-requisites
 
 1. Create a python virtual environment `venv` using the following command:
-    
-    ```
-    python -m venv venv
-    ```
-    
-    By now your current file directory should look like:
-    
-    ```
-    cloud_cost/
-    ├── venv/
-    │   ├── include/
-    │   ├── lib/
-    │   ├── scripts/
-    │   └── pyvenv.cfg
-    └── app.py
-    ```
-    
+
+   ```
+   python -m venv venv
+   ```
+
+   By now your current file directory should look like:
+
+   ```
+   cloud_cost/
+   ├── venv/
+   │   ├── include/
+   │   ├── lib/
+   │   ├── scripts/
+   │   └── pyvenv.cfg
+   └── app.py
+   ```
+
 2. Activate virtual environment using the following command:
-    
-    ```
-    .\venv\Scripts\Activate
-    ```
-    
-    If you run into an error while activating the virtual environment change the execution policy for the current user to allow local scripts and scripts signed by a trusted publisher using the following command:
-    
-    ```
-    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-    ```
-    
-    Once you’ve successfully activated the virtual environment you should see the following as your directory path in the PowerShell terminal:
-    
-    ```
-    (venv) PS C:\Users\Desktop\SigNoz\flasklog> 
-    ```
-    
+
+   ```
+   .\venv\Scripts\Activate
+   ```
+
+   If you run into an error while activating the virtual environment change the execution policy for the current user to allow local scripts and scripts signed by a trusted publisher using the following command:
+
+   ```
+   Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+   ```
+
+   Once you’ve successfully activated the virtual environment you should see the following as your directory path in the PowerShell terminal:
+
+   ```
+   (venv) PS C:\Users\Desktop\SigNoz\flasklog>
+   ```
+
 3. Install the required packages
-    
-    ```
-    pip install flask opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation-logging opentelemetry-instrumentation-requests
-    ```
-    
+
+   ```
+   pip install flask opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation-logging opentelemetry-instrumentation-requests
+   ```
 
 ### Implementation Code
 
@@ -589,36 +611,36 @@ if __name__ == "__main__":
 Key components and functionality:
 
 1. Tracer and Metrics Setup:
-    
-    The OpenTelemetry tracer provider and meter provider are configured to enable tracing and metrics collection. These are exported to [SigNoz](https://signoz.io/docs/introduction/) via OTLP exporters. Custom metrics, like the count of HTTP requests, are tracked using a counter.
-    
+
+   The OpenTelemetry tracer provider and meter provider are configured to enable tracing and metrics collection. These are exported to [SigNoz](https://signoz.io/docs/introduction/) via OTLP exporters. Custom metrics, like the count of HTTP requests, are tracked using a counter.
+
 2. Instrumentation:
-    
-    The `requests` library is instrumented to trace outgoing HTTP requests, and the `logging` module is instrumented for enhanced logging capabilities.
-    
-3. Flask Routes: 
-    
-    We define several routes such as:
-    
-    | Routes | Description |
-    | --- | --- |
-    | `/` | The main endpoint, where tracing occurs on the root operation and a sub-operation. |
-    | `/resource-intensive` | Simulates a resource-heavy computation, and its performance is traced. |
-    | `/simulate-latency` | Introduces artificial latency to simulate performance delays and records the trace. |
-    | `/logging-demo` | Demonstrates logging within a traced operation. |
-    | `/fetch-data` | Fetches data from an external API and traces the HTTP request. |
+
+   The `requests` library is instrumented to trace outgoing HTTP requests, and the `logging` module is instrumented for enhanced logging capabilities.
+
+3. Flask Routes:
+
+   We define several routes such as:
+
+   | Routes                | Description                                                                         |
+   | --------------------- | ----------------------------------------------------------------------------------- |
+   | `/`                   | The main endpoint, where tracing occurs on the root operation and a sub-operation.  |
+   | `/resource-intensive` | Simulates a resource-heavy computation, and its performance is traced.              |
+   | `/simulate-latency`   | Introduces artificial latency to simulate performance delays and records the trace. |
+   | `/logging-demo`       | Demonstrates logging within a traced operation.                                     |
+   | `/fetch-data`         | Fetches data from an external API and traces the HTTP request.                      |
+
 4. Error Handling and Logging:
-    
-    Exception handling is implemented for the resource-intensive and fetch-data routes. Errors are recorded in the trace and logged for visibility.
-    
 
-Run the code with the following command: 
+   Exception handling is implemented for the resource-intensive and fetch-data routes. Errors are recorded in the trace and logged for visibility.
+
+Run the code with the following command:
 
 ```
 python app.py
 ```
 
-Output: 
+Output:
 
 ```
 (venv) PS C:\Users\Desktop\signoz> python app.py
@@ -627,7 +649,7 @@ Overriding of current TracerProvider is not allowed
  * Debug mode: on
 2024-12-21 18:01:18,682 INFO [werkzeug] [_internal.py:97] [trace_id=0 span_id=0 resource.service.name=my_flask_service trace_sampled=False] - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
  * Running on http://127.0.0.1:5000
-2024-12-21 18:01:18,683 INFO [werkzeug] [_internal.py:97] [trace_id=0 span_id=0 resource.service.name=my_flask_service trace_sampled=False] - Press CTRL+C to quit 
+2024-12-21 18:01:18,683 INFO [werkzeug] [_internal.py:97] [trace_id=0 span_id=0 resource.service.name=my_flask_service trace_sampled=False] - Press CTRL+C to quit
 2024-12-21 18:01:18,684 INFO [werkzeug] [_internal.py:97] [trace_id=0 span_id=0 resource.service.name=my_flask_service trace_sampled=False] -  * Restarting with stat
 Overriding of current TracerProvider is not allowed
 2024-12-21 18:01:19,395 WARNING [werkzeug] [_internal.py:97] [trace_id=0 span_id=0 resource.service.name=my_flask_service trace_sampled=False] -  * Debugger is active!
@@ -644,29 +666,48 @@ Overriding of current TracerProvider is not allowed
 After running the code, access the provided endpoints to trigger and observe the root operations. Each endpoint initiates a specific process, allowing you to verify the functionality and performance.
 
 1. Select `127.0.0.1:5000` to initiate the tracing, this is how it will look
-    
-    <Figure src="/img/guides/2024/12/optimize-cloud-costs-image%205.webp" alt="Main Operation Endpoint" caption="Main Operation Endpoint" />
-    
+
+   <Figure
+     src="/img/guides/2024/12/optimize-cloud-costs-image%205.webp"
+     alt="Main Operation Endpoint"
+     caption="Main Operation Endpoint"
+   />
+
 2. Select `127.0.0.1:5000/simulate-latency` to initiate the latency simulation,
-    
-    <Figure src="/img/guides/2024/12/optimize-cloud-costs-image%206.webp" alt="Latency Simulation Endpoint" caption="Latency Simulation Endpoint" />
-    
-3. Select `127.0.0.1:5000/resource-intensive` to initiate the resource-intensive operation. 
-    
-    <Figure src="/img/guides/2024/12/optimize-cloud-costs-image%207.webp" alt="Resource Intensive Endpoint" caption="Resource Intensive Endpoint" />
-    
+
+   <Figure
+     src="/img/guides/2024/12/optimize-cloud-costs-image%206.webp"
+     alt="Latency Simulation Endpoint"
+     caption="Latency Simulation Endpoint"
+   />
+
+3. Select `127.0.0.1:5000/resource-intensive` to initiate the resource-intensive operation.
+
+   <Figure
+     src="/img/guides/2024/12/optimize-cloud-costs-image%207.webp"
+     alt="Resource Intensive Endpoint"
+     caption="Resource Intensive Endpoint"
+   />
 
 ### Monitoring with SigNoz
 
 Migrate to SigNoz, choose "Traces," select your service name (`my_flask_service`), and set the recent time range to verify if traces have been successfully received from the endpoints.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%208.webp" alt="Traces dashboard in SigNoz" caption="Traces dashboard in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%208.webp"
+  alt="Traces dashboard in SigNoz"
+  caption="Traces dashboard in SigNoz"
+/>
 
 Go to the Traces tab to view the root duration for each root operation.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%209.webp" alt="SigNoz root duration for defined services" caption="SigNoz root duration for defined services" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%209.webp"
+  alt="SigNoz root duration for defined services"
+  caption="SigNoz root duration for defined services"
+/>
 
-As you can see, the root duration of both `simulate_latency` and `resource_intensive_operation` is greater than that of the `main_operation`. 
+As you can see, the root duration of both `simulate_latency` and `resource_intensive_operation` is greater than that of the `main_operation`.
 
 ### Optimizing Cloud Costs
 
@@ -688,35 +729,43 @@ def simulate_latency():
 ```
 
 1. Optimize Resource-Intensive Endpoint
-    
-    The `/resource-intensive` endpoint has a root duration of 149.51 ms, which seems acceptable, but we can further optimize it.
-    
-    - Problem: The computation in the `resource_intensive` endpoint is an inefficient loop (`sum([i2 for i in range(106)])`) that takes some time.
-    - Solution: We can optimize the code to perform the computation faster. One approach would be to use NumPy for vectorized operations, which are typically much faster for large datasets.
-    
-    ```python
-    import numpy as np
-    @app.route('/resource-intensive')
-    def resource_intensive():
-    with tracer.start_as_current_span("resource_intensive_operation") as span:
-    arr = np.arange(10**6)  # Create an array of numbers
-    result = np.sum(arr ** 2)  # Vectorized computation (much faster)
-    span.set_attribute("operation", "heavy_computation")
-    span.add_event("Completed heavy computation")
-    [logger.info](http://logger.info/)("Resource-intensive operation completed.")
-    return f"Resource-intensive operation complete! Result: {result}"
-    ```
-    
+
+   The `/resource-intensive` endpoint has a root duration of 149.51 ms, which seems acceptable, but we can further optimize it.
+
+   - Problem: The computation in the `resource_intensive` endpoint is an inefficient loop (`sum([i2 for i in range(106)])`) that takes some time.
+   - Solution: We can optimize the code to perform the computation faster. One approach would be to use NumPy for vectorized operations, which are typically much faster for large datasets.
+
+   ```python
+   import numpy as np
+   @app.route('/resource-intensive')
+   def resource_intensive():
+   with tracer.start_as_current_span("resource_intensive_operation") as span:
+   arr = np.arange(10**6)  # Create an array of numbers
+   result = np.sum(arr ** 2)  # Vectorized computation (much faster)
+   span.set_attribute("operation", "heavy_computation")
+   span.add_event("Completed heavy computation")
+   [logger.info](http://logger.info/)("Resource-intensive operation completed.")
+   return f"Resource-intensive operation complete! Result: {result}"
+   ```
 
 ### Optimized Results
 
 After implementing these changes, re-run the application and trigger the endpoints again to see how the metrics change in SigNoz. Refresh the SigNoz Metrics Dashboard to check how the latency and other metrics improve over time.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%2010.webp" alt="" caption="" /><Figure src="/img/guides/2024/12/optimize-cloud-costs-image%2011.webp" alt="Optimized duration results" caption="Optimized duration results" />
+<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%2010.webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%2011.webp"
+  alt="Optimized duration results"
+  caption="Optimized duration results"
+/>
 
 Navigate to dashboard metrics in order to see the relative comparison. This dashboard provides an overview of application performance metrics.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%2012.webp" alt="Dashboard metrics for `my_flask_service`" caption="Dashboard metrics for `my_flask_service`" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%2012.webp"
+  alt="Dashboard metrics for `my_flask_service`"
+  caption="Dashboard metrics for `my_flask_service`"
+/>
 
 ### Can we optimize more?
 
@@ -727,7 +776,11 @@ Navigate to dashboard metrics in order to see the relative comparison. This dash
 
 Managing cloud costs can often feel like an uphill battle. The very features that make the cloud appealing—like self-service access and virtually unlimited scalability—can quickly become challenges if not properly managed.
 
-<Figure src="/img/guides/2024/12/optimize-cloud-costs-image%2013.webp" alt="Challenges in Cost Controlling" caption="Challenges in Cost Controlling" />
+<Figure
+  src="/img/guides/2024/12/optimize-cloud-costs-image%2013.webp"
+  alt="Challenges in Cost Controlling"
+  caption="Challenges in Cost Controlling"
+/>
 
 - Complex Pricing Models: The intricacies of cloud pricing are a major contributor to cost management difficulties. SaaS pricing, for instance, typically depends on the number of subscriptions a company holds, requiring constant vigilance to avoid unused licenses. On the other hand, IaaS pricing often hinges on the computing, networking, and storage capacity reserved monthly, adding another layer of complexity.
 - Lack of Governance: In decentralized cloud environments, IT teams may independently acquire resources without centralized oversight. While this enables rapid decision-making, unchecked additions can inflate costs. Features like autoscaling offer some control but require well-defined policies, such as clear performance triggers and scaling limits, to prevent overspending.
@@ -758,4 +811,4 @@ While cost optimization is generally beneficial, overly aggressive measures can
 
 ### How often should cloud costs be reviewed and optimized?
 
-Cloud costs should be reviewed on an ongoing basis, with detailed analyses performed at least monthly. However, the frequency may vary depending on your organization's size, cloud usage patterns, and rate of change. Automated tools can help with continuous monitoring and optimization.
\ No newline at end of file
+Cloud costs should be reviewed on an ongoing basis, with detailed analyses performed at least monthly. However, the frequency may vary depending on your organization's size, cloud usage patterns, and rate of change. Automated tools can help with continuous monitoring and optimization.
diff --git a/data/guides/pino-logger.mdx b/data/guides/pino-logger.mdx
index e52ad2012..5abb40432 100644
--- a/data/guides/pino-logger.mdx
+++ b/data/guides/pino-logger.mdx
@@ -1,11 +1,24 @@
 ---
-title: "Pino Logger: Complete Node.js Guide with Examples [2025]"
-slug: "pino-logger"
-date: "2025-09-03"
+title: 'Pino Logger: Complete Node.js Guide with Examples [2025]'
+date: '2025-09-03'
 tags: [JavaScript, Logging]
 authors: [anubhav_omar]
-description: "Master Pino logging in Node.js. Learn installation, configuration, production setup, and advanced features with practical examples. 5x faster than alternatives."
-keywords: [pino logger, nodejs logging, structured logging, pino-pretty, pino-http, child loggers, asynchronous logging, log levels, nodejs debugging, application monitoring, json logging, high performance logging]
+description: 'Master Pino logging in Node.js. Learn installation, configuration, production setup, and advanced features with practical examples. 5x faster than alternatives.'
+keywords:
+  [
+    pino logger,
+    nodejs logging,
+    structured logging,
+    pino-pretty,
+    pino-http,
+    child loggers,
+    asynchronous logging,
+    log levels,
+    nodejs debugging,
+    application monitoring,
+    json logging,
+    high performance logging,
+  ]
 ---
 
 Your Node.js application logs are critical for debugging production issues, monitoring performance, and maintaining system health. But if your logging library becomes a bottleneck, it defeats the purpose.
@@ -13,7 +26,7 @@ Your Node.js application logs are critical for debugging production issues, moni
 Pino solves this with a fundamentally different approach to logging:
 
 - **5x faster than Winston** with minimal CPU overhead
-- **Structured JSON output** that's immediately machine-readable  
+- **Structured JSON output** that's immediately machine-readable
 - **Asynchronous by design** to prevent event loop blocking
 - **[Production-ready](https://signoz.io/guides/production-readiness-checklist/)** with built-in security and performance optimizations
 
@@ -24,6 +37,7 @@ This guide covers everything from basic setup to advanced production patterns, i
 Pino is built around a simple principle: logging should never slow down your application. Unlike traditional loggers that perform expensive formatting operations in the main thread, Pino takes a minimalist approach.
 
 **Core Design Principles:**
+
 - **JSON-first**: Every log is structured data, not formatted text
 - **Async transports**: Heavy operations happen in worker threads
 - **Minimal serialization**: Only essential data transformation
@@ -33,13 +47,14 @@ Pino is built around a simple principle: logging should never slow down your app
 
 Here's how Pino compares to popular alternatives in real-world scenarios:
 
-| Library | Logs/Second | CPU Usage | Memory Overhead |
-|---------|-------------|-----------|-----------------|
-| **Pino** | 50,000+ | 2-4% | ~45MB |
-| Winston | ~10,000 | 10-15% | ~180MB |
-| Bunyan | ~15,000 | 8-12% | ~150MB |
+| Library  | Logs/Second | CPU Usage | Memory Overhead |
+| -------- | ----------- | --------- | --------------- |
+| **Pino** | 50,000+     | 2-4%      | ~45MB           |
+| Winston  | ~10,000     | 10-15%    | ~180MB          |
+| Bunyan   | ~15,000     | 8-12%     | ~150MB          |
 
 These numbers translate to concrete benefits:
+
 - **Faster response times** under high load
 - **Lower infrastructure costs** through reduced resource usage
 - **Better application stability** with minimal logging overhead
@@ -71,13 +86,15 @@ logger.error('Database connection failed')
 ```
 
 Default output is structured JSON:
+
 ```json
 {"level":30,"time":1690747200000,"pid":12345,"hostname":"server-01","msg":"Application started"}
 {"level":50,"time":1690747201000,"pid":12345,"hostname":"server-01","msg":"Database connection failed"}
 ```
 
 Each log includes:
-- `level`: Numeric severity (30=info, 50=error)  
+
+- `level`: Numeric severity (30=info, 50=error)
 - `time`: High-precision timestamp
 - `pid`: Process ID for multi-process debugging
 - `hostname`: Server identification
@@ -97,25 +114,27 @@ function createLogger() {
 
   return pino({
     level: process.env.LOG_LEVEL || (isDevelopment ? 'debug' : 'info'),
-    
+
     // Pretty output for development
-    transport: isDevelopment ? {
-      target: 'pino-pretty',
-      options: {
-        colorize: true,
-        ignore: 'pid,hostname',
-        translateTime: 'yyyy-mm-dd HH:MM:ss'
-      }
-    } : undefined,
-    
+    transport: isDevelopment
+      ? {
+          target: 'pino-pretty',
+          options: {
+            colorize: true,
+            ignore: 'pid,hostname',
+            translateTime: 'yyyy-mm-dd HH:MM:ss',
+          },
+        }
+      : undefined,
+
     // Disable in tests unless explicitly needed
     enabled: !isTest,
-    
+
     // Add application context
     base: {
       env: process.env.NODE_ENV,
-      version: process.env.APP_VERSION
-    }
+      version: process.env.APP_VERSION,
+    },
   })
 }
 
@@ -128,14 +147,14 @@ Pino uses numeric levels that correspond to severity. Understanding when to use
 
 ### Standard Levels
 
-| Level | Numeric | Purpose | Example Use Cases |
-|-------|---------|---------|-------------------|
-| **fatal** | 60 | Application crash imminent | Database connection lost, critical service down |
-| **error** | 50 | Errors requiring investigation | API failures, validation errors, exceptions |
-| **warn** | 40 | Potential issues | Deprecated API usage, resource limits approaching |
-| **info** | 30 | Significant application events | User authentication, service starts, key operations |
-| **debug** | 20 | Detailed debugging information | Function entry/exit, variable states |
-| **trace** | 10 | Very detailed execution flow | Loop iterations, deep debugging |
+| Level     | Numeric | Purpose                        | Example Use Cases                                   |
+| --------- | ------- | ------------------------------ | --------------------------------------------------- |
+| **fatal** | 60      | Application crash imminent     | Database connection lost, critical service down     |
+| **error** | 50      | Errors requiring investigation | API failures, validation errors, exceptions         |
+| **warn**  | 40      | Potential issues               | Deprecated API usage, resource limits approaching   |
+| **info**  | 30      | Significant application events | User authentication, service starts, key operations |
+| **debug** | 20      | Detailed debugging information | Function entry/exit, variable states                |
+| **trace** | 10      | Very detailed execution flow   | Loop iterations, deep debugging                     |
 
 ### Level Configuration Strategy
 
@@ -165,18 +184,18 @@ const app = express()
 app.post('/admin/log-level', (req, res) => {
   const { level } = req.body
   const validLevels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal']
-  
+
   if (!validLevels.includes(level)) {
     return res.status(400).json({ error: 'Invalid log level' })
   }
-  
+
   logger.level = level
   logger.info({ newLevel: level }, 'Log level changed')
   res.json({ message: `Log level changed to ${level}` })
 })
 ```
 
-## Structured Logging for Observability  
+## Structured Logging for Observability
 
 Structured logging makes your logs immediately useful for monitoring, alerting, and debugging. Instead of parsing text strings, you get queryable data.
 
@@ -191,13 +210,16 @@ const logger = pino()
 logger.info(`User ${userId} completed order ${orderId} for ${amount}`)
 
 // Structured approach (better)
-logger.info({
-  userId: 'usr_123',
-  orderId: 'ord_456', 
-  amount: 99.99,
-  currency: 'USD',
-  paymentMethod: 'credit_card'
-}, 'Order completed successfully')
+logger.info(
+  {
+    userId: 'usr_123',
+    orderId: 'ord_456',
+    amount: 99.99,
+    currency: 'USD',
+    paymentMethod: 'credit_card',
+  },
+  'Order completed successfully'
+)
 ```
 
 ### Error Logging with Context
@@ -208,25 +230,31 @@ When logging errors, always include relevant context. This example shows how to
 async function processPayment(orderId, userId) {
   try {
     const result = await paymentService.charge(orderId)
-    
-    logger.info({
-      orderId,
-      userId,
-      paymentId: result.id,
-      amount: result.amount,
-      duration: result.processingTime
-    }, 'Payment processed successfully')
-    
+
+    logger.info(
+      {
+        orderId,
+        userId,
+        paymentId: result.id,
+        amount: result.amount,
+        duration: result.processingTime,
+      },
+      'Payment processed successfully'
+    )
+
     return result
   } catch (error) {
-    logger.error({
-      err: error,
-      orderId,
-      userId,
-      operation: 'payment_processing',
-      paymentProvider: 'stripe'
-    }, 'Payment processing failed')
-    
+    logger.error(
+      {
+        err: error,
+        orderId,
+        userId,
+        operation: 'payment_processing',
+        paymentProvider: 'stripe',
+      },
+      'Payment processing failed'
+    )
+
     throw error
   }
 }
@@ -239,37 +267,43 @@ You can use structured logs to monitor application performance. This function me
 ```javascript
 async function performDatabaseQuery(query) {
   const startTime = process.hrtime.bigint()
-  
+
   try {
     const result = await db.query(query)
     const duration = Number(process.hrtime.bigint() - startTime) / 1000000 // Convert to ms
-    
-    logger.info({
-      operation: 'database_query',
-      table: query.table,
-      duration: Math.round(duration * 100) / 100,
-      recordCount: result.length,
-      performanceCategory: categorizePerformance(duration)
-    }, 'Database query completed')
-    
+
+    logger.info(
+      {
+        operation: 'database_query',
+        table: query.table,
+        duration: Math.round(duration * 100) / 100,
+        recordCount: result.length,
+        performanceCategory: categorizePerformance(duration),
+      },
+      'Database query completed'
+    )
+
     return result
   } catch (error) {
     const duration = Number(process.hrtime.bigint() - startTime) / 1000000
-    
-    logger.error({
-      err: error,
-      operation: 'database_query',
-      table: query.table,
-      duration: Math.round(duration * 100) / 100
-    }, 'Database query failed')
-    
+
+    logger.error(
+      {
+        err: error,
+        operation: 'database_query',
+        table: query.table,
+        duration: Math.round(duration * 100) / 100,
+      },
+      'Database query failed'
+    )
+
     throw error
   }
 }
 
 function categorizePerformance(ms) {
   if (ms < 100) return 'fast'
-  if (ms < 500) return 'normal'  
+  if (ms < 500) return 'normal'
   if (ms < 1000) return 'slow'
   return 'critical'
 }
@@ -293,15 +327,15 @@ const app = express()
 // Create request-scoped logger middleware
 app.use((req, res, next) => {
   const requestId = req.headers['x-request-id'] || uuidv4()
-  
+
   req.log = logger.child({
     requestId,
     method: req.method,
     path: req.path,
     userAgent: req.headers['user-agent'],
-    ip: req.ip
+    ip: req.ip,
   })
-  
+
   req.log.info('Request started')
   next()
 })
@@ -309,9 +343,9 @@ app.use((req, res, next) => {
 // Route handlers automatically have contextual logging
 app.get('/users/:id', async (req, res) => {
   const { id } = req.params
-  
+
   req.log.debug({ userId: id }, 'Fetching user data')
-  
+
   try {
     const user = await getUserById(id)
     req.log.info({ userId: id, fetchDuration: 45 }, 'User retrieved')
@@ -336,20 +370,20 @@ module.exports = {
   auth: baseLogger.child({ service: 'auth' }),
   database: baseLogger.child({ service: 'database' }),
   payment: baseLogger.child({ service: 'payment' }),
-  notification: baseLogger.child({ service: 'notification' })
+  notification: baseLogger.child({ service: 'notification' }),
 }
 ```
 
 Now, your authentication service can use its dedicated logger:
 
-```javascript  
+```javascript
 // auth-service.js
 const { auth: logger } = require('./logger')
 
 class AuthService {
   async authenticateUser(email, password) {
     logger.info({ email }, 'Authentication attempt')
-    
+
     try {
       const user = await this.validateCredentials(email, password)
       logger.info({ userId: user.id, email }, 'Authentication successful')
@@ -381,20 +415,20 @@ const logger = pino({
       email: user.email ? maskEmail(user.email) : undefined,
       role: user.role,
       // Never log password, apiKey, tokens, etc.
-      lastLogin: user.lastLogin
+      lastLogin: user.lastLogin,
     }),
-    
+
     request: (req) => {
       const safe = { ...req }
       if (safe.headers) {
         // Remove sensitive headers
         delete safe.headers.authorization
-        delete safe.headers['x-api-key'] 
+        delete safe.headers['x-api-key']
         delete safe.headers.cookie
       }
       return safe
     },
-    
+
     error: (err) => {
       const safeError = { ...err }
       // Sanitize error messages that might contain sensitive data
@@ -404,8 +438,8 @@ const logger = pino({
           .replace(/token=[\w-]+/gi, 'token=***')
       }
       return safeError
-    }
-  }
+    },
+  },
 })
 
 function maskEmail(email) {
@@ -423,28 +457,31 @@ const logger = pino({
   redact: {
     paths: [
       'password',
-      'token', 
+      'token',
       'apiKey',
       'creditCard.number',
       'ssn',
       '*.password',
       '*.token',
       'req.headers.authorization',
-      'req.headers.cookie'
+      'req.headers.cookie',
     ],
-    remove: true // Completely remove these fields
-  }
+    remove: true, // Completely remove these fields
+  },
 })
 
 // This will automatically remove sensitive fields
-logger.info({
-  user: {
-    id: 123,
-    email: 'user@example.com',
-    password: 'secret123', // This won't appear in logs
-    apiKey: 'sk_live_abc123' // This won't appear either
-  }
-}, 'User data processed')
+logger.info(
+  {
+    user: {
+      id: 123,
+      email: 'user@example.com',
+      password: 'secret123', // This won't appear in logs
+      apiKey: 'sk_live_abc123', // This won't appear either
+    },
+  },
+  'User data processed'
+)
 ```
 
 ## HTTP Request Logging
@@ -468,32 +505,34 @@ const logger = require('./logger')
 
 const app = express()
 
-app.use(pinoHttp({
-  logger,
-  
-  // Custom log levels based on response status
-  customLogLevel: (req, res, err) => {
-    if (res.statusCode >= 400 && res.statusCode < 500) return 'warn'
-    if (res.statusCode >= 500 || err) return 'error'
-    if (res.statusCode >= 300 && res.statusCode < 400) return 'silent'
-    return 'info'
-  },
-  
-  // Custom success message with timing
-  customSuccessMessage: (req, res) => {
-    return `${req.method} ${req.url} completed in ${res.responseTime}ms`
-  }
-}))
+app.use(
+  pinoHttp({
+    logger,
+
+    // Custom log levels based on response status
+    customLogLevel: (req, res, err) => {
+      if (res.statusCode >= 400 && res.statusCode < 500) return 'warn'
+      if (res.statusCode >= 500 || err) return 'error'
+      if (res.statusCode >= 300 && res.statusCode < 400) return 'silent'
+      return 'info'
+    },
+
+    // Custom success message with timing
+    customSuccessMessage: (req, res) => {
+      return `${req.method} ${req.url} completed in ${res.responseTime}ms`
+    },
+  })
+)
 
 app.get('/api/users/:id', async (req, res) => {
   // req.log is automatically available with request context
   req.log.info({ userId: req.params.id }, 'Processing user request')
-  
+
   try {
     const user = await getUserById(req.params.id)
     res.json(user)
   } catch (error) {
-    req.log.error({ err: error }, 'User retrieval failed') 
+    req.log.error({ err: error }, 'User retrieval failed')
     res.status(500).json({ error: 'Internal server error' })
   }
 })
@@ -508,27 +547,29 @@ const pinoHttp = require('pino-http')
 
 const httpLogger = pinoHttp({
   logger: pino({ level: 'info' }),
-  
+
   // Skip logging for health checks and static assets
   autoLogging: {
     ignore: (req) => {
-      return req.url === '/health' || 
-             req.url.startsWith('/static/') ||
-             req.url.match(/\.(css|js|png|jpg|ico)$/)
-    }
+      return (
+        req.url === '/health' ||
+        req.url.startsWith('/static/') ||
+        req.url.match(/\.(css|js|png|jpg|ico)$/)
+      )
+    },
   },
-  
+
   // Minimal serialization for performance
   serializers: {
     req: (req) => ({
       method: req.method,
       url: req.url,
-      id: req.id
+      id: req.id,
     }),
     res: (res) => ({
-      statusCode: res.statusCode
-    })
-  }
+      statusCode: res.statusCode,
+    }),
+  },
 })
 
 app.use(httpLogger)
@@ -551,7 +592,7 @@ This function demonstrates a robust, environment-aware logger configuration. It
 function createProductionLogger() {
   const isDevelopment = process.env.NODE_ENV === 'development'
   const isProduction = process.env.NODE_ENV === 'production'
-  
+
   const config = {
     level: process.env.LOG_LEVEL || (isDevelopment ? 'debug' : 'info'),
     formatters: {
@@ -560,24 +601,24 @@ function createProductionLogger() {
         pid: bindings.pid,
         hostname: bindings.hostname,
         env: process.env.NODE_ENV,
-        version: process.env.APP_VERSION
-      })
-    }
+        version: process.env.APP_VERSION,
+      }),
+    },
   }
-  
+
   if (isDevelopment) {
     config.transport = {
       target: 'pino-pretty',
-      options: { colorize: true, translateTime: 'yyyy-mm-dd HH:MM:ss' }
+      options: { colorize: true, translateTime: 'yyyy-mm-dd HH:MM:ss' },
     }
   } else if (isProduction) {
     // Production optimizations
     config.redact = {
       paths: ['password', 'token', 'apiKey', '*.password', '*.token'],
-      remove: true
+      remove: true,
     }
   }
-  
+
   return pino(config)
 }
 
@@ -597,13 +638,16 @@ const dest = new SonicBoom({
   dest: '/var/log/app/application.log',
   sync: false, // Async writes
   append: true,
-  mkdir: true
+  mkdir: true,
 })
 
-const logger = pino({
-  level: 'info',
-  timestamp: pino.stdTimeFunctions.epochTime, // Faster timestamps
-}, dest)
+const logger = pino(
+  {
+    level: 'info',
+    timestamp: pino.stdTimeFunctions.epochTime, // Faster timestamps
+  },
+  dest
+)
 
 // Graceful shutdown handling
 process.on('SIGTERM', () => {
@@ -627,7 +671,7 @@ process.on('uncaughtException', (error) => {
   process.exit(1)
 })
 
-// Handle unhandled promise rejections  
+// Handle unhandled promise rejections
 process.on('unhandledRejection', (reason, promise) => {
   const finalLogger = pino.final(logger)
   finalLogger.fatal({ reason }, 'Unhandled promise rejection')
@@ -681,19 +725,23 @@ const logger = pino({
           resourceAttributes: {
             'service.name': 'nodejs-api',
             'service.version': process.env.APP_VERSION || '1.0.0',
-            'deployment.environment': process.env.NODE_ENV || 'development'
-          }
+            'deployment.environment': process.env.NODE_ENV || 'development',
+          },
         },
-        level: 'info'
+        level: 'info',
       },
       // Keep console output for development
-      ...(process.env.NODE_ENV === 'development' ? [{
-        target: 'pino-pretty',
-        level: 'debug',
-        options: { colorize: true }
-      }] : [])
-    ]
-  }
+      ...(process.env.NODE_ENV === 'development'
+        ? [
+            {
+              target: 'pino-pretty',
+              level: 'debug',
+              options: { colorize: true },
+            },
+          ]
+        : []),
+    ],
+  },
 })
 
 module.exports = logger
@@ -736,47 +784,56 @@ app.use(pinoHttp({ logger }))
 app.get('/api/users/:id', async (req, res) => {
   const { id } = req.params
   const startTime = Date.now()
-  
+
   req.log.info({ userId: id }, 'Fetching user data')
-  
+
   try {
     const user = await getUserById(id)
     const duration = Date.now() - startTime
-    
-    req.log.info({ 
-      userId: id,
-      userEmail: user.email,
-      fetchDuration: duration,
-      cacheHit: user.fromCache
-    }, 'User data retrieved')
-    
+
+    req.log.info(
+      {
+        userId: id,
+        userEmail: user.email,
+        fetchDuration: duration,
+        cacheHit: user.fromCache,
+      },
+      'User data retrieved'
+    )
+
     res.json(user)
   } catch (error) {
     const duration = Date.now() - startTime
-    
-    req.log.error({ 
-      err: error,
-      userId: id,
-      duration,
-      operation: 'user_fetch'
-    }, 'Failed to retrieve user data')
-    
+
+    req.log.error(
+      {
+        err: error,
+        userId: id,
+        duration,
+        operation: 'user_fetch',
+      },
+      'Failed to retrieve user data'
+    )
+
     res.status(500).json({ error: 'Internal server error' })
   }
 })
 
 app.listen(3000, () => {
-  logger.info({
-    port: 3000,
-    env: process.env.NODE_ENV,
-    version: process.env.APP_VERSION
-  }, 'Server started successfully')
+  logger.info(
+    {
+      port: 3000,
+      env: process.env.NODE_ENV,
+      version: process.env.APP_VERSION,
+    },
+    'Server started successfully'
+  )
 })
 ```
 
 ### Get Started with SigNoz
 
-You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features. 
+You can choose between various deployment options in SigNoz. The easiest way to get started with SigNoz is [SigNoz cloud](https://signoz.io/teams/). We offer a 30-day free trial account with access to all features.
 
 Those who have data privacy concerns and can't send their data outside their infrastructure can sign up for either [enterprise self-hosted or BYOC offering](https://signoz.io/contact-us/).
 
@@ -806,7 +863,7 @@ if (!fs.existsSync(logDir)) {
 const dest = pino.destination({
   dest: './logs/app.log',
   sync: false,
-  mkdir: true
+  mkdir: true,
 })
 
 // Handle destination errors
@@ -831,7 +888,7 @@ const dest = new SonicBoom({
   dest: './app.log',
   sync: false,
   minLength: 4096, // Buffer before writing
-  maxWrite: 16384  // Maximum write size
+  maxWrite: 16384, // Maximum write size
 })
 
 // Monitor backpressure
@@ -858,9 +915,10 @@ process.on('SIGTERM', async () => {
 function createSafeLogger() {
   try {
     return pino({
-      transport: process.env.NODE_ENV === 'development' 
-        ? { target: 'pino-pretty', options: { colorize: true } }
-        : { target: 'pino/file', options: { destination: './logs/app.log' } }
+      transport:
+        process.env.NODE_ENV === 'development'
+          ? { target: 'pino-pretty', options: { colorize: true } }
+          : { target: 'pino/file', options: { destination: './logs/app.log' } },
     })
   } catch (error) {
     console.error('Logger creation failed, falling back to console:', error)
@@ -883,8 +941,8 @@ const logger = winston.createLogger({
   format: winston.format.json(),
   transports: [
     new winston.transports.File({ filename: 'error.log', level: 'error' }),
-    new winston.transports.File({ filename: 'combined.log' })
-  ]
+    new winston.transports.File({ filename: 'combined.log' }),
+  ],
 })
 
 // Pino equivalent
@@ -894,16 +952,16 @@ const logger = pino({
   transport: {
     targets: [
       { target: 'pino/file', options: { destination: './combined.log' }, level: 'info' },
-      { target: 'pino/file', options: { destination: './error.log' }, level: 'error' }
-    ]
-  }
+      { target: 'pino/file', options: { destination: './error.log' }, level: 'error' },
+    ],
+  },
 })
 ```
 
 ### Migration Strategy
 
 1. **Replace logger creation** with Pino initialization
-2. **Convert string interpolation** to [structured logging](https://signoz.io/blog/structured-logs/)  
+2. **Convert string interpolation** to [structured logging](https://signoz.io/blog/structured-logs/)
 3. **Update [error logging](https://signoz.io/guides/error-log/)** to use Pino's error serializers
 4. **Test performance impact** and adjust configuration
 5. **Update monitoring configurations** to handle new log format
@@ -913,17 +971,20 @@ const logger = pino({
 Pino represents a fundamental shift in Node.js logging philosophy, prioritizing performance without sacrificing the structured data needed for modern observability.
 
 **Performance Benefits:**
+
 - 5x faster than traditional loggers with minimal CPU overhead
 - Asynchronous architecture prevents event loop blocking
 - Memory-efficient design maintains stability under load
 
 **Production Readiness:**
+
 - Structured JSON output enables powerful querying and analysis
 - Child loggers provide excellent context management
 - Built-in security features protect sensitive data
 
 **Modern Integration:**
-- Native OpenTelemetry support enables trace correlation  
+
+- Native OpenTelemetry support enables trace correlation
 - Seamless integration with observability platforms like SigNoz
 - Extensive ecosystem of transports and plugins
 
diff --git a/data/guides/pq-could-not-resize-shared-memory-segment-no-space-left-on-device.mdx b/data/guides/pq-could-not-resize-shared-memory-segment-no-space-left-on-device.mdx
index ac7c7a150..bf5ca8daf 100644
--- a/data/guides/pq-could-not-resize-shared-memory-segment-no-space-left-on-device.mdx
+++ b/data/guides/pq-could-not-resize-shared-memory-segment-no-space-left-on-device.mdx
@@ -1,22 +1,32 @@
 ---
-
 title: How to Fix “PQ Could Not Resize Shared Memory" Error
-slug: pq-could-not-resize-shared-memory-segment-no-space-left-on-device
 date: 2024-09-18
 tags: [faq]
 authors: [simran_kumari]
 description: Learn how to fix the "PQ - Could Not Resize Shared Memory" error in PostgreSQL. Discover quick fixes and long-term solutions for optimal database performance.
-keywords: [PostgreSQL error, shared memory, Docker, database performance, PQ error, memory management, PostgreSQL configuration]
-
+keywords:
+  [
+    PostgreSQL error,
+    shared memory,
+    Docker,
+    database performance,
+    PQ error,
+    memory management,
+    PostgreSQL configuration,
+  ]
 ---
 
-If you’re running PostgreSQL in Docker, you’ve probably come across the dreaded "PQ: Could Not Resize Shared Memory" error. It can stop your database in its tracks and mess with your app’s performance. Understanding why this happens and how to fix it is key to keeping your PostgreSQL setup running smoothly.  This guide provides comprehensive strategies to resolve this error, from quick fixes to long-term optimizations.
+If you’re running PostgreSQL in Docker, you’ve probably come across the dreaded "PQ: Could Not Resize Shared Memory" error. It can stop your database in its tracks and mess with your app’s performance. Understanding why this happens and how to fix it is key to keeping your PostgreSQL setup running smoothly. This guide provides comprehensive strategies to resolve this error, from quick fixes to long-term optimizations.
 
 ## What Causes the "PQ: Could Not Resize Shared Memory" Error?
 
 PostgreSQL uses shared memory to let its processes access common data. When PostgreSQL can’t resize the shared memory segment, you get hit with the error: "pq: could not resize shared memory segment. No space left on the device." It can severely impact database operations, preventing new connections and potentially causing inconsistencies. Don’t be fooled by the “No space left on device” part—this usually refers to memory, not disk space.
 
-<Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image.webp" alt="How to fix 'PQ Could Not Resize Shared Memory' Error" caption="How to fix 'PQ: Could Not Resize Shared Memory' Error" />
+<Figure
+  src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image.webp"
+  alt="How to fix 'PQ Could Not Resize Shared Memory' Error"
+  caption="How to fix 'PQ: Could Not Resize Shared Memory' Error"
+/>
 
 ### Common Causes of Shared Memory Resizing Issues
 
@@ -32,21 +42,28 @@ Here are some common reasons why you might encounter shared memory resizing issu
 For Docker users, a quick solution involves increasing the shared memory allocation for the PostgreSQL container. Here's how:
 
 1. Stop your PostgreSQL container:
-    
-    ```
-    docker stop <container_name>
-    ```
-    
-    <Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%201.webp" alt="Stopping PostgreSQL container" caption="Stopping PostgreSQL container" />
-    
+
+   ```
+   docker stop <container_name>
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%201.webp"
+     alt="Stopping PostgreSQL container"
+     caption="Stopping PostgreSQL container"
+   />
+
 2. Restart the container with increased shared memory:
-    
-    ```
-    docker run --shm-size="1g" --name <container_name> -e POSTGRES_PASSWORD="<password>" <your_postgres_image>
-    ```
-    
-    <Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%202.webp" alt="Restarting PostgreSQL container with increased shared memory" caption="Restarting PostgreSQL container with increased shared memory" />
-    
+
+   ```
+   docker run --shm-size="1g" --name <container_name> -e POSTGRES_PASSWORD="<password>" <your_postgres_image>
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%202.webp"
+     alt="Restarting PostgreSQL container with increased shared memory"
+     caption="Restarting PostgreSQL container with increased shared memory"
+   />
 
 This command allocates 1GB of shared memory to the container. Adjust the value based on your specific needs and system resources.
 
@@ -64,50 +81,40 @@ While the quick fix gets your container back on its feet, you’ll want to addre
 Tweaking PostgreSQL’s memory-related settings can help you avoid running into shared memory limits:
 
 - shared_buffers: This parameter defines how much memory PostgreSQL uses for caching data. Aim to set it to about 25% of your system’s total RAM.
-    
-    ```bash
-    shared_buffers = 1GB
-    ```
-    
+  ```bash
+  shared_buffers = 1GB
+  ```
 - work_mem: This controls how much memory is used for operations like sorting. Start with 4MB and adjust based on your system’s load.
-    
-    ```bash
-    work_mem = 4MB
-    ```
-    
+  ```bash
+  work_mem = 4MB
+  ```
 - maintenance_work_mem: This setting is for maintenance tasks like `VACUUM` and `CREATE INDEX`.
-    
-    ```bash
-    maintenance_work_mem = 64MB
-    ```
-    
+  ```bash
+  maintenance_work_mem = 64MB
+  ```
 
-Make sure to test each change carefully to find the sweet spot for your configuration. 
+Make sure to test each change carefully to find the sweet spot for your configuration.
 
-Note: These configurations can be updated by making use of the PostgreSQL configuration file which needs to be used for starting the container. 
+Note: These configurations can be updated by making use of the PostgreSQL configuration file which needs to be used for starting the container.
 
 ### 2. Manage Resources in Containers
 
 If you’re using Docker or Kubernetes, properly allocating memory to your containers is key.
 
 - In Docker Compose, you can add memory limits like this:
-    
-    ```yaml
-    services:
-      postgres:
-        shm_size: '1gb'
-    ```
-    
+  ```yaml
+  services:
+    postgres:
+      shm_size: '1gb'
+  ```
 - In Kubernetes, you’ll want to set resource requests and limits for your pods:
-    
-    ```yaml
-    resources:
-      requests:
-        memory: "1Gi"
-      limits:
-        memory: "2Gi"
-    ```
-    
+  ```yaml
+  resources:
+    requests:
+      memory: '1Gi'
+    limits:
+      memory: '2Gi'
+  ```
 
 ### 3. Monitor Your Memory Usage
 
@@ -118,30 +125,25 @@ You can avoid running into shared memory errors by keeping an eye on PostgreSQL
 Shared memory problems can manifest differently across various deployment environments:
 
 1. Bare-metal installations:
-    - Check system-wide shared memory limits:
-        
-        ```
-        sysctl -a | grep kernel.shm
-        
-        ```
-        
-    - Adjust limits in `/etc/sysctl.conf` if necessary.
+   - Check system-wide shared memory limits:
+     ```
+     sysctl -a | grep kernel.shm
+
+     ```
+   - Adjust limits in `/etc/sysctl.conf` if necessary.
 2. Virtual machines:
-    - Ensure the VM is allocated sufficient memory.
-    - Check hypervisor settings for any memory limitations.
+   - Ensure the VM is allocated sufficient memory.
+   - Check hypervisor settings for any memory limitations.
 3. Kubernetes:
-    - Use resource requests and limits in pod specifications:
-        
-        ```yaml
-        resources:
-          requests:
-            memory: "1Gi"
-          limits:
-            memory: "2Gi"
-        
-        ```
-        
-    - Consider using a StorageClass that supports volume expansion for persistent volumes.
+   - Use resource requests and limits in pod specifications:
+     ```yaml
+     resources:
+       requests:
+         memory: '1Gi'
+       limits:
+         memory: '2Gi'
+     ```
+   - Consider using a StorageClass that supports volume expansion for persistent volumes.
 
 <aside>
 💡
@@ -151,23 +153,22 @@ PostgreSQL Memory Settings
 Given you need to configure various memory-related settings in PostgreSQL, it will be helpful to understand various memory types and their use.
 
 - Shared Buffers
-    - Role: Shared memory area used for caching data and index pages. It helps reduce the need to access a disk for frequently accessed data.
-    - Default Value: Typically around 128MB, but varies by installation.
+  - Role: Shared memory area used for caching data and index pages. It helps reduce the need to access a disk for frequently accessed data.
+  - Default Value: Typically around 128MB, but varies by installation.
 - Work Memory
-    - Role: Memory used for internal operations such as sorting and hash tables. Each query operation gets its work memory.
-    - Default Value: Usually set to 4MB.
+  - Role: Memory used for internal operations such as sorting and hash tables. Each query operation gets its work memory.
+  - Default Value: Usually set to 4MB.
 - Maintenance Work Memory
-    - Role: Memory used for maintenance operations like `VACUUM`, `CREATE INDEX`, and `ALTER TABLE`. This memory is used during operations that need more memory for temporary data.
-    - Default Value: Typically set to 64MB
+  - Role: Memory used for maintenance operations like `VACUUM`, `CREATE INDEX`, and `ALTER TABLE`. This memory is used during operations that need more memory for temporary data.
+  - Default Value: Typically set to 64MB
 - Temp Buffers
-    - Role: Memory used for temporary data that is not permanent, such as temporary tables and complex query operations.
-    - Default Value: Usually set to 8MB.
+  - Role: Memory used for temporary data that is not permanent, such as temporary tables and complex query operations.
+  - Default Value: Usually set to 8MB.
 - Effective Cache Size
-    - Role: A rough estimate of how much memory is available for disk caching by the operating system and PostgreSQL. It helps the query planner estimate how much memory is available for caching data.
-    - Default Value: Often set to 4GB or more, depending on the system's RAM.
-- Shared Memory (Docker-specific)
-    - Role: Controls the amount of memory allocated for inter-process communication (IPC) within Docker containers. Not directly a PostgreSQL setting, but affects how PostgreSQL and other processes within the container handle shared memory.
-</aside>
+  - Role: A rough estimate of how much memory is available for disk caching by the operating system and PostgreSQL. It helps the query planner estimate how much memory is available for caching data.
+  - Default Value: Often set to 4GB or more, depending on the system's RAM.
+- Shared Memory (Docker-specific) - Role: Controls the amount of memory allocated for inter-process communication (IPC) within Docker containers. Not directly a PostgreSQL setting, but affects how PostgreSQL and other processes within the container handle shared memory.
+  </aside>
 
 ## Best Practices to Prevent Shared Memory Errors
 
@@ -176,42 +177,32 @@ Shared memory errors in PostgreSQL can severely impact performance and stability
 ### 1. Configure Shared Memory Appropriately
 
 - Adjust `shared_buffers`: This setting controls the amount of memory PostgreSQL uses for caching data. Ensure it's set to a value that balances performance and available system memory. For most systems, a common recommendation is to allocate 25% of the total system RAM.
-    
-    ```sql
-    ALTER SYSTEM SET shared_buffers = '1GB'; -- Adjust based on your system
-    ```
-    
+  ```sql
+  ALTER SYSTEM SET shared_buffers = '1GB'; -- Adjust based on your system
+  ```
 
 ### 2. Monitor Shared Memory Usage
 
 - Regular Monitoring: Use tools like `pg_stat_activity` and `pg_stat_database` to monitor memory usage. Track the amount of memory used and check for potential issues.
-    
-    ```sql
-    SELECT * FROM pg_stat_activity;
-    SELECT * FROM pg_stat_database;
-    ```
-    
+  ```sql
+  SELECT * FROM pg_stat_activity;
+  SELECT * FROM pg_stat_database;
+  ```
 - Check for Errors: Review PostgreSQL logs for any warnings or errors related to shared memory. Configure your logging to capture detailed information.
-    
-    ```sql
-    SET log_min_messages = 'WARNING'; -- Adjust the logging level as needed
-    ```
-    
+  ```sql
+  SET log_min_messages = 'WARNING'; -- Adjust the logging level as needed
+  ```
 
 ### 3. Optimize PostgreSQL Configuration
 
 - Tune `work_mem`: This setting controls the amount of memory allocated for operations like sorting and hashing. Set it appropriately to avoid excessive memory consumption during complex queries.
-    
-    ```sql
-    ALTER SYSTEM SET work_mem = '4MB'; -- Adjust based on query needs
-    ```
-    
+  ```sql
+  ALTER SYSTEM SET work_mem = '4MB'; -- Adjust based on query needs
+  ```
 - Adjust `maintenance_work_mem`: This setting determines the amount of memory used for maintenance tasks like vacuuming and indexing. Ensure it’s sufficient to avoid long-running maintenance operations.
-    
-    ```sql
-    ALTER SYSTEM SET maintenance_work_mem = '64MB'; -- Adjust based on workload
-    ```
-    
+  ```sql
+  ALTER SYSTEM SET maintenance_work_mem = '64MB'; -- Adjust based on workload
+  ```
 
 ### 4. Proper Resource Allocation
 
@@ -221,11 +212,9 @@ Shared memory errors in PostgreSQL can severely impact performance and stability
 ### 5. Perform Routine Maintenance
 
 - Regular Vacuuming: Perform regular vacuum operations to prevent bloat and manage memory efficiently.
-    
-    ```sql
-    VACUUM ANALYZE;
-    ```
-    
+  ```sql
+  VACUUM ANALYZE;
+  ```
 - Index Management: Regularly review and optimize indexes to improve query performance and memory usage.
 
 ### 6. Plan for Scaling
@@ -251,17 +240,26 @@ While optimizing memory settings and following best practices help in preventing
 SigNoz integrates with PostgreSQL to provide:
 
 - Real-Time Metrics: Visualize memory usage, query performance, and other critical metrics in real-time dashboards.
-    
-    <Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%203.webp" alt="Real time Monitoring Dashboards in SigNoz" caption="Real time Monitoring Dashboards in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%203.webp"
+    alt="Real time Monitoring Dashboards in SigNoz"
+    caption="Real time Monitoring Dashboards in SigNoz"
+  />
 - Detailed Logs: Access detailed logs to analyze and troubleshoot issues effectively.
-    
-    <Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%204.webp" alt="Analyzing logs in SigNoz" caption="Analyzing logs in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%204.webp"
+    alt="Analyzing logs in SigNoz"
+    caption="Analyzing logs in SigNoz"
+  />
 - Custom Alerts: Set up alerts for specific conditions, such as high memory usage or slow queries, to stay informed about potential issues.
-    
-    <Figure src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%205.webp" alt="Setting up Custom Alerts and Notifications in SigNoz" caption="Setting up Custom Alerts and Notifications in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/pq-could-not-resize-shared-memory-segment-no-space-left-on-device-image%205.webp"
+    alt="Setting up Custom Alerts and Notifications in SigNoz"
+    caption="Setting up Custom Alerts and Notifications in SigNoz"
+  />
 
 <GetStartedSigNoz />
 
@@ -288,7 +286,7 @@ SELECT * FROM pg_shmem_allocations;
 
 This query shows all shared memory allocations and their sizes.
 
-In PostgreSQL version 12 and earlier, the `pg_shmem_allocations` system catalog doesn't exist, as it was introduced in PostgreSQL 13 to provide insight into shared memory allocations. So there is no direct way to fetch the details. Instead you can make use of  the command 
+In PostgreSQL version 12 and earlier, the `pg_shmem_allocations` system catalog doesn't exist, as it was introduced in PostgreSQL 13 to provide insight into shared memory allocations. So there is no direct way to fetch the details. Instead you can make use of the command
 
 ```java
 SELECT buffers_checkpoint, buffers_clean, buffers_backend, buffers_alloc
@@ -314,4 +312,4 @@ Yes, insufficient shared memory can impact performance without triggering explic
 - Increased disk I/O
 - Higher CPU usage
 
-Regular monitoring of PostgreSQL performance metrics can help identify these issues before they become critical.
\ No newline at end of file
+Regular monitoring of PostgreSQL performance metrics can help identify these issues before they become critical.
diff --git a/data/guides/proactive-monitoring.mdx b/data/guides/proactive-monitoring.mdx
index 682e1b6db..cd3ec670c 100644
--- a/data/guides/proactive-monitoring.mdx
+++ b/data/guides/proactive-monitoring.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Proactive Monitoring - Prevent Issues Before They Happen
-slug: proactive-monitoring
 date: 2024-11-29
 tags: [monitoring]
 authors: [nilesh_sinha]
 description: Discover how proactive monitoring prevents IT issues, improves system reliability, and boosts business performance. Learn implementation strategies and best practices.
-keywords: [proactive monitoring, IT management, system reliability, preventive maintenance, AIOps, performance optimization, SigNoz, DevOps]
-
+keywords:
+  [
+    proactive monitoring,
+    IT management,
+    system reliability,
+    preventive maintenance,
+    AIOps,
+    performance optimization,
+    SigNoz,
+    DevOps,
+  ]
 ---
 
 In today's fast-paced digital landscape, system failures and performance issues can spell disaster for businesses. You can't afford to wait for problems to occur before taking action. This is where proactive monitoring comes into play. It's a game-changing approach that allows you to anticipate and prevent issues before they impact your operations. But what exactly is proactive monitoring, and how can you implement it effectively?
@@ -20,16 +27,16 @@ Proactive vs. Reactive Monitoring
 
 Proactive and reactive monitoring are two distinct strategies for managing IT systems. Let’s look at the major differences between the two.
 
-| Aspect | Proactive Monitoring | Reactive Monitoring |
-| --- | --- | --- |
-| Approach | Preventive and anticipatory | Reactive and responsive |
-| Data Analysis | Involves real-time data collection, historical trend analysis, and predictive modeling | Limited to real-time data analysis only |
-| Response Time | Immediate response through automation or alerting before issues escalate | Response only after an incident occurs, leading to potential downtime |
-| Technology Used | Advanced analytics, AI, and machine learning | Basic monitoring tools |
-| Impact on Downtime | Significantly reduces downtime by preventing issues | Higher downtime risk due to delayed responses |
-| User Experience | Maintains high user satisfaction by ensuring continuous service performance | User experience is affected during incidents or outages |
-| IT Team Focus | Frees up resources for innovation by minimizing manual issue handling | IT teams are often occupied with firefighting, reducing time for strategic work |
-| Cost Implications | Cost-effective in the long term by preventing major disruptions and optimizing resource allocation | May incur higher costs due to emergency responses, downtime, and possible revenue loss |
+| Aspect             | Proactive Monitoring                                                                               | Reactive Monitoring                                                                    |
+| ------------------ | -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| Approach           | Preventive and anticipatory                                                                        | Reactive and responsive                                                                |
+| Data Analysis      | Involves real-time data collection, historical trend analysis, and predictive modeling             | Limited to real-time data analysis only                                                |
+| Response Time      | Immediate response through automation or alerting before issues escalate                           | Response only after an incident occurs, leading to potential downtime                  |
+| Technology Used    | Advanced analytics, AI, and machine learning                                                       | Basic monitoring tools                                                                 |
+| Impact on Downtime | Significantly reduces downtime by preventing issues                                                | Higher downtime risk due to delayed responses                                          |
+| User Experience    | Maintains high user satisfaction by ensuring continuous service performance                        | User experience is affected during incidents or outages                                |
+| IT Team Focus      | Frees up resources for innovation by minimizing manual issue handling                              | IT teams are often occupied with firefighting, reducing time for strategic work        |
+| Cost Implications  | Cost-effective in the long term by preventing major disruptions and optimizing resource allocation | May incur higher costs due to emergency responses, downtime, and possible revenue loss |
 
 While proactive monitoring aims to prevent issues from arising, reactive monitoring involves responding to problems after they have occurred. In a reactive approach, IT teams act when an alert signals an issue, working quickly to diagnose and resolve it. This can result in service disruptions and customer dissatisfaction.
 
@@ -61,8 +68,16 @@ Overall, proactive monitoring is a vital part of modern IT system management, en
 
 In the rapidly advancing IT landscape, monitoring practices have undergone a significant transformation, evolving from reactive approaches to proactive strategies. This shift has been driven by the need for enhanced reliability, efficiency, and customer satisfaction in modern systems.
 
-<Figure src="/img/guides/2024/11/proactive-monitoring-CleanShot_2024-11-29_at_15.55.082x.webp" alt="" caption="" />Historical context of IT monitoring practices:
-In the early days of IT monitoring, practices were predominantly reactive. System administrators would respond to alerts and incidents as they arose, often racing against time to identify root causes and restore functionality. While this approach ensured that problems were addressed, it had significant limitations: unplanned downtimes, stressed operations teams, and customer dissatisfaction were common consequences of unexpected failures.
+<Figure
+  src="/img/guides/2024/11/proactive-monitoring-CleanShot_2024-11-29_at_15.55.082x.webp"
+  alt=""
+  caption=""
+/>
+Historical context of IT monitoring practices: In the early days of IT monitoring, practices were
+predominantly reactive. System administrators would respond to alerts and incidents as they arose,
+often racing against time to identify root causes and restore functionality. While this approach
+ensured that problems were addressed, it had significant limitations: unplanned downtimes, stressed
+operations teams, and customer dissatisfaction were common consequences of unexpected failures.
 
 Technological advancements and shift in mindset from firefighting to prevention:
 Technological advancements have gradually enabled a shift from reactive to proactive monitoring. Modern observability platforms, enhanced with machine learning and real-time analytics, empower organizations to anticipate potential issues before they disrupt operations. Proactive monitoring encompasses the continuous analysis of performance metrics, historical data trends, and anomaly detection to preempt failures. This shift reflects a broader change in IT strategy—moving from a “firefighting” mode to a preventive and resilience-focused mindset.
@@ -135,7 +150,7 @@ Once these baselines are established, deviations like a sudden drop in web traff
 
 ### Setting Up Comprehensive Monitoring Across All Systems
 
-Proactive monitoring must cover all layers of the IT environment to provide a unified view. Here are some examples: 
+Proactive monitoring must cover all layers of the IT environment to provide a unified view. Here are some examples:
 
 - A logistics company might monitor server CPU usage, API response times, and delivery app performance. A slowdown in API response times could indicate a database bottleneck, allowing teams to address it before it impacts delivery tracking.
 - In a SaaS application, monitor both server health and end-user experience metrics, such as page load times. If servers show 100% uptime but users face long load times, you may need to optimize content delivery or caching mechanisms.
@@ -193,33 +208,33 @@ Benefits of Using SigNoz for Both Cloud and Open-Source Environments
 
 While proactive monitoring offers significant benefits, it also comes with its own set of challenges. Here's how the information can be represented in a table for better readability:
 
-| Challenge | Description | Solution |
-| --- | --- | --- |
-| False Positives and Alert Fatigue | Overly sensitive monitoring systems can generate excessive alerts, causing important notifications to be overlooked. | Regularly refine alert thresholds and use intelligent alert grouping to minimize noise. |
-| Performance Impact | Intensive monitoring can degrade system performance if not implemented carefully. | Use lightweight monitoring agents and optimize data collection frequency to reduce overhead. |
-| Data Privacy and Security | Collecting system data raises concerns about unauthorized access and compliance with regulations. | Implement strong data encryption, access controls, and compliance measures to secure data. |
-| Integration Complexity | Integrating proactive monitoring with existing workflows and tools can be difficult. | Opt for solutions with robust API support and pre-built integrations with popular DevOps tools. |
-| Skill Gap | Specialized skills in data analysis and machine learning are often required for effective monitoring. | Provide training for your team or leverage managed monitoring services to bridge the expertise gap. |
+| Challenge                         | Description                                                                                                          | Solution                                                                                            |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| False Positives and Alert Fatigue | Overly sensitive monitoring systems can generate excessive alerts, causing important notifications to be overlooked. | Regularly refine alert thresholds and use intelligent alert grouping to minimize noise.             |
+| Performance Impact                | Intensive monitoring can degrade system performance if not implemented carefully.                                    | Use lightweight monitoring agents and optimize data collection frequency to reduce overhead.        |
+| Data Privacy and Security         | Collecting system data raises concerns about unauthorized access and compliance with regulations.                    | Implement strong data encryption, access controls, and compliance measures to secure data.          |
+| Integration Complexity            | Integrating proactive monitoring with existing workflows and tools can be difficult.                                 | Opt for solutions with robust API support and pre-built integrations with popular DevOps tools.     |
+| Skill Gap                         | Specialized skills in data analysis and machine learning are often required for effective monitoring.                | Provide training for your team or leverage managed monitoring services to bridge the expertise gap. |
+
 1. False Positives and [Alert Fatigue](https://signoz.io/blog/alert-fatigue/): Overly sensitive monitoring systems can lead to a flood of alerts, many of which may be false positives. This can lead to alert fatigue, where important notifications are missed or ignored.
-    
-    Solution: Regularly refine your alert thresholds and use intelligent alert grouping to reduce noise.
-    
+
+   Solution: Regularly refine your alert thresholds and use intelligent alert grouping to reduce noise.
+
 2. Performance Impact: Intensive monitoring can itself impact system performance if not implemented carefully.
-    
-    Solution: Use lightweight monitoring agents and optimize data collection frequency.
-    
+
+   Solution: Use lightweight monitoring agents and optimize data collection frequency.
+
 3. Data Privacy and Security: Collecting comprehensive system data raises concerns about data privacy and security.
-    
-    Solution: Implement strong data encryption, access controls, and compliance measures in your monitoring setup.
-    
+
+   Solution: Implement strong data encryption, access controls, and compliance measures in your monitoring setup.
+
 4. Integration Complexity: Integrating proactive monitoring into existing workflows and tools can be challenging.
-    
-    Solution: Choose monitoring solutions with robust API support and pre-built integrations with popular DevOps tools.
-    
+
+   Solution: Choose monitoring solutions with robust API support and pre-built integrations with popular DevOps tools.
+
 5. Skill Gap: Effective proactive monitoring often requires specialized skills in data analysis and machine learning.
-    
-    Solution: Invest in training for your team or consider managed monitoring services.
-    
+
+   Solution: Invest in training for your team or consider managed monitoring services.
 
 ## Future Trends in Proactive Monitoring
 
@@ -257,12 +272,12 @@ Automation will continue to play a key role in proactive monitoring, with system
 
 Proactive monitoring focuses on preventing issues before they occur by analyzing trends and predicting potential problems. Reactive monitoring, on the other hand, involves responding to issues after they've already impacted your systems.
 
-| Aspect | Proactive Monitoring | Reactive Monitoring |
-| --- | --- | --- |
-| Timing | Anticipates issues before they occur | Responds to issues after they have occurred |
-| Approach | Continuous monitoring and preventive actions | Incident-driven responses and troubleshooting |
-| Goals | Maintain optimal performance and prevent downtime | Quickly resolve issues to minimize impact |
-| Resource Allocation | Requires ongoing maintenance and updates | Involves emergency responses and repair activities |
+| Aspect              | Proactive Monitoring                              | Reactive Monitoring                                |
+| ------------------- | ------------------------------------------------- | -------------------------------------------------- |
+| Timing              | Anticipates issues before they occur              | Responds to issues after they have occurred        |
+| Approach            | Continuous monitoring and preventive actions      | Incident-driven responses and troubleshooting      |
+| Goals               | Maintain optimal performance and prevent downtime | Quickly resolve issues to minimize impact          |
+| Resource Allocation | Requires ongoing maintenance and updates          | Involves emergency responses and repair activities |
 
 ### How does proactive monitoring improve system reliability?
 
@@ -280,4 +295,4 @@ To start implementing proactive monitoring:
 2. Define key performance indicators (KPIs) and establish baseline metrics.
 3. Choose a monitoring solution that fits your needs and budget.
 4. Begin with monitoring your most critical systems and gradually expand coverage.
-5. Train your team on the new tools and processes, emphasizing the importance of a proactive mindset.
\ No newline at end of file
+5. Train your team on the new tools and processes, emphasizing the importance of a proactive mindset.
diff --git a/data/guides/production-readiness-checklist.mdx b/data/guides/production-readiness-checklist.mdx
index 2608cf023..ca241cf0d 100644
--- a/data/guides/production-readiness-checklist.mdx
+++ b/data/guides/production-readiness-checklist.mdx
@@ -1,20 +1,26 @@
 ---
-
 title: Essential Production Readiness Checklist for Developers
-slug: production-readiness-checklist
 date: 2024-12-05
 tags: [observability]
 authors: [manjunath_irukulla]
 description: Discover the essential components of a production readiness checklist for developers. Learn how to ensure your software is secure, performant, and reliable before deployment.
-keywords: [production readiness, deployment checklist, software reliability, DevOps best practices, application performance, security measures, observability]
-
+keywords:
+  [
+    production readiness,
+    deployment checklist,
+    software reliability,
+    DevOps best practices,
+    application performance,
+    security measures,
+    observability,
+  ]
 ---
 
-In the fast-paced world of software development, ensuring your application is truly ready for production is crucial. A comprehension production readiness checklist serves as your roadmap to a successful deployment. This guide will walk you through the essential components of a production readiness checklist, helping you minimize risks and maximize the reliability of your software in a production environment. 
+In the fast-paced world of software development, ensuring your application is truly ready for production is crucial. A comprehension production readiness checklist serves as your roadmap to a successful deployment. This guide will walk you through the essential components of a production readiness checklist, helping you minimize risks and maximize the reliability of your software in a production environment.
 
 ## What is Production Readiness?
 
-Production readiness refers to the state in which software is fully prepared to operate in a production environment with minimal risk of failure. It ensures the application is secure, scalable, reliable, and easily observable under real-world conditions. This readiness is critical for delivering a seamless user experience and meeting organizational and compliance requirements. 
+Production readiness refers to the state in which software is fully prepared to operate in a production environment with minimal risk of failure. It ensures the application is secure, scalable, reliable, and easily observable under real-world conditions. This readiness is critical for delivering a seamless user experience and meeting organizational and compliance requirements.
 
 ## Key Components of Production Readiness
 
@@ -28,13 +34,17 @@ Implementing a robust production readiness process provides several compelling b
 - Reduce Downtime: Proactively identifying and addressing potential issues before deployment minimizes the risk of unexpected outages. This leads to higher system availability, reduced disruptions, and greater end-user trust.
 - Improve User Experience: A production-ready application is optimized for performance and reliability, delivering faster load times, smoother interactions, and fewer errors. These factors contribute to a positive user experience and increased customer satisfaction.
 - Reducing Cost: Catching and resolving issues during the development and testing phases is far less expensive than fixing them after deployment. A well-prepared application also reduces operational costs by avoiding unplanned maintenance and emergency fixes.
-- Maintain Regulatory Compliance: Many industries enforce strict security, privacy, and reliability standards. Production readiness ensures adherence to these requirements, helping you avoid penalties, maintain regulatory approvals, and safeguard your organization’s reputation.  
+- Maintain Regulatory Compliance: Many industries enforce strict security, privacy, and reliability standards. Production readiness ensures adherence to these requirements, helping you avoid penalties, maintain regulatory approvals, and safeguard your organization’s reputation.
 
 ## Why is a Production Readiness Checklist Crucial?
 
-<Figure src="/img/guides/2024/12/production-readiness-checklist-524cec3b-6c16-45a4-b100-2c37dc001c7f.webp" alt="Benefits of a Production Readiness Checklist" caption="Benefits of a Production Readiness Checklist" />
+<Figure
+  src="/img/guides/2024/12/production-readiness-checklist-524cec3b-6c16-45a4-b100-2c37dc001c7f.webp"
+  alt="Benefits of a Production Readiness Checklist"
+  caption="Benefits of a Production Readiness Checklist"
+/>
 
-A production readiness checklist is more than just a tool; it’s a cornerstone of successful software delivery. Here’s why every development team should prioritize it: 
+A production readiness checklist is more than just a tool; it’s a cornerstone of successful software delivery. Here’s why every development team should prioritize it:
 
 - Reduces Cognitive Load and Ensures Consistency: A well-structured checklist eliminates dependence on memory or individual expertise while ensuring every release undergoes thorough evaluation, maintaining high-quality standards across deployments.
 - Minimizes Risks and Enhances System Resilience: Systematically addressing potential issues before they arise reduces the chances of critical problems, leading to smoother releases. Over time, this process fosters continual improvements in your system’s architecture and practices, resulting in a more dependable application.
@@ -43,102 +53,101 @@ A production readiness checklist is more than just a tool; it’s a cornerstone
 
 ### Security Measures
 
-Security is critical to production readiness, as it protects your application, users, and data from vulnerabilities and threats. Here’s how to ensure robust security in your production environment. 
+Security is critical to production readiness, as it protects your application, users, and data from vulnerabilities and threats. Here’s how to ensure robust security in your production environment.
 
 - Robust Authentication and authorization: Implement secure user authentication using industry-standard protocols like OAuth 2.0, OpenID Connect, or JSON Web Tokens (JWT).
-    - Enforce role-based access control (RBAC) to limit access to sensitive features and data.
+  - Enforce role-based access control (RBAC) to limit access to sensitive features and data.
 - Regular Vulnerability Assessments: Regularly scan your codebase and third-party dependencies for known vulnerabilities.
-    - Use tools like Synl, OWASP ZAP, or Dependency-Track to automate the detection and mitigation of risks.
+  - Use tools like Synl, OWASP ZAP, or Dependency-Track to automate the detection and mitigation of risks.
 - Data Encryption: Ensure that sensitive data is encrypted at rest (e.g., database encryption) and in transit (e.g., HTTPS).
-    - Use strong encryption algorithms like AES-256 for data at rest and TLS 1.2/1.3 for data in transit.
+  - Use strong encryption algorithms like AES-256 for data at rest and TLS 1.2/1.3 for data in transit.
 - Secret Management: Avoid hardcoding sensitive credentials like API keys, database passwords, or tokens in your code.
-    - Use secret management tools such as HashiCorp Vault, AWS Secrets Manager, or Azure Key Vault to store and manage sensitive data securely.
+  - Use secret management tools such as HashiCorp Vault, AWS Secrets Manager, or Azure Key Vault to store and manage sensitive data securely.
 
 Example of implementing secure secret management in a Node.js application
 
-Below is an example of how to securely fetch and manage secrets in a `Node.js` application using Google Cloud Secret Manager: 
+Below is an example of how to securely fetch and manage secrets in a `Node.js` application using Google Cloud Secret Manager:
 
 ```jsx
-const { SecretManagerServiceClient } = require('@google-cloud/secret-manager');
+const { SecretManagerServiceClient } = require('@google-cloud/secret-manager')
 
 async function getSecret(secretName) {
-  const client = new SecretManagerServiceClient();
+  const client = new SecretManagerServiceClient()
   const [version] = await client.accessSecretVersion({
     name: `projects/your-project-id/secrets/${secretName}/versions/latest`,
-  });
-  return version.payload.data.toString('utf8');
+  })
+  return version.payload.data.toString('utf8')
 }
 
 // Usage Example
-(async () => {
+;(async () => {
   try {
-    const dbPassword = await getSecret('database-password');
-    console.log('Database Password:', dbPassword);
+    const dbPassword = await getSecret('database-password')
+    console.log('Database Password:', dbPassword)
     // Use the password securely in your application
   } catch (error) {
-    console.error('Error accessing secret:', error);
+    console.error('Error accessing secret:', error)
   }
-})();
+})()
 ```
 
-This approach ensures that sensitive information is never exposed in your code or version control, reducing the risk of breaches. 
+This approach ensures that sensitive information is never exposed in your code or version control, reducing the risk of breaches.
 
 ### Performance and Scalability
 
-Performance and scalability are critical to ensure your application remains responsive and reliable, even under varying loads or high traffic conditions. Implement the following strategies to prepare your production application: 
+Performance and scalability are critical to ensure your application remains responsive and reliable, even under varying loads or high traffic conditions. Implement the following strategies to prepare your production application:
 
 - Load Testing: Simulate real-world traffic scenarios using tools like Apache, JMeter, Gatling, or Locust to identify performance bottlenecks.
-    - [Analyze metrics](https://signoz.io/blog/metrics-explorer/) like response time, throughput, and error rates to ensure the application can handle expected traffic loads.
+  - [Analyze metrics](https://signoz.io/blog/metrics-explorer/) like response time, throughput, and error rates to ensure the application can handle expected traffic loads.
 - Auto-Scaling: Set up auto-scaling in your infrastructure (e.g., AWS Auto Scaling, Kubernetes Horizontal Pod Autoscaler) to dynamically allocate resources during traffic spikes.
-    - Ensure proper configurations to avoid over-provisioning or under-provisioning resources.
+  - Ensure proper configurations to avoid over-provisioning or under-provisioning resources.
 - Query Optimization: Regularly review database queries for inefficiencies such as unnecessary joins or lack of proper indexing.
-    - Use database profiling tools (e.g., MYSQL EXPLAIN, PostgreSQL EXPLAIN ANALYZE) to fine-tune query performance.
+  - Use database profiling tools (e.g., MYSQL EXPLAIN, PostgreSQL EXPLAIN ANALYZE) to fine-tune query performance.
 - Caching Strategies: Reducing load on the primary database and improving response times by caching frequently requested data. You can implement caching at various levels:
-    - Application level: Use in-memory caching with libraries like Redis or Memcached.
-    - Database level: Enable query caching features where supported.
-    - Content Delivery Network (CDN): Cache static assets (e.g., images, scripts) close to end-users.
+  - Application level: Use in-memory caching with libraries like Redis or Memcached.
+  - Database level: Enable query caching features where supported.
+  - Content Delivery Network (CDN): Cache static assets (e.g., images, scripts) close to end-users.
 
 Example of implementing a caching strategy using Redis in a Node.js application:
 
-Below is an example of implementing a caching strategy using Redis to reduce database load and improve response times. 
+Below is an example of implementing a caching strategy using Redis to reduce database load and improve response times.
 
 ```jsx
-const redis = require('redis');
-const client = redis.createClient();
+const redis = require('redis')
+const client = redis.createClient()
 
 async function getCachedData(key) {
   return new Promise((resolve, reject) => {
     client.get(key, async (err, data) => {
-      if (err) return reject(err);
+      if (err) return reject(err)
 
       if (data !== null) {
-        console.log('Cache hit');
-        resolve(JSON.parse(data));
+        console.log('Cache hit')
+        resolve(JSON.parse(data))
       } else {
-        console.log('Cache miss');
+        console.log('Cache miss')
         // Fetch data from the primary source
-        const newData = await fetchDataFromPrimarySource();
+        const newData = await fetchDataFromPrimarySource()
         // Cache the new data with a TTL (Time-To-Live) of 1 hour
-        client.setex(key, 3600, JSON.stringify(newData));
-        resolve(newData);
+        client.setex(key, 3600, JSON.stringify(newData))
+        resolve(newData)
       }
-    });
-  });
+    })
+  })
 }
 
 // Example Usage
 async function fetchData() {
-  const key = 'unique-data-key';
+  const key = 'unique-data-key'
   try {
-    const data = await getCachedData(key);
-    console.log('Data:', data);
+    const data = await getCachedData(key)
+    console.log('Data:', data)
   } catch (error) {
-    console.error('Error fetching data:', error);
+    console.error('Error fetching data:', error)
   }
 }
 
-fetchData();
-
+fetchData()
 ```
 
 ### Observability and Monitoring
@@ -146,101 +155,100 @@ fetchData();
 Observability is the cornerstone of maintaining and optimizing your application's performance and reliability in production. Effective monitoring strategies ensure you can detect and resolve issues before they impact users.
 
 - [Centralized Logging](https://signoz.io/blog/centralized-logging/): Ensure logs are structured and tagged with metadata (e.g., timestamps, request IDs) for easier filtering and troubleshooting. Aggregate logs from application components using tools like:
-    - ELK Stack (Elasticsearch, Logstash, Kibana): Ideal for searching, analyzing, and visualizing log data.
-    - Splunk: Offers powerful data analysis capabilities and enterprise-grade solutions.
+  - ELK Stack (Elasticsearch, Logstash, Kibana): Ideal for searching, analyzing, and visualizing log data.
+  - Splunk: Offers powerful data analysis capabilities and enterprise-grade solutions.
 - Application Performance Monitoring (APM): Use [APM tools](https://signoz.io/blog/open-source-apm-tools/) like New Relic, Datadog, or AppDynamics to monitor application behavior in real-time.
-    - Track critical metrics such as response times, error rates, and throughput.
-    - Enable [distributed tracing](https://signoz.io/distributed-tracing/) to diagnose performance issues across microservices.
+  - Track critical metrics such as response times, error rates, and throughput.
+  - Enable [distributed tracing](https://signoz.io/distributed-tracing/) to diagnose performance issues across microservices.
 - Custom Dashboards: Create intuitive dashboards to visualize key performance indicators (KPIs) such as:
-    - System health: CPU and memory usage, disk I/O, and network traffic.
-    - Application metrics: Request rates, latencies, and error counts.
-    - Use tools like Grafana or Kibana to design and share dashboards with your team.
+  - System health: CPU and memory usage, disk I/O, and network traffic.
+  - Application metrics: Request rates, latencies, and error counts.
+  - Use tools like Grafana or Kibana to design and share dashboards with your team.
 - Alerting: set up proactive alerts for critical thresholds (e.g., high CPU usage, low disk space, or API failures).
-    - Use tools like PagerDuty, OpsGenie, or VictorOps to notify on-call engineers immediately.
-    - Implement escalation policies to ensure unresolved issues are addressed promptly.
-    
-    Effective alerting is crucial for responding to critical production issues promptly. Tools like SigNoz enhance your alerting capabilities, ensuring real-time notifications and informed decision-making. 
-    
-    For a step-by-step guide on creating and managing alerts in SigNoz, refer to [Setup Alerts Notification Channels](https://signoz.io/docs/setup-alerts-notification/). 
-    
+  - Use tools like PagerDuty, OpsGenie, or VictorOps to notify on-call engineers immediately.
+  - Implement escalation policies to ensure unresolved issues are addressed promptly.
+  Effective alerting is crucial for responding to critical production issues promptly. Tools like SigNoz enhance your alerting capabilities, ensuring real-time notifications and informed decision-making.
+  For a step-by-step guide on creating and managing alerts in SigNoz, refer to [Setup Alerts Notification Channels](https://signoz.io/docs/setup-alerts-notification/).
 
 ### Reliability and Resilience
 
-Building reliability and resilience into your system ensures that your application can handle partial failures gracefully without significantly impacting user experience. Here are the essential strategies to implement. 
+Building reliability and resilience into your system ensures that your application can handle partial failures gracefully without significantly impacting user experience. Here are the essential strategies to implement.
 
 - Redundancy: Eliminate single points of failure by introducing redundancy at critical layers:
-    - Server redundancy: Use load balancers to distribute traffic across multiple instances.
-    - Database redundancy: Set up primary-replica configuration or cluster solutions like MySQL Cluster or Amazon Aurora.
-    - Network redundancy: Implement multi-zone or multi-region deployments in cloud environments.
-    - Regularly test failover mechanisms to ensure they function correctly under failure conditions.
+  - Server redundancy: Use load balancers to distribute traffic across multiple instances.
+  - Database redundancy: Set up primary-replica configuration or cluster solutions like MySQL Cluster or Amazon Aurora.
+  - Network redundancy: Implement multi-zone or multi-region deployments in cloud environments.
+  - Regularly test failover mechanisms to ensure they function correctly under failure conditions.
 - Chaos Engineering: Conduct controlled experiments to identify weaknesses in your system under adverse.
-    - Use tools like Chaos Monkey (from Netflix’s Simian Army)  or Gremlin to simulate outages and latency. Learn from these experiments to improve fault tolerance and system stability.
+  - Use tools like Chaos Monkey (from Netflix’s Simian Army) or Gremlin to simulate outages and latency. Learn from these experiments to improve fault tolerance and system stability.
 - Backup and Recovery: Automate regular backups of critical data and verify the integrity of backup files.
-    - Define and test your disaster recovery (DR) plan:
-        - Recovery Time Objective (RTO): The maximum acceptable downtime.
-        - Recovery Point Objective (RPO): The maximum acceptable data loss period.
-    - Use cloud-based backup solutions like AWS Backup or on-premise tools like Veeam.
+  - Define and test your disaster recovery (DR) plan:
+    - Recovery Time Objective (RTO): The maximum acceptable downtime.
+    - Recovery Point Objective (RPO): The maximum acceptable data loss period.
+  - Use cloud-based backup solutions like AWS Backup or on-premise tools like Veeam.
 - Graceful Degradation: Design your application to maintain core functionality even when some components fail.
-    - Showing cached data when the database is unavailable.
-    - Offering read-only functionality when write operations fail.
-    - Implement circuit breakers (exception handlers) to prevent cascading failures.
+  - Showing cached data when the database is unavailable.
+  - Offering read-only functionality when write operations fail.
+  - Implement circuit breakers (exception handlers) to prevent cascading failures.
 
 Example: Circuit Breaker with Opossum in Node.js
 
-The following example demonstrates how to use the Opossum library to implement a circuit breaker pattern in Node.js:  
+The following example demonstrates how to use the Opossum library to implement a circuit breaker pattern in Node.js:
 
 ```jsx
-const CircuitBreaker = require('opossum');
+const CircuitBreaker = require('opossum')
 
 // Configuration options for the circuit breaker
 const options = {
   timeout: 3000, // Trigger failure if the function takes more than 3 seconds
   errorThresholdPercentage: 50, // Trip the logic after 50% of requests fail
   resetTimeout: 30000, // Wait 30 seconds before trying again
-};
+}
 
 // Wrap the function that might fail with a circuit breaker
-const breaker = new CircuitBreaker(functionThatMayFail, options);
+const breaker = new CircuitBreaker(functionThatMayFail, options)
 
 // Provide a fallback in case the circuit is open
-breaker.fallback(() => ({ error: 'Service unavailable. Please try again later.' }));
+breaker.fallback(() => ({ error: 'Service unavailable. Please try again later.' }))
 
 // Using the circuit breaker
-breaker.fire()
-  .then(response => console.log('Success:', response))
-  .catch(error => console.error('Failure:', error));
-
+breaker
+  .fire()
+  .then((response) => console.log('Success:', response))
+  .catch((error) => console.error('Failure:', error))
 ```
 
 ## How to Implement a Production Readiness Review Process
 
-A well-executed production readiness review process ensures your application meets quality, performance, and security standards before deployment. Here’s a step-by-step guide to implementing an effective process: 
+A well-executed production readiness review process ensures your application meets quality, performance, and security standards before deployment. Here’s a step-by-step guide to implementing an effective process:
 
 1. Establish a Cross-Functional Team: Assemble a team with expertise across development, operations, security, and quality assurance.
-    - Assign roles for specific checklist components, such as performance testing, vulnerability assessment, or compliance verification.
-    - Encourage collaboration to identify potential gaps that individual teams might overlook.  
-    
-    Example: Developers can focus on code efficiency, while security experts review compliance and vulnerability scans. 
-    
-2. Define Clear Acceptance Criteria: For every item in your checklist, specify measurable and actionable standards to determine whether it is a “pass” or “fail.” For Example: 
-    - Performance: API response time must be under 200ms for 95% of requests during peak load.
-    - Security: All dependencies must pass a vulnerability scan with no critical or high-risk issues.
-    - Monitoring: Alerts for critical issues must route to the on-call team within 1 minute.
-    
-    Note : Leverage templates or previous reviews to create well-defined criteria that are easy to follow. 
-    
-3. Conduct Regular Reviews: 
-    - Shift-left approach: Incorporate production readiness checks early and regularly in the development lifecycle to identify and fix issues incrementally.
-    - Schedule key reviews at the following stages:
-        - Pre-development: Confirm architectural designs meet production standards.
-        - Mid-development: Verify progress against critical readiness criteria.
-        - Pre-deployment: Perform a comprehensive review of the final release.
-4. Iterate and Improve: After each review, document findings and lessons learned. You can use these insights to: 
-    - Refine the checklist by adding or removing items based on evolving requirements.
-    - Improve processes by identifying bottlenecks or redundant steps.
-    
-    Encourage feedback from all stakeholders to ensure the checklist remains relevant and practical. For example, If a recurring issue is identified, such as missed alert configurations, include specific steps to verify these future reviews. 
-    
+
+   - Assign roles for specific checklist components, such as performance testing, vulnerability assessment, or compliance verification.
+   - Encourage collaboration to identify potential gaps that individual teams might overlook.
+
+   Example: Developers can focus on code efficiency, while security experts review compliance and vulnerability scans.
+
+2. Define Clear Acceptance Criteria: For every item in your checklist, specify measurable and actionable standards to determine whether it is a “pass” or “fail.” For Example:
+
+   - Performance: API response time must be under 200ms for 95% of requests during peak load.
+   - Security: All dependencies must pass a vulnerability scan with no critical or high-risk issues.
+   - Monitoring: Alerts for critical issues must route to the on-call team within 1 minute.
+
+   Note : Leverage templates or previous reviews to create well-defined criteria that are easy to follow.
+
+3. Conduct Regular Reviews:
+   - Shift-left approach: Incorporate production readiness checks early and regularly in the development lifecycle to identify and fix issues incrementally.
+   - Schedule key reviews at the following stages:
+     - Pre-development: Confirm architectural designs meet production standards.
+     - Mid-development: Verify progress against critical readiness criteria.
+     - Pre-deployment: Perform a comprehensive review of the final release.
+4. Iterate and Improve: After each review, document findings and lessons learned. You can use these insights to:
+
+   - Refine the checklist by adding or removing items based on evolving requirements.
+   - Improve processes by identifying bottlenecks or redundant steps.
+
+   Encourage feedback from all stakeholders to ensure the checklist remains relevant and practical. For example, If a recurring issue is identified, such as missed alert configurations, include specific steps to verify these future reviews.
 
 ## Leveraging SigNoz for Enhanced Observability
 
@@ -266,51 +274,43 @@ cd signoz/deploy/
 ./install.sh
 ```
 
-This deploys SigNoz and all necessary components (loke backend services, Elasticsearch, and the UI) using Docker containers. Once done, SigNoz runs on your local machine, and you can access the dashboard. 
+This deploys SigNoz and all necessary components (loke backend services, Elasticsearch, and the UI) using Docker containers. Once done, SigNoz runs on your local machine, and you can access the dashboard.
 
-1. Cloud Deployment Option: SigNoz also provides a cloud option, so you can skip the local setup and opt for a managed service to avoid infrastructure management. Here’s how to get started with SigNoz Cloud: 
-    - Visit [SigNoz Cloud](https://signoz.io/teams/) and sign up for an account.
-    - Follow the SigNoz Cloud dashboard instructions to integrate your application with their cloud-based observability services.
+1. Cloud Deployment Option: SigNoz also provides a cloud option, so you can skip the local setup and opt for a managed service to avoid infrastructure management. Here’s how to get started with SigNoz Cloud:
+   - Visit [SigNoz Cloud](https://signoz.io/teams/) and sign up for an account.
+   - Follow the SigNoz Cloud dashboard instructions to integrate your application with their cloud-based observability services.
 
-This eliminates the need for manual installation and configuration, as SigNoz handles all aspects of hosting and scaling. 
+This eliminates the need for manual installation and configuration, as SigNoz handles all aspects of hosting and scaling.
 
 <GetStartedSigNoz />
 
-By integrating [SigNoz](https://signoz.io/docs/introduction/) into your production environment, you can gain deeper insights into system behavior, enhance [proactive monitoring](https://signoz.io/guides/proactive-monitoring/), and respond swiftly to issues, improving reliability and performance. 
+By integrating [SigNoz](https://signoz.io/docs/introduction/) into your production environment, you can gain deeper insights into system behavior, enhance [proactive monitoring](https://signoz.io/guides/proactive-monitoring/), and respond swiftly to issues, improving reliability and performance.
 
 ## Best Practices for Maintaining Production Readiness
 
-Maintaining production readiness is an ongoing process that requires proactive measures and a culture of continuous improvement. Follow these best practices to ensure your applications stay prepared for production environments. 
+Maintaining production readiness is an ongoing process that requires proactive measures and a culture of continuous improvement. Follow these best practices to ensure your applications stay prepared for production environments.
 
 - Automate checklist validation: Integrate automated validations into your CI/CD pipelines to streamline the readiness process and reduce human error. This ensures consistency, speeds up deployments, and allows teams to focus on higher-value tasks.
-    - Automate tasks such as:
-        - Running security scans (e.g., Synk, OWASP Zap).
-        - Performing performance tests (e.g., JMeter, Locust).
-        - Verifying compliance with Infrastructure as Code (IaC) configurations.
-    
-    Example: Use tools like Jenkins or GitHub Actions to trigger checklist validations as part of the build or deployment pipeline. 
-    
+  - Automate tasks such as:
+    - Running security scans (e.g., Synk, OWASP Zap).
+    - Performing performance tests (e.g., JMeter, Locust).
+    - Verifying compliance with Infrastructure as Code (IaC) configurations.
+  Example: Use tools like Jenkins or GitHub Actions to trigger checklist validations as part of the build or deployment pipeline.
 - Keep the checklist updated: Regularly revisit your checklist to reflect changes in:
-    - Technology: Adopt new tools or frameworks that enhance security, performance, or scalability.
-    - Threat landscape: Address emerging vulnerabilities or compliance requirements.
-    - Organizational goals: Align the checklist with evolving business objectives.
-    
-    Note: Schedule periodic reviews (e.g., quarterly) to update the checklist with lessons learned from previous deployments or industry advancements. 
-    
+  - Technology: Adopt new tools or frameworks that enhance security, performance, or scalability.
+  - Threat landscape: Address emerging vulnerabilities or compliance requirements.
+  - Organizational goals: Align the checklist with evolving business objectives.
+  Note: Schedule periodic reviews (e.g., quarterly) to update the checklist with lessons learned from previous deployments or industry advancements.
 - Foster a culture of shared responsibility: A culture of shared responsibility improves accountability and ensures everyone works toward delivering reliable and robust software.
-    - Make production readiness a team-wide priority rather than limiting it to the operations team.
-    - Encourage collaboration between developers, DevOps engineers, QA teams, and security experts.
-    - Provide training and resources to help all team members understand and contribute to readiness efforts.
-    
-    Example: Incorporate production readiness discussions into sprint planning and retrospective meetings. 
-    
+  - Make production readiness a team-wide priority rather than limiting it to the operations team.
+  - Encourage collaboration between developers, DevOps engineers, QA teams, and security experts.
+  - Provide training and resources to help all team members understand and contribute to readiness efforts.
+  Example: Incorporate production readiness discussions into sprint planning and retrospective meetings.
 - Conduct post-mortem analyses: Conduct a blameless post-mortem to analyze the root cause after any production incident or downtime. Use these insights from the analysis to:
-    - Add new items to the checklist if gaps are identified.
-    - Improve existing processes to prevent similar incidents in the future.
-    - Enhance team learning and resilience.
-    
-    Note: Document findings in a shared repository for future reference and continuous improvement. 
-    
+  - Add new items to the checklist if gaps are identified.
+  - Improve existing processes to prevent similar incidents in the future.
+  - Enhance team learning and resilience.
+  Note: Document findings in a shared repository for future reference and continuous improvement.
 
 ## Key Takeaways
 
@@ -323,17 +323,17 @@ Maintaining production readiness is an ongoing process that requires proactive m
 
 ### What is the difference between a staging environment and production readiness?
 
-| Aspect  | Staging Environment | Production Readiness |
-| --- | --- | --- |
-| Definition  | A simulated environment that mimics production for final testing before deployment.  | A comprehensive state of preparedness, encompassing processes, checks and validations beyond environment setup.  |
-| Focus | Validating functionality, performance, and integration under conditions similar to production.  | Ensuring the application meets all security, reliability, scalability, and operational requirement.  |
-| Scope  | Focused on testing the application in a production like environment.  | Covers infrastructure, processes, monitoring, and team readiness.  |
-| Frequency | Used for every release or major change before production deployment. | Conducted periodically or integrated into the development lifecycle for continuous improvement.  |
-| Outcome | Identifies issues in application behavior that might occur in production.  | Certifies the application and associated systems as fully prepared for live environments.  |
+| Aspect     | Staging Environment                                                                            | Production Readiness                                                                                            |
+| ---------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| Definition | A simulated environment that mimics production for final testing before deployment.            | A comprehensive state of preparedness, encompassing processes, checks and validations beyond environment setup. |
+| Focus      | Validating functionality, performance, and integration under conditions similar to production. | Ensuring the application meets all security, reliability, scalability, and operational requirement.             |
+| Scope      | Focused on testing the application in a production like environment.                           | Covers infrastructure, processes, monitoring, and team readiness.                                               |
+| Frequency  | Used for every release or major change before production deployment.                           | Conducted periodically or integrated into the development lifecycle for continuous improvement.                 |
+| Outcome    | Identifies issues in application behavior that might occur in production.                      | Certifies the application and associated systems as fully prepared for live environments.                       |
 
 ### How often should production readiness reviews be conducted?
 
-Ideally, production readiness reviews should be conducted regularly throughout the development cycle. For example: 
+Ideally, production readiness reviews should be conducted regularly throughout the development cycle. For example:
 
 - Sprint or iteration-based reviews in agile environments.
 - Pre-release reviews to ensure that everything is aligned before a major release.
@@ -342,20 +342,20 @@ The frequency may vary based on your release cadence, but it is important to hav
 
 ### Can production readiness checklists be automated?
 
-Yes, many aspects of a production readiness checklist can be automated using CI/CD pipelines, automated testing tools, and monitoring systems. Automation can handle tasks like: 
+Yes, many aspects of a production readiness checklist can be automated using CI/CD pipelines, automated testing tools, and monitoring systems. Automation can handle tasks like:
 
 - Security scans (e.g., vulnerability scanning).
 - Performance testing (e.g., load testing).
 - Infrastructure as code validations.
 
-However, sometimes, such as business logic validation or certain compliance checks may still require manual review or decision-making. 
+However, sometimes, such as business logic validation or certain compliance checks may still require manual review or decision-making.
 
 ### How does production readiness impact DevOps practices?
 
-Production readiness plays a crucial role in DevOps practices by aligning development, operations, and security teams. It promotes: 
+Production readiness plays a crucial role in DevOps practices by aligning development, operations, and security teams. It promotes:
 
 - Collaboration between teams to ensure all aspects of the application are ready for deployment.
 - Automation of checks, deployments, and monitoring to ensure consistent quality.
 - Continuous improvement by allowing teams to learn from past incidents and reviews.
 
-Production readiness ensures that the development and operations teams share an understanding of what constitutes a production-ready application, making deployments smoother and more reliable.
\ No newline at end of file
+Production readiness ensures that the development and operations teams share an understanding of what constitutes a production-ready application, making deployments smoother and more reliable.
diff --git a/data/guides/prometheus-doesnt-match-regex-query.mdx b/data/guides/prometheus-doesnt-match-regex-query.mdx
index a3d5f24ee..57e359fd9 100644
--- a/data/guides/prometheus-doesnt-match-regex-query.mdx
+++ b/data/guides/prometheus-doesnt-match-regex-query.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How to Fix Prometheus Regex Query Mismatches - A Quick Guide
-slug: prometheus-doesnt-match-regex-query
 date: 2024-09-11
 tags: [faq, prometheus]
 authors: [simran_kumari]
 description: Learn how to troubleshoot and fix Prometheus regex query mismatches. This guide covers common issues, advanced techniques, and best practices for optimal monitoring.
 keywords: [Prometheus, regex query, monitoring, troubleshooting, query optimization, SigNoz]
-
 ---
 
 Prometheus, a powerful open-source monitoring system, relies heavily on regex queries to fetch and [analyze metrics](https://signoz.io/blog/metrics-explorer/). Regex queries in Prometheus can be powerful, but they can also trip you up. If your queries aren’t returning the expected results, it’s likely due to syntax errors or label mismatches. This guide will walk you through troubleshooting regex query mismatches in Prometheus and provide tips to optimize query performance.
@@ -30,52 +27,39 @@ These mismatches can significantly impact your monitoring and alerting systems,
 To quickly address [Prometheus regex](https://signoz.io/guides/a-regex-in-query-in-grafana/) query mismatches:
 
 - Check Your Label Names and Values
-    
-    Make sure the label names and values used in your queries are correct. One common mistake is referencing a non-existent label.
-    
-    Example:
-    
-    ```java
-    {job="myapp", status=~"2.."} //Ensure `status` is a valid label for `myapp`.
-    ```
-    
+  Make sure the label names and values used in your queries are correct. One common mistake is referencing a non-existent label.
+  Example:
+  ```java
+  {job="myapp", status=~"2.."} //Ensure `status` is a valid label for `myapp`.
+  ```
 - Verify Your Regex Pattern
-    
-    Test your regex pattern to ensure it behaves as expected. Use online regex testing tools to confirm.
-    
-    Example:
-    If you're trying to match all HTTP 4xx and 5xx status codes, ensure your pattern is correct:
-    
-    ```java
-    {status_code=~"4..|5.."}
-    ```
-    
+  Test your regex pattern to ensure it behaves as expected. Use online regex testing tools to confirm.
+  Example:
+  If you're trying to match all HTTP 4xx and 5xx status codes, ensure your pattern is correct:
+  ```java
+  {status_code=~"4..|5.."}
+  ```
 - Watch Special Characters
-    
-    In regex, special characters like `.` and `*` need to be escaped if you intend to match them literally.
-    
-    Example:
-    If you want to match the literal string `1.2.3` as a version number:
-    
-    ```java
-    {version=~"1\.2\.3"}
-    ```
-    
+  In regex, special characters like `.` and `*` need to be escaped if you intend to match them literally.
+  Example:
+  If you want to match the literal string `1.2.3` as a version number:
+  ```java
+  {version=~"1\.2\.3"}
+  ```
 - Quotes and Escapes Matter
-    
-    Prometheus is sensitive to how you escape special characters and use quotation marks in queries.
-    
-    Example:
-    To match a label containing double quotes (`"`), ensure the quote is properly escaped:
-    
-    ```java
-    {label=~"\"value\""}
-    ```
-    
+  Prometheus is sensitive to how you escape special characters and use quotation marks in queries.
+  Example:
+  To match a label containing double quotes (`"`), ensure the quote is properly escaped:
+  ```java
+  {label=~"\"value\""}
+  ```
 - Test in expression browser: Use Prometheus' built-in expression browser to validate your queries.
-    
-    <Figure src="/img/guides/2024/09/prometheus-doesnt-match-regex-query-image.webp" alt="Validating Queries in Prometheus Built-in expression browser" caption="Validating Queries in Prometheus Built-in expression browser" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/prometheus-doesnt-match-regex-query-image.webp"
+    alt="Validating Queries in Prometheus Built-in expression browser"
+    caption="Validating Queries in Prometheus Built-in expression browser"
+  />
 
 ### Common Regex Patterns for Prometheus Queries
 
@@ -84,13 +68,13 @@ Once you've addressed regex query mismatches, it's helpful to understand how to
 1. Matching Specific Prefixes or Suffixes: Use `^` to match prefixes and `$` to match suffixes.
 
 - To match labels that start with "app": `{job=~"^app"}`
-- To match labels that end with "service":  `{job=~"service$"}`
+- To match labels that end with "service": `{job=~"service$"}`
 
 2. Excluding Certain Patterns: You can use a negative character class (`[^]`) to exclude patterns, but for more complex exclusions, you may need to rethink your query since RE2 doesn't support lookaheads or lookbehinds.
 
-You can also exclude certain patterns using the negated regex pattern by using the `!~`  operator, but it must be applied to a valid metric with at least one non-empty label matcher. For example;
+You can also exclude certain patterns using the negated regex pattern by using the `!~` operator, but it must be applied to a valid metric with at least one non-empty label matcher. For example;
 
-- To match `job` labels that do *not* contain the string"test": `{job!~"test"}`
+- To match `job` labels that do _not_ contain the string"test": `{job!~"test"}`
 
 ```jsx
 flask_http_request_duration_seconds_bucket{job!~"test"}
@@ -103,13 +87,13 @@ flask_http_request_duration_seconds_bucket{job!~"test"}
 4. Using Quantifiers Effectively: Quantifiers help define how many times a character or group should appear.
 
 - `*`: Match 0 or more times
-    - To match any label that starts with "env" followed by zero or more characters: `{env=~"env.*"}`
+  - To match any label that starts with "env" followed by zero or more characters: `{env=~"env.*"}`
 - `+`: Match 1 or more times
-    - To match labels with a version number like "v1.2.3": `{version=~"v[0-9]+\.[0-9]+\.[0-9]+"}`
+  - To match labels with a version number like "v1.2.3": `{version=~"v[0-9]+\.[0-9]+\.[0-9]+"}`
 - `?`: Match 0 or 1 time
-    - To match an optional "prod" in a label, like "env" or "env-prod": `{env=~"env(-prod)?"}`
+  - To match an optional "prod" in a label, like "env" or "env-prod": `{env=~"env(-prod)?"}`
 - `{n}`: Match exactly `n` times
-    - To match any two-digit number: `{code=~"[0-9]{2}"}`
+  - To match any two-digit number: `{code=~"[0-9]{2}"}`
 
 Using these patterns can significantly refine your Prometheus queries for better performance and more accurate results.
 
@@ -118,56 +102,57 @@ Using these patterns can significantly refine your Prometheus queries for better
 For more complex scenarios, consider these advanced techniques:
 
 1. Label Matching Operators: Use `=` for exact matches and `=~` for regex matches.
-    
-    ```
-    {environment="production", instance=~"10\\.0\\.0\\..*"}
-    ```
-    
+
+   ```
+   {environment="production", instance=~"10\\.0\\.0\\..*"}
+   ```
+
 2. Metric Relabeling: Metric relabeling is a powerful feature in Prometheus that allows you to modify metrics before they are stored or queried. Use relabeling to handle complex scenarios where regex alone isn't sufficient.
-    
-    Example: To exclude certain labels from metrics:
-    
-    ```yaml
-    metric_relabel_configs:
-      - source_labels: [__name__]
-        regex: 'http_requests_total'
-        action: drop
-    ```
-    
-    You can refer to metric relabeling documentation <a href="https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config" rel="noopener noreferrer nofollow" target="_blank">here</a>.
-    
-    How It Helps?
-    
-    - By removing unnecessary or irrelevant labels through relabeling, you can simplify queries and reduce the risk of mismatches.
-    - Prevent mismatches caused by inconsistent or non-standardized labels.
+
+   Example: To exclude certain labels from metrics:
+
+   ```yaml
+   metric_relabel_configs:
+     - source_labels: [__name__]
+       regex: 'http_requests_total'
+       action: drop
+   ```
+
+   You can refer to metric relabeling documentation <a href="https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config" rel="noopener noreferrer nofollow" target="_blank">here</a>.
+
+   How It Helps?
+
+   - By removing unnecessary or irrelevant labels through relabeling, you can simplify queries and reduce the risk of mismatches.
+   - Prevent mismatches caused by inconsistent or non-standardized labels.
+
 3. Query Optimization: Optimizing your queries can help avoid performance bottlenecks and improve query results. Consider the following strategies:
-    - Limit Regex Complexity: Simplify regex patterns to reduce processing time.
-    - Use Label Matching First: Apply exact label matches before regex to reduce the dataset size.
-    - Avoid Wildcards: Minimize the use of wildcards `(*)` as they can lead to inefficiencies.
-    
-    Example: Instead of using a complex regex pattern, use specific label matches where possible:
-    
-    ```
-    {instance="server1", job="app"}
-    ```
-    
-    How It Helps?
-    
-    - Reduces Processing Time: Less complex patterns are faster to evaluate.
-    - Decreases Ambiguity: Simpler patterns are less likely to cause confusion or match unintended data.
+
+   - Limit Regex Complexity: Simplify regex patterns to reduce processing time.
+   - Use Label Matching First: Apply exact label matches before regex to reduce the dataset size.
+   - Avoid Wildcards: Minimize the use of wildcards `(*)` as they can lead to inefficiencies.
+
+   Example: Instead of using a complex regex pattern, use specific label matches where possible:
+
+   ```
+   {instance="server1", job="app"}
+   ```
+
+   How It Helps?
+
+   - Reduces Processing Time: Less complex patterns are faster to evaluate.
+   - Decreases Ambiguity: Simpler patterns are less likely to cause confusion or match unintended data.
+
 4. Prometheus' HTTP API provides endpoints for debugging and troubleshooting queries. Utilize these endpoints to gain insights into your query performance and behavior. Check the documentation here for specific details: <a href="https://prometheus.io/docs/prometheus/latest/querying/api/#querying-target-metadata" rel="noopener noreferrer nofollow" target="_blank">Querying Target Metadata using HTTP API</a>
-    
-    Example Use Case: If your query is not returning expected results, you might want to check if the target has the labels you’re querying for and their current values.
-    
-    How to Use:
-    
-    - Fetch Metadata: Use the API to fetch the metadata for the target to verify the labels and their values.
-        
-        ```bash
-        curl -g 'http://localhost:9090/api/v1/targets/metadata'
-        ```
-        
-    - Verify Labels: Compare the returned metadata with your query to ensure that the labels and values align with your expectations.
+
+   Example Use Case: If your query is not returning expected results, you might want to check if the target has the labels you’re querying for and their current values.
+
+   How to Use:
+
+   - Fetch Metadata: Use the API to fetch the metadata for the target to verify the labels and their values.
+     ```bash
+     curl -g 'http://localhost:9090/api/v1/targets/metadata'
+     ```
+   - Verify Labels: Compare the returned metadata with your query to ensure that the labels and values align with your expectations.
 
 ## Best Practices for Writing Prometheus Regex Queries
 
@@ -183,16 +168,19 @@ Follow these best practices to minimize regex query mismatches:
 
 ## Leveraging SigNoz to Overcome Prometheus Query Mismatches
 
-When dealing with Prometheus query mismatches, pinpointing the root cause can be challenging. Standard Prometheus tools provide foundational debugging capabilities, but they may not always offer the depth of insight required for complex issues. [SigNoz](https://signoz.io/), an open-source observability platform, simplifies the debugging process by offering enhanced monitoring capabilities. 
+When dealing with Prometheus query mismatches, pinpointing the root cause can be challenging. Standard Prometheus tools provide foundational debugging capabilities, but they may not always offer the depth of insight required for complex issues. [SigNoz](https://signoz.io/), an open-source observability platform, simplifies the debugging process by offering enhanced monitoring capabilities.
 
 SigNoz is designed to enhance monitoring and debugging across distributed systems. It integrates metrics, logs, and traces, providing a unified view of system performance and behavior.
 
 ### How can SigNoz help?
 
 - Simplified Querying: Writing complex regex queries in Prometheus can be challenging. SigNoz's built-in functions in the [Query Builder](https://signoz.io/docs/userguide/query-builder/) allow you to construct efficient queries without needing to manually craft regex, saving time and effort.
-    
-    <Figure src="/img/guides/2024/09/prometheus-doesnt-match-regex-query-image%201.webp" alt="SigNoz Query Builder" caption="SigNoz Query Builder" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/prometheus-doesnt-match-regex-query-image%201.webp"
+    alt="SigNoz Query Builder"
+    caption="SigNoz Query Builder"
+  />
 - Performance Optimization: Prometheus queries can experience performance bottlenecks, especially with large data sets. SigNoz is optimized for fast query processing, ensuring quicker insights even when dealing with high data volumes.
 - [Unified Observability](https://signoz.io/unified-observability/): SigNoz provides a single platform that combines metrics, logs, and traces, allowing you to diagnose issues across multiple dimensions. Unlike Prometheus, which focuses solely on metrics, SigNoz gives a holistic view of your system’s performance.
 
@@ -221,4 +209,4 @@ Yes, complex regex patterns can be resource-intensive. Use label matching before
 
 ### Can I use negative lookahead or lookbehind in Prometheus regex queries?
 
-No, Prometheus uses RE2 for regex matching, which doesn't support lookahead or lookbehind assertions. You'll need to find alternative ways to express these patterns.
\ No newline at end of file
+No, Prometheus uses RE2 for regex matching, which doesn't support lookahead or lookbehind assertions. You'll need to find alternative ways to express these patterns.
diff --git a/data/guides/prometheus-exclude-0-values-from-query-result.mdx b/data/guides/prometheus-exclude-0-values-from-query-result.mdx
index 4068cead2..3ec9d1269 100644
--- a/data/guides/prometheus-exclude-0-values-from-query-result.mdx
+++ b/data/guides/prometheus-exclude-0-values-from-query-result.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Filter Out Zero Values in Prometheus Queries
-slug: prometheus-exclude-0-values-from-query-result
 date: 2024-11-14
 tags: [prometheus, faq]
 authors: [simran_kumari]
 description: Learn how to effectively filter zero values from Prometheus queries. Step-by-step guide covering basic to advanced filtering techniques with practical examples.
-keywords: [prometheus queries, zero values filter, promql, metrics filtering, prometheus monitoring, grafana visualization, time series data]
-
+keywords:
+  [
+    prometheus queries,
+    zero values filter,
+    promql,
+    metrics filtering,
+    prometheus monitoring,
+    grafana visualization,
+    time series data,
+  ]
 ---
 
 In Prometheus, zero values in metrics can clutter data visualizations, making it challenging to get clear insights. Filtering out these zero values can improve the clarity of your metrics, making monitoring and alerting more effective. This article walks you through techniques to filter zero values, advanced Prometheus query (PromQL) methods, and tips for implementing zero value filtering.
@@ -44,14 +50,22 @@ Prometheus offers several ways to filter zero values, depending on your use case
 The `!= 0` operator is a straightforward way to filter out zero values in Prometheus queries. Rshyntax for using the operator is `metric !=0`. For example:
 
 ```toml
-prometheus_http_requests_total != 0 
+prometheus_http_requests_total != 0
 ```
 
 This filters out any metric values that are exactly zero.
 
-<Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image.webp" alt="Counts of metric prometheus_http_requests_total" caption="Counts of metric prometheus_http_requests_total" />
+<Figure
+  src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image.webp"
+  alt="Counts of metric prometheus_http_requests_total"
+  caption="Counts of metric prometheus_http_requests_total"
+/>
 
-<Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%201.webp" alt="Counts of metric prometheus_http_requests_total excluding zeros" caption="Counts of metric prometheus_http_requests_total excluding zeros" />
+<Figure
+  src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%201.webp"
+  alt="Counts of metric prometheus_http_requests_total excluding zeros"
+  caption="Counts of metric prometheus_http_requests_total excluding zeros"
+/>
 
 ### Using Conditional Expressions
 
@@ -63,7 +77,11 @@ prometheus_http_requests_total > 0
 
 This returns only those time series where the metric value is greater than zero, filtering out zeros from your visualizations.
 
-<Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%202.webp" alt="Excluding zeros using Conditional Expressions" caption="Excluding zeros using Conditional Expressions" />
+<Figure
+  src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%202.webp"
+  alt="Excluding zeros using Conditional Expressions"
+  caption="Excluding zeros using Conditional Expressions"
+/>
 
 Here are key best practices for filtering zero values in monitoring:
 
@@ -77,92 +95,125 @@ Here are key best practices for filtering zero values in monitoring:
 Prometheus provides flexibility to create advanced filters, which help refine metrics for more complex observability requirements. Here are some advanced techniques for filtering:
 
 1. Using Boolean Operators for Complex Queries
-    
-    Combining zero filtering with Boolean operators allows you to create nuanced queries. For instance, to filter out zeros but include only values between a threshold:
-    
-    ```sql
-    prometheus_http_requests_total > 0 and prometheus_http_requests_total < 100
-    ```
-    
-    The above query filters results to include only metrics where `prometheus_http_requests_total` is greater than 0 and less than 100. This range ensures that only non-zero, low-traffic values are captured, effectively excluding zero values and any high spikes that could distort analysis of low-level traffic patterns.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%203.webp" alt="Boolean Operators for Complex Queries" caption="Boolean Operators for Complex Queries" />
-    
+
+   Combining zero filtering with Boolean operators allows you to create nuanced queries. For instance, to filter out zeros but include only values between a threshold:
+
+   ```sql
+   prometheus_http_requests_total > 0 and prometheus_http_requests_total < 100
+   ```
+
+   The above query filters results to include only metrics where `prometheus_http_requests_total` is greater than 0 and less than 100. This range ensures that only non-zero, low-traffic values are captured, effectively excluding zero values and any high spikes that could distort analysis of low-level traffic patterns.
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%203.webp"
+     alt="Boolean Operators for Complex Queries"
+     caption="Boolean Operators for Complex Queries"
+   />
+
 2. Combining Multiple Filters
-    
-    Filtering zero values alongside other conditions (like job labels, status codes etc) refines data further:
-    
-    ```sql
-    prometheus_http_requests_total{code="400"} > 0
-    ```
-    
-    This example filters out zero values and includes only specific status codes.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%204.webp" alt="Combining Multiple Filters" caption="Combining Multiple Filters" />
-    
+
+   Filtering zero values alongside other conditions (like job labels, status codes etc) refines data further:
+
+   ```sql
+   prometheus_http_requests_total{code="400"} > 0
+   ```
+
+   This example filters out zero values and includes only specific status codes.
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%204.webp"
+     alt="Combining Multiple Filters"
+     caption="Combining Multiple Filters"
+   />
+
 3. Handling Edge Cases with Zero Values
-    
-    Some cases might involve intermittent zero values or spikes. Experiment with filtering thresholds or `rate()` functions to smooth data, such as:
-    
-    ```prolog
-    rate(prometheus_http_requests_total[5m]) != 0
-    ```
-    
-    The above query calculates the per-second rate of `prometheus_http_requests_total` over the last 5 minutes and filters out any instances where the rate is zero. This approach ensures that only active traffic is displayed, excluding any periods with no requests, which can help focus on times when the service is actively receiving traffic.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%205.webp" alt="Handling Edge Cases with Zero Values" caption="Handling Edge Cases with Zero Values" />
-    
+
+   Some cases might involve intermittent zero values or spikes. Experiment with filtering thresholds or `rate()` functions to smooth data, such as:
+
+   ```prolog
+   rate(prometheus_http_requests_total[5m]) != 0
+   ```
+
+   The above query calculates the per-second rate of `prometheus_http_requests_total` over the last 5 minutes and filters out any instances where the rate is zero. This approach ensures that only active traffic is displayed, excluding any periods with no requests, which can help focus on times when the service is actively receiving traffic.
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%205.webp"
+     alt="Handling Edge Cases with Zero Values"
+     caption="Handling Edge Cases with Zero Values"
+   />
+
 4. Time-Based Filtering
-    
-    To exclude zeros over a particular period, apply time-based filters:
-    
-    ```
-    sum_over_time(prometheus_http_requests_total[10m]) > 0
-    ```
-    
-    This approach aggregates data over a time range, excluding any series that stayed at zero throughout the period.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%206.webp" alt="Time-Based Filtering" caption="Time-Based Filtering" />
-    
+
+   To exclude zeros over a particular period, apply time-based filters:
+
+   ```
+   sum_over_time(prometheus_http_requests_total[10m]) > 0
+   ```
+
+   This approach aggregates data over a time range, excluding any series that stayed at zero throughout the period.
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%206.webp"
+     alt="Time-Based Filtering"
+     caption="Time-Based Filtering"
+   />
 
 ## Implementing Zero Value Filtering in Grafana
 
-Filtering out zero values in Grafana helps keep dashboards focused on meaningful data, removing noise from metrics with no activity. For Prometheus,  it can be achieved directly in the query editor. For instance, using a query like `rate(metric_name[5m]) != 0` will exclude zero-rate values.
+Filtering out zero values in Grafana helps keep dashboards focused on meaningful data, removing noise from metrics with no activity. For Prometheus, it can be achieved directly in the query editor. For instance, using a query like `rate(metric_name[5m]) != 0` will exclude zero-rate values.
 
 Follow these steps to set up zero-value filtering for your metrics in Grafana:
 
 1. Open your Grafana dashboard
 2. Edit the panel containing your Prometheus metrics
 3. Add the filter in the Metrics browser:
-    
-    ```
-    your_metric != 0
-    ```
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%207.webp" alt="Grafana graph with zero values" caption="Grafana graph with zero values" />
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%208.webp" alt="Grafana graph filtering out zero values" caption="Grafana graph filtering out zero values" />
-    
+
+   ```
+   your_metric != 0
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%207.webp"
+     alt="Grafana graph with zero values"
+     caption="Grafana graph with zero values"
+   />
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%208.webp"
+     alt="Grafana graph filtering out zero values"
+     caption="Grafana graph filtering out zero values"
+   />
 
 ## Alternative Approach: Using SigNoz
 
-When managing metrics, clean and focused visualizations are key for effective monitoring. [SigNoz](https://signoz.io), an open-source observability platform, offers a powerful alternative to Prometheus and Grafana. 
+When managing metrics, clean and focused visualizations are key for effective monitoring. [SigNoz](https://signoz.io), an open-source observability platform, offers a powerful alternative to Prometheus and Grafana.
 Built to support [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/), SigNoz provides seamless integrations for metrics, traces, and logs within a single platform. Its intuitive UI and query builder simplify the process of setting up visualizations and reduce the need for complex filtering—making it easier to create actionable dashboards.
 
 Here are a few reasons why SigNoz can be particularly helpful for filtering out zero values in metrics:
 
-1. Simplified Querying for Zero-Value Filtering: SigNoz’s user-friendly [query builder](https://signoz.io/blog/query-builder-v5/) allows for straightforward filtering, making it easier to exclude zero values without complex PromQL syntax. 
-    
-    <Figure src="/img/docs/product-features/query-builder/query-builder-filtering.gif" alt="Simplified Querying for Zero-Value Filtering" caption="Simplified Querying for Zero-Value Filtering" />
-    
+1. Simplified Querying for Zero-Value Filtering: SigNoz’s user-friendly [query builder](https://signoz.io/blog/query-builder-v5/) allows for straightforward filtering, making it easier to exclude zero values without complex PromQL syntax.
+
+   <Figure
+     src="/img/docs/product-features/query-builder/query-builder-filtering.gif"
+     alt="Simplified Querying for Zero-Value Filtering"
+     caption="Simplified Querying for Zero-Value Filtering"
+   />
+
 2. Integrated Observability for Contextual Filtering: With SigNoz, metrics, traces, and logs are all integrated into one platform. This context allows for more targeted zero-value filtering based on correlated data, enabling users to focus on relevant metrics alongside related traces or logs.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%209.webp" alt="Integrated Observability for Contextual Filtering" caption="Integrated Observability for Contextual Filtering" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%209.webp"
+     alt="Integrated Observability for Contextual Filtering"
+     caption="Integrated Observability for Contextual Filtering"
+   />
+
 3. Flexible Dashboard Customization: SigNoz provides more intuitive options for setting dynamic thresholds and visual cues, helping users to automatically hide zero-value data or highlight only active metrics. This leads to more streamlined visualizations without needing extensive manual adjustments.
-    
-    <Figure src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%2010.webp" alt="Flexible Dashboard Customization" caption="Flexible Dashboard Customization" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/prometheus-exclude-0-values-from-query-result-image%2010.webp"
+     alt="Flexible Dashboard Customization"
+     caption="Flexible Dashboard Customization"
+   />
 
 <GetStartedSigNoz />
 
@@ -190,4 +241,4 @@ Yes, removing zeros can reduce noise but may also suppress signals, especially i
 
 ### How to handle intermittent zero values?
 
-Use time-based aggregations with the `rate()` function to smooth out intermittent zeros. Example : `rate(metric[5m]) > 0`.
\ No newline at end of file
+Use time-based aggregations with the `rate()` function to smooth out intermittent zeros. Example : `rate(metric[5m]) > 0`.
diff --git a/data/guides/prometheus-instant-vector-vs-range-vector.mdx b/data/guides/prometheus-instant-vector-vs-range-vector.mdx
index 9b7594c14..dc9227413 100644
--- a/data/guides/prometheus-instant-vector-vs-range-vector.mdx
+++ b/data/guides/prometheus-instant-vector-vs-range-vector.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: What is the Difference Between Prometheus Vectors - Instant vs Range Explained
-slug: prometheus-instant-vector-vs-range-vector
 date: 2024-10-14
 tags: [Prometheus, Monitoring, Time Series Data, PromQL]
 authors: [simran_kumari]
 description: Explore the key differences between Prometheus instant vectors and range vectors, their use cases, and how to effectively utilize them in monitoring and querying time series data.
-keywords: [Prometheus vectors, instant vector, range vector, PromQL, time series data, monitoring, data analysis]
-
+keywords:
+  [
+    Prometheus vectors,
+    instant vector,
+    range vector,
+    PromQL,
+    time series data,
+    monitoring,
+    data analysis,
+  ]
 ---
 
 Prometheus, a powerful open-source monitoring and alerting toolkit, relies heavily on vector-based data structures to handle time series information. Understanding the difference between instant vectors and range vectors is crucial for effective monitoring and data analysis. This article delves into the intricacies of these vector types, their applications, and how to leverage them for optimal performance in your monitoring setup.
@@ -24,7 +30,11 @@ Each time series in a Prometheus vector consists of three key components:
 2. Label Set: Key-value pairs that provide additional context for the metric (e.g., `{method="GET", endpoint="/api/v1/users"}`)
 3. Sample: A data point that records the value of the metric at a specific point in time.
 
-<Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image.webp" alt="Components of Prometheus time series" caption="Components of Prometheus time series" />
+<Figure
+  src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image.webp"
+  alt="Components of Prometheus time series"
+  caption="Components of Prometheus time series"
+/>
 
 These components together allow Prometheus to store and query multi-dimensional data efficiently.
 
@@ -64,35 +74,46 @@ Examples of Instant Vector Queries
 Let's explore some practical examples of instant vector queries:
 
 1. Simple metric selection:
-    
-    ```arduino
-    app_requests_total
-    ```
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%201.webp" alt="Simple metric selection using instant vector" caption="Simple metric selection using instant vector" />
-    
-    This query returns the requests based on the metric specified.
-    
+
+   ```arduino
+   app_requests_total
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%201.webp"
+     alt="Simple metric selection using instant vector"
+     caption="Simple metric selection using instant vector"
+   />
+
+   This query returns the requests based on the metric specified.
+
 2. Label matching:
-    
-    ```arduino
-    app_requests_total{endpoint="/error"}
-    ```
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%202.webp" alt="Label matching using instant vector" caption="Label matching using instant vector" />
-    
-    This query returns the requests based on specified metric and matching label
-    
+
+   ```arduino
+   app_requests_total{endpoint="/error"}
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%202.webp"
+     alt="Label matching using instant vector"
+     caption="Label matching using instant vector"
+   />
+
+   This query returns the requests based on specified metric and matching label
+
 3. Applying functions:
-    
-    ```arduino
-    sum(app_requests_total)
-    ```
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%203.webp" alt="Applying functions using instant vector" caption="Applying functions using instant vector" />
-    
-    This query returns the summation for all values based on the metric specified.
-    
+
+   ```arduino
+   sum(app_requests_total)
+   ```
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%203.webp"
+     alt="Applying functions using instant vector"
+     caption="Applying functions using instant vector"
+   />
+
+   This query returns the summation for all values based on the metric specified.
 
 Use Cases for Instant Vectors:
 
@@ -116,7 +137,11 @@ To query range vectors in PromQL, you append a time range selector to the metric
 app_requests_total{endpoint="/"}[2m]
 ```
 
-<Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%204.webp" alt="Range Vectors in Prometheus" caption="Range Vectors in Prometheus" />
+<Figure
+  src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%204.webp"
+  alt="Range Vectors in Prometheus"
+  caption="Range Vectors in Prometheus"
+/>
 
 This query returns the values of the `app_requests_total` metric with an `endpoint` of "/" over the last 2 minutes.
 
@@ -125,35 +150,51 @@ Practical Applications of Range Vectors
 Range vectors excel in scenarios that require historical context:
 
 1. Calculating rates:
-    
-    ```
-    rate(app_requests_total[15m])
-    ```
-    
-    This calculates the per-second average increase in the `app_requests_total` counter over the last 15 minutes.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%205.webp" alt="Calculating rates using range vector" caption="Calculating rates using range vector" />
-    
+
+   ```
+   rate(app_requests_total[15m])
+   ```
+
+   This calculates the per-second average increase in the `app_requests_total` counter over the last 15 minutes.
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%205.webp"
+     alt="Calculating rates using range vector"
+     caption="Calculating rates using range vector"
+   />
+
 2. Detecting anomalies:
-    
-    ```
-    avg_over_time(app_requests_total[1h]) > 90
-    ```
-    
-    This checks if the average value of `app_requests_total` over the past hour is greater than 90.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%206.webp" alt="Detecting anomalies using range vector" caption="Detecting anomalies using range vector" />
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%207.webp" alt="" caption="" />3. Aggregating data:
-    
-    ```
-    sum by (method) (rate(app_requests_total[1h]))
-    ```
-    
-    This query will show you the average request rate, aggregated by HTTP method, over the last 1 hour.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%208.webp" alt="Aggregating data using range vector" caption="Aggregating data using range vector" />
-    
+
+   ```
+   avg_over_time(app_requests_total[1h]) > 90
+   ```
+
+   This checks if the average value of `app_requests_total` over the past hour is greater than 90.
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%206.webp"
+     alt="Detecting anomalies using range vector"
+     caption="Detecting anomalies using range vector"
+   />
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%207.webp"
+     alt=""
+     caption=""
+   />
+   3. Aggregating data:
+
+   ```
+   sum by (method) (rate(app_requests_total[1h]))
+   ```
+
+   This query will show you the average request rate, aggregated by HTTP method, over the last 1 hour.
+
+   <Figure
+     src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%208.webp"
+     alt="Aggregating data using range vector"
+     caption="Aggregating data using range vector"
+   />
 
 Best practice: Choose an appropriate time range for your range vector queries. Too short, and you may miss important trends; too long, and you risk performance issues.
 
@@ -161,13 +202,13 @@ Best practice: Choose an appropriate time range for your range vector queries. T
 
 Understanding the distinctions between instant and range vectors is crucial for effective Prometheus usage:
 
-| Aspect | Instant Vector | Range Vector |
-| --- | --- | --- |
-| Temporal Scope | Captures data at a single moment in time | Captures data over a specified time interval |
-| Data representation | Returns a scalar or value | Returns a series of values across time |
-| Use Case | Best for real-time monitoring | Best for trend analysis and rate calculations |
-| Performance | Faster, as it retrieves a single point | Requires more resources due to time-range processing |
-| Query complexity | Simple queries | More complex, often involving functions |
+| Aspect              | Instant Vector                           | Range Vector                                         |
+| ------------------- | ---------------------------------------- | ---------------------------------------------------- |
+| Temporal Scope      | Captures data at a single moment in time | Captures data over a specified time interval         |
+| Data representation | Returns a scalar or value                | Returns a series of values across time               |
+| Use Case            | Best for real-time monitoring            | Best for trend analysis and rate calculations        |
+| Performance         | Faster, as it retrieves a single point   | Requires more resources due to time-range processing |
+| Query complexity    | Simple queries                           | More complex, often involving functions              |
 
 ## When to Use Instant Vectors vs Range Vectors
 
@@ -190,53 +231,61 @@ Use Range Vectors When:
 Mastering vector manipulation in PromQL unlocks powerful querying capabilities:
 
 1. Combining instant and range vectors:
-    
-    ```
-    sum(rate(app_requests_total[5m])) / sum(up)
-    ```
-    
-    This query calculates the average request rate per active instance.
-    
+
+   ```
+   sum(rate(app_requests_total[5m])) / sum(up)
+   ```
+
+   This query calculates the average request rate per active instance.
+
 2. Subqueries
-    
-    Subqueries allow you to extract intermediate data, making it easier to combine instant and range vectors for more complex analysis.
-    
-    For example, to calculate the average request rate over 5 minutes, within the last hour window:
-    
-    ```
-    avg_over_time(rate(app_requests_total[5m])[1h:])
-    ```
-    
-    This query calculates the average rate of requests (`app_requests_total`) over a 5-minute window, for the past 1 hour. It helps track trends in request rates over time.
-    
+
+   Subqueries allow you to extract intermediate data, making it easier to combine instant and range vectors for more complex analysis.
+
+   For example, to calculate the average request rate over 5 minutes, within the last hour window:
+
+   ```
+   avg_over_time(rate(app_requests_total[5m])[1h:])
+   ```
+
+   This query calculates the average rate of requests (`app_requests_total`) over a 5-minute window, for the past 1 hour. It helps track trends in request rates over time.
+
 3. Vector Arithmetic
-    
-    You can also perform arithmetic operations between vectors for customized metrics. For instance, to compute the ratio of requests to CPU usage over a 5-minute window:
-    
-    ```
-    (app_requests_total[5m]) / (node_cpu_seconds_total[5m])
-    ```
-    
-    This query divides the number of requests (`app_requests_total`) by the CPU time (`node_cpu_seconds_total`), giving you a ratio of requests per CPU second over the last 5 minutes. This can help you understand how efficiently your application is utilizing CPU resources relative to the incoming traffic.
-    
+
+   You can also perform arithmetic operations between vectors for customized metrics. For instance, to compute the ratio of requests to CPU usage over a 5-minute window:
+
+   ```
+   (app_requests_total[5m]) / (node_cpu_seconds_total[5m])
+   ```
+
+   This query divides the number of requests (`app_requests_total`) by the CPU time (`node_cpu_seconds_total`), giving you a ratio of requests per CPU second over the last 5 minutes. This can help you understand how efficiently your application is utilizing CPU resources relative to the incoming traffic.
 
 ## Optimizing Prometheus Queries with SigNoz
 
 While Prometheus offers powerful querying capabilities, tools like SigNoz can further optimize and visualize your data. [SigNoz](https://signoz.io/) offers enhanced features for vector-based querying and visualization. SigNoz is a Prometheus-compatible monitoring solution that makes it easy to work with both instant and range vectors.
 
 - Enhanced Visualization: SigNoz offers out-of-the-box dashboards that improve the readability of vector-based queries.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%209.webp" alt="Enhanced Visualization of vectors using SigNoz" caption="Enhanced Visualization of vectors using SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%209.webp"
+    alt="Enhanced Visualization of vectors using SigNoz"
+    caption="Enhanced Visualization of vectors using SigNoz"
+  />
 - Improved Performance: SigNoz optimizes large data sets and vector queries, making it faster to handle complex queries.
 - Traceability and Context: SigNoz provides a holistic view of your application by integrating traces, logs, and metrics. This enables you to correlate metrics from Prometheus with traces to identify the root cause of performance issues more efficiently.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%2010.webp" alt="Holistic view of traces, logs and metrics using SigNoz" caption="Holistic view of traces, logs and metrics using SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-image%2010.webp"
+    alt="Holistic view of traces, logs and metrics using SigNoz"
+    caption="Holistic view of traces, logs and metrics using SigNoz"
+  />
 - Customizable Alerts: SigNoz allows for setting up advanced alerting mechanisms based on your vector queries, ensuring that you receive timely notifications about any anomalies or performance degradation in your application.
-    
-    <Figure src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-07a00ed9-5e18-447b-85c3-e257142e8abf.webp" alt="Customizable Alerts in SigNoz" caption="Customizable Alerts in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/10/prometheus-instant-vector-vs-range-vector-07a00ed9-5e18-447b-85c3-e257142e8abf.webp"
+    alt="Customizable Alerts in SigNoz"
+    caption="Customizable Alerts in SigNoz"
+  />
 
 <GetStartedSigNoz />
 
@@ -245,17 +294,17 @@ While Prometheus offers powerful querying capabilities, tools like SigNoz can fu
 When working with Prometheus vectors, you may encounter several challenges:
 
 1. Missing data:
-    - For instant vectors: Use default values (e.g., `or` operator in PromQL) to handle missing data.
-    - For range vectors: Consider using functions like `absent_over_time()` to detect gaps.
+   - For instant vectors: Use default values (e.g., `or` operator in PromQL) to handle missing data.
+   - For range vectors: Consider using functions like `absent_over_time()` to detect gaps.
 2. [High cardinality](https://signoz.io/blog/high-cardinality-data/):
-    - Limit the number of unique label combinations in your metrics.
-    - Use aggregation to reduce the dimensionality of your data.
+   - Limit the number of unique label combinations in your metrics.
+   - Use aggregation to reduce the dimensionality of your data.
 3. Query performance:
-    - Optimize your queries by limiting time ranges and using efficient functions.
-    - Consider using recording rules for frequently used queries.
+   - Optimize your queries by limiting time ranges and using efficient functions.
+   - Consider using recording rules for frequently used queries.
 4. PromQL errors:
-    - Double-check your syntax, especially when mixing vector types.
-    - Use the Prometheus expression browser to test and debug complex queries.
+   - Double-check your syntax, especially when mixing vector types.
+   - Use the Prometheus expression browser to test and debug complex queries.
 
 ## Key Takeaways
 
@@ -280,4 +329,4 @@ Vector selectors, especially those with complex label matching, can significantl
 
 ### Are there any limitations to using range vectors with high-resolution metrics?
 
-Yes, using range vectors with high-resolution metrics over long time periods can lead to increased memory usage and slower query performance. When working with high-resolution data, consider using shorter time ranges or aggregating data to a lower resolution for long-term analysis.
\ No newline at end of file
+Yes, using range vectors with high-resolution metrics over long time periods can lead to increased memory usage and slower query performance. When working with high-resolution data, consider using shorter time ranges or aggregating data to a lower resolution for long-term analysis.
diff --git a/data/guides/prometheus-metrics-endpoint.mdx b/data/guides/prometheus-metrics-endpoint.mdx
index 2d355f6b4..ed318a25d 100644
--- a/data/guides/prometheus-metrics-endpoint.mdx
+++ b/data/guides/prometheus-metrics-endpoint.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: How to Set Up and Secure Prometheus Metrics Endpoints
-slug: prometheus-metrics-endpoint
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [daniel]
 description: Learn how to set up and secure Prometheus metrics endpoints for effective system monitoring. Discover best practices and troubleshooting tips.
 keywords: [prometheus, metrics, endpoint, monitoring, security, observability, configuration]
-
 ---
 
 [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) endpoints are essential components for modern system monitoring and observability. They provide a standardized way to expose and collect metrics, enabling you to gain valuable insights into your applications and infrastructure. This guide will walk you through the process of setting up Prometheus metrics endpoints, securing them, and implementing best practices for effective monitoring.
@@ -84,7 +81,6 @@ scrape_configs:
     scrape_interval: 15s
     static_configs:
       - targets: ['localhost:8000']
-
 ```
 
 This configuration tells Prometheus to scrape metrics from `localhost:8000` every 15 seconds.
@@ -163,4 +159,4 @@ To get started with SigNoz:
 
 <GetStartedSigNoz />
 
-SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
\ No newline at end of file
+SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
diff --git a/data/guides/prometheus-monitoring-101.mdx b/data/guides/prometheus-monitoring-101.mdx
index 6defe6da0..5e1d8ad65 100644
--- a/data/guides/prometheus-monitoring-101.mdx
+++ b/data/guides/prometheus-monitoring-101.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: Prometheus Monitoring 101 - A Beginner's Guide
-slug: prometheus-monitoring-101
 date: 2025-02-11
 tags: [monitoring, prometheus]
 authors: [simran_kumari]
 description: Learn the basics of Prometheus monitoring, from setup to advanced querying. Discover how this powerful tool can enhance your system observability.
-keywords: [Prometheus, monitoring, PromQL, metrics, alerting, observability, time series, data visualization]
-
+keywords:
+  [
+    Prometheus,
+    monitoring,
+    PromQL,
+    metrics,
+    alerting,
+    observability,
+    time series,
+    data visualization,
+  ]
 ---
 
 Prometheus, an open-source monitoring and alerting toolkit, has emerged as a popular choice for DevOps teams and site reliability engineers. This guide will walk you through the fundamentals of Prometheus, helping you understand its core concepts, set up your first instance, and leverage its powerful features for effective system monitoring.
@@ -23,13 +30,17 @@ Developed by SoundCloud in 2012, Prometheus was created to address the need for
 Some of the key features of Prometheus include:
 
 1. **Multi-Dimensional Data Model:**
-Prometheus stores time-series data using a multi-dimensional model. Each metric is uniquely identified by its name and labels (key-value pairs), making it easy to filter and analyze data across various dimensions.
+   Prometheus stores time-series data using a multi-dimensional model. Each metric is uniquely identified by its name and labels (key-value pairs), making it easy to filter and analyze data across various dimensions.
 2. **Flexible Query Language (PromQL):**
-Prometheus uses PromQL (Prometheus Query Language), a powerful query language for selecting, aggregating, and manipulating time-series data. PromQL enables complex queries for detailed insights and performance analysis.
+   Prometheus uses PromQL (Prometheus Query Language), a powerful query language for selecting, aggregating, and manipulating time-series data. PromQL enables complex queries for detailed insights and performance analysis.
 3. **Autonomous Server Nodes:**
-Prometheus operates with autonomous server nodes, meaning each node collects and stores its own data independently. This decentralized setup enhances scalability and ensures fault tolerance, removing the need for a centralized database.
+   Prometheus operates with autonomous server nodes, meaning each node collects and stores its own data independently. This decentralized setup enhances scalability and ensures fault tolerance, removing the need for a centralized database.
 
-<Figure src="/img/guides/2025/02/prometheus-monitoring-101-image.webp" alt="Key Features of Prometheus" caption="Key Features of Prometheus" />
+<Figure
+  src="/img/guides/2025/02/prometheus-monitoring-101-image.webp"
+  alt="Key Features of Prometheus"
+  caption="Key Features of Prometheus"
+/>
 
 Unlike traditional monitoring systems like Nagios or Zabbix, Prometheus is optimized for dynamic environments, particularly in cloud-native architectures. Prometheus uses a pull-based model for data collection, in contrast to the push-based methods used by many other systems. This gives Prometheus flexibility in monitoring services that are constantly changing, making it a powerful tool for modern infrastructure.
 
@@ -51,7 +62,6 @@ Prometheus is great for time-series monitoring but not ideal for:
 
 Prometheus is best paired with other tools for a complete [observability stack](https://signoz.io/guides/observability-stack/).
 
-
 ## How Does Prometheus Work?
 
 Prometheus operates with a straightforward yet powerful architecture designed for monitoring dynamic and large-scale systems. Here’s a breakdown of how it works:
@@ -67,7 +77,7 @@ Metrics are scraped from configured endpoints, with intervals (default 15 second
 For Prometheus to pull metrics from a target, the target must expose a specific HTTP endpoint, typically at the `/metrics` path. The HTTP endpoints follow the format; `hostaddress/metrics`. This endpoint provides the current state of the target in a plain text format that Prometheus can understand. <br />
 
     <Figure src="/img/guides/2025/02/prometheus-monitoring-101-how-does-prometheus-work-Untitled201.webp" alt="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)" caption="Metrics displayed from an HTTP endpoint (localhost:8080/metrics)" />
-    
+
 Collected data is stored in a Time Series Database (TSDB), where each time series is identified by a metric name and labels. Data is efficiently compressed for fast storage and retrieval. <br />
 
 Prometheus uses PromQL, a powerful query language, for querying, filtering, and analyzing time-series data to gain insights, create alerts, and generate reports. <br />
@@ -76,147 +86,165 @@ Prometheus uses PromQL, a powerful query language, for querying, filtering, and
 
 Prometheus comprises several key components that work together to create a comprehensive monitoring solution.
 
-<Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%201.webp" alt="Prometheus architecture" caption="Prometheus architecture" />
+<Figure
+  src="/img/guides/2025/02/prometheus-monitoring-101-image%201.webp"
+  alt="Prometheus architecture"
+  caption="Prometheus architecture"
+/>
 
 1. **Prometheus Server**
-    
-    **Purpose:** This is the core of the Prometheus ecosystem, responsible for scraping, storing, and serving metrics.
-    
-    **Components:**
-    
-    - **Data Retriever:** Pulls metrics from monitored targets at defined intervals using a pull-based model.
-    - **Time Series Database (TSDB):** Stores metrics as time series data, optimized for high performance and efficient storage.
-    - **HTTP Server:** Serves data to users and external tools via the Prometheus Query Language (PromQL).
+
+   **Purpose:** This is the core of the Prometheus ecosystem, responsible for scraping, storing, and serving metrics.
+
+   **Components:**
+
+   - **Data Retriever:** Pulls metrics from monitored targets at defined intervals using a pull-based model.
+   - **Time Series Database (TSDB):** Stores metrics as time series data, optimized for high performance and efficient storage.
+   - **HTTP Server:** Serves data to users and external tools via the Prometheus Query Language (PromQL).
+
 2. **Service Discovery**
-    
-    **Purpose:** Dynamically discover targets to monitor without manual intervention. This eliminates the need for static configurations, making Prometheus adaptable to scaling and dynamic infrastructure changes.
-    
-    **Tools Supported:**
-    
-    - **Kubernetes:** For monitoring containers, pods, and clusters.
-    - **Consul:** For service discovery in dynamic environments.
-    
-    <Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%202.webp" alt="Prometheus service discovery" caption="Prometheus service discovery" />
-    
+
+   **Purpose:** Dynamically discover targets to monitor without manual intervention. This eliminates the need for static configurations, making Prometheus adaptable to scaling and dynamic infrastructure changes.
+
+   **Tools Supported:**
+
+   - **Kubernetes:** For monitoring containers, pods, and clusters.
+   - **Consul:** For service discovery in dynamic environments.
+
+   <Figure
+     src="/img/guides/2025/02/prometheus-monitoring-101-image%202.webp"
+     alt="Prometheus service discovery"
+     caption="Prometheus service discovery"
+   />
+
 3. **Exporters**
-    
-    **Purpose:** Exporters act as intermediaries that enable Prometheus to monitor systems, services, or applications that do not natively expose metrics in a Prometheus-compatible format. They collect data from these sources, transform it into a Prometheus-readable format, and expose the metrics to Prometheus.
-    
-    **Each exporter exposes an HTTP endpoint that Prometheus scrapes for metrics.**
-    
+
+   **Purpose:** Exporters act as intermediaries that enable Prometheus to monitor systems, services, or applications that do not natively expose metrics in a Prometheus-compatible format. They collect data from these sources, transform it into a Prometheus-readable format, and expose the metrics to Prometheus.
+
+   **Each exporter exposes an HTTP endpoint that Prometheus scrapes for metrics.**
+
 4. **Alertmanager**
-    
-    **Purpose:** Handles alerts generated by Prometheus, manages their lifecycle, and routes them to the appropriate channels.
-    
-    **Features:**
-    
-    - Deduplication, grouping, and routing of alerts.
-    - Integration with notification systems like:
-        - **Email:** Sends email notifications for alerts.
-        - **Slack:** Sends alerts to Slack channels.
-        - **PagerDuty:** Handles incident response workflows.
-    
-    Alerts are configured in [Prometheus rules](https://signoz.io/guides/what-is-a-prometheus-rule/) and pushed to Alertmanager when triggered.
-    
+
+   **Purpose:** Handles alerts generated by Prometheus, manages their lifecycle, and routes them to the appropriate channels.
+
+   **Features:**
+
+   - Deduplication, grouping, and routing of alerts.
+   - Integration with notification systems like:
+     - **Email:** Sends email notifications for alerts.
+     - **Slack:** Sends alerts to Slack channels.
+     - **PagerDuty:** Handles incident response workflows.
+
+   Alerts are configured in [Prometheus rules](https://signoz.io/guides/what-is-a-prometheus-rule/) and pushed to Alertmanager when triggered.
+
 5. **Visualization Tools**
-    
-    **Purpose:** Enables users to analyze metrics and visualize trends.
-    
-    **Options:**
-    
-    - **Prometheus Web UI:** Built-in interface for basic exploration and querying.
-    - **Grafana:** Advanced dashboards with rich visualizations.
-    - **SigNoz:** Combines [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/), focusing on end-to-end tracking.
-    - **PromLens:** Simplifies PromQL query building and exploration.
-    
-    Grafana is the most popular tool for dashboarding, but SigNoz provides deeper observability integrations.
-    
+
+   **Purpose:** Enables users to analyze metrics and visualize trends.
+
+   **Options:**
+
+   - **Prometheus Web UI:** Built-in interface for basic exploration and querying.
+   - **Grafana:** Advanced dashboards with rich visualizations.
+   - **SigNoz:** Combines [observability and monitoring](https://signoz.io/blog/observability-vs-monitoring/), focusing on end-to-end tracking.
+   - **PromLens:** Simplifies PromQL query building and exploration.
+
+   Grafana is the most popular tool for dashboarding, but SigNoz provides deeper observability integrations.
+
 6. **Remote Storage (Optional)**
-    
-    **Purpose:** Extends Prometheus for long-term storage or external analytics.
-    
-    **Features:**
-    
-    - Forwarding scraped metrics to external systems (e.g., AWS S3, Thanos, Cortex).
-    - Enables scalability for long-term historical data.
-    
-    This feature is useful for environments where retaining metrics for extended periods is critical.
-    
+
+   **Purpose:** Extends Prometheus for long-term storage or external analytics.
+
+   **Features:**
+
+   - Forwarding scraped metrics to external systems (e.g., AWS S3, Thanos, Cortex).
+   - Enables scalability for long-term historical data.
+
+   This feature is useful for environments where retaining metrics for extended periods is critical.
+
 7. **Pushgateway (Optional)**
-    
-    **Purpose:** Collects metrics from short-lived jobs (e.g., batch jobs) that cannot be scraped directly by Prometheus.
-    
-    **Usage:** Jobs push their metrics to Pushgateway, which exposes them for Prometheus to scrape. It is also used in environments with transient workloads, such as CI/CD pipelines.
-    
+
+   **Purpose:** Collects metrics from short-lived jobs (e.g., batch jobs) that cannot be scraped directly by Prometheus.
+
+   **Usage:** Jobs push their metrics to Pushgateway, which exposes them for Prometheus to scrape. It is also used in environments with transient workloads, such as CI/CD pipelines.
+
 8. **Query Language (PromQL)**
-    
-    **Purpose:** Prometheus's query language, is used to retrieve and [analyze metrics](https://signoz.io/blog/metrics-explorer/) data.
-    
-    **PromQL allows for flexible querying with features like filtering, aggregation, and mathematical operations to extract actionable insights.**
-    
-    Example of a PromQL query:
-    
-    <Figure src="/img/guides/2025/02/prometheus-monitoring-101-how-does-prometheus-work-Untitled203.webp" alt="PromQL query" caption="PromQL query" />
-    
-    This query checks the status of targets (Prometheus, node_exporter, cadvisor, or mysqld_exporter) and returns whether they are up (1) or down (0).
-    
+
+   **Purpose:** Prometheus's query language, is used to retrieve and [analyze metrics](https://signoz.io/blog/metrics-explorer/) data.
+
+   **PromQL allows for flexible querying with features like filtering, aggregation, and mathematical operations to extract actionable insights.**
+
+   Example of a PromQL query:
+
+   <Figure
+     src="/img/guides/2025/02/prometheus-monitoring-101-how-does-prometheus-work-Untitled203.webp"
+     alt="PromQL query"
+     caption="PromQL query"
+   />
+
+   This query checks the status of targets (Prometheus, node_exporter, cadvisor, or mysqld_exporter) and returns whether they are up (1) or down (0).
+
 9. **Scrape Targets**
-    
-    **Purpose:** Endpoints that expose metrics for Prometheus to scrape.
-    
-    **Types of Scrape Targets:**
-    
-    - **Applications:** Custom or pre-built applications that expose metrics directly through an HTTP endpoint (e.g., `/metrics`).
-    - **Infrastructure Components:** Such as Linux hosts, Docker containers, Kubernetes pods, and other system-level entities.
-    - **Third-Party Exporters:** Services that bridge the gap between Prometheus and non-native systems by exposing metrics on behalf of those systems.
-    
-    Targets are defined in the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file or dynamically discovered via service discovery.
-    
-<InterlinkCard title="Read more on How Does Prometheus Work?" href="/guides/how-does-prometheus-work/" />
+
+   **Purpose:** Endpoints that expose metrics for Prometheus to scrape.
+
+   **Types of Scrape Targets:**
+
+   - **Applications:** Custom or pre-built applications that expose metrics directly through an HTTP endpoint (e.g., `/metrics`).
+   - **Infrastructure Components:** Such as Linux hosts, Docker containers, Kubernetes pods, and other system-level entities.
+   - **Third-Party Exporters:** Services that bridge the gap between Prometheus and non-native systems by exposing metrics on behalf of those systems.
+
+   Targets are defined in the [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/) file or dynamically discovered via service discovery.
+
+<InterlinkCard
+  title="Read more on How Does Prometheus Work?"
+  href="/guides/how-does-prometheus-work/"
+/>
 
 ## Setting Up Prometheus: A Quick Start Guide
 
 Let's walk through the process of setting up Prometheus on a Linux system:
 
 1. Download the <a href="https://github.com/prometheus/prometheus/releases" rel="noopener noreferrer nofollow" target="_blank">latest Prometheus release</a>:
-    
-    ```bash
-    wget <https://github.com/prometheus/prometheus/releases/download/v2.30.3/prometheus-2.30.3.linux-amd64.tar.gz>
-    
-    ```
-    
+
+   ```bash
+   wget <https://github.com/prometheus/prometheus/releases/download/v2.30.3/prometheus-2.30.3.linux-amd64.tar.gz>
+
+   ```
+
 2. Extract the archive:
-    
-    ```bash
-    tar xvfz prometheus-*.tar.gz
-    cd prometheus-*
-    
-    ```
-    
+
+   ```bash
+   tar xvfz prometheus-*.tar.gz
+   cd prometheus-*
+
+   ```
+
 3. Create a basic configuration file named `prometheus.yml`:
-    
-    ```yaml
-    global:
-      scrape_interval: 15s
-    
-    scrape_configs:
-      - job_name: 'prometheus'
-        static_configs:
-          - targets: ['localhost:9090']
-    
-    ```
-    
+
+   ```yaml
+   global:
+     scrape_interval: 15s
+
+   scrape_configs:
+     - job_name: 'prometheus'
+       static_configs:
+         - targets: ['localhost:9090']
+   ```
+
 4. Start Prometheus:
-    
-    ```bash
-    ./prometheus --config.file=prometheus.yml
-    
-    ```
-    
+
+   ```bash
+   ./prometheus --config.file=prometheus.yml
+
+   ```
 
 Prometheus is now running and accessible at `http://localhost:9090`.
 
-<Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%203.webp" alt="Accessing Prometheus UI" caption="Accessing Prometheus UI" />
+<Figure
+  src="/img/guides/2025/02/prometheus-monitoring-101-image%203.webp"
+  alt="Accessing Prometheus UI"
+  caption="Accessing Prometheus UI"
+/>
 
 ## Understanding Prometheus Metrics and Data Model
 
@@ -225,17 +253,17 @@ Prometheus organizes its data using a flexible and powerful model to track and a
 ### Types of Metrics
 
 1. Counter:
-    - A counter is a metric that only increases over time, representing a cumulative value. Common use cases include tracking the number of requests or errors.
-    - Example: `http_requests_total` (number of HTTP requests processed).
+   - A counter is a metric that only increases over time, representing a cumulative value. Common use cases include tracking the number of requests or errors.
+   - Example: `http_requests_total` (number of HTTP requests processed).
 2. Gauge:
-    - A gauge represents a value that can go up or down, such as temperature or memory usage.
-    - Example: `memory_usage_bytes` (memory usage in bytes).
+   - A gauge represents a value that can go up or down, such as temperature or memory usage.
+   - Example: `memory_usage_bytes` (memory usage in bytes).
 3. Histogram:
-    - A histogram samples observations (usually durations or sizes) and counts them in configurable buckets. It also provides summary statistics like the sum and count of observations.
-    - Example: `http_request_duration_seconds` (histogram of request durations in seconds).
+   - A histogram samples observations (usually durations or sizes) and counts them in configurable buckets. It also provides summary statistics like the sum and count of observations.
+   - Example: `http_request_duration_seconds` (histogram of request durations in seconds).
 4. Summary:
-    - A summary is similar to a histogram but also provides quantiles (e.g., 95th percentile) for a set of observations. It is typically used for tracking latencies or response times.
-    - Example: `http_request_duration_seconds_sum` (total request duration) and `http_request_duration_seconds_count` (count of requests).
+   - A summary is similar to a histogram but also provides quantiles (e.g., 95th percentile) for a set of observations. It is typically used for tracking latencies or response times.
+   - Example: `http_request_duration_seconds_sum` (total request duration) and `http_request_duration_seconds_count` (count of requests).
 
 ### Labels and Dimensions in Prometheus
 
@@ -255,13 +283,9 @@ Labels help create a multi-dimensional data model that allows efficient aggregat
 Adopting consistent naming conventions is crucial for readability and maintainability. Here’s how to structure metrics and labels effectively:
 
 - Metric Name: It should be clear, concise, and represent what the metric measures. Conventionally, metric names are in lowercase, and underscores are used to separate words.
-    
-    Example: `http_requests_total` (total number of HTTP requests).
-    
+  Example: `http_requests_total` (total number of HTTP requests).
 - Label Names: Label names should describe the dimensions they represent. Use short but meaningful names to identify specific characteristics and avoid using high-cardinality labels (e.g., user IDs or timestamps) to maintain efficiency.
-    
-    Example: `method` (GET, POST) or `status` (200, 404).
-    
+  Example: `method` (GET, POST) or `status` (200, 404).
 
 ### Best Practices for Creating and Organizing Metrics
 
@@ -282,10 +306,10 @@ PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/
 - Metric Name: The name of the metric you want to query (e.g., `http_requests_total`).
 - Labels: You can filter metrics by label values using curly braces `{}` (e.g., `http_requests_total{status="200"}`).
 - Operators: PromQL supports various operators in filtering and comparing metrics.
-    - Comparison operators: `=`, `!=`, `>`, `<`, `>=`, `<=`.
-    - Arithmetic operators: `+`, ``, ``,`/`, `%` for operations on time-series data.
-    - Logical operators: `and`, `or`, `unless` for combining or excluding series.
-    - Aggregation operators: `sum`, `avg`, `min`, `max`, `count`, etc.
+  - Comparison operators: `=`, `!=`, `>`, `<`, `>=`, `<=`.
+  - Arithmetic operators: `+`, `, `,`/`, `%` for operations on time-series data.
+  - Logical operators: `and`, `or`, `unless` for combining or excluding series.
+  - Aggregation operators: `sum`, `avg`, `min`, `max`, `count`, etc.
 
 Example: To query all HTTP requests with a status code of 200:
 
@@ -297,65 +321,63 @@ http_requests_total{status="200"}
 ### Common Query Patterns and Examples
 
 1. Rate of Change: Calculate the rate of change for a [counter metric](https://signoz.io/guides/what-is-the-difference-between-a-gauge-and-a-counter/) (e.g., requests per second).
-    
-    ```
-    rate(http_requests_total[5m])
-    
-    ```
-    
-    This returns the per-second rate of HTTP requests over the last 5 minutes.
-    
+
+   ```
+   rate(http_requests_total[5m])
+
+   ```
+
+   This returns the per-second rate of HTTP requests over the last 5 minutes.
+
 2. Aggregation: Aggregate data by a label, such as the total requests per HTTP method.
-    
-    ```
-    sum(http_requests_total) by (method)
-    
-    ```
-    
-    This sums the `http_requests_total` metric and groups it by the `method` label (e.g., GET, POST).
-    
+
+   ```
+   sum(http_requests_total) by (method)
+
+   ```
+
+   This sums the `http_requests_total` metric and groups it by the `method` label (e.g., GET, POST).
+
 3. Filtering by Time Range: Query metrics over a specific time range (e.g., the last 1 hour).
-    
-    ```
-    http_requests_total{status="200"}[1h]
-    
-    ```
-    
-    This returns the `http_requests_total` metric for status "200" over the last hour.
-    
+
+   ```
+   http_requests_total{status="200"}[1h]
+
+   ```
+
+   This returns the `http_requests_total` metric for status "200" over the last hour.
 
 ### Using Functions for Aggregation and Analysis
 
 PromQL includes a variety of functions that allow for complex aggregation and analysis of metrics:
 
 1. `avg()`: Calculate the average value of a metric.
-    
-    ```
-    avg(http_request_duration_seconds)
-    
-    ```
-    
+
+   ```
+   avg(http_request_duration_seconds)
+
+   ```
+
 2. `max()`: Find the maximum value of a metric.
-    
-    ```
-    max(http_request_duration_seconds)
-    
-    ```
-    
+
+   ```
+   max(http_request_duration_seconds)
+
+   ```
+
 3. `count()`: Count the number of time-series for a given metric.
-    
-    ```
-    count(http_requests_total)
-    
-    ```
-    
+
+   ```
+   count(http_requests_total)
+
+   ```
+
 4. `rate()`: Calculate the rate of increase for counters (used for time-series data that only increases, like HTTP request counts).
-    
-    ```
-    rate(http_requests_total[1m])
-    
-    ```
-    
+
+   ```
+   rate(http_requests_total[1m])
+
+   ```
 
 ### Tips for Writing Efficient Queries
 
@@ -375,56 +397,64 @@ Prometheus comes with a simple expression browser for querying and visualizing m
 
 1. Access the Browser: Navigate to `http://localhost:9090` and click on the "Graph" tab.
 2. Run Queries: Enter PromQL expressions in the query box to fetch metrics.
-    - Example: `rate(prometheus_http_requests_total[5m])` displays the per-second request rate over the past 5 minutes.
+   - Example: `rate(prometheus_http_requests_total[5m])` displays the per-second request rate over the past 5 minutes.
 3. Visualize: The results can be displayed as a graph or a table by toggling the view.
 
-<Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%204.webp" alt="Prometheus’s Built-in Expression Browser" caption="Prometheus’s Built-in Expression Browser" />
+<Figure
+  src="/img/guides/2025/02/prometheus-monitoring-101-image%204.webp"
+  alt="Prometheus’s Built-in Expression Browser"
+  caption="Prometheus’s Built-in Expression Browser"
+/>
 
 While useful for quick checks, the expression browser lacks advanced features like dashboards, making tools like Grafana essential.
 
 ### Introduction to Grafana for Advanced Dashboarding
 
-<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana</a> is a widely used open-source visualization tool that pairs perfectly with Prometheus for creating rich, interactive dashboards.
+<a href="https://grafana.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Grafana
+</a> is a widely used open-source visualization tool that pairs perfectly with Prometheus for
+creating rich, interactive dashboards.
 
 - Features:
-    - Customizable panels for metrics, logs, and alerts.
-    - Pre-built templates for popular metrics.
-    - Integration with multiple data sources, not just Prometheus.
+  - Customizable panels for metrics, logs, and alerts.
+  - Pre-built templates for popular metrics.
+  - Integration with multiple data sources, not just Prometheus.
 - Installation: You can install Grafana from <a href="https://grafana.com/grafana/download" rel="noopener noreferrer nofollow" target="_blank">here</a>.
 - Setup: To connect Grafana to Prometheus:
-    1. Open Grafana (`http://localhost:3000`) and log in (default username/password: `admin`/`admin`).
-    2. Add Prometheus as a data source:
-        - Navigate to Configuration > Data Sources.
-        - Click Add Data Source, select Prometheus, and configure the URL (e.g., `http://localhost:9090`).
+  1. Open Grafana (`http://localhost:3000`) and log in (default username/password: `admin`/`admin`).
+  2. Add Prometheus as a data source:
+     - Navigate to Configuration > Data Sources.
+     - Click Add Data Source, select Prometheus, and configure the URL (e.g., `http://localhost:9090`).
 
 ### Creating Your First Prometheus Dashboard in Grafana
 
 1. Start a New Dashboard:
-    - In Grafana, go to Create > Dashboard and click Add New Panel.
+   - In Grafana, go to Create > Dashboard and click Add New Panel.
 2. Add a Query:
-    - Enter a PromQL query, such as:
-        
-        ```
-        rate(prometheus_http_requests_total[5m])
-        
-        ```
-        
-    - Preview the results in the graph below.
-        
-        <Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%205.webp" alt="Visualizing Metrics in Grafana" caption="Visualizing Metrics in Grafana" />
-        
+   - Enter a PromQL query, such as:
+     ```
+     rate(prometheus_http_requests_total[5m])
+
+     ```
+   - Preview the results in the graph below.
+     {' '}
+     <Figure
+       src="/img/guides/2025/02/prometheus-monitoring-101-image%205.webp"
+       alt="Visualizing Metrics in Grafana"
+       caption="Visualizing Metrics in Grafana"
+     />
 3. Customize Visualization:
-    - Select the panel type (e.g., time series, gauge, table).
-    - Add titles, legends, and thresholds for clarity.
+   - Select the panel type (e.g., time series, gauge, table).
+   - Add titles, legends, and thresholds for clarity.
 4. Save Your Dashboard:
-    - Click Save Dashboard, give it a name, and optionally set sharing permissions.
+   - Click Save Dashboard, give it a name, and optionally set sharing permissions.
 
 ### Best Practices for Effective Data Visualization
 
 1. Keep Dashboards Focused: Group related metrics into panels to avoid clutter.
-    - Example: Group CPU, memory, and disk usage metrics in a "System Health" dashboard.
+   - Example: Group CPU, memory, and disk usage metrics in a "System Health" dashboard.
 2. Use Aggregations Wisely: Summarize data to focus on trends rather than individual points.
-    - Example: Use `sum(rate(...))` to visualize the overall request rate.
+   - Example: Use `sum(rate(...))` to visualize the overall request rate.
 3. Set Thresholds: Define thresholds to highlight critical values (e.g., red for high error rates).
 4. Leverage Annotations: Add event markers (e.g., deployments or outages) to correlate data with incidents.
 5. Optimize Panel Queries: Avoid overly complex queries that could slow down your dashboard. Use shorter time ranges or caching when possible.
@@ -437,75 +467,85 @@ Prometheus alerting lets you proactively identify system issues by setting up th
 
 Prometheus uses alerting rules defined in the `prometheus.yml` configuration file to trigger alerts based on conditions. Here's how you can set them up:
 
-1. Define Alerting Rules:
-Add an `alerting` section in the `prometheus.yml` file or include a separate rules file:
-    
-    ```yaml
-    rule_files:
-      - "alerts.yml"
-    
-    ```
-    
-2. Example Alerting Rule:
-In `alerts.yml`, define an alert for high CPU usage:
-    
-    ```yaml
-    groups:
-      - name: cpu_alerts
-        rules:
-          - alert: HighCPUUsage
-            expr: avg(rate(node_cpu_seconds_total{mode!="idle"}[5m])) > 0.8
-            for: 2m
-            labels:
-              severity: critical
-            annotations:
-              summary: "High CPU usage detected"
-              description: "The average CPU usage is above 80% for the last 2 minutes."
-    
-    ```
-    
-    - `expr`: PromQL expression to evaluate.
-    - `for`: How long must the condition persist before firing an alert?
-    - `labels`: Metadata for categorizing alerts (e.g., severity).
-    - `annotations`: Add context for the alert, like a summary and description.
-3. Apply Configuration: Restart the Prometheus server to apply the changes.
-
-<Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%206.webp" alt="Setting Alerts in Prometheus" caption="Setting Alerts in Prometheus" />
+1.  Define Alerting Rules:
+    Add an `alerting` section in the `prometheus.yml` file or include a separate rules file:
+        ```yaml
+        rule_files:
+          - "alerts.yml"
+
+        ```
+2.  Example Alerting Rule:
+    In `alerts.yml`, define an alert for high CPU usage:
+        ```yaml
+        groups:
+          - name: cpu_alerts
+            rules:
+              - alert: HighCPUUsage
+                expr: avg(rate(node_cpu_seconds_total{mode!="idle"}[5m])) > 0.8
+                for: 2m
+                labels:
+                  severity: critical
+                annotations:
+                  summary: "High CPU usage detected"
+                  description: "The average CPU usage is above 80% for the last 2 minutes."
+
+        ```
+
+        - `expr`: PromQL expression to evaluate.
+        - `for`: How long must the condition persist before firing an alert?
+        - `labels`: Metadata for categorizing alerts (e.g., severity).
+        - `annotations`: Add context for the alert, like a summary and description.
+3.  Apply Configuration: Restart the Prometheus server to apply the changes.
+
+<Figure
+  src="/img/guides/2025/02/prometheus-monitoring-101-image%206.webp"
+  alt="Setting Alerts in Prometheus"
+  caption="Setting Alerts in Prometheus"
+/>
 
 ### Understanding Alert States and Labels
 
 1. Alert States:
-    - Pending: The condition has been met but not for the required duration.
-    - Firing: The alert is active and will trigger notifications.
-    - Resolved: The condition is no longer met.
-    
-    <Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%207.webp" alt="Alert States" caption="Alert States" />
-    
+
+   - Pending: The condition has been met but not for the required duration.
+   - Firing: The alert is active and will trigger notifications.
+   - Resolved: The condition is no longer met.
+
+   <Figure
+     src="/img/guides/2025/02/prometheus-monitoring-101-image%207.webp"
+     alt="Alert States"
+     caption="Alert States"
+   />
+
 2. Labels:
-    - Labels help identify and group alerts.
-    - Example: `severity: critical` can be used to route high-priority alerts to specific channels.
-    
-    <Figure src="/img/guides/2025/02/prometheus-monitoring-101-image%208.webp" alt="Alert Labels" caption="Alert Labels" />
-    
+
+   - Labels help identify and group alerts.
+   - Example: `severity: critical` can be used to route high-priority alerts to specific channels.
+
+   <Figure
+     src="/img/guides/2025/02/prometheus-monitoring-101-image%208.webp"
+     alt="Alert Labels"
+     caption="Alert Labels"
+   />
 
 Alertmanager is used to handle notifications triggered by Prometheus alerts. It supports routing, deduplication, and silencing. You can configure Alertmanager using this [guide](https://signoz.io/guides/how-do-i-add-alerts-to-prometheus/#configuring-notification-channels).
 
 ### Best Practices for Creating Meaningful and Actionable Alerts
 
 1. Define Clear Alert Thresholds:
-    - Use thresholds that represent real issues, avoiding false positives.
-    - Example: Set disk usage alerts at 90%, not 70%.
+   - Use thresholds that represent real issues, avoiding false positives.
+   - Example: Set disk usage alerts at 90%, not 70%.
 2. Categorize Alerts by Severity:
-    - Use labels like `severity: critical` or `severity: warning` to prioritize responses.
+   - Use labels like `severity: critical` or `severity: warning` to prioritize responses.
 3. Add Context to Alerts:
-    - Include meaningful summaries and descriptions in `annotations`.
-    - Example: Specify affected systems or recommended actions.
+   - Include meaningful summaries and descriptions in `annotations`.
+   - Example: Specify affected systems or recommended actions.
 4. Avoid Overlapping Alerts:
-    - Ensure alerts are distinct and don’t create noise for the same issue.
+   - Ensure alerts are distinct and don’t create noise for the same issue.
 5. Test Alerts Regularly:
-    - Use tools like the Prometheus web UI or PromQL queries to simulate alert conditions.
+   - Use tools like the Prometheus web UI or PromQL queries to simulate alert conditions.
 6. Integrate with Incident Management Tools:
-    - Route alerts to tools like PagerDuty, Opsgenie, or Slack for streamlined handling.
+   - Route alerts to tools like PagerDuty, Opsgenie, or Slack for streamlined handling.
 
 ## Scaling Prometheus for Production Environments
 
@@ -520,8 +560,8 @@ Scaling Prometheus effectively ensures it can handle the demands of large-scale,
 ### 2. Long-Term Storage Solutions
 
 - Prometheus’s built-in storage is not designed for long-term retention. Use remote write integrations with tools like:
-    - Thanos: Adds long-term storage and global querying.
-    - Cortex or VictoriaMetrics: Scalable solutions for high availability and extended data retention.
+  - Thanos: Adds long-term storage and global querying.
+  - Cortex or VictoriaMetrics: Scalable solutions for high availability and extended data retention.
 
 ### 3. High Availability Setups
 
@@ -562,13 +602,13 @@ If no existing exporter meets your requirements, you can create custom exporters
 
 [SigNoz](https://signoz.io/) is a powerful, full-stack observability platform designed to monitor, trace, and debug modern applications seamlessly. While Prometheus excels at metrics monitoring, SigNoz extends observability by integrating metrics, logs, and distributed tracing into a unified interface, offering a comprehensive solution for modern application monitoring. Here’s how SigNoz complements Prometheus and why it could be the right choice for your full-stack observability needs:
 
-| Feature | Prometheus | SigNoz |
-| --- | --- | --- |
-| Metrics Monitoring | Yes | Yes |
-| Distributed Tracing | No (requires Jaeger/others) | Yes (built-in) |
-| Long-Term Storage | Requires external tools | Built-in with scalable storage |
-| Visualization | Requires Grafana | Integrated dashboards |
-| Ease of Setup | Manual configuration | Simple out-of-the-box setup |
+| Feature             | Prometheus                  | SigNoz                         |
+| ------------------- | --------------------------- | ------------------------------ |
+| Metrics Monitoring  | Yes                         | Yes                            |
+| Distributed Tracing | No (requires Jaeger/others) | Yes (built-in)                 |
+| Long-Term Storage   | Requires external tools     | Built-in with scalable storage |
+| Visualization       | Requires Grafana            | Integrated dashboards          |
+| Ease of Setup       | Manual configuration        | Simple out-of-the-box setup    |
 
 While Prometheus is an excellent tool for collecting and querying metrics, SigNoz provides a more comprehensive observability solution by including [distributed tracing](https://signoz.io/blog/distributed-tracing/) and log management alongside metrics. SigNoz is built on open standards like OpenTelemetry, ensuring compatibility and flexibility, while simplifying the setup and management of complex observability tasks.
 
@@ -587,64 +627,67 @@ Pre-requisites:
 Follow these steps:
 
 1. Set Up the Prometheus Receiver
-    
-    Once the OpenTelemetry Collector is installed, configure it to scrape Prometheus metrics. Edit your `otel-collector-config.yaml` file and add a [Prometheus receiver](https://signoz.io/blog/opentelemetry-collector-prometheus-receiver/) configuration:
-    
-    - New Job:
-    
-    ```sql
-    receivers:
-      prometheus:
-        config:
-          scrape_configs:
-            - job_name: 'prometheus'
-              static_configs:
-                - targets: ['localhost:8080'] *#update your port here*
-    
-    ```
-    
-    - Existing Job:
-    
-    ```sql
-    - job_name: "otel-collector"
-      scrape_interval: 30s
-      static_configs:
-        - targets: ["otel-collector:8889", "localhost:31000"] #update the prometheus port
-    
-    ```
-    
+
+   Once the OpenTelemetry Collector is installed, configure it to scrape Prometheus metrics. Edit your `otel-collector-config.yaml` file and add a [Prometheus receiver](https://signoz.io/blog/opentelemetry-collector-prometheus-receiver/) configuration:
+
+   - New Job:
+
+   ```sql
+   receivers:
+     prometheus:
+       config:
+         scrape_configs:
+           - job_name: 'prometheus'
+             static_configs:
+               - targets: ['localhost:8080'] *#update your port here*
+
+   ```
+
+   - Existing Job:
+
+   ```sql
+   - job_name: "otel-collector"
+     scrape_interval: 30s
+     static_configs:
+       - targets: ["otel-collector:8889", "localhost:31000"] #update the prometheus port
+
+   ```
+
 2. Connect to SigNoz Cloud
-    
-    Update the exporter section of the configuration to send metrics to your SigNoz Cloud endpoint. Replace `<cloud-instance-url>` and `<SIGNOZ_INGESTION_KEY>` with your SigNoz Cloud details:
-    
-    ```sql
-    exporters:
-      otlp:
-        endpoint: <cloud-instance-url>
-        tls:
-          insecure: false
-        headers:
-          "signoz-ingestion-key": <SIGNOZ_INGESTION_KEY>
-    
-    service:
-      pipelines:
-        metrics:
-          receivers: [prometheus]
-          processors: [batch, resourcedetection]
-          exporters: [otlp]
-    
-    ```
-    
+
+   Update the exporter section of the configuration to send metrics to your SigNoz Cloud endpoint. Replace `<cloud-instance-url>` and `<SIGNOZ_INGESTION_KEY>` with your SigNoz Cloud details:
+
+   ```sql
+   exporters:
+     otlp:
+       endpoint: <cloud-instance-url>
+       tls:
+         insecure: false
+       headers:
+         "signoz-ingestion-key": <SIGNOZ_INGESTION_KEY>
+
+   service:
+     pipelines:
+       metrics:
+         receivers: [prometheus]
+         processors: [batch, resourcedetection]
+         exporters: [otlp]
+
+   ```
+
 3. Apply Changes
-    
-    Restart the OpenTelemetry Collector to apply the new configuration
-    
+
+   Restart the OpenTelemetry Collector to apply the new configuration
+
 4. Verify Configuration in SigNoz Cloud
-    
-    Log in to your SigNoz Cloud dashboard and check for Prometheus metrics to ensure the metrics are being scraped and sent successfully.
-    
-    <Figure src="/img/guides/2025/02/prometheus-monitoring-101-configure-prometheus-to-use-non-default-port-image204.webp" alt="Verify Configuration in SigNoz Cloud" caption="Verify Configuration in SigNoz Cloud" />
-    
+
+   Log in to your SigNoz Cloud dashboard and check for Prometheus metrics to ensure the metrics are being scraped and sent successfully.
+
+   <Figure
+     src="/img/guides/2025/02/prometheus-monitoring-101-configure-prometheus-to-use-non-default-port-image204.webp"
+     alt="Verify Configuration in SigNoz Cloud"
+     caption="Verify Configuration in SigNoz Cloud"
+   />
 
 By combining Prometheus with SigNoz, you can elevate your monitoring and observability strategy, ensuring better performance, security, and reliability for your systems.
 
@@ -672,4 +715,4 @@ Prometheus is primarily designed for metrics. For logging, consider complementar
 
 ### What are the limitations of Prometheus, and how can they be addressed?
 
-Prometheus has limitations in long-term storage and high-cardinality data handling. These can be addressed through remote storage solutions and careful metric design. Alternatively, consider a more comprehensive solution like SigNoz.
\ No newline at end of file
+Prometheus has limitations in long-term storage and high-cardinality data handling. These can be addressed through remote storage solutions and careful metric design. Alternatively, consider a more comprehensive solution like SigNoz.
diff --git a/data/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods.mdx b/data/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods.mdx
index 9f4a9a615..eae2931d7 100644
--- a/data/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods.mdx
+++ b/data/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods.mdx
@@ -1,172 +1,186 @@
 ---
-
 title: What are the Prometheus Queries to Monitoring Kubernetes Pod CPU and Memory
-slug: prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods
 date: 2024-07-25
 tags: [prometheus, faq]
 authors: [daniel]
 description: Learn how to monitor Kubernetes pod CPU and memory usage with Prometheus queries. Optimize your cluster performance with effective resource tracking.
-keywords: [Kubernetes monitoring, Prometheus queries, pod CPU usage, pod memory usage, PromQL, resource metrics, container monitoring]
-
+keywords:
+  [
+    Kubernetes monitoring,
+    Prometheus queries,
+    pod CPU usage,
+    pod memory usage,
+    PromQL,
+    resource metrics,
+    container monitoring,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What are the Prometheus Queries to Monitoring Kubernetes Pod CPU and Memory",
-    "alternativeHeadline": "Prometheus Queries for Monitoring Kubernetes Pod CPU and Memory Usage",
-    "author": {
-      "@type": "Daniel",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-25T00:00:00Z",
-    "dateModified": "2024-07-25T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods/"
-    },
-    "description": "Learn how to monitor Kubernetes pod CPU and memory usage with Prometheus queries. Optimize your cluster performance with effective resource tracking.",
-    "keywords": "Kubernetes monitoring, Prometheus queries, pod CPU usage, pod memory usage, PromQL, resource metrics, container monitoring",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Kubernetes",
-        "description": "An open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications."
-      },
-      {
-        "@type": "Thing",
-        "name": "PromQL",
-        "description": "Prometheus Query Language used to query and analyze metrics."
-      },
-      {
-        "@type": "Thing",
-        "name": "CPU Usage",
-        "description": "Measurement of the processing power used by an application or system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Memory Usage",
-        "description": "Measurement of the memory consumed by an application or system."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Grafana",
-        "applicationCategory": "Visualization Tool"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Why monitor Kubernetes pod resources?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Monitoring Kubernetes pod resources is essential for maintaining optimal cluster performance and cost-efficiency. It helps track resource usage, identify issues, make informed scaling decisions, and control costs."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What are key metrics for CPU and memory usage in Kubernetes pods?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Key metrics include container_cpu_usage_seconds_total for CPU usage and container_memory_usage_bytes for memory usage. Additionally, kube_pod_container_resource_limits and kube_pod_container_resource_requests provide information on resource limits and requests."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What are the Prometheus Queries to Monitoring Kubernetes Pod CPU and Memory',
+        alternativeHeadline:
+          'Prometheus Queries for Monitoring Kubernetes Pod CPU and Memory Usage',
+        author: {
+          '@type': 'Daniel',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "How to query CPU usage in Kubernetes pods with Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "To query CPU usage, use Prometheus queries such as: sum(rate(container_cpu_usage_seconds_total{container!=\"\"}[5m])) by (pod) for basic CPU usage per pod, and sum(rate(container_cpu_usage_seconds_total{container!=\"\"}[5m])) by (pod) / sum(kube_pod_container_resource_limits{resource=\"cpu\"}) by (pod) * 100 for CPU usage as a percentage of allocated resources."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "How to monitor memory usage in Kubernetes pods with Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use queries like sum(container_memory_usage_bytes{container!=\"\"}) by (pod) for current memory usage across pods and sum(rate(container_memory_usage_bytes{container!=\"\"}[1h])) by (pod) for memory usage trends over time. To identify potential memory leaks, use sum(container_memory_working_set_bytes{container!=\"\"}) by (pod) / sum(kube_pod_container_resource_limits{resource=\"memory\"}) by (pod) > 0.8."
-          }
+        datePublished: '2024-07-25T00:00:00Z',
+        dateModified: '2024-07-25T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id':
+            'https://signoz.io/guides/prometheus-queries-to-get-cpu-and-memory-usage-in-kubernetes-pods/',
         },
-        {
-          "@type": "Question",
-          "name": "What are best practices for Prometheus queries in Kubernetes?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Best practices include using label selectors efficiently, aggregating metrics wisely, implementing rate() and increase() functions for accurate measurements, and optimizing query performance by using time range selectors judiciously and avoiding overly complex queries."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Monitoring Kubernetes Pod CPU and Memory Usage with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Understand PromQL",
-          "text": "Grasp the basics of PromQL (Prometheus Query Language) to unlock powerful insights from your Kubernetes metrics."
+        description:
+          'Learn how to monitor Kubernetes pod CPU and memory usage with Prometheus queries. Optimize your cluster performance with effective resource tracking.',
+        keywords:
+          'Kubernetes monitoring, Prometheus queries, pod CPU usage, pod memory usage, PromQL, resource metrics, container monitoring',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Identify Key Metrics",
-          "text": "Key metrics for CPU and memory usage in Kubernetes pods include container_cpu_usage_seconds_total, container_memory_usage_bytes, kube_pod_container_resource_limits, and kube_pod_container_resource_requests."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Kubernetes',
+            description:
+              'An open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'PromQL',
+            description: 'Prometheus Query Language used to query and analyze metrics.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'CPU Usage',
+            description: 'Measurement of the processing power used by an application or system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Memory Usage',
+            description: 'Measurement of the memory consumed by an application or system.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Grafana',
+            applicationCategory: 'Visualization Tool',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Why monitor Kubernetes pod resources?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Monitoring Kubernetes pod resources is essential for maintaining optimal cluster performance and cost-efficiency. It helps track resource usage, identify issues, make informed scaling decisions, and control costs.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are key metrics for CPU and memory usage in Kubernetes pods?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Key metrics include container_cpu_usage_seconds_total for CPU usage and container_memory_usage_bytes for memory usage. Additionally, kube_pod_container_resource_limits and kube_pod_container_resource_requests provide information on resource limits and requests.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How to query CPU usage in Kubernetes pods with Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To query CPU usage, use Prometheus queries such as: sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod) for basic CPU usage per pod, and sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod) / sum(kube_pod_container_resource_limits{resource="cpu"}) by (pod) * 100 for CPU usage as a percentage of allocated resources.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How to monitor memory usage in Kubernetes pods with Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use queries like sum(container_memory_usage_bytes{container!=""}) by (pod) for current memory usage across pods and sum(rate(container_memory_usage_bytes{container!=""}[1h])) by (pod) for memory usage trends over time. To identify potential memory leaks, use sum(container_memory_working_set_bytes{container!=""}) by (pod) / sum(kube_pod_container_resource_limits{resource="memory"}) by (pod) > 0.8.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are best practices for Prometheus queries in Kubernetes?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Best practices include using label selectors efficiently, aggregating metrics wisely, implementing rate() and increase() functions for accurate measurements, and optimizing query performance by using time range selectors judiciously and avoiding overly complex queries.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Query CPU Usage",
-          "text": "Use PromQL queries to monitor CPU usage, such as sum(rate(container_cpu_usage_seconds_total{container!=\"\"}[5m])) by (pod) for basic CPU usage per pod."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Monitoring Kubernetes Pod CPU and Memory Usage with Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Understand PromQL',
+              text: 'Grasp the basics of PromQL (Prometheus Query Language) to unlock powerful insights from your Kubernetes metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Identify Key Metrics',
+              text: 'Key metrics for CPU and memory usage in Kubernetes pods include container_cpu_usage_seconds_total, container_memory_usage_bytes, kube_pod_container_resource_limits, and kube_pod_container_resource_requests.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Query CPU Usage',
+              text: 'Use PromQL queries to monitor CPU usage, such as sum(rate(container_cpu_usage_seconds_total{container!=""}[5m])) by (pod) for basic CPU usage per pod.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Query Memory Usage',
+              text: 'Use PromQL queries to monitor memory usage, such as sum(container_memory_usage_bytes{container!=""}) by (pod) for current memory usage across pods.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize Data in Grafana',
+              text: 'Create informative dashboards in Grafana by setting up panels for CPU and memory usage trends, using gauge charts for current resource utilization percentages, and implementing heat maps to identify patterns in resource usage over time.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Query Memory Usage",
-          "text": "Use PromQL queries to monitor memory usage, such as sum(container_memory_usage_bytes{container!=\"\"}) by (pod) for current memory usage across pods."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize Data in Grafana",
-          "text": "Create informative dashboards in Grafana by setting up panels for CPU and memory usage trends, using gauge charts for current resource utilization percentages, and implementing heat maps to identify patterns in resource usage over time."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Kubernetes has revolutionized container orchestration, but with great power comes great responsibility—especially when it comes to resource management. Monitoring your Kubernetes pod CPU and memory usage is crucial for maintaining optimal cluster performance and cost-efficiency. Prometheus, a powerful open-source monitoring system, offers robust querying capabilities to help you track these vital metrics. This guide will walk you through essential Prometheus queries to get CPU and memory usage in Kubernetes pods, ensuring you can keep your cluster running smoothly.
@@ -313,8 +327,9 @@ While Prometheus offers powerful monitoring capabilities, managing retention and
 <GetStartedSigNoz />
 
 With [SigNoz](https://signoz.io/docs/introduction/), you can:
+
 - Scale your monitoring infrastructure effortlessly
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
 - Get high performance with the clickhouse database
-- Take advantage of SigNoz's exceptional exception monitoring capabilities
\ No newline at end of file
+- Take advantage of SigNoz's exceptional exception monitoring capabilities
diff --git a/data/guides/prometheus-query-to-count-unique-label-values.mdx b/data/guides/prometheus-query-to-count-unique-label-values.mdx
index 09ed621c9..d453c9986 100644
--- a/data/guides/prometheus-query-to-count-unique-label-values.mdx
+++ b/data/guides/prometheus-query-to-count-unique-label-values.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Count Unique Label Values with Prometheus Queries
-slug: prometheus-query-to-count-unique-label-values
 date: 2024-09-06
 tags: [Prometheus, Monitoring, PromQL, Metrics]
 authors: [simran_kumari]
 description: Learn how to effectively count unique label values using Prometheus queries. Master PromQL functions, optimize performance, and visualize results in Grafana.
-keywords: [Prometheus, PromQL, unique label values, count function, monitoring, metrics, Grafana, SigNoz]
-
+keywords:
+  [Prometheus, PromQL, unique label values, count function, monitoring, metrics, Grafana, SigNoz]
 ---
 
 Prometheus is renowned for its robust time-series data collection and querying capabilities. However, when it comes to counting unique label values, you may encounter some challenges. This guide will walk you through the essentials of Prometheus labels, the intricacies of counting unique values, and advanced techniques for optimizing your queries. We’ll also explore how to visualize these insights in Grafana and leverage SigNoz for enhanced monitoring.
@@ -16,7 +14,11 @@ Prometheus is renowned for its robust time-series data collection and querying c
 
 [Prometheus labels](https://signoz.io/guides/what-are-prometheus-labels/) are key-value pairs attached to metrics that provide additional context and allow for more detailed data analysis. They play a crucial role in identifying and categorizing metrics, enabling you to slice and dice your data in numerous ways.
 
-<Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image.webp" alt="Prometheus Labels" caption="Prometheus Labels" />
+<Figure
+  src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image.webp"
+  alt="Prometheus Labels"
+  caption="Prometheus Labels"
+/>
 
 Labels allow you to slice and dice your metrics with precision. For example, instead of having a single, monolithic count of HTTP requests, you can break it down by method, status code, endpoint, or any other dimension that matters to you. This granularity is key for:
 
@@ -36,9 +38,9 @@ In a dynamic environment, labels can multiply quickly. You might have hundreds o
 
 ## The Challenge of Counting Unique Label Values
 
-Counting unique label values can be tricky with Prometheus's basic queries. While Prometheus excels at tracking metrics over time, its standard functions aren’t designed to directly count distinct label values. 
+Counting unique label values can be tricky with Prometheus's basic queries. While Prometheus excels at tracking metrics over time, its standard functions aren’t designed to directly count distinct label values.
 
-The problem lies in Prometheus’s design. It’s optimized for performance and scalability, which means handling high-cardinality data (data with a large number of unique label combinations) isn’t its strong suit. 
+The problem lies in Prometheus’s design. It’s optimized for performance and scalability, which means handling high-cardinality data (data with a large number of unique label combinations) isn’t its strong suit.
 
 To tackle this, PromQL offers specialized functions designed for counting unique values:
 
@@ -76,29 +78,28 @@ Step-by-Step Guide to Using `count()`
 Examples of `count()` Queries
 
 1. Service Discovery: To find out how many instances of each service are running:
-    
-    ```
-    count(service_up) by (service_name)
-    ```
-    
-    This aggregates the number of service instances by `service_name`.
-    
+
+   ```
+   count(service_up) by (service_name)
+   ```
+
+   This aggregates the number of service instances by `service_name`.
+
 2. Capacity Planning: To count unique tenants or users:
-    
-    ```
-    count(user_activity_total) by (tenant_id)
-    ```
-    
-    This shows the number of metrics per unique `tenant_id`.
-    
+
+   ```
+   count(user_activity_total) by (tenant_id)
+   ```
+
+   This shows the number of metrics per unique `tenant_id`.
+
 3. Error Analysis: To count occurrences of each error type:
-    
-    ```
-    count(application_errors_total) by (error_type)
-    ```
-    
-    This groups error counts by `error_type`.
-    
+
+   ```
+   count(application_errors_total) by (error_type)
+   ```
+
+   This groups error counts by `error_type`.
 
 Best Practices for Optimizing `count()` Queries
 
@@ -112,7 +113,7 @@ When you need to dive deeper into your metrics, combining `count()` with `by()`
 
 Combining `count()` with `by()`
 
-Using `count()` in conjunction with `by()`  lets you [aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/) across different dimensions. This is essential for complex queries where you want to analyze data across multiple labels.
+Using `count()` in conjunction with `by()` lets you [aggregate metrics](https://signoz.io/docs/metrics-management/types-and-aggregation/) across different dimensions. This is essential for complex queries where you want to analyze data across multiple labels.
 
 Syntax Example:
 
@@ -125,29 +126,28 @@ Here, `metric_name` is the metric you’re querying, and `label1` and `label2` a
 Examples of Complex Queries
 
 1. Service and Region Analysis: To count the number of active services by both `service_name` and `region`:
-    
-    ```
-    count(service_up) by (service_name, region)
-    ```
-    
-    This query helps in understanding how many instances of each service are running in each region.
-    
+
+   ```
+   count(service_up) by (service_name, region)
+   ```
+
+   This query helps in understanding how many instances of each service are running in each region.
+
 2. User Activity by Role and Region: To count the number of unique users segmented by `user_role` and `region`:
-    
-    ```
-    count(user_activity_total) by (user_role, region)
-    ```
-    
-    This provides insight into user activity levels across different roles and regions.
-    
+
+   ```
+   count(user_activity_total) by (user_role, region)
+   ```
+
+   This provides insight into user activity levels across different roles and regions.
+
 3. Error Types by Service and Environment: To count distinct error types across `service_name` and `environment`:
-    
-    ```
-    count(application_errors_total) by (error_type, service_name, environment)
-    ```
-    
-    This helps in pinpointing which error types are occurring in which services and environments.
-    
+
+   ```
+   count(application_errors_total) by (error_type, service_name, environment)
+   ```
+
+   This helps in pinpointing which error types are occurring in which services and environments.
 
 Handling [High Cardinality](https://signoz.io/blog/high-cardinality-data/) Efficiently
 
@@ -198,37 +198,72 @@ This query creates a new time series for each unique HTTP status code, allowing
 Grafana, a popular open-source visualization tool, integrates seamlessly with Prometheus to create powerful dashboards. To visualize unique label counts:
 
 1. Add the Prometheus server as the data source to your Grafana server.
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%201.webp" alt="Adding Prometheus server as a data source in Grafana" caption="Adding Prometheus server as a data source in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%201.webp"
+     alt="Adding Prometheus server as a data source in Grafana"
+     caption="Adding Prometheus server as a data source in Grafana"
+   />
+
 2. Create a new dashboard by adding a visualization.
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%202.webp" alt="Creating Grafana Dashboard" caption="Creating Grafana Dashboard" />
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%203.webp" alt="Add visualization to Grafana Dashboard" caption="Add visualization to Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%202.webp"
+     alt="Creating Grafana Dashboard"
+     caption="Creating Grafana Dashboard"
+   />
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%203.webp"
+     alt="Add visualization to Grafana Dashboard"
+     caption="Add visualization to Grafana Dashboard"
+   />
+
 3. Select the data source i.e. the Prometheus server.
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%204.webp" alt="Selecting Prometheus server as data source for Grafana Dashboard" caption="Selecting Prometheus server as data source for Grafana Dashboard" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%204.webp"
+     alt="Selecting Prometheus server as data source for Grafana Dashboard"
+     caption="Selecting Prometheus server as data source for Grafana Dashboard"
+   />
+
 4. Use the Prometheus query editor to enter your unique label count query (e.g., `count(up) without(instance)`)
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%205.webp" alt="Running PromQL queries in Grafana to see unique label counts." caption="Running PromQL queries in Grafana to see unique label counts." />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%205.webp"
+     alt="Running PromQL queries in Grafana to see unique label counts."
+     caption="Running PromQL queries in Grafana to see unique label counts."
+   />
+
 5. Choose an appropriate visualization type (e.g., gauge, bar chart, or table)
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%206.webp" alt="Choosing visualization type in the Grafana dashboard" caption="Choosing visualization type in the Grafana dashboard" />
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%207.webp" alt="Switching to pie charts and running PromQL queries" caption="Switching to pie charts and running PromQL queries" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%206.webp"
+     alt="Choosing visualization type in the Grafana dashboard"
+     caption="Choosing visualization type in the Grafana dashboard"
+   />
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%207.webp"
+     alt="Switching to pie charts and running PromQL queries"
+     caption="Switching to pie charts and running PromQL queries"
+   />
+
 6. Set the panel title to "Active Instances"
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%208.webp" alt="Giving a title to Dashboard Panel in Grafana" caption="Giving a title to Dashboard Panel in Grafana" />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%208.webp"
+     alt="Giving a title to Dashboard Panel in Grafana"
+     caption="Giving a title to Dashboard Panel in Grafana"
+   />
+
 7. Adjust thresholds and other display options as needed and apply the changes.
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%209.webp" alt="Grafana panel showing unique instance count." caption="Grafana panel showing unique instance count." />
-    
+
+   <Figure
+     src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%209.webp"
+     alt="Grafana panel showing unique instance count."
+     caption="Grafana panel showing unique instance count."
+   />
 
 Tips for effective visualizations:
 
@@ -246,24 +281,33 @@ PromQL, while powerful for time-series data collection and querying, has certain
 
 ## Enhancing Monitoring with SigNoz
 
-While Prometheus is excellent for time-series data collection and querying, SigNoz extends its capabilities by offering advanced features for label-based analysis and visualization. 
+While Prometheus is excellent for time-series data collection and querying, SigNoz extends its capabilities by offering advanced features for label-based analysis and visualization.
 
 SigNoz is an open-source monitoring and observability platform designed to provide comprehensive insights into your applications and infrastructure. It offers a robust suite of features for tracking and analyzing metrics, traces, and logs, all from a unified interface. SigNoz aims to enhance observability, improve troubleshooting, and optimize performance across your systems.
 
 Here’s how SigNoz complements Prometheus:
 
 - Efficient High-Cardinality Management: SigNoz is optimized to handle metrics with numerous unique label combinations, improving performance and reducing resource strain compared to standard PromQL setups.
-    
-    <Figure src="/img/docs/product-features/query-builder/query-builder-filtering.gif" alt="Efficient High-Cardinality Data Management using SigNoz" caption="Efficient High-Cardinality Data Management using SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/docs/product-features/query-builder/query-builder-filtering.gif"
+    alt="Efficient High-Cardinality Data Management using SigNoz"
+    caption="Efficient High-Cardinality Data Management using SigNoz"
+  />
 - Streamlined Querying: SigNoz offers a more user-friendly interface for constructing complex queries, making it easier to perform multi-dimensional analysis without the complexity often encountered in PromQL.
-    
-    <Figure src="/img/docs/product-features/query-builder/group_by.gif" alt="Streamline Querying using SigNoz" caption="Streamline Querying using SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/docs/product-features/query-builder/group_by.gif"
+    alt="Streamline Querying using SigNoz"
+    caption="Streamline Querying using SigNoz"
+  />
 - Integrated Visualization: With built-in advanced visualization tools, SigNoz enables dynamic and insightful dashboards, making it simpler to analyze and understand metrics, especially when dealing with high-cardinality data.
-    
-    <Figure src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%2010.webp" alt="Integrated Visualization in SigNoz" caption="Integrated Visualization in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/09/prometheus-query-to-count-unique-label-values-image%2010.webp"
+    alt="Integrated Visualization in SigNoz"
+    caption="Integrated Visualization in SigNoz"
+  />
 
 <GetStartedSigNoz />
 
@@ -310,4 +354,4 @@ Counting unique label values aids capacity planning by:
 2. Monitoring user or tenant growth in multi-tenant systems
 3. Identifying trends in resource utilization across different services or environments
 
-By analyzing these unique counts over time, you can forecast future resource needs and plan accordingly.
\ No newline at end of file
+By analyzing these unique counts over time, you can forecast future resource needs and plan accordingly.
diff --git a/data/guides/promql-cheat-sheet.mdx b/data/guides/promql-cheat-sheet.mdx
index e0668ff74..37f107476 100644
--- a/data/guides/promql-cheat-sheet.mdx
+++ b/data/guides/promql-cheat-sheet.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: Essential PromQL Cheat Sheet - Master Prometheus Queries
-slug: promql-cheat-sheet
 date: 2024-11-29
 tags: [prometheus]
 authors: [simran_kumari]
 description: Master Prometheus queries with our comprehensive PromQL cheat sheet. Learn syntax, functions, and advanced techniques for effective monitoring and troubleshooting.
 keywords: [PromQL, Prometheus, monitoring, queries, cheat sheet, DevOps, metrics, observability]
-
 ---
 
 Prometheus Query Language (PromQL) is a powerful tool for extracting insights from Prometheus metrics. Whether you're diagnosing system performance, setting up alerts, or analyzing historical trends, PromQL enables precise data querying and visualization. This comprehensive cheat sheet will guide you from the basics to advanced techniques, with practical examples and tips for performance optimization.
@@ -111,44 +108,42 @@ PromQL includes a wide range of functions that simplify tasks like rate calculat
 ### Rate Calculations
 
 1. `rate()`: Calculate per-second average rate of increase
-    
-    ```
-    rate(http_requests_total[5m])
-    ```
-    
+
+   ```
+   rate(http_requests_total[5m])
+   ```
+
 2. `irate()`: Calculate instant rate of increase
-    
-    ```
-    irate(http_requests_total[5m])
-    ```
-    
+
+   ```
+   irate(http_requests_total[5m])
+   ```
 
 ### Aggregation Functions
 
 1. `sum()`: Add values
-    
-    ```
-    sum(http_requests_total) by (status)
-    ```
-    
+
+   ```
+   sum(http_requests_total) by (status)
+   ```
+
 2. `avg()`: Calculate average
-    
-    ```
-    avg(node_cpu_utilization) by (instance)
-    ```
-    
+
+   ```
+   avg(node_cpu_utilization) by (instance)
+   ```
+
 3. `max()` and `min()`: Find maximum and minimum values
-    
-    ```
-    max(http_request_duration_seconds) by (endpoint)
-    ```
-    
+
+   ```
+   max(http_request_duration_seconds) by (endpoint)
+   ```
+
 4. `increase()`: Calculates the total increase over a time window.
-    
-    ```
-    increase(http_requests_total[5m])
-    ```
-    
+
+   ```
+   increase(http_requests_total[5m])
+   ```
 
 ### Histogram Analysis
 
@@ -161,17 +156,16 @@ histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
 ### Absence Detection
 
 1. `absent()`: Check if a metric is missing
-    
-    ```
-    absent(up{job="important-service"})
-    ```
-    
+
+   ```
+   absent(up{job="important-service"})
+   ```
+
 2. `absent_over_time()`: Check if a metric was absent for a time range
-    
-    ```
-    absent_over_time(up{job="important-service"}[1h])
-    ```
-    
+
+   ```
+   absent_over_time(up{job="important-service"}[1h])
+   ```
 
 ## Mastering Time Series Selection in PromQL
 
@@ -219,29 +213,27 @@ This computes the maximum rate of `http_requests_total` over each 1-hour interva
 
 ## Advanced PromQL Techniques for Performance Optimization
 
-As your infrastructure grows, writing efficient PromQL queries becomes increasingly critical to ensure smooth performance and quick responses. 
+As your infrastructure grows, writing efficient PromQL queries becomes increasingly critical to ensure smooth performance and quick responses.
 
 Here are some best practices and advanced techniques to optimize your PromQL queries for large-scale deployments and complex monitoring scenarios.
 
 1. Use label matching efficiently:
-    - Avoid using `{__name__=~".*"}` which selects all metrics
-    - Be specific with label matches to reduce the query scope
+   - Avoid using `{__name__=~".*"}` which selects all metrics
+   - Be specific with label matches to reduce the query scope
 2. Leverage pre-recorded rules:
-    - Create recording rules for frequently used queries
-    - Example rule:
-        
-        ```yaml
-        - record: job:http_requests_total:rate5m
-          expr: rate(http_requests_total[5m])
-        ```
-        
+   - Create recording rules for frequently used queries
+   - Example rule:
+     ```yaml
+     - record: job:http_requests_total:rate5m
+       expr: rate(http_requests_total[5m])
+     ```
 3. Optimize aggregation operations:
-    - Aggregate metrics at collection time when possible
-    - Use `without` instead of `by` for excluding specific labels
+   - Aggregate metrics at collection time when possible
+   - Use `without` instead of `by` for excluding specific labels
 4. Best practices for performant queries:
-    - Avoid using `group_left` and `group_right` for large datasets
-    - Use time-bounded range vectors (e.g., `[5m]` instead of `[1h]`)
-    - Limit the use of regex in label matches
+   - Avoid using `group_left` and `group_right` for large datasets
+   - Use time-bounded range vectors (e.g., `[5m]` instead of `[1h]`)
+   - Limit the use of regex in label matches
 
 ## Real-World PromQL Examples for Common Monitoring Scenarios
 
@@ -346,23 +338,43 @@ This query returns 0 for any missing data points in `http_requests_total`.
 [SigNoz](https://signoz.io) is a comprehensive open-source [APM and observability](https://signoz.io/guides/apm-vs-observability/) platform that complements Prometheus and extends PromQL capabilities. It provides:
 
 1. Run PromQL Queries Directly in SigNoz: Use the built-in Metrics Explorer in SigNoz to run PromQL queries and visualize results instantly. You can craft, debug, and iterate on PromQL queries.
-    
-    <Figure src="/img/guides/2024/11/promql-cheat-sheet-image.webp" alt="Built-in Functions in SigNoz" caption="Built-in Functions in SigNoz" />
-    
-    <Figure src="/img/guides/2024/11/promql-cheat-sheet-image%201.webp" alt="Query Builder SigNoz" caption="Query Builder SigNoz" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/promql-cheat-sheet-image.webp"
+     alt="Built-in Functions in SigNoz"
+     caption="Built-in Functions in SigNoz"
+   />
+
+   <Figure
+     src="/img/guides/2024/11/promql-cheat-sheet-image%201.webp"
+     alt="Query Builder SigNoz"
+     caption="Query Builder SigNoz"
+   />
+
 2. Enhanced visualization: SigNoz offers advanced dashboards and charts for PromQL queries.
-    
-    <Figure src="/img/guides/2024/11/promql-cheat-sheet-image%202.webp" alt="Custom Dashboards in SigNoz" caption="Custom Dashboards in SigNoz" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/promql-cheat-sheet-image%202.webp"
+     alt="Custom Dashboards in SigNoz"
+     caption="Custom Dashboards in SigNoz"
+   />
+
 3. Trace correlation: Link PromQL query metrics to distributed traces within SigNoz to uncover root causes of performance bottlenecks. For example, trace high CPU utilization to specific services or requests.
-    
-    <Figure src="/img/guides/2024/11/promql-cheat-sheet-image%203.webp" alt="Distributed Tracing in SigNoz" caption="Distributed Tracing in SigNoz" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/promql-cheat-sheet-image%203.webp"
+     alt="Distributed Tracing in SigNoz"
+     caption="Distributed Tracing in SigNoz"
+   />
+
 4. Long-term storage: While Prometheus has limited retention periods, SigNoz ensures you can analyze PromQL query results over extended durations, which is ideal for historical trends and capacity planning.
-    
-    <Figure src="/img/guides/2024/11/promql-cheat-sheet-image%204.webp" alt="Retention Period in  SigNoz" caption="Retention Period in  SigNoz" />
-    
+
+   <Figure
+     src="/img/guides/2024/11/promql-cheat-sheet-image%204.webp"
+     alt="Retention Period in  SigNoz"
+     caption="Retention Period in  SigNoz"
+   />
+
 5. Custom functions: Leverage SigNoz-specific functions and aggregations to perform deeper analysis that complements PromQL’s native capabilities.
 
 <GetStartedSigNoz />
@@ -394,4 +406,4 @@ Instant vectors return the current value of a metric at a specific time, whereas
 
 ### How does PromQL handle missing or incomplete metrics data?
 
-PromQL uses functions like absent() to detect missing metrics and absent_over_time() to check for gaps in data over a specified time window.
\ No newline at end of file
+PromQL uses functions like absent() to detect missing metrics and absent_over_time() to check for gaps in data over a specified time window.
diff --git a/data/guides/promql-if-else-like-expression.mdx b/data/guides/promql-if-else-like-expression.mdx
index 259348692..cd4d6374a 100644
--- a/data/guides/promql-if-else-like-expression.mdx
+++ b/data/guides/promql-if-else-like-expression.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Mastering PromQL - How to Use If-Else Expressions
-slug: promql-if-else-like-expression
 date: 2024-10-30
 tags: [prometheus]
 authors: [simran_kumari]
 description: Learn how to implement if-else like expressions in PromQL for advanced Prometheus monitoring. Master conditional logic and optimize your queries.
-keywords: [PromQL, if-else expressions, Prometheus monitoring, conditional logic, time-series data, alerting, vector matching]
-
+keywords:
+  [
+    PromQL,
+    if-else expressions,
+    Prometheus monitoring,
+    conditional logic,
+    time-series data,
+    alerting,
+    vector matching,
+  ]
 ---
 
 Prometheus is a powerful monitoring tool, and PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)) is its heart. However, one thing you may quickly realize is that PromQL doesn’t support traditional if-else statements. So, how do you implement conditional logic? In this guide, we’ll dive into the ways PromQL can simulate if-else behavior using its powerful set of operators and show you how to build dynamic queries to monitor your systems effectively.
@@ -66,7 +72,11 @@ The query will return results only when both conditions are true (mimicking the
 - The Prometheus service is up (`up == 1`).
 - The scrape duration is less than 0.5 seconds.
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image.webp" alt="Using the and Operator" caption="Using the and Operator" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image.webp"
+  alt="Using the and Operator"
+  caption="Using the and Operator"
+/>
 
 ### Using the `or` Operator
 
@@ -76,14 +86,22 @@ The `or` operator provides a fallback option. For example, if you want to monito
 http_requests_total{status="500"} or up{job="prometheus"} == 0
 ```
 
-This returns results if either of the conditions is true, like an "else if" clause. 
+This returns results if either of the conditions is true, like an "else if" clause.
 It checks for HTTP requests with a status of 500 (indicating server errors) or checks if the [Prometheus service](https://signoz.io/guides/cannot-start-prometheus-by-using-systemd/) is down (`up == 0`).
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%201.webp" alt="Using the or Operator" caption="Using the or Operator" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%201.webp"
+  alt="Using the or Operator"
+  caption="Using the or Operator"
+/>
 
 The query `http_requests_total{status="500"} or up == 0` checks for the total number of HTTP requests with a 500 status code, or if any targets are down (`up == 0`), returning results if either condition is true.
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%202.webp" alt="Using the or Operator in PromQL query" caption="Using the or Operator in PromQL query" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%202.webp"
+  alt="Using the or Operator in PromQL query"
+  caption="Using the or Operator in PromQL query"
+/>
 
 ### Combining `and` and `or` for Complex Logic
 
@@ -94,10 +112,14 @@ By combining these operators, you can handle more sophisticated conditions. For
 ```
 
 - The query will return true if either of the following is true:
-    - The `python-job` is down and its scrape duration was fast (less than 0.5 seconds), OR
-    - The `prometheus` job is down and its scrape duration was fast (less than 0.5 seconds).
+  - The `python-job` is down and its scrape duration was fast (less than 0.5 seconds), OR
+  - The `prometheus` job is down and its scrape duration was fast (less than 0.5 seconds).
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%203.webp" alt="Combining and and or for Complex Logic" caption="Combining and and or for Complex Logic" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%203.webp"
+  alt="Combining and and or for Complex Logic"
+  caption="Combining and and or for Complex Logic"
+/>
 
 In summary, this query helps detect when either of the two jobs (`python-job` or `prometheus`) is down, while highlighting that their last scrape duration was quick, possibly indicating that the job went down right after a successful scrape.
 
@@ -109,25 +131,32 @@ A common use case for if-else logic in PromQL is setting up conditional alerts.
 up{job="prometheus"} == 1 or up{job="python-job"} == 1
 ```
 
-The above query returns the value 2 if both the services are operational, so you can set the threshold as a value below 2 and trigger alerts. If any one of the services is non-operational, the count will go below 2. 
+The above query returns the value 2 if both the services are operational, so you can set the threshold as a value below 2 and trigger alerts. If any one of the services is non-operational, the count will go below 2.
 
 Steps for setting up alerts in Grafana:
 
 - Add Prometheus as the data source in your Grafana server.
 - Go to Alerting → Alert Rules → New alert rule button.
 - Provide details like:
-    - Alert rule name: Any meaningful name of your choice.
-    - Select the data source
-    - Add in the query based on the result of which alert needs to be triggered. Set the threshold for the same.
-        
-        <Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%204.webp" alt="Setting alert rule in Grafana" caption="Setting alert rule in Grafana" />
-        
-    - Click on `Set as alert condition`
+  - Alert rule name: Any meaningful name of your choice.
+  - Select the data source
+  - Add in the query based on the result of which alert needs to be triggered. Set the threshold for the same.
+    {' '}
+    <Figure
+      src="/img/guides/2024/10/promql-if-else-like-expression-image%204.webp"
+      alt="Setting alert rule in Grafana"
+      caption="Setting alert rule in Grafana"
+    />
+  - Click on `Set as alert condition`
 - Next, save the rule and exit.
 
 Your alerts will get fired if the specified condition is met.
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%205.webp" alt="Firing alerts using Grafana" caption="Firing alerts using Grafana" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%205.webp"
+  alt="Firing alerts using Grafana"
+  caption="Firing alerts using Grafana"
+/>
 
 Handling Multiple Conditions
 
@@ -143,13 +172,13 @@ Multiple conditions can be handled using nested `and` and `or` operators:
 This query evaluates multiple conditions related to the HTTP requests for the `python-job` and the status of the `prometheus` job:
 
 1. Condition 1: `(sum(prometheus_http_requests_total{job="python-job"}) > 1000 and up{job="prometheus"} == 1)`
-    - This checks if the total HTTP requests for the `python-job` exceed `1000` and the `prometheus` job is up. If both conditions are true, you may want to take action or trigger an alert.
+   - This checks if the total HTTP requests for the `python-job` exceed `1000` and the `prometheus` job is up. If both conditions are true, you may want to take action or trigger an alert.
 2. Condition 2: `(sum(prometheus_http_requests_total{job="python-job"}) <= 1000 and up{job="python-job"} == 1)`
-    - This checks if the total HTTP requests for the `python-job` are `1000` or fewer while ensuring that the `python-job` is operational. This may indicate that the service is underutilized.
+   - This checks if the total HTTP requests for the `python-job` are `1000` or fewer while ensuring that the `python-job` is operational. This may indicate that the service is underutilized.
 3. Condition 3: `(up{job="prometheus"} == 0)`
-    - This condition checks if the `prometheus` job is down. If true, it may trigger alerts regardless of request counts.
+   - This condition checks if the `prometheus` job is down. If true, it may trigger alerts regardless of request counts.
 4. Condition 4: `(up{job="python-job"} == 0)`
-    - This checks if the `python-job` is down, indicating an issue that should trigger an alert.
+   - This checks if the `python-job` is down, indicating an issue that should trigger an alert.
 
 Dealing with Edge Cases and Potential Pitfalls
 
@@ -175,7 +204,11 @@ sum(prometheus_http_requests_total) unless up{job="prometheus"} == 0
 
 This query returns the total number of HTTP requests unless the Prometheus service is down.
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%206.webp" alt="Using the unless Operator" caption="Using the unless Operator" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%206.webp"
+  alt="Using the unless Operator"
+  caption="Using the unless Operator"
+/>
 
 ### Ternary-Like Operations with Vector Matching
 
@@ -191,9 +224,17 @@ PromQL can handle ternary-like behavior using vector matching. For example, to g
 sum(prometheus_http_requests_total{job="prometheus"}) > 1000 or vector(0)
 ```
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%207.webp" alt="Ternary-like behavior using vector matching- Satisfying if condition" caption="Ternary-like behavior using vector matching- Satisfying if condition" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%207.webp"
+  alt="Ternary-like behavior using vector matching- Satisfying if condition"
+  caption="Ternary-like behavior using vector matching- Satisfying if condition"
+/>
 
-<Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%208.webp" alt="Ternary-like behavior using vector matching - Satisfying else condition" caption="Ternary-like behavior using vector matching - Satisfying else condition" />
+<Figure
+  src="/img/guides/2024/10/promql-if-else-like-expression-image%208.webp"
+  alt="Ternary-like behavior using vector matching - Satisfying else condition"
+  caption="Ternary-like behavior using vector matching - Satisfying else condition"
+/>
 
 This allows you to simulate ternary logic with metrics, returning different values depending on the condition.
 
@@ -232,7 +273,7 @@ Let's explore some practical applications of conditional logic in PromQL:
 In certain environments, you may want to avoid triggering alerts on specific holidays when systems are expected to operate under different conditions.
 
 ```
-high_cpu_usage and on(day) (day_of_week != 6 and day_of_week != 0) 
+high_cpu_usage and on(day) (day_of_week != 6 and day_of_week != 0)
 unless on(date) holiday_calendar == 1
 ```
 
@@ -284,9 +325,12 @@ SigNoz extends PromQL capabilities by:
 1. Offering a more user-friendly interface for building complex queries
 2. Providing advanced visualization options for conditional data
 3. Integrating traces and logs with metrics for comprehensive observability
-    
-    <Figure src="/img/guides/2024/10/promql-if-else-like-expression-image%209.webp" alt="Integrating traces and logs with metrics for comprehensive observability" caption="Integrating traces and logs with metrics for comprehensive observability" />
-    
+
+   <Figure
+     src="/img/guides/2024/10/promql-if-else-like-expression-image%209.webp"
+     alt="Integrating traces and logs with metrics for comprehensive observability"
+     caption="Integrating traces and logs with metrics for comprehensive observability"
+   />
 
 <GetStartedSigNoz />
 
@@ -313,4 +357,4 @@ Complex conditions can increase query execution time and resource usage. Optimiz
 
 ### How can I debug complex conditional queries in PromQL?
 
-Use the Prometheus web interface to test your queries and visualize the results. Break down complex queries into smaller components and test each part individually for better debugging.
\ No newline at end of file
+Use the Prometheus web interface to test your queries and visualize the results. Break down complex queries into smaller components and test each part individually for better debugging.
diff --git a/data/guides/python-logging-best-practices.mdx b/data/guides/python-logging-best-practices.mdx
index 0442c75be..e6685e5b7 100644
--- a/data/guides/python-logging-best-practices.mdx
+++ b/data/guides/python-logging-best-practices.mdx
@@ -1,14 +1,25 @@
 ---
-title: "Python Logging Best Practices - Obvious and Not-So-Obvious"
-slug: "python-logging-best-practices"
-date: "2025-09-29"
+title: 'Python Logging Best Practices - Obvious and Not-So-Obvious'
+date: '2025-09-29'
 tags: [python, logging]
 authors: [vivek_goswami, yuvraj]
-description: "Master Python logging with 12 proven best practices, code examples, and expert techniques for better debugging, monitoring, and production deployments."
-keywords: [Python logging, logging best practices, structured logging, python debugging, logging configuration, production logging, log management, monitoring, observability, SigNoz]
+description: 'Master Python logging with 12 proven best practices, code examples, and expert techniques for better debugging, monitoring, and production deployments.'
+keywords:
+  [
+    Python logging,
+    logging best practices,
+    structured logging,
+    python debugging,
+    logging configuration,
+    production logging,
+    log management,
+    monitoring,
+    observability,
+    SigNoz,
+  ]
 ---
 
-The `logging` module is a core part of Python's standard library, but its default configuration is insufficient for serious application development. 
+The `logging` module is a core part of Python's standard library, but its default configuration is insufficient for serious application development.
 
 This guide provides a comprehensive overview of best practices for instrumenting your code effectively. It begins with the "obvious" configuration and usage patterns for basic scripts and services, then progresses to the "not-so-obvious" techniques: including structured formatting, exception handling, and telemetry correlation, that are essential for building robust, observable, and easily debuggable systems.
 
@@ -67,6 +78,7 @@ Note: Python log levels also have numeric values used for filtering and formatti
 Don't sprinkle logging configuration code throughout your application. **Configure it once** at the application's entry point. Using `logging.config.dictConfig` is the most flexible and recommended way to do this.
 
 Here’s a simple centralized configuration that logs `INFO`-level messages to the console:
+
 ```python
 # In your application's main entry point (e.g., main.py or __init__.py)
 import logging.config
@@ -131,8 +143,8 @@ These techniques will elevate your logging from a simple diagnostic tool to a po
 
 As applications scale, logs become a source of data to be queried and analyzed. Plain text logs are difficult for machines to parse reliably. **Structured logging** is the solution, transforming log entries into machine-readable formats like JSON.
 
-By logging in JSON, you can easily filter, search, and visualize your logs in tools like [SigNoz](https://signoz.io/), Elasticsearch (ELK), or Datadog. 
-While Python's standard `logging` module can achieve structured output with extra libraries like `python-json-logger`, **`structlog`** is a powerful, highly performant, and Pythonic library designed from the ground up for structured logging. 
+By logging in JSON, you can easily filter, search, and visualize your logs in tools like [SigNoz](https://signoz.io/), Elasticsearch (ELK), or Datadog.
+While Python's standard `logging` module can achieve structured output with extra libraries like `python-json-logger`, **`structlog`** is a powerful, highly performant, and Pythonic library designed from the ground up for structured logging.
 It simplifies the process significantly by treating log entries as dictionaries that are processed in a chain before final rendering.
 
 #### Why `structlog`?
@@ -151,7 +163,6 @@ python -m pip install structlog
 
 Here's how to configure `structlog` to produce JSON output. This configuration is typically done once at your application's startup.
 
-
 ```python
 # In your application's main entry point (e.g., main.py or __init__.py)
 import logging
@@ -200,7 +211,14 @@ request_logger.info("User logged in")
 This will produce a clean JSON output (the exact timestamp will vary):
 
 ```json
-{"event": "User logged in", "logger": "my_app.auth", "level": "info", "timestamp": "2025-09-29T10:00:00.123456Z", "user_id": 123, "ip_address": "192.168.1.100"}
+{
+  "event": "User logged in",
+  "logger": "my_app.auth",
+  "level": "info",
+  "timestamp": "2025-09-29T10:00:00.123456Z",
+  "user_id": 123,
+  "ip_address": "192.168.1.100"
+}
 ```
 
 With `structlog`, you get powerful structured logging that's easy to read during development and perfectly machine-readable for production.
@@ -213,7 +231,6 @@ While the standard `logging` library requires a custom `Filter` object, `structl
 
 First, ensure the `merge_contextvars` processor is included in your `structlog` configuration. This processor automatically adds any data from `structlog`'s context into your log's event dictionary.
 
-
 ```python
 # In your structlog configuration
 import structlog
@@ -245,7 +262,6 @@ def request_middleware(request):
 
 Now, any log call made during that request's lifecycle will automatically include the `correlation_id` without any extra effort.
 
-
 ```python
 # In some other part of your application
 logger = structlog.get_logger(__name__)
@@ -258,12 +274,16 @@ def process_order(order_id):
 The resulting JSON output will be cleanly enriched:
 
 ```json
-{"event": "Processing order", "order_id": 451, "correlation_id": "a1b2c3d4-e5f6-7890-1234-567890abcdef"}
+{
+  "event": "Processing order",
+  "order_id": 451,
+  "correlation_id": "a1b2c3d4-e5f6-7890-1234-567890abcdef"
+}
 ```
 
-This pattern is a powerful step up for diagnostics. 
+This pattern is a powerful step up for diagnostics.
 
->For fully distributed systems, this concept is formalized and automated by **[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)**, which uses standardized `trace_id` and `span_id` fields to provide even richer, cross-service tracing, as discussed in section 11.
+> For fully distributed systems, this concept is formalized and automated by **[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)**, which uses standardized `trace_id` and `span_id` fields to provide even richer, cross-service tracing, as discussed in section 11.
 
 ### 8. Log Exceptions Correctly with Stack Traces
 
@@ -345,7 +365,11 @@ By instrumenting your Python application with OpenTelemetry, you can:
 
 Once you're generating telemetry data with OpenTelemetry, you need a backend to collect, store, and visualize it. **SigNoz** is an OTel-native observability platform that provides a unified experience for logs, metrics, and traces in a single application.
 
-<Figure src="/img/log-management/LogManagementHero.svg" alt="SigNoz Logs Dashboard" caption="SigNoz Logs Dashboard" />
+<Figure
+  src="/img/log-management/LogManagementHero.svg"
+  alt="SigNoz Logs Dashboard"
+  caption="SigNoz Logs Dashboard"
+/>
 
 With SigNoz, you can use the rich, structured logs you've configured to:
 
diff --git a/data/guides/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does.mdx b/data/guides/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does.mdx
index d12ca2f6f..70bbc526f 100644
--- a/data/guides/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does.mdx
+++ b/data/guides/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Create or Append to Log Files - Python Logging
-slug: python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does
 date: 2024-09-06
 tags: [faq]
 authors: [sushant_gaurav]
 description: Learn how to create new log files or append to existing ones using Python's logging module. This guide covers basic and advanced logging techniques.
-keywords: [Python logging, create log file, append to log file, FileHandler, log rotation, SigNoz, logging best practices]
-
+keywords:
+  [
+    Python logging,
+    create log file,
+    append to log file,
+    FileHandler,
+    log rotation,
+    SigNoz,
+    logging best practices,
+  ]
 ---
 
 Maintaining and troubleshooting Python applications requires effective logging. Implementing a dependable logging system can greatly reduce the amount of work needed for debugging and monitoring, regardless of the script size or application being developed. This article will cover how to use Python's robust logging module to create new log files or append to existing ones. With the help of this article, you can set up your logging system to either continue logging to an already existing log file or generate a new one if one doesn't already exist.
@@ -90,46 +96,49 @@ Explanation:
 To gain more control over how your log files are created and managed, you can configure several aspects of the `FileHandler`:
 
 1. Set the File Mode: By default, the `FileHandler` opens the log file in append mode (`'a'`). If you want to overwrite the file each time the script runs, use write mode (`'w'`):
-    
-    ```python
-    handler = logging.FileHandler('app.log', mode='w')
-    ```
-    
-    - Append Mode (`'a'`): New log entries are added to the end of the existing file.
-    - Write Mode (`'w'`): The file is overwritten each time the logger is initialized, erasing previous logs.
+
+   ```python
+   handler = logging.FileHandler('app.log', mode='w')
+   ```
+
+   - Append Mode (`'a'`): New log entries are added to the end of the existing file.
+   - Write Mode (`'w'`): The file is overwritten each time the logger is initialized, erasing previous logs.
+
 2. Specify Log File Paths: Absolute paths are an excellent approach to ensure that your log files are created in the correct location, especially in production environments. This method helps to avoid problems with relative routes that may differ depending on where your script is executed.
-    
-    ```python
-    import os
-    
-    log_directory = '/var/log/myapp'
-    os.makedirs(log_directory, exist_ok=True)
-    handler = logging.FileHandler(os.path.join(log_directory, 'app.log'))
-    ```
-    
-    - Absolute Paths: Using `os.path.join`, you can create a log file at a specific location, ensuring that other logs are stored consistently across different environments.
-    - Directory Creation: The `os.makedirs(log_directory, exist_ok=True)` line ensures that the directory exists before attempting to create the log file.
+
+   ```python
+   import os
+
+   log_directory = '/var/log/myapp'
+   os.makedirs(log_directory, exist_ok=True)
+   handler = logging.FileHandler(os.path.join(log_directory, 'app.log'))
+   ```
+
+   - Absolute Paths: Using `os.path.join`, you can create a log file at a specific location, ensuring that other logs are stored consistently across different environments.
+   - Directory Creation: The `os.makedirs(log_directory, exist_ok=True)` line ensures that the directory exists before attempting to create the log file.
+
 3. Implement Error Handling: When working with file systems, handling potential problems with caution, such as permission difficulties that may prohibit the log file from being created is essential.
-    
-    ```python
-    try:
-        handler = logging.FileHandler('app.log')
-    except PermissionError:
-        print("Error: Unable to create log file due to permission issues.")
-        sys.exit(1)
-    ```
-    
-    - Permission Handling: By catching `PermissionError`, you can provide a clear error message and take appropriate action, such as exiting the program or logging to an alternative destination.
+
+   ```python
+   try:
+       handler = logging.FileHandler('app.log')
+   except PermissionError:
+       print("Error: Unable to create log file due to permission issues.")
+       sys.exit(1)
+   ```
+
+   - Permission Handling: By catching `PermissionError`, you can provide a clear error message and take appropriate action, such as exiting the program or logging to an alternative destination.
+
 4. Customize Log File Naming: To avoid overwriting log files or to create unique logs for different sessions, you can dynamically generate log file names using timestamps or other identifiers:
-    
-    ```python
-    from datetime import datetime
-    
-    log_filename = f"app_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
-    handler = logging.FileHandler(log_filename)
-    ```
-    
-    - Dynamic Naming: This approach ensures that each log file has a unique name, making it easier to organize and review logs from different runs or sessions.
+
+   ```python
+   from datetime import datetime
+
+   log_filename = f"app_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+   handler = logging.FileHandler(log_filename)
+   ```
+
+   - Dynamic Naming: This approach ensures that each log file has a unique name, making it easier to organize and review logs from different runs or sessions.
 
 ## Appending to Existing Log Files
 
@@ -214,7 +223,11 @@ for i in range(10000):
 
 It will generate files like:
 
-<Figure src="/img/guides/2024/09/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does-image.webp" alt="Output Example" caption="Output Example" />
+<Figure
+  src="/img/guides/2024/09/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does-image.webp"
+  alt="Output Example"
+  caption="Output Example"
+/>
 
 ### Rotating Log Files Based on Time
 
@@ -410,7 +423,11 @@ Compressed app_log1.log -> app_log1.log.gz
 Compressed app_log2.log -> app_log2.log.gz
 ```
 
-<Figure src="/img/guides/2024/09/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does-image%201.webp" alt="Compressed log files" caption="Compressed log files" />
+<Figure
+  src="/img/guides/2024/09/python-logging-create-log-if-not-exists-or-open-and-continue-logging-if-it-does-image%201.webp"
+  alt="Compressed log files"
+  caption="Compressed log files"
+/>
 
 ## Monitoring and Analyzing Log Files with SigNoz
 
@@ -437,31 +454,31 @@ For detailed implementation steps, refer to SigNoz's guide on [logging in Python
 To get the most out of Python's logging capabilities, you can follow some of the recommended practices that ensure your logs are both useful and manageable.
 
 1. Structure Log Messages Consistently: Use a consistent format for log messages to make them easier to parse and analyze, particularly when working with log management tools like SigNoz.
-    
-    ```python
-    logger.info("User %s logged in from %s", username, ip_address)
-    ```
-    
+
+   ```python
+   logger.info("User %s logged in from %s", username, ip_address)
+   ```
+
 2. Log Exceptions with Tracebacks: When an exception occurs, always log the entire traceback to assist diagnose the problem. This provides useful context and makes debugging much easier.
-    
-    ```python
-    try:
-        # Some risky operation
-    except Exception as e:
-        logger.exception("An error occurred: %s", str(e))
-    ```
-    
+
+   ```python
+   try:
+       # Some risky operation
+   except Exception as e:
+       logger.exception("An error occurred: %s", str(e))
+   ```
+
 3. Use Context Managers for Temporary Configurations: If you need to temporarily change the logging level or settings, think about utilizing a context manager. This allows you to make modifications that are automatically undone when the context is exited.
-    
-    ```python
-    with logger.temporary_level(logging.DEBUG):
-        logger.debug("This is temporarily a debug message")
-    ```
-    
+
+   ```python
+   with logger.temporary_level(logging.DEBUG):
+       logger.debug("This is temporarily a debug message")
+   ```
+
 4. Balance Logging Verbosity and Performance: Logging is a great tool, but it can have an impact on performance if not maintained properly. Follow these suggestions to keep a healthy balance:
-    - Set Appropriate Log Levels: `DEBUG` is reserved for thorough diagnostic information, whereas `INFO`, `WARNING`, `ERROR`, and `CRITICAL` are used for progressively important warnings.
-    - Don't Log Sensitive Data: Maintain privacy and security by not logging important information (such as passwords and personal data).
-    - Consider Lazy Logging for Costly Operations: Use lazy evaluation for logs that require expensive procedures, so that they are only evaluated when the log level is enabled.
+   - Set Appropriate Log Levels: `DEBUG` is reserved for thorough diagnostic information, whereas `INFO`, `WARNING`, `ERROR`, and `CRITICAL` are used for progressively important warnings.
+   - Don't Log Sensitive Data: Maintain privacy and security by not logging important information (such as passwords and personal data).
+   - Consider Lazy Logging for Costly Operations: Use lazy evaluation for logs that require expensive procedures, so that they are only evaluated when the log level is enabled.
 
 ## Key Takeaways
 
@@ -514,4 +531,4 @@ class ThreadSafeHandler(logging.Handler):
     def emit(self, record):
         with self.lock:
             # Perform thread-safe logging operations here
-```
\ No newline at end of file
+```
diff --git a/data/guides/python-logging-function-name-file-name-line-number-using-a-single-file.mdx b/data/guides/python-logging-function-name-file-name-line-number-using-a-single-file.mdx
index d55c7f4a7..561a57a8b 100644
--- a/data/guides/python-logging-function-name-file-name-line-number-using-a-single-file.mdx
+++ b/data/guides/python-logging-function-name-file-name-line-number-using-a-single-file.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Log Function, File, and Line in Python - A Guide
-slug: python-logging-function-name-file-name-line-number-using-a-single-file
 date: 2024-08-28
 tags: [logging, faq]
 authors: [sushant_gaurav]
 description: Learn how to implement comprehensive Python logging, capturing function names, file names, and line numbers for effective debugging and error tracking.
-keywords: [Python logging, debugging, error tracking, log configuration, function name, file name, line number]
-
+keywords:
+  [
+    Python logging,
+    debugging,
+    error tracking,
+    log configuration,
+    function name,
+    file name,
+    line number,
+  ]
 ---
 
 Effective logging is essential for troubleshooting and maintaining Python applications. A good logging system does more than just record messages; it also collects contextual information like as function names, file names, and line numbers, which can greatly help in debugging. This article will walk you through the process of configuring complete logging in Python, with a focus on capturing these crucial details using a single file.
@@ -162,81 +168,73 @@ INFO:my_app:Application has started
 To effectively integrate logging into your Python code, you need to take care of some of the best practices:
 
 1. Log at appropriate levels.: You should select the appropriate logging level based on the severity and purpose of the log message. There are mainly 5 types of logging levels:
-    - DEBUG: It provides comprehensive diagnostic information.
-    - INFO: It can be used for general operating messages (such as application startup).
-    - WARNING: It can be used for scenarios that may cause problems (such as deprecated features).
-    - ERROR: It can be used for major issues that need quick action.
-    - CRITICAL: It can be used for the fatal errors that could cause the program to crash.
+   - DEBUG: It provides comprehensive diagnostic information.
+   - INFO: It can be used for general operating messages (such as application startup).
+   - WARNING: It can be used for scenarios that may cause problems (such as deprecated features).
+   - ERROR: It can be used for major issues that need quick action.
+   - CRITICAL: It can be used for the fatal errors that could cause the program to crash.
 2. Log Exceptions Effectively: When you are dealing with exceptions, you should use the `logger.exception()` method to automatically include the whole stack trace in the log. This provides precise information on what produced the exception.
-    - Example:
-        
-        ```python
-        try:
-            # Example risky operation
-            risky_operation()
-        except Exception as e:
-            logger.exception("An error occurred during risky_operation")
-        ```
-        
-    - Explanation: The `logger.exception()` method logs an `ERROR` level message with the exception’s stack trace, making it easier to debug the issue.
-    - Output Sample:
-        
-        ```
-        2024-08-24 10:45:00,001 - my_app - ERROR - example.py:48 - <module>() - An error occurred during risky_operation
-        Traceback (most recent call last):
-        File "example.py", line 46, in <module>
-            risky_operation()
-        File "example.py", line 44, in risky_operation
-            raise ValueError("Something went wrong")
-        ValueError: Something went wrong
-        ```
-        
+   - Example:
+     ```python
+     try:
+         # Example risky operation
+         risky_operation()
+     except Exception as e:
+         logger.exception("An error occurred during risky_operation")
+     ```
+   - Explanation: The `logger.exception()` method logs an `ERROR` level message with the exception’s stack trace, making it easier to debug the issue.
+   - Output Sample:
+     ```
+     2024-08-24 10:45:00,001 - my_app - ERROR - example.py:48 - <module>() - An error occurred during risky_operation
+     Traceback (most recent call last):
+     File "example.py", line 46, in <module>
+         risky_operation()
+     File "example.py", line 44, in risky_operation
+         raise ValueError("Something went wrong")
+     ValueError: Something went wrong
+     ```
 3. Use Context Managers for Temporary Logging Changes: Sometimes you may need to temporarily adjust the logging level for a specific block of code. You can utilize this using a context manager.
-    - Example:
-        
-        ```python
-        import logging
-        import contextlib
-        
-        # Create and configure the logger
-        logger = logging.getLogger(__name__)
-        logger.setLevel(logging.INFO)  # Set the default logging level to INFO
-        
-        # Configure the logger to output to the console
-        console_handler = logging.StreamHandler()
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-        
-        @contextlib.contextmanager
-        def temporary_log_level(logger, level):
-            """
-            Temporarily change the logging level within a context.
-        
-            Args:
-                logger (logging.Logger): The logger whose level is to be changed.
-                level: The new logging level to be set temporarily.
-            """
-            old_level = logger.level
-            logger.setLevel(level)
-            try:
-                yield
-            finally:
-                logger.setLevel(old_level)
-        
-        # Usage example
-        with temporary_log_level(logger, logging.DEBUG):
-            logger.debug("This DEBUG message will be logged")
-        logger.debug("This won't be logged if the default level is higher than DEBUG")
-        ```
-        
-    - Explanation: Within the `with` block of the Context Manager (`temporary_log_level`), the logger is temporarily set to a different level, which is then restored after the block is executed.
-    - Output Sample:
-        
-        ```
-        DEBUG:my_app:This DEBUG message will be logged
-        ```
-        
+   - Example:
+     ```python
+     import logging
+     import contextlib
+
+     # Create and configure the logger
+     logger = logging.getLogger(__name__)
+     logger.setLevel(logging.INFO)  # Set the default logging level to INFO
+
+     # Configure the logger to output to the console
+     console_handler = logging.StreamHandler()
+     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+     console_handler.setFormatter(formatter)
+     logger.addHandler(console_handler)
+
+     @contextlib.contextmanager
+     def temporary_log_level(logger, level):
+         """
+         Temporarily change the logging level within a context.
+
+         Args:
+             logger (logging.Logger): The logger whose level is to be changed.
+             level: The new logging level to be set temporarily.
+         """
+         old_level = logger.level
+         logger.setLevel(level)
+         try:
+             yield
+         finally:
+             logger.setLevel(old_level)
+
+     # Usage example
+     with temporary_log_level(logger, logging.DEBUG):
+         logger.debug("This DEBUG message will be logged")
+     logger.debug("This won't be logged if the default level is higher than DEBUG")
+     ```
+   - Explanation: Within the `with` block of the Context Manager (`temporary_log_level`), the logger is temporarily set to a different level, which is then restored after the block is executed.
+   - Output Sample:
+     ```
+     DEBUG:my_app:This DEBUG message will be logged
+     ```
 
 ## Advanced Logging Techniques
 
@@ -469,7 +467,11 @@ SigNoz provides a holistic view of your application's performance by correlating
 
 For detailed implementation steps, refer to SigNoz's guide on [logging in Python with OpenTelemetry here](https://signoz.io/opentelemetry/logging-in-python/). This guide will provide specific instructions tailored to integrate Python logging with SigNoz's observability platform using OpenTelemetry.
 
-<Figure src="/img/guides/2024/08/python-logging-function-name-file-name-line-number-using-a-single-file-image.webp" alt="image.webp" caption="image.webp" />
+<Figure
+  src="/img/guides/2024/08/python-logging-function-name-file-name-line-number-using-a-single-file-image.webp"
+  alt="image.webp"
+  caption="image.webp"
+/>
 
 ## Key Takeaways
 
@@ -530,66 +532,65 @@ To protect sensitive information in your logs, consider these practices:
 
 1. Use Appropriate Log Levels: Avoid logging sensitive data at levels like DEBUG or INFO unless necessary. Use higher levels like `ERROR` or `WARNING` for critical data.
 2. Implement Custom Redaction Logic: Create a custom formatter to redact sensitive information from your logs:
-    
-    ```python
-    import logging
-    import re
-    
-    def redact_sensitive_info(log_message):
-        """
-        Redact sensitive information such as credit card numbers or SSNs.
-        """
-        patterns = {
-            'credit_card': r'\\b(?:\\d{4}[-\\s]?){3}\\d{4}\\b',
-            'ssn': r'\\b\\d{3}-\\d{2}-\\d{4}\\b'
-        }
-        for key, pattern in patterns.items():
-            log_message = re.sub(pattern, f'[REDACTED {key.upper()}]', log_message)
-        return log_message
-    
-    class RedactingFormatter(logging.Formatter):
-        def format(self, record):
-            message = super().format(record)
-            return redact_sensitive_info(message)
-    
-    # Example of setting the redacting formatter
-    formatter = RedactingFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler = logging.StreamHandler()
-    handler.setFormatter(formatter)
-    
-    logger = logging.getLogger(__name__)
-    logger.addHandler(handler)
-    
-    # Example log message with sensitive information
-    logger.info("User's SSN is 123-45-6789")
-    ```
-    
-    Output Example:
-    
-    ```
-    2024-08-24 04:52:01,662 - __main__ - INFO - <ipython-input-4-fb697e744496>:30 - <cell line: 30>() - User's SSN is 123-45-6789
-    2024-08-24 04:52:01,662 - __main__ - INFO - User's SSN is 123-45-6789
-    INFO:__main__:User's SSN is 123-45-6789
-    ```
-    
+
+   ```python
+   import logging
+   import re
+
+   def redact_sensitive_info(log_message):
+       """
+       Redact sensitive information such as credit card numbers or SSNs.
+       """
+       patterns = {
+           'credit_card': r'\\b(?:\\d{4}[-\\s]?){3}\\d{4}\\b',
+           'ssn': r'\\b\\d{3}-\\d{2}-\\d{4}\\b'
+       }
+       for key, pattern in patterns.items():
+           log_message = re.sub(pattern, f'[REDACTED {key.upper()}]', log_message)
+       return log_message
+
+   class RedactingFormatter(logging.Formatter):
+       def format(self, record):
+           message = super().format(record)
+           return redact_sensitive_info(message)
+
+   # Example of setting the redacting formatter
+   formatter = RedactingFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+   handler = logging.StreamHandler()
+   handler.setFormatter(formatter)
+
+   logger = logging.getLogger(__name__)
+   logger.addHandler(handler)
+
+   # Example log message with sensitive information
+   logger.info("User's SSN is 123-45-6789")
+   ```
+
+   Output Example:
+
+   ```
+   2024-08-24 04:52:01,662 - __main__ - INFO - <ipython-input-4-fb697e744496>:30 - <cell line: 30>() - User's SSN is 123-45-6789
+   2024-08-24 04:52:01,662 - __main__ - INFO - User's SSN is 123-45-6789
+   INFO:__main__:User's SSN is 123-45-6789
+   ```
 
 ### How Can I Integrate Python Logging with Third-Party Libraries?
 
 Most third-party libraries in Python use the built-in logging module, so their logs can be captured by configuring the root logger. Here’s how to manage third-party library logs:
 
 1. Configure the Root Logger: Set the logging level for all libraries by configuring the root logger:
-    
-    ```python
-    import logging
-    
-    logging.basicConfig(level=logging.INFO)
-    ```
-    
+
+   ```python
+   import logging
+
+   logging.basicConfig(level=logging.INFO)
+   ```
+
 2. Adjust Specific Loggers: If you want to control the logging level for specific libraries, adjust their loggers:
-    
-    ```python
-    import logging
-    
-    # Set the logging level for the 'requests' library
-    logging.getLogger('requests').setLevel(logging.WARNING)
-    ```
\ No newline at end of file
+
+   ```python
+   import logging
+
+   # Set the logging level for the 'requests' library
+   logging.getLogger('requests').setLevel(logging.WARNING)
+   ```
diff --git a/data/guides/python-performance-monitoring.mdx b/data/guides/python-performance-monitoring.mdx
index 5502ff5af..d04d12d79 100644
--- a/data/guides/python-performance-monitoring.mdx
+++ b/data/guides/python-performance-monitoring.mdx
@@ -1,20 +1,27 @@
 ---
-
 title: Python Performance Monitoring - Implementation, Tools and Best Practices
-slug: python-performance-monitoring
 date: 2024-07-26
 tags: [apm]
 authors: [bhavya_sachdeva]
 description: Discover essential tools and best practices for Python performance monitoring. Learn how to optimize your applications and boost efficiency.
-keywords: [Python performance, application monitoring, APM tools, performance optimization, Python profiling, monitoring best practices, Python metrics, application efficiency]
-
+keywords:
+  [
+    Python performance,
+    application monitoring,
+    APM tools,
+    performance optimization,
+    Python profiling,
+    monitoring best practices,
+    Python metrics,
+    application efficiency,
+  ]
 ---
 
-Python performance monitoring is a critical aspect of maintaining efficient and reliable applications. It involves tracking key metrics, identifying bottlenecks, and optimizing code to ensure your Python programs run smoothly. 
+Python performance monitoring is a critical aspect of maintaining efficient and reliable applications. It involves tracking key metrics, identifying bottlenecks, and optimizing code to ensure your Python programs run smoothly.
 
 Imagine launching a new feature that slows down your application or causes crashes. Such issues can frustrate users and harm your reputation. Real-time performance monitoring acts as a safeguard to detect and address problems before they escalate.
 
-In this guide, we will understand Python performance monitoring, discuss popular python performance montioring tools, and how to implement with native python libraries like py-spy and memory_profiler and full-scale APM solutions like SigNoz. 
+In this guide, we will understand Python performance monitoring, discuss popular python performance montioring tools, and how to implement with native python libraries like py-spy and memory_profiler and full-scale APM solutions like SigNoz.
 
 ## What is Python Performance Monitoring?
 
@@ -64,16 +71,15 @@ Python applications often face several performance challenges:
 Several tools can help you monitor and optimize your Python applications:
 
 - Open-source Options: Prometheus, Grafana, and SigNoz offer powerful monitoring capabilities for Python applications.
-    
-    <GetStartedSigNoz />
-    
+  {' '}
+  <GetStartedSigNoz />
 - Cloud-native Solutions: AWS CloudWatch and Google Cloud Monitoring provide integrated monitoring for cloud-based Python apps.
 - Comprehensive APM Platforms: New Relic and Datadog offer extensive monitoring features with Python SDK integration but often comes with hefty billing charges.
 - Python-specific Libraries: Tools like py-spy and memory_profiler allow for targeted performance analysis.
 
 ## Key Metrics for Python Performance Monitoring
 
-Understanding the metrics to keep an eye on is essential to maintaining the optimal performance of your Python applications.  We can track various performance metrics using SigNoz. It is an open-source application performance monitoring tool that helps you track various performance metrics for your Python applications. Here are examples of how to monitor key metrics using SigNoz, with details on how each metric is derived from span data:
+Understanding the metrics to keep an eye on is essential to maintaining the optimal performance of your Python applications. We can track various performance metrics using SigNoz. It is an open-source application performance monitoring tool that helps you track various performance metrics for your Python applications. Here are examples of how to monitor key metrics using SigNoz, with details on how each metric is derived from span data:
 
 - Response Time is the amount of time it takes for a program to reply to a user's request. Faster responses result in a better user experience. SigNoz tracks response time using latency metrics derived from spans. The `signoz_latency_bucket`, `signoz_latency_sum`, and `signoz_latency_count` metrics help in monitoring response times. You can set up alerts if the latency exceeds a certain threshold, indicating potential performance bottlenecks.
 
@@ -122,7 +128,7 @@ signoz_db_latency_count{operation="/dbQuery", service_name="databaseservice", sp
 
 ## Monitoring Python Application Performance with Monitoring Tool
 
-Using Python application monitoring tools is similar to having an advanced health check system. To do this, we can use observability tool like SigNoz. SigNoz helps identify areas requiring development by giving developers real-time data on how well your application is doing.  It is an [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-based, robust, and easily navigable open-source observability tool alternative to DataDog and New Relic.
+Using Python application monitoring tools is similar to having an advanced health check system. To do this, we can use observability tool like SigNoz. SigNoz helps identify areas requiring development by giving developers real-time data on how well your application is doing. It is an [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-based, robust, and easily navigable open-source observability tool alternative to DataDog and New Relic.
 
 Python application monitoring is made more accessible with SigNoz, as it provides a uniform platform for visualizing application traces and data. Full-fledged [distributed tracing](https://signoz.io/distributed-tracing/) is supported, which aids in identifying the underlying reasons for failures or performance bottlenecks in a microservices architecture.
 
@@ -155,8 +161,9 @@ We can build any Python application to monitor. This could be a basic API using
 In this guide, we are using a flask-based application.
 
 Prerequisites:
+
 - Having Git installed in your system
-- Docker Installed to interact with MongoDB 
+- Docker Installed to interact with MongoDB
 
 Clone sample Flask app repository
 
@@ -178,7 +185,7 @@ source .venv/bin/activate
 
 Install dependencies to run the app:
 
-After you cloned the repo, you have seen the requirements.txt file to install the dependencies we need to run this particular application. 
+After you cloned the repo, you have seen the requirements.txt file to install the dependencies we need to run this particular application.
 
 ```
 pip install -r requirements.txt
@@ -190,13 +197,20 @@ Run your flask based Application
 python3 app.py
 ```
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.45.35_PM.webp" alt="Screenshot 2024-07-16 at 4.45.35 PM.webp" caption="Run your flask application" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.45.35_PM.webp"
+  alt="Screenshot 2024-07-16 at 4.45.35 PM.webp"
+  caption="Run your flask application"
+/>
 
-This application is running on  `http://localhost:5002` 
+This application is running on `http://localhost:5002`
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.16.32_AM.webp" alt="Screenshot 2024-07-25 at 12.16.32 AM.webp" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.16.32_AM.webp"
+  alt="Screenshot 2024-07-25 at 12.16.32 AM.webp"
+/>
 
-But we haven’t installed instrumentation packages yet. We will do this in the next step make sure to stop your application and kill the process as well. 
+But we haven’t installed instrumentation packages yet. We will do this in the next step make sure to stop your application and kill the process as well.
 
 To find out which process is using port `5002`, use the `lsof` command with the `-i` flag:
 
@@ -205,7 +219,7 @@ To find out which process is using port `5002`, use the `lsof` command with the
 - `lsof`: Lists open files and network connections.
 - `i :5002`: Filters the results to show only processes using port `5002`.
 
-As we are running the Flask app on `http://localhost:5002`, this command helps you check if another process is already using this port.  If you see that `http://localhost:5002` is occupied, killing the process releases the port so you can run your application on it. Identify the Process ID (PID) from the `lsof` output, you need to stop this process to free up the port using `sudo kill -9 <process-id>`
+As we are running the Flask app on `http://localhost:5002`, this command helps you check if another process is already using this port. If you see that `http://localhost:5002` is occupied, killing the process releases the port so you can run your application on it. Identify the Process ID (PID) from the `lsof` output, you need to stop this process to free up the port using `sudo kill -9 <process-id>`
 
 Ensuring `http://localhost:5002` is available is crucial before starting your application or installing new monitoring tools. This avoids conflicts and ensures smooth operation.
 
@@ -213,9 +227,12 @@ Ensuring `http://localhost:5002` is available is crucial before starting your ap
 
 In your Python Flask application, Install the instrumentation packages using this command :
 
-`opentelemetry-bootstrap --action=install` 
+`opentelemetry-bootstrap --action=install`
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.18.37_AM.webp" alt="Screenshot 2024-07-25 at 12.18.37 AM.webp" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.18.37_AM.webp"
+  alt="Screenshot 2024-07-25 at 12.18.37 AM.webp"
+/>
 
 After installing the open telemetry package, you just need to configure a few environment variables for your OTLP exporters. Environment variables that need to be configured:
 
@@ -232,11 +249,14 @@ OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317" \
 OTEL_EXPORTER_OTLP_PROTOCOL=grpc opentelemetry-instrument python3 app.py
 ```
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.20.32_AM.webp" alt="Screenshot 2024-07-25 at 12.20.32 AM.webp"  />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-25_at_12.20.32_AM.webp"
+  alt="Screenshot 2024-07-25 at 12.20.32 AM.webp"
+/>
 
 But you haven’t seen anything in the SigNoz Cloud. There are two ways to send data to SigNoz Cloud. You can read that from here. In this guide, we are using the [Send traces via OTel Collector binary](https://signoz.io/docs/instrumentation/python/#send-traces-via-otel-collector-binary), which is also recommended one as well.
 
-OpenTelemetry-instrumented applications in a VM can send data to the `otel-binary` agent running in the same VM. The [OTel agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) can then be configured to send data to the SigNoz cloud. Refer to this [documentation](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to download according to your platform and operating system. 
+OpenTelemetry-instrumented applications in a VM can send data to the `otel-binary` agent running in the same VM. The [OTel agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) can then be configured to send data to the SigNoz cloud. Refer to this [documentation](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to download according to your platform and operating system.
 
 Here are the steps to set up OpenTelemetry binary as an agent.
 
@@ -255,9 +275,9 @@ receivers:
       grpc:
         endpoint: 0.0.0.0:4317
       http:
-         cors:
-            allowed_origins:
-               - http://localhost:5002       
+        cors:
+          allowed_origins:
+            - http://localhost:5002
   hostmetrics:
     collection_interval: 60s
     scrapers:
@@ -298,11 +318,11 @@ extensions:
   zpages: {}
 exporters:
   otlp:
-    endpoint: "ingest.{region}.signoz.cloud:443"
+    endpoint: 'ingest.{region}.signoz.cloud:443'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"
+      'signoz-ingestion-key': '<SIGNOZ_INGESTION_KEY>'
   debug:
     verbosity: normal
 service:
@@ -331,11 +351,12 @@ service:
 
 Depending on the choice of your region for the SigNoz cloud, the otlp endpoint will vary according to this table.
 
-| Region | Endpoint |
-| --- | --- |
-| US | ingest.us.signoz.cloud:443 |
-| IN | ingest.in.signoz.cloud:443 |
-| EU | ingest.eu.signoz.cloud:443 |
+| Region | Endpoint                   |
+| ------ | -------------------------- |
+| US     | ingest.us.signoz.cloud:443 |
+| IN     | ingest.in.signoz.cloud:443 |
+| EU     | ingest.eu.signoz.cloud:443 |
+
 1. Once we are done with the above configurations, we can now run the collector service with the following command:
 
 From the `otelcol-contrib`, run the following command:
@@ -348,11 +369,20 @@ From the `otelcol-contrib`, run the following command:
 
 After running the above application and making the correct configurations, you can navigate to the SigNoz services and traces to check that.
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.32.02_PM.webp" alt="Screenshot 2024-07-16 at 4.32.02 PM.webp" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.32.02_PM.webp"
+  alt="Screenshot 2024-07-16 at 4.32.02 PM.webp"
+/>
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.40.09_PM.webp" alt="Screenshot 2024-07-16 at 4.40.09 PM.webp" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.40.09_PM.webp"
+  alt="Screenshot 2024-07-16 at 4.40.09 PM.webp"
+/>
 
-<Figure src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.33.39_PM.webp" alt="Screenshot 2024-07-16 at 4.33.39 PM.webp" />
+<Figure
+  src="/img/guides/2024/07/python-performance-monitoring-Screenshot_2024-07-16_at_4.33.39_PM.webp"
+  alt="Screenshot 2024-07-16 at 4.33.39 PM.webp"
+/>
 
 ## Best Practices for Implementing Python Performance Monitoring
 
@@ -369,54 +399,53 @@ To get the most out of your monitoring efforts:
 While comprehensive APM platforms offer broad monitoring capabilities, Python-specific libraries provide targeted performance analysis tools that can be invaluable for developers looking to optimize their code. Two notable examples are py-spy and memory_profiler:
 
 1. py-spy
-    
-    py-spy is a sampling profiler for Python programs. It lets you visualize what your Python program is spending time on without restarting the program or modifying the code in any way.
-    
-    Key features:
-    
-    - Low-overhead profiling
-    - Works with Python 2 and 3
-    - Doesn't require modifying your Python code
-    - Can profile Python programs that are already running
-    
-    Example usage:
-    
-    ```bash
-    py-spy record -o profile.svg --pid 12345
-    
-    ```
-    
-    This command generates a [flame graph](https://signoz.io/blog/flamegraphs/) of the running Python process with PID 12345.
-    
+
+   py-spy is a sampling profiler for Python programs. It lets you visualize what your Python program is spending time on without restarting the program or modifying the code in any way.
+
+   Key features:
+
+   - Low-overhead profiling
+   - Works with Python 2 and 3
+   - Doesn't require modifying your Python code
+   - Can profile Python programs that are already running
+
+   Example usage:
+
+   ```bash
+   py-spy record -o profile.svg --pid 12345
+
+   ```
+
+   This command generates a [flame graph](https://signoz.io/blog/flamegraphs/) of the running Python process with PID 12345.
+
 2. memory_profiler
-    
-    memory_profiler is a Python module for monitoring memory consumption of a process as well as line-by-line analysis of memory consumption for Python programs.
-    
-    Key features:
-    
-    - Line-by-line memory usage information
-    - Memory usage over time with mprof
-    - Works with Jupiter notebooks
-    
-    Example usage:
-    
-    ```python
-    from memory_profiler import profile
-    
-    @profile
-    def my_func():
-        a = [1] * (10 ** 6)
-        b = [2] * (2 * 10 ** 7)
-        del b
-        return a
-    
-    if __name__ == '__main__':
-        my_func()
-    
-    ```
-    
-    Running this script with `python -m memory_profiler example.py` will output the memory usage for each line in the `my_func` function.
-    
+
+   memory_profiler is a Python module for monitoring memory consumption of a process as well as line-by-line analysis of memory consumption for Python programs.
+
+   Key features:
+
+   - Line-by-line memory usage information
+   - Memory usage over time with mprof
+   - Works with Jupiter notebooks
+
+   Example usage:
+
+   ```python
+   from memory_profiler import profile
+
+   @profile
+   def my_func():
+       a = [1] * (10 ** 6)
+       b = [2] * (2 * 10 ** 7)
+       del b
+       return a
+
+   if __name__ == '__main__':
+       my_func()
+
+   ```
+
+   Running this script with `python -m memory_profiler example.py` will output the memory usage for each line in the `my_func` function.
 
 These Python-specific tools complement broader APM solutions by providing deep, code-level insights that can be crucial for optimizing performance in Python applications. They're particularly useful during the development and debugging phases, allowing developers to identify memory leaks, excessive memory usage, and performance bottlenecks at a granular level.
 
diff --git a/data/guides/rabbit-mq-error-while-waiting-for-mnesia-tables.mdx b/data/guides/rabbit-mq-error-while-waiting-for-mnesia-tables.mdx
index 7e0ab1070..99f076ab4 100644
--- a/data/guides/rabbit-mq-error-while-waiting-for-mnesia-tables.mdx
+++ b/data/guides/rabbit-mq-error-while-waiting-for-mnesia-tables.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Troubleshooting RabbitMQ - How to Fix Mnesia Table Errors
-slug: rabbit-mq-error-while-waiting-for-mnesia-tables
 date: 2024-09-24
 tags: [faq]
 authors: [bhavya_sachdeva]
 description: Learn how to troubleshoot and fix the "Error while waiting for Mnesia tables" in RabbitMQ. Comprehensive guide for system admins and developers.
-keywords: [RabbitMQ, Mnesia tables, Error troubleshooting, Message queuing, Database management, Cluster configuration, Kubernetes deployment]
-
+keywords:
+  [
+    RabbitMQ,
+    Mnesia tables,
+    Error troubleshooting,
+    Message queuing,
+    Database management,
+    Cluster configuration,
+    Kubernetes deployment,
+  ]
 ---
 
 RabbitMQ is a powerful message broker that relies on Mnesia, a distributed database management system, for storing its metadata. Mnesia is designed for high availability and fault tolerance, enabling data to be replicated across multiple nodes in a cluster. When you encounter the error "Error while waiting for Mnesia tables" in RabbitMQ, it can bring your messaging system to a halt. This issue often leaves system administrators and developers scratching their heads, wondering how to restore their RabbitMQ instance to a functional state. In this comprehensive guide, we'll explore the causes of this error, provide step-by-step troubleshooting techniques, and offer strategies to prevent future occurrences — ensuring your RabbitMQ deployment remains robust and reliable.
@@ -41,7 +47,7 @@ When you see this error, it typically means:
 2. RabbitMQ cannot read or write to the Mnesia tables
 3. There's a synchronization issue in a multi-node cluster
 
-To identify this error, check your RabbitMQ logs. You can usually find these logs in `/var/log/rabbitmq/` on Linux systems or in the RabbitMQ application data directory on Windows in `C:\Users\<YourUsername>\AppData\Roaming\RabbitMQ\log\`  and in MacOS it is generally located at this location: `/opt/homebrew/var/log/rabbitmq`
+To identify this error, check your RabbitMQ logs. You can usually find these logs in `/var/log/rabbitmq/` on Linux systems or in the RabbitMQ application data directory on Windows in `C:\Users\<YourUsername>\AppData\Roaming\RabbitMQ\log\` and in MacOS it is generally located at this location: `/opt/homebrew/var/log/rabbitmq`
 
 Look for lines similar to:
 
@@ -74,7 +80,11 @@ This command provides detailed information about the nodes in the cluster, their
 - Partitions: Network partitions can split the cluster, causing Mnesia to behave erratically.
 - Node roles: Identify if nodes are acting as disc or RAM nodes, as issues could differ based on the role.
 
-<Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.37.10_AM.webp" alt="rabbitmq_cluster" caption="rabbitmq_cluster" />
+<Figure
+  src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.37.10_AM.webp"
+  alt="rabbitmq_cluster"
+  caption="rabbitmq_cluster"
+/>
 
 2. Verify Node Connectivity
 
@@ -84,7 +94,11 @@ In a RabbitMQ cluster, all nodes must be able to communicate with each other. If
 rabbitmqctl ping
 ```
 
-<Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.37.24_AM.webp" alt="rabbitmq ping" caption="rabbitmq ping" />
+<Figure
+  src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.37.24_AM.webp"
+  alt="rabbitmq ping"
+  caption="rabbitmq ping"
+/>
 
 Run this command on each node to ensure that they can reach each other. If a node does not respond with `ping`, it could indicate network or configuration issues. Possible reasons for connectivity failure include:
 
@@ -102,7 +116,11 @@ Mnesia requires disk space to store its data, and insufficient disk space can ca
 df -h
 ```
 
-<Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.04.54_PM.webp" alt="df command" caption="df command" />
+<Figure
+  src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.04.54_PM.webp"
+  alt="df command"
+  caption="df command"
+/>
 
 This command shows disk usage for the system. Pay attention to:
 
@@ -120,9 +138,13 @@ ls -l /var/lib/rabbitmq/mnesia/
 
 ```
 
-You need to change the path for your Mac, as shown in below image: 
+You need to change the path for your Mac, as shown in below image:
 
-<Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.44.46_AM.webp" alt="ls command" caption="ls command" />
+<Figure
+  src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-18_at_11.44.46_AM.webp"
+  alt="ls command"
+  caption="ls command"
+/>
 
 - Ownership: The directory should be owned by the RabbitMQ user.
 - Permissions: The RabbitMQ process should have `rwx` (read, write, execute) permissions on the directory.
@@ -137,7 +159,11 @@ sudo chmod -R 755 /var/lib/rabbitmq/mnesia/
 
 Below, I have shown in the MacOS, you can change the path according to your OS because it differs in MacOS, Windows and Linux :
 
-<Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.40.30_PM.webp" alt="chown command" caption="chown command" />
+<Figure
+  src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.40.30_PM.webp"
+  alt="chown command"
+  caption="chown command"
+/>
 
 After fixing the permissions, restart RabbitMQ to apply changes.
 
@@ -172,27 +198,34 @@ This command bypasses the usual cluster consistency checks and forces the node t
 To prevent future issues:
 
 1. Always use proper shutdown procedures:
-    
-    ```
-    rabbitmqctl stop
-    ```
-    
+
+   ```
+   rabbitmqctl stop
+   ```
+
 2. Regularly back up your Mnesia database:
-    
-    ```
-    rabbitmqctl export_definitions backup.json
-    ```
-    
-    <Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.24.05_PM.webp" alt="export defintions" caption="export defintions" />
-    
+
+   ```
+   rabbitmqctl export_definitions backup.json
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.24.05_PM.webp"
+     alt="export defintions"
+     caption="export defintions"
+   />
+
 3. If necessary, recover data from Mnesia files:
-    
-    ```
-    cp /opt/homebrew/var/lib/rabbitmq/mnesia/backup.json /opt/homebrew/var/lib/rabbitmq/mnesia/rabbit@node_check
-    ```
-    
-    <Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.42.28_PM.webp" alt="Backup" caption="Backup" />
-    
+
+   ```
+   cp /opt/homebrew/var/lib/rabbitmq/mnesia/backup.json /opt/homebrew/var/lib/rabbitmq/mnesia/rabbit@node_check
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.42.28_PM.webp"
+     alt="Backup"
+     caption="Backup"
+   />
 
 ### Fixing Mnesia Errors in RabbitMQ Clusters
 
@@ -200,46 +233,47 @@ Resolving Mnesia errors in a clustered environment requires more care:
 
 1. Identify the last node to go down — this node likely has the most up-to-date data.
 2. Start this node first:
-    
-    ```
-    rabbitmq-server -detached
-    ```
-    
+
+   ```
+   rabbitmq-server -detached
+   ```
+
 3. Once it's up, rejoin other nodes to the cluster:
-    
-    ```
-    rabbitmqctl stop_app
-    rabbitmqctl reset
-    rabbitmqctl join_cluster rabbit@[first_node_name]
-    rabbitmqctl start_app
-    ```
-    
-    <Figure src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.43.26_PM.webp" alt="Server Detached" caption="Server Detached" />
-    
-    In severe cases, you might need to use the `forget_cluster_node` command:
-    
-    ```
-    rabbitmqctl forget_cluster_node --offline rabbit@[problematic_node]
-    ```
-    
-    This removes a node from the cluster without contacting it, useful when a node is permanently lost.
-    
+
+   ```
+   rabbitmqctl stop_app
+   rabbitmqctl reset
+   rabbitmqctl join_cluster rabbit@[first_node_name]
+   rabbitmqctl start_app
+   ```
+
+   <Figure
+     src="/img/guides/2024/09/rabbit-mq-error-while-waiting-for-mnesia-tables-Screenshot_2024-09-25_at_1.43.26_PM.webp"
+     alt="Server Detached"
+     caption="Server Detached"
+   />
+
+   In severe cases, you might need to use the `forget_cluster_node` command:
+
+   ```
+   rabbitmqctl forget_cluster_node --offline rabbit@[problematic_node]
+   ```
+
+   This removes a node from the cluster without contacting it, useful when a node is permanently lost.
 
 ## Preventing Future Mnesia Table Errors
 
 Prevention is always better than cure. Here are strategies to minimize Mnesia table errors:
 
-1. Implement proper shutdown procedures for all nodes.
-2. Schedule regular backups of your Mnesia database.
-3. Monitor disk space and system resources closely.
-4. Configure appropriate Mnesia table properties:
-These settings in your `rabbitmq.conf` file can help manage table loading issues.
-    
-    ```erlang
-    {mnesia_table_loading_retry_timeout, 30000},
-    {mnesia_table_loading_retry_limit, 10}
-    ```
-    
+1.  Implement proper shutdown procedures for all nodes.
+2.  Schedule regular backups of your Mnesia database.
+3.  Monitor disk space and system resources closely.
+4.  Configure appropriate Mnesia table properties:
+    These settings in your `rabbitmq.conf` file can help manage table loading issues.
+        ```erlang
+        {mnesia_table_loading_retry_timeout, 30000},
+        {mnesia_table_loading_retry_limit, 10}
+        ```
 
 ## Mnesia Table Errors in Kubernetes Environments
 
@@ -263,14 +297,13 @@ spec:
 
 ```yaml
 volumeClaimTemplates:
-- metadata:
-    name: rabbitmq-data
-  spec:
-    accessModes: [ "ReadWriteOnce" ]
-    resources:
-      requests:
-        storage: 1Gi
-
+  - metadata:
+      name: rabbitmq-data
+    spec:
+      accessModes: ['ReadWriteOnce']
+      resources:
+        requests:
+          storage: 1Gi
 ```
 
 1. Implement proper pod restart policies:
@@ -280,7 +313,6 @@ spec:
   template:
     spec:
       restartPolicy: Always
-
 ```
 
 1. Use readiness probes that account for Mnesia table initialization:
@@ -288,10 +320,9 @@ spec:
 ```yaml
 readinessProbe:
   exec:
-    command: ["rabbitmq-diagnostics", "check_port_connectivity"]
+    command: ['rabbitmq-diagnostics', 'check_port_connectivity']
   initialDelaySeconds: 60
   periodSeconds: 30
-
 ```
 
 ## Monitoring RabbitMQ Performance with SigNoz
@@ -301,21 +332,21 @@ To prevent Mnesia table errors proactively, robust monitoring is essential. SigN
 Here's how to set up SigNoz for RabbitMQ monitoring:
 
 1. Install SigNoz using Docker:
-    
-    ```
-    git clone -b main <https://github.com/SigNoz/signoz.git>
-    cd signoz/deploy/
-    ./install.sh
-    
-    ```
-    
+
+   ```
+   git clone -b main <https://github.com/SigNoz/signoz.git>
+   cd signoz/deploy/
+   ./install.sh
+
+   ```
+
 2. Configure RabbitMQ to expose metrics:
-    
-    ```
-    management_agent.disable_metrics_collector = false
-    
-    ```
-    
+
+   ```
+   management_agent.disable_metrics_collector = false
+
+   ```
+
 3. Set up Prometheus to scrape RabbitMQ metrics and forward them to [SigNoz](https://signoz.io/docs/introduction/).
 
 <GetStartedSigNoz />
@@ -351,4 +382,4 @@ While `rabbitmqctl force_boot` can resolve some Mnesia table errors, use it caut
 
 ### How often should I back up RabbitMQ's Mnesia database?
 
-The frequency of backups depends on your specific use case and data criticality. However, a good practice is to perform daily backups and additional backups before major system changes or updates.
\ No newline at end of file
+The frequency of backups depends on your specific use case and data criticality. However, a good practice is to perform daily backups and additional backups before major system changes or updates.
diff --git a/data/guides/rails-logger.mdx b/data/guides/rails-logger.mdx
index 1579b3940..ad4432ce3 100644
--- a/data/guides/rails-logger.mdx
+++ b/data/guides/rails-logger.mdx
@@ -1,155 +1,177 @@
 ---
-
 title: Mastering Rails Logger - Tips for Effective Debugging
-slug: rails-logger
 date: 2024-07-22
 tags: [logging]
 authors: [vasu_bansal]
 description: Learn how to master Rails Logger for effective debugging. Discover setup tips, advanced techniques, and best practices to optimize your Rails applications.
-keywords: [Rails Logger, debugging, Ruby on Rails, logging, application development, troubleshooting, performance optimization]
-
+keywords:
+  [
+    Rails Logger,
+    debugging,
+    Ruby on Rails,
+    logging,
+    application development,
+    troubleshooting,
+    performance optimization,
+  ]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Mastering Rails Logger - Tips for Effective Debugging",
-  "alternativeHeadline": "Learn how to master Rails Logger for effective debugging. Discover setup tips, advanced techniques, and best practices to optimize your Rails applications.",
-  "author": {
-    "@type": "Person",
-    "name": "Vasu Bansal"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-22T00:00:00Z",
-  "dateModified": "2024-07-22T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/rails-logger/"
-  },
-  "description": "Learn how to master Rails Logger for effective debugging. Discover setup tips, advanced techniques, and best practices to optimize your Rails applications.",
-  "keywords": ["Rails Logger", "debugging", "Ruby on Rails", "logging", "application development", "troubleshooting", "performance optimization"],
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Rails Logger",
-      "description": "The built-in logging tool in Ruby on Rails, designed to help developers track and understand the behavior of their applications."
-    },
-    {
-      "@type": "Thing",
-      "name": "Debugging",
-      "description": "The process of identifying, analyzing, and removing errors or bugs from software applications."
-    },
-    {
-      "@type": "Thing",
-      "name": "Performance Optimization",
-      "description": "Techniques and practices aimed at improving the efficiency and speed of a software application."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What are the common log levels used in Rails Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Rails Logger uses debug, info, warn, error, and fatal log levels to manage the severity and verbosity of log messages."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How can I change the log level in my Rails application?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Modify `config.log_level` in the environment-specific configuration file (`config/environments/development.rb`, `config/environments/production.rb`) to adjust the logging verbosity."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the role of a log formatter in Rails Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "A log formatter in Rails Logger formats log messages before they are written to define their structure, including timestamps, severity levels, and additional context."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How can I integrate external logging services with Rails?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Integrate external logging services like SigNoz by installing the corresponding client gem and configuring it with your service's API key."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are some best practices for logging sensitive information?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Avoid logging sensitive data like passwords or personal information directly; instead, use masking or encryption techniques to protect sensitive information."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How can I troubleshoot logging issues in my Rails application?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To troubleshoot logging issues, check `config.log_level` settings, logger configurations (`config.logger`), and review application and server logs for errors related to logging initialization or operation."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I make Rails Logger output to the console during testing?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Add the following to your `config/environments/test.rb` file: \n```ruby\nRails.application.configure do\n  config.logger = ActiveSupport::Logger.new(STDOUT)\n  config.log_level = :debug\nend\n```"
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What's the difference between Rails.logger and puts for debugging?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "`Rails.logger` is more flexible and configurable than `puts`. It allows you to set log levels, format output, and direct logs to various destinations. `puts` simply prints to the console and doesn't provide these advanced features."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How can I implement custom log formatting in Rails?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Create a custom formatter class and set it in your Rails configuration: \n```ruby\nclass CustomFormatter < ActiveSupport::Logger::SimpleFormatter\n  def call(severity, timestamp, progname, msg)\n    \"[#{timestamp}] #{severity}: #{msg}\\n\"\n  end\nend\n\nRails.application.configure do\n  config.logger.formatter = CustomFormatter.new\nend\n```"
-        }
-      }
-    ]
-  }
-}) }} />
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Mastering Rails Logger - Tips for Effective Debugging',
+        alternativeHeadline:
+          'Learn how to master Rails Logger for effective debugging. Discover setup tips, advanced techniques, and best practices to optimize your Rails applications.',
+        author: {
+          '@type': 'Person',
+          name: 'Vasu Bansal',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-22T00:00:00Z',
+        dateModified: '2024-07-22T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/rails-logger/',
+        },
+        description:
+          'Learn how to master Rails Logger for effective debugging. Discover setup tips, advanced techniques, and best practices to optimize your Rails applications.',
+        keywords: [
+          'Rails Logger',
+          'debugging',
+          'Ruby on Rails',
+          'logging',
+          'application development',
+          'troubleshooting',
+          'performance optimization',
+        ],
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Rails Logger',
+            description:
+              'The built-in logging tool in Ruby on Rails, designed to help developers track and understand the behavior of their applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Debugging',
+            description:
+              'The process of identifying, analyzing, and removing errors or bugs from software applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Performance Optimization',
+            description:
+              'Techniques and practices aimed at improving the efficiency and speed of a software application.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are the common log levels used in Rails Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Rails Logger uses debug, info, warn, error, and fatal log levels to manage the severity and verbosity of log messages.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I change the log level in my Rails application?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Modify `config.log_level` in the environment-specific configuration file (`config/environments/development.rb`, `config/environments/production.rb`) to adjust the logging verbosity.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the role of a log formatter in Rails Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'A log formatter in Rails Logger formats log messages before they are written to define their structure, including timestamps, severity levels, and additional context.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I integrate external logging services with Rails?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Integrate external logging services like SigNoz by installing the corresponding client gem and configuring it with your service's API key.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some best practices for logging sensitive information?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Avoid logging sensitive data like passwords or personal information directly; instead, use masking or encryption techniques to protect sensitive information.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I troubleshoot logging issues in my Rails application?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To troubleshoot logging issues, check `config.log_level` settings, logger configurations (`config.logger`), and review application and server logs for errors related to logging initialization or operation.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I make Rails Logger output to the console during testing?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Add the following to your `config/environments/test.rb` file: \n```ruby\nRails.application.configure do\n  config.logger = ActiveSupport::Logger.new(STDOUT)\n  config.log_level = :debug\nend\n```',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "What's the difference between Rails.logger and puts for debugging?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "`Rails.logger` is more flexible and configurable than `puts`. It allows you to set log levels, format output, and direct logs to various destinations. `puts` simply prints to the console and doesn't provide these advanced features.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can I implement custom log formatting in Rails?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Create a custom formatter class and set it in your Rails configuration: \n```ruby\nclass CustomFormatter < ActiveSupport::Logger::SimpleFormatter\n  def call(severity, timestamp, progname, msg)\n    "[#{timestamp}] #{severity}: #{msg}\\n"\n  end\nend\n\nRails.application.configure do\n  config.logger.formatter = CustomFormatter.new\nend\n```',
+              },
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
-Logging is an essential part of building and maintaining any Rails application. It helps developers keep track of what’s happening under the hood, making it easier to spot and fix issues before they become serious problems. Rails Logger, the built-in logging tool in Ruby on Rails, is a powerful and flexible way to handle all your logging needs. 
+Logging is an essential part of building and maintaining any Rails application. It helps developers keep track of what’s happening under the hood, making it easier to spot and fix issues before they become serious problems. Rails Logger, the built-in logging tool in Ruby on Rails, is a powerful and flexible way to handle all your logging needs.
 
 In this guide, we’ll walk you through everything you need to know about Rails Logger - from setting it up and configuring it to using best practices and advanced techniques. We'll also show you how to send your logs to [SigNoz](https://signoz.io/docs/introduction/), an open-source observability platform that can help you get even more out of your logs by providing detailed monitoring and analysis.
 
@@ -250,69 +272,63 @@ Working:
 The `call` method in the `CustomLoggerFormatter` class is invoked internally by the `Logger` class whenever a log message is processed. Here’s a breakdown of how it works:
 
 - Initialization of Custom Formatter:
-    - The `CustomLoggerFormatter` class inherits from `Logger::Formatter`.
-    - It overrides the `call` method to define a custom format for log messages.
+  - The `CustomLoggerFormatter` class inherits from `Logger::Formatter`.
+  - It overrides the `call` method to define a custom format for log messages.
 - Assigning the Custom Formatter to Rails Logger:
-    - `config.logger.formatter = CustomLoggerFormatter.new` assigns an instance of the custom formatter to the Rails logger. This tells the logger to use this custom formatter when formatting log messages.
+  - `config.logger.formatter = CustomLoggerFormatter.new` assigns an instance of the custom formatter to the Rails logger. This tells the logger to use this custom formatter when formatting log messages.
 - Logging a Message:
-    - When a log message is generated, such as `Rails.logger.info('This is an info message.')`, the logger processes the log entry.
+  - When a log message is generated, such as `Rails.logger.info('This is an info message.')`, the logger processes the log entry.
 - Formatter Invocation:
-    - During the processing of the log entry, the logger invokes the `call` method of the assigned formatter.
-    - The `call` method is provided with the `severity`, `time`, `progname`, and `msg` parameters.
-    - The `call` method constructs and returns the formatted log message as a string.
+  - During the processing of the log entry, the logger invokes the `call` method of the assigned formatter.
+  - The `call` method is provided with the `severity`, `time`, `progname`, and `msg` parameters.
+  - The `call` method constructs and returns the formatted log message as a string.
 
 ### Example Flow
 
 Let's walk through an example to see this flow in action:
 
 1. Define the Custom Formatter:
-    
-    ```ruby
-    class CustomLoggerFormatter < Logger::Formatter
-      def call(severity, time, progname, msg)
-        "#{time.to_s(:db)} #{severity} #{msg}\n"
-      end
-    end
-    ```
-    
+
+   ```ruby
+   class CustomLoggerFormatter < Logger::Formatter
+     def call(severity, time, progname, msg)
+       "#{time.to_s(:db)} #{severity} #{msg}\n"
+     end
+   end
+   ```
+
 2. Configure the Logger:
-    
-    ```ruby
-    Rails.application.configure do
-      config.logger.formatter = CustomLoggerFormatter.new
-    end
-    ```
-    
+
+   ```ruby
+   Rails.application.configure do
+     config.logger.formatter = CustomLoggerFormatter.new
+   end
+   ```
+
 3. Generate a Log Message:
-    
-    ```ruby
-    Rails.logger.info('This is an info message.')
-    ```
-    
+
+   ```ruby
+   Rails.logger.info('This is an info message.')
+   ```
+
 4. Internal Logger Processing:
-    - The `Rails.logger.info` call creates a log entry with a severity of `INFO`, the current time, `nil` for `progname` (unless specified), and the message `'This is an info message.'`.
+   - The `Rails.logger.info` call creates a log entry with a severity of `INFO`, the current time, `nil` for `progname` (unless specified), and the message `'This is an info message.'`.
 5. Formatter Call:
-    - The logger calls the `call` method on the `CustomLoggerFormatter` instance:
-        
-        ```ruby
-        ustomLoggerFormatter.new.call('INFO', Time.now, nil, 'This is an info message.')
-        ```
-        
+   - The logger calls the `call` method on the `CustomLoggerFormatter` instance:
+     ```ruby
+     ustomLoggerFormatter.new.call('INFO', Time.now, nil, 'This is an info message.')
+     ```
 6. Formatted Log Message:
-    - The `call` method formats the log message:
-        
-        ```ruby
-        "#{time.to_s(:db)} #{severity} #{msg}\n"
-        ```
-        
-    - This might produce a log message like:
-        
-        ```
-        2024-07-07 12:34:56 INFO This is an info message.
-        ```
-        
+   - The `call` method formats the log message:
+     ```ruby
+     "#{time.to_s(:db)} #{severity} #{msg}\n"
+     ```
+   - This might produce a log message like:
+     ```
+     2024-07-07 12:34:56 INFO This is an info message.
+     ```
 7. Output:
-    - The formatted log message is then written to the log file or output destination.
+   - The formatted log message is then written to the log file or output destination.
 
 ### Rotating Log Files
 
@@ -356,15 +372,15 @@ Rails.application.configure do
   # info, warn, error, and fatal will be logged. Debug messages will be ignored.
   config.log_level = :info
 
-  # Use a different logger for distributed setups. This checks if the 
-  # RAILS_LOG_TO_STDOUT environment variable is set, which is useful for logging 
+  # Use a different logger for distributed setups. This checks if the
+  # RAILS_LOG_TO_STDOUT environment variable is set, which is useful for logging
   # to STDOUT in environments like Heroku where logs are captured from STDOUT.
   if ENV["RAILS_LOG_TO_STDOUT"].present?
     logger = ActiveSupport::Logger.new(STDOUT)
-    
+
     # Use the default log formatter for this logger.
     logger.formatter = config.log_formatter
-    
+
     # Wrap the logger in TaggedLogging to support adding tags to log messages.
     config.logger = ActiveSupport::TaggedLogging.new(logger)
   end
@@ -381,7 +397,7 @@ Rails.application.configure do
   # Apply the custom log formatter to the Rails logger.
   config.logger.formatter = CustomLoggerFormatter.new
 
-  # Configure log file rotation. This line sets up the logger to write to 
+  # Configure log file rotation. This line sets up the logger to write to
   # 'log/production.log', rotate the log file when it reaches 100 megabytes, and
   # keep up to 10 old log files.
   config.logger = Logger.new('log/production.log', 10, 100.megabytes)
@@ -410,7 +426,7 @@ class UsersController < ApplicationController
   def show
 	  # Controller logic
     @user = User.find(params[:id])
-    # Logging in controller 
+    # Logging in controller
     Rails.logger.info "User #{@user.id} viewed" # Logger is called in your controller class
   end
 end
@@ -487,34 +503,33 @@ In some cases, you may need to use custom loggers to handle specific logging req
 Here’s how to set up a custom logger:
 
 1. Create a Custom Logger Class:
-    
-    ```ruby
-    class CustomLogger < Logger
-      def initialize
-        super(Rails.root.join('log/custom.log'), 'daily')
-        self.formatter = proc do |severity, datetime, progname, msg|
-          "#{datetime.to_s(:db)} #{severity}: #{msg}\n"
-        end
-      end
-    end
-    ```
-    
-    This custom logger writes to a separate log file (`log/custom.log`) and rotates the log file daily. The log format is also customized.
-    
+
+   ```ruby
+   class CustomLogger < Logger
+     def initialize
+       super(Rails.root.join('log/custom.log'), 'daily')
+       self.formatter = proc do |severity, datetime, progname, msg|
+         "#{datetime.to_s(:db)} #{severity}: #{msg}\n"
+       end
+     end
+   end
+   ```
+
+   This custom logger writes to a separate log file (`log/custom.log`) and rotates the log file daily. The log format is also customized.
+
 2. Use the Custom Logger in Your Application:
-    
-    ```ruby
-    Rails.application.configure do
-      config.custom_logger = CustomLogger.new
-    end
-    ```
-    
-    Now, you can use the custom logger in your application:
-    
-    ```ruby
-    Rails.configuration.custom_logger.info "This is a custom log message."
-    ```
-    
+
+   ```ruby
+   Rails.application.configure do
+     config.custom_logger = CustomLogger.new
+   end
+   ```
+
+   Now, you can use the custom logger in your application:
+
+   ```ruby
+   Rails.configuration.custom_logger.info "This is a custom log message."
+   ```
 
 ### Tagging Logs
 
@@ -535,27 +550,26 @@ In this configuration, each log message will include the request ID and the remo
 Lograge is a popular gem that replaces the default Rails logging with a more concise and readable log format. It’s particularly useful for production environments.
 
 1. Add Lograge to Your Gemfile:
-    
-    ```ruby
-    gem 'lograge'
-    ```
-    
+
+   ```ruby
+   gem 'lograge'
+   ```
+
 2. Configure Lograge:
-    
-    ```ruby
-    # config/environments/production.rb
-    
-    Rails.application.configure do
-      config.lograge.enabled = true
-    
-      config.lograge.custom_options = lambda do |event|
-        { time: event.time, params: event.payload[:params] }
-      end
-    end
-    ```
-    
-    Lograge condenses the default Rails log output into a single line per request, making it easier to read and analyze.
-    
+
+   ```ruby
+   # config/environments/production.rb
+
+   Rails.application.configure do
+     config.lograge.enabled = true
+
+     config.lograge.custom_options = lambda do |event|
+       { time: event.time, params: event.payload[:params] }
+     end
+   end
+   ```
+
+   Lograge condenses the default Rails log output into a single line per request, making it easier to read and analyze.
 
 ### Asynchronous Logging
 
@@ -865,13 +879,9 @@ SigNoz is a full-stack open-source application performance monitoring and obser
 Key architecture features:
 
 - Logs, Metrics, and traces under a single dashboard
-    
-    SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
-    
+  SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
 - Native OpenTelemetry support
-    
-    SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
-    
+  SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
 
 ### Setup SigNoz
 
diff --git a/data/guides/react-monitoring.mdx b/data/guides/react-monitoring.mdx
index 16805b2a8..b9d8c4c86 100644
--- a/data/guides/react-monitoring.mdx
+++ b/data/guides/react-monitoring.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Mastering React Monitoring - Best Practices and Tools
-slug: react-monitoring
 date: 2024-12-26
 tags: [React, Monitoring]
 authors: [sushant_gaurav]
 description: Discover essential React monitoring techniques, tools, and best practices to optimize your application's performance and user experience.
-keywords: [react monitoring, performance optimization, error tracking, user experience, web development, SigNoz, DevTools]
-
+keywords:
+  [
+    react monitoring,
+    performance optimization,
+    error tracking,
+    user experience,
+    web development,
+    SigNoz,
+    DevTools,
+  ]
 ---
 
 React has revolutionized web development, but with great power comes great responsibility. How can you optimize the performance of your React applications? What metrics should you be tracking? What tools can you utilize to ensure a seamless user experience? [React monitoring](https://signoz.io/guides/react-monitoring/#error-tracking) provides solutions to these queries.
@@ -36,7 +42,12 @@ React monitoring requires tracking, evaluating, and improving the performance of
 
 React monitoring involves four interconnected areas that work together to ensure optimal application performance. Let's break down these key features and understand how they contribute to a robust monitoring strategy:
 
-<Figure src="/img/guides/2024/12/react-monitoring-CleanShot_2024-12-26_at_15.42.092x.webp" alt="" caption="" />### 1. Performance Monitoring
+<Figure
+  src="/img/guides/2024/12/react-monitoring-CleanShot_2024-12-26_at_15.42.092x.webp"
+  alt=""
+  caption=""
+/>
+### 1. Performance Monitoring
 
 - Component Render Times: Track how quickly your React components render and re-render
 - Load Performance: Measure initial load times, Time to Interactive (TTI), and First Contentful Paint (FCP)
@@ -83,43 +94,43 @@ Tracking the correct metrics is essential for evaluating your app's health. Here
 Example: Let's take an example of utilizing Error Boundary to catch component failures:
 
 ```jsx
-import React from 'react';
+import React from 'react'
 
 class ErrorBoundary extends React.Component {
   constructor(props) {
-    super(props);
-    this.state = { hasError: false };
+    super(props)
+    this.state = { hasError: false }
   }
 
   static getDerivedStateFromError(error) {
-    return { hasError: true };
+    return { hasError: true }
   }
 
   componentDidCatch(error, errorInfo) {
-    console.error('Error occurred:', error, errorInfo);
+    console.error('Error occurred:', error, errorInfo)
   }
 
   render() {
     if (this.state.hasError) {
-      return <h1>Something went wrong.</h1>;
+      return <h1>Something went wrong.</h1>
     }
-    return this.props.children;
+    return this.props.children
   }
 }
 
-export default ErrorBoundary;
+export default ErrorBoundary
 ```
 
 Wrap critical components in `ErrorBoundary` to ensure seamless error recovery.
 
 - User Interactions
-    - Click Events: It means what components users interacting with.  You can collect interaction data using tools such as Google Analytics or custom logs.
-    - Formal Submissions: It checks whether users are completing forms. You can track submission rates and validation mistakes with a monitoring library or custom events.
-    - Navigation Patterns: It means how do consumers navigate around your app? You can use monitoring (tools like [SigNoz](https://signoz.io/)) to detect drop-off spots in your user experience.
+  - Click Events: It means what components users interacting with. You can collect interaction data using tools such as Google Analytics or custom logs.
+  - Formal Submissions: It checks whether users are completing forms. You can track submission rates and validation mistakes with a monitoring library or custom events.
+  - Navigation Patterns: It means how do consumers navigate around your app? You can use monitoring (tools like [SigNoz](https://signoz.io/)) to detect drop-off spots in your user experience.
 - Resource Utilization
-    - Memory Usage: Check to see if your software is using excessive memory. Tools such as Chrome DevTools Memory Profiler can assist in detecting leaks caused by unmounted components or stale states.
-    - CPU Consumption: This indicates whether CPU-intensive processes cause slowdowns. To optimize costly updates, measure processes such as virtual DOM reconciliation.
-    - Network Requests: This refers to how efficient your API calls are. To discover bottlenecks, you can monitor latency, payload size, and request frequency.
+  - Memory Usage: Check to see if your software is using excessive memory. Tools such as Chrome DevTools Memory Profiler can assist in detecting leaks caused by unmounted components or stale states.
+  - CPU Consumption: This indicates whether CPU-intensive processes cause slowdowns. To optimize costly updates, measure processes such as virtual DOM reconciliation.
+  - Network Requests: This refers to how efficient your API calls are. To discover bottlenecks, you can monitor latency, payload size, and request frequency.
 
 ## Understanding React-Specific Performance Indicators
 
@@ -132,7 +143,7 @@ Tracking component render durations is critical for identifying inefficiencies,
 Implementation Example: React's `Profiler` API makes it easy to monitor render times:
 
 ```jsx
-import { Profiler } from 'react';
+import { Profiler } from 'react'
 
 function onRenderCallback(
   id, // The "id" prop of the Profiler tree
@@ -143,7 +154,7 @@ function onRenderCallback(
   commitTime, // When React committed this update
   interactions // Set of interactions triggering the update
 ) {
-  console.log(`Component ${id} rendered in ${actualDuration}ms`);
+  console.log(`Component ${id} rendered in ${actualDuration}ms`)
 }
 
 function MyComponent() {
@@ -151,13 +162,17 @@ function MyComponent() {
     <Profiler id="MyComponent" onRender={onRenderCallback}>
       <div>Component Content</div>
     </Profiler>
-  );
+  )
 }
 ```
 
 You can send this information to a monitoring provider to track trends over time. To improve visibility, integrate a monitoring dashboard. For example, a Render Tracking Workflow:
 
-<Figure src="/img/guides/2024/12/react-monitoring-image.webp" alt="Workflow of Rendering Components" caption="Workflow of Rendering Components" />
+<Figure
+  src="/img/guides/2024/12/react-monitoring-image.webp"
+  alt="Workflow of Rendering Components"
+  caption="Workflow of Rendering Components"
+/>
 
 ### Virtual DOM Reconciliation
 
@@ -175,31 +190,31 @@ React hooks are strong but can cause performance bottlenecks if not managed prop
 Custom Hook Example with Monitoring:
 
 ```jsx
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback } from 'react'
 
 function useDataFetching(url) {
-  const [data, setData] = useState(null);
+  const [data, setData] = useState(null)
 
   const fetchData = useCallback(() => {
-    const startTime = performance.now();
+    const startTime = performance.now()
     fetch(url)
       .then((response) => response.json())
       .then((result) => {
-        setData(result);
-        const endTime = performance.now();
-        console.log(`Data fetched in ${endTime - startTime}ms`);
-      });
-  }, [url]);
+        setData(result)
+        const endTime = performance.now()
+        console.log(`Data fetched in ${endTime - startTime}ms`)
+      })
+  }, [url])
 
   useEffect(() => {
-    fetchData();
-  }, [fetchData]);
+    fetchData()
+  }, [fetchData])
 
-  return data;
+  return data
 }
 
 // Usage
-const data = useDataFetching('/api/data');
+const data = useDataFetching('/api/data')
 ```
 
 Logging the fetch time allows you to track the efficiency of your hooks.
@@ -232,35 +247,39 @@ Code Example:
 ```jsx
 class ErrorBoundary extends React.Component {
   constructor(props) {
-    super(props);
-    this.state = { hasError: false };
+    super(props)
+    this.state = { hasError: false }
   }
 
   static getDerivedStateFromError(error) {
-    return { hasError: true };
+    return { hasError: true }
   }
 
   componentDidCatch(error, errorInfo) {
-    logErrorToMonitoringService(error, errorInfo); // Log errors
+    logErrorToMonitoringService(error, errorInfo) // Log errors
   }
 
   render() {
     if (this.state.hasError) {
-      return <h1>Something went wrong.</h1>;
+      return <h1>Something went wrong.</h1>
     }
-    return this.props.children;
+    return this.props.children
   }
 }
 
 // Usage
-<ErrorBoundary>
+;<ErrorBoundary>
   <MyComponent />
-</ErrorBoundary>;
+</ErrorBoundary>
 ```
 
 Diagram: Error Boundary Lifecycle
 
-<Figure src="/img/guides/2024/12/react-monitoring-image%201.webp" alt="Error Boundary Lifecycle" caption="Error Boundary Lifecycle" />
+<Figure
+  src="/img/guides/2024/12/react-monitoring-image%201.webp"
+  alt="Error Boundary Lifecycle"
+  caption="Error Boundary Lifecycle"
+/>
 
 ### 2. Utilize React DevTools
 
@@ -293,29 +312,29 @@ Example of Monitoring Tools:
 To achieve maximum performance, combine modern technology with tried-and-true strategies while monitoring your React application.
 
 - Browser Development Tools: These tools are essential for examining your app's runtime behaviour.
-    - Chrome DevTools: Select the Performance tab to capture and investigate runtime performance issues.
-    - React Developer Tools: This Chrome and Firefox addon can investigate component hierarchies, evaluate state changes, and identify needless re-renders.
+  - Chrome DevTools: Select the Performance tab to capture and investigate runtime performance issues.
+  - React Developer Tools: This Chrome and Firefox addon can investigate component hierarchies, evaluate state changes, and identify needless re-renders.
 - Open-Source Monitoring Libraries: Various open-source libraries increase your capacity to monitor React apps.
-    - why-did-you-render: Notifies you of unnecessary re-renders, which helps optimize component updates.
-    - react-query-dev tools: A debugging tool for effectively monitoring and controlling server-side state.
+  - why-did-you-render: Notifies you of unnecessary re-renders, which helps optimize component updates.
+  - react-query-dev tools: A debugging tool for effectively monitoring and controlling server-side state.
 - Cloud-based Monitoring Solutions: These services offer real-time insights into your application's performance, making them perfect for production situations.
-    - SigNoz: [SigNoz](https://signoz.io/) is a complete, open-source observability software that provides deep insights into the performance and behaviour of your React apps.
-    - New Relic: A full-stack observability platform with React-specific metrics.
-    - Datadog: Provides real-time analytics, error tracking, and performance monitoring specifically for React apps.
+  - SigNoz: [SigNoz](https://signoz.io/) is a complete, open-source observability software that provides deep insights into the performance and behaviour of your React apps.
+  - New Relic: A full-stack observability platform with React-specific metrics.
+  - Datadog: Provides real-time analytics, error tracking, and performance monitoring specifically for React apps.
 - Customized Logging and Analytics: They can be used to track component activities for specific monitoring requirements.
 
 ```jsx
 const logComponentRender = (componentName) => {
-  console.log(`Component ${componentName} rendered at ${new Date().toISOString()}`);
+  console.log(`Component ${componentName} rendered at ${new Date().toISOString()}`)
   // Optionally send this data to a monitoring service
-};
+}
 
 function MyComponent() {
   useEffect(() => {
-    logComponentRender('MyComponent');
-  }, []);
+    logComponentRender('MyComponent')
+  }, [])
 
-  return <div>My Component Content</div>;
+  return <div>My Component Content</div>
 }
 ```
 
@@ -327,34 +346,28 @@ Monitoring your React application offers useful information about potential perf
 
 1. Profile Component Performance: Use the React Profiler to detect which components are generating delayed renderings.
 2. Optimize Component Re-renders:
-    - Use `React.memo()` to prevent unnecessary re-renders of functional components:
-        
-        ```jsx
-        const MyComponent = React.memo(function MyComponent(props) {
-          /* render using props */
-        });
-        ```
-        
-    - Utilize the `useCallback` hook to memoize functions passed as props:
-        
-        ```jsx
-        const memoizedCallback = useCallback(() => {
-          doSomething(a, b);
-        }, [a, b]);
-        ```
-        
+   - Use `React.memo()` to prevent unnecessary re-renders of functional components:
+     ```jsx
+     const MyComponent = React.memo(function MyComponent(props) {
+       /* render using props */
+     })
+     ```
+   - Utilize the `useCallback` hook to memoize functions passed as props:
+     ```jsx
+     const memoizedCallback = useCallback(() => {
+       doSomething(a, b)
+     }, [a, b])
+     ```
 
 ### Strategies for Reducing Unnecessary Re-renders
 
 1. Optimize Class Components:
-    - Use `shouldComponentUpdate` or extend `React.PureComponent` to avoid re-renders caused by unchanged props or states.
+   - Use `shouldComponentUpdate` or extend `React.PureComponent` to avoid re-renders caused by unchanged props or states.
 2. Utilize Memoization for Expensive Operations:
-    - Use the `useMemo` hook for computationally costly calculations:
-        
-        ```jsx
-        const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);
-        ```
-        
+   - Use the `useMemo` hook for computationally costly calculations:
+     ```jsx
+     const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b])
+     ```
 
 ### Optimizing State Management and Data Flow
 
@@ -366,14 +379,14 @@ Monitoring your React application offers useful information about potential perf
 To lower the size of the first bundle, split your code and load components just as needed.
 
 ```jsx
-const OtherComponent = React.lazy(() => import('./OtherComponent'));
+const OtherComponent = React.lazy(() => import('./OtherComponent'))
 
 function MyComponent() {
   return (
     <React.Suspense fallback={<div>Loading...</div>}>
       <OtherComponent />
     </React.Suspense>
-  );
+  )
 }
 ```
 
@@ -457,83 +470,95 @@ SigNoz integrates with OpenTelemetry to provide deep insights into your React ap
 Track and optimize crucial Web Vitals metrics that directly impact your user experience and SEO:
 
 - Loading Performance
-    - Monitor Largest Contentful Paint (LCP) to ensure main content loads quickly
-    - Track First Contentful Paint (FCP) to optimize initial render times
-    - Analyze Time to First Byte (TTFB) to identify server response delays
+  - Monitor Largest Contentful Paint (LCP) to ensure main content loads quickly
+  - Track First Contentful Paint (FCP) to optimize initial render times
+  - Analyze Time to First Byte (TTFB) to identify server response delays
 - Interactivity
-    - Measure First Input Delay (FID) to ensure responsive user interactions
-    - Track Total Blocking Time (TBT) to identify JavaScript execution issues
-    - Identify and fix interaction bottlenecks affecting user experience
+  - Measure First Input Delay (FID) to ensure responsive user interactions
+  - Track Total Blocking Time (TBT) to identify JavaScript execution issues
+  - Identify and fix interaction bottlenecks affecting user experience
 - Visual Stability
-    - Monitor Cumulative Layout Shift (CLS) to maintain stable page layouts
-    - Track layout shifts that could frustrate users during page load
-    - Identify problematic components causing unexpected movements
+  - Monitor Cumulative Layout Shift (CLS) to maintain stable page layouts
+  - Track layout shifts that could frustrate users during page load
+  - Identify problematic components causing unexpected movements
 
-<Figure src="/img/guides/2024/12/react-monitoring-image%202.webp" alt="Web Vitals Dashboard in SigNoz" caption="Web Vitals Dashboard in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/react-monitoring-image%202.webp"
+  alt="Web Vitals Dashboard in SigNoz"
+  caption="Web Vitals Dashboard in SigNoz"
+/>
 
 ### Performance Analytics
 
 Gain comprehensive insights into your application's behavior:
 
 - Component Performance
-    - Identify slow-rendering React components
-    - Track component mount and update times
-    - Monitor state management efficiency
-    - Analyze render cycles and optimization opportunities
+  - Identify slow-rendering React components
+  - Track component mount and update times
+  - Monitor state management efficiency
+  - Analyze render cycles and optimization opportunities
 - Resource Utilization
-    - Monitor JavaScript heap usage
-    - Track memory consumption patterns
-    - Identify potential memory leaks
-    - Analyze CPU utilization
+  - Monitor JavaScript heap usage
+  - Track memory consumption patterns
+  - Identify potential memory leaks
+  - Analyze CPU utilization
 
 ### Advanced Visualization
 
 Make data-driven decisions with SigNoz's powerful visualization tools:
 
 - Custom Dashboards
-    - Create focused views for different performance aspects
-    - Set up role-specific monitoring dashboards
-    - Design executive summaries for high-level metrics
-    - Build detailed technical dashboards for debugging
+  - Create focused views for different performance aspects
+  - Set up role-specific monitoring dashboards
+  - Design executive summaries for high-level metrics
+  - Build detailed technical dashboards for debugging
 - Smart Thresholds
-    - Implement color-coded performance thresholds
-    - Set up visual indicators for performance targets
-    - Create custom threshold levels for different metrics
-    - Get instant visual feedback on performance status
+  - Implement color-coded performance thresholds
+  - Set up visual indicators for performance targets
+  - Create custom threshold levels for different metrics
+  - Get instant visual feedback on performance status
 
-<Figure src="/img/guides/2024/12/react-monitoring-image%203.webp" alt="Smart thresholds in SigNoz" caption="Smart thresholds in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/react-monitoring-image%203.webp"
+  alt="Smart thresholds in SigNoz"
+  caption="Smart thresholds in SigNoz"
+/>
 
 ### Proactive Monitoring
 
 Stay ahead of performance issues:
 
 - Intelligent Alerting
-    - Set up threshold-based alerts for key metrics
-    - Configure trend-based anomaly detection
-    - Create custom alert rules for specific scenarios
-    - Define alert priorities and notification channels
+  - Set up threshold-based alerts for key metrics
+  - Configure trend-based anomaly detection
+  - Create custom alert rules for specific scenarios
+  - Define alert priorities and notification channels
 - Performance Forecasting
-    - Analyze performance trends over time
-    - Identify potential future bottlenecks
-    - Plan capacity based on usage patterns
-    - Make data-driven optimization decisions
+  - Analyze performance trends over time
+  - Identify potential future bottlenecks
+  - Plan capacity based on usage patterns
+  - Make data-driven optimization decisions
 
-<Figure src="/img/guides/2024/12/react-monitoring-image%204.webp" alt="Anamoly Detection in SigNoz" caption="Anamoly Detection in SigNoz" />
+<Figure
+  src="/img/guides/2024/12/react-monitoring-image%204.webp"
+  alt="Anamoly Detection in SigNoz"
+  caption="Anamoly Detection in SigNoz"
+/>
 
 ### Business Impact Analysis
 
 Connect performance metrics to business outcomes:
 
 - User Experience Metrics
-    - Correlate performance with user engagement
-    - Track impact of performance on conversion rates
-    - Monitor user satisfaction indicators
-    - Measure performance across user segments
+  - Correlate performance with user engagement
+  - Track impact of performance on conversion rates
+  - Monitor user satisfaction indicators
+  - Measure performance across user segments
 - ROI Tracking
-    - Measure the impact of performance improvements
-    - Track performance-related business metrics
-    - Analyze cost implications of performance issues
-    - Justify optimization investments
+  - Measure the impact of performance improvements
+  - Track performance-related business metrics
+  - Analyze cost implications of performance issues
+  - Justify optimization investments
 
 To get started with SigNoz monitoring for your React application, visit our [Web Vitals Monitoring documentation](https://signoz.io/docs/frontend-monitoring/opentelemetry-web-vitals/) and [OpenTelemetry implementation guide](http://signoz.io/blog/opentelemetry-react).
 
@@ -610,4 +635,4 @@ React monitoring is primarily application-layer monitoring, focusing on the beha
 - React Profiler identifies rendering bottlenecks at the component level.
 - LogRocket monitors user sessions and front-end problems.
 - New Relic/Datadog: Integrates application and system monitoring for React-based setups.
-- [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/): Allows for [distributed tracing](https://signoz.io/blog/distributed-tracing/) in applications with complicated backends.
\ No newline at end of file
+- [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/): Allows for [distributed tracing](https://signoz.io/blog/distributed-tracing/) in applications with complicated backends.
diff --git a/data/guides/relabel-instance-to-hostname-in-prometheus.mdx b/data/guides/relabel-instance-to-hostname-in-prometheus.mdx
index 84b0ab2d6..646960b44 100644
--- a/data/guides/relabel-instance-to-hostname-in-prometheus.mdx
+++ b/data/guides/relabel-instance-to-hostname-in-prometheus.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: How to Relabel Instance to Hostname in Prometheus
-slug: relabel-instance-to-hostname-in-prometheus
 date: 2024-09-24
 tags: [faq, prometheus]
 authors: [simran_kumari]
 description: Learn how to relabel instance to hostname in Prometheus for improved monitoring clarity. Discover methods, best practices, and advanced techniques.
-keywords: [Prometheus, relabeling, instance labels, hostname, monitoring, metrics, service discovery, SigNoz]
-
+keywords:
+  [
+    Prometheus,
+    relabeling,
+    instance labels,
+    hostname,
+    monitoring,
+    metrics,
+    service discovery,
+    SigNoz,
+  ]
 ---
 
 Prometheus, a powerful open-source monitoring system, uses labels to identify and organize metrics. One crucial label is the "instance" label, which typically contains the IP address of the target being monitored. However, IP addresses can be challenging to read and interpret, especially in large-scale environments. This is where relabeling instances to hostnames comes in handy. By replacing IP addresses with more human-readable hostnames, you can significantly improve your monitoring experience and make troubleshooting easier.
@@ -16,7 +23,11 @@ Prometheus, a powerful open-source monitoring system, uses labels to identify an
 
 Labels are key-value pairs in Prometheus that provide metadata about metrics. The `instance` label, by default, refers to the IP address and port of a target, but in complex environments, IPs alone can be cryptic. Using hostnames instead of IPs makes monitoring more intuitive and debugging faster, especially when correlating with logs or other monitoring tools.
 
-<Figure src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image.webp" alt="Default instance label in Prometheus" caption="Default instance label in Prometheus" />
+<Figure
+  src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image.webp"
+  alt="Default instance label in Prometheus"
+  caption="Default instance label in Prometheus"
+/>
 
 While IP addresses serve their purpose, they present several challenges:
 
@@ -69,7 +80,11 @@ Explanation:
 
 In other words, it simply ov
 
-<Figure src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image%201.webp" alt="Relabeling instance with relabel_configs" caption="Relabeling instance with relabel_configs" /> 
+<Figure
+  src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image%201.webp"
+  alt="Relabeling instance with relabel_configs"
+  caption="Relabeling instance with relabel_configs"
+/>{' '}
 
 <aside>
 💡
@@ -105,9 +120,9 @@ scrape_configs:
     dns_sd_configs:
       - names:
           - 'service.example.com'
-        type: 'A'  # Specify the type of DNS query
-        port: 9090  # Port to use for non-SRV records
-        refresh_interval: 30s  # Refresh interval for querying DNS
+        type: 'A' # Specify the type of DNS query
+        port: 9090 # Port to use for non-SRV records
+        refresh_interval: 30s # Refresh interval for querying DNS
 ```
 
 Instance Relabeling
@@ -133,11 +148,11 @@ You can check out the documentation <a href="https://prometheus.io/docs/promethe
 For environments without DNS, file-based service discovery is an alternative. Create a JSON or YAML file with your targets and hostnames, and point Prometheus to this file:
 
 ```yaml
-- targets: ["localhost:9090"] # replace with ip and port of required server
+- targets: ['localhost:9090'] # replace with ip and port of required server
   labels:
-    region: "India"
-    team: "Testing"
-    platform: "AWS"
+    region: 'India'
+    team: 'Testing'
+    platform: 'AWS'
     instance: 'backend-1' # labelling can be specified here or in the prometheus.yml file using relabel_configs
 ```
 
@@ -153,7 +168,11 @@ scrape_configs:
 
 Prometheus will use the labels from the file for instance relabeling.
 
-<Figure src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image%202.webp" alt="Labelling instance with hostname using File-based Service discovery" caption="Labelling instance with hostname using File-based Service discovery" />
+<Figure
+  src="/img/guides/2024/09/relabel-instance-to-hostname-in-prometheus-image%202.webp"
+  alt="Labelling instance with hostname using File-based Service discovery"
+  caption="Labelling instance with hostname using File-based Service discovery"
+/>
 
 ## Advanced Techniques for Instance Relabeling
 
@@ -161,17 +180,15 @@ If your environment is more complex, you may need advanced techniques for relabe
 
 - Meta labels: Use meta labels like `__meta_kubernetes_node_name` in Kubernetes to automatically relabel instances based on node names or other metadata.
 - Multi-stage relabeling: You can apply multiple `relabel_configs` for more granular control. For instance, first map an IP to a hostname, and then apply further transformations based on service or location.
-    
-    ```yaml
-    relabel_configs:
-      - source_labels: [__meta_kubernetes_node_name]
-        target_label: instance
-      - source_labels: [instance]
-        regex: 'node-(.*)'
-        target_label: region
-        replacement: 'us-east-$1'
-    ```
-    
+  ```yaml
+  relabel_configs:
+    - source_labels: [__meta_kubernetes_node_name]
+      target_label: instance
+    - source_labels: [instance]
+      regex: 'node-(.*)'
+      target_label: region
+      replacement: 'us-east-$1'
+  ```
 
 ### Handling Edge Cases
 
@@ -239,4 +256,4 @@ Using hostnames can potentially expose more information about your infrastructur
 
 ### How do I handle dynamic IP addresses when relabeling to hostnames?
 
-For environments with dynamic IP addresses, consider using a service discovery mechanism that can update hostname mappings automatically. DNS-based service discovery or integration with your cloud provider's API can help maintain accurate hostname labels even as IP addresses change.
\ No newline at end of file
+For environments with dynamic IP addresses, consider using a service discovery mechanism that can update hostname mappings automatically. DNS-based service discovery or integration with your cloud provider's API can help maintain accurate hostname labels even as IP addresses change.
diff --git a/data/guides/reliability-metrics.mdx b/data/guides/reliability-metrics.mdx
index f69817ca7..97ec0fd21 100644
--- a/data/guides/reliability-metrics.mdx
+++ b/data/guides/reliability-metrics.mdx
@@ -1,13 +1,21 @@
 ---
-
 title: 10 Essential Reliability Metrics for Software Quality
-slug: reliability-metrics
 date: 2024-12-19
 tags: [monitoring, SRE]
 authors: [abdulsalaam_noibi]
 description: Discover the 10 essential reliability metrics that drive software quality. Learn how to measure, interpret, and improve these key indicators for better system performance.
-keywords: [reliability metrics, software quality, MTBF, MTTR, availability, defect density, failure rate, POFOD, customer-reported defects]
-
+keywords:
+  [
+    reliability metrics,
+    software quality,
+    MTBF,
+    MTTR,
+    availability,
+    defect density,
+    failure rate,
+    POFOD,
+    customer-reported defects,
+  ]
 ---
 
 Creating reliable, high-quality products in software development isn’t just a goal; it’s a necessity. Reliability metrics are a set of indicators that help developers, product teams, and companies understand how well a software application performs over time and how likely it is to meet user expectations. By monitoring these metrics, you can catch issues before they affect users, reduce system downtime, and make more informed development decisions.
@@ -104,7 +112,7 @@ Where:
 
 ### 4. Availability
 
-Availability measures the percentage of time a system is operational and accessible to users. It directly indicates a system's stability and uptime, helping to answer questions like, “How often is my application ready for use?”. 
+Availability measures the percentage of time a system is operational and accessible to users. It directly indicates a system's stability and uptime, helping to answer questions like, “How often is my application ready for use?”.
 
 Why It's Important:
 
@@ -148,7 +156,7 @@ Why It's Important:
 
 Formula
 
-To Calculate UpTime  use this formula:
+To Calculate UpTime use this formula:
 
 ```java
 Uptime (%) = (Total time – Downtime) / Total time * 100
@@ -245,7 +253,7 @@ Formula
 To calculate the Probability of Failure on Demand , use the following formula:
 
 ```java
-POFOD = 1 / MTBF 
+POFOD = 1 / MTBF
 ```
 
 Where:
@@ -309,7 +317,7 @@ Once you have defined your objectives, choose the metrics that directly support
 
 ### 3. Set Clear, Measurable Targets
 
-With metrics selected, establish clear and achievable targets to track progress. Start with a few key metrics, especially if your team is new to reliability tracking, to avoid overwhelming them with too much data. Strategic simplicity prevents overwhelming your team with excessive data. 
+With metrics selected, establish clear and achievable targets to track progress. Start with a few key metrics, especially if your team is new to reliability tracking, to avoid overwhelming them with too much data. Strategic simplicity prevents overwhelming your team with excessive data.
 
 Consider the following when setting targets:
 
@@ -373,18 +381,24 @@ Solution: Define how your metrics relate to one another and track them together.
 
 ## Observability Tools for Enhanced Reliability Monitoring
 
-[SigNoz](https://signoz.io/) provides powerful capabilities for monitoring and analyzing application performance, making it an ideal solution for tracking software reliability metrics. With its robust observability features and seamless integration with OpenTelemetry, SigNoz empowers teams to proactively manage system reliability and improve software quality. 
+[SigNoz](https://signoz.io/) provides powerful capabilities for monitoring and analyzing application performance, making it an ideal solution for tracking software reliability metrics. With its robust observability features and seamless integration with OpenTelemetry, SigNoz empowers teams to proactively manage system reliability and improve software quality.
 
 Here's how SigNoz stands out:
 
 - [Unified Observability](https://signoz.io/unified-observability/): With SigNoz, you get logs, metrics, and traces all in one platform. This centralization is crucial for understanding reliability metrics, as it lets you see the entire picture of your application’s performance.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-signoz-header-2.webp" alt="A clear picture of a SigNoz Dashboard showing logs, metrics and traces on a single platform" caption="A clear picture of a SigNoz Dashboard showing logs, metrics and traces on a single platform" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-signoz-header-2.webp"
+    alt="A clear picture of a SigNoz Dashboard showing logs, metrics and traces on a single platform"
+    caption="A clear picture of a SigNoz Dashboard showing logs, metrics and traces on a single platform"
+  />
 - [Distributed Tracing](https://signoz.io/distributed-tracing/): SigNoz allows you to trace requests across various microservices, making it easier to pinpoint exactly where an issue occurred. This feature is particularly valuable for teams working with complex architectures, as it helps track metrics like Mean Time to Repair (MTTR) by identifying the root cause of issues quickly.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-signoz_flamegraphs.webp" alt="Spans of a trace visualized with the help of flamegraphs and gantt charts in SigNoz dashboard" caption="Spans of a trace visualized with the help of flamegraphs and gantt charts in SigNoz dashboard" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-signoz_flamegraphs.webp"
+    alt="Spans of a trace visualized with the help of flamegraphs and gantt charts in SigNoz dashboard"
+    caption="Spans of a trace visualized with the help of flamegraphs and gantt charts in SigNoz dashboard"
+  />
 - Customizable Dashboards: SigNoz enables you to create dashboards tailored to the reliability metrics you care about most, such as availability, error rates, or defect density. These dashboards give you at-a-glance insights into your application’s health, so you can make data-driven decisions.
 - Alerting and Notifications: You can set up alerts based on specific thresholds or events, such as a spike in error rates or a drop in availability. This feature ensures that you’re always aware of potential issues and can address them before they escalate, improving metrics like MTBF (Mean Time Between Failures).
 - [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Integration: SigNoz uses OpenTelemetry, an open-source observability framework, which makes it compatible with many programming languages and frameworks. This integration helps in capturing data for reliability metrics across various parts of your application without extensive configuration
@@ -403,35 +417,33 @@ Step 1: Create a SigNoz Cloud Account
 Step 2: Connect Your Application to SigNoz Cloud
 
 - To connect to SigNoz Cloud, you need an [Ingestion Key](https://signoz.io/docs/ingestion/signoz-cloud/keys/). Navigate to the `Settings` page in the SigNoz UI and click on the `ingestion settings Tab` to generate your `ingestion key`
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_001_-_SigNoz_-_Ingestion_Settings_-_guiding-grub.us.signoz.cloud.webp" alt="SigNoz UI showing the ingestion settings Tab" caption="SigNoz UI showing the ingestion settings Tab" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_001_-_SigNoz_-_Ingestion_Settings_-_guiding-grub.us.signoz.cloud.webp"
+    alt="SigNoz UI showing the ingestion settings Tab"
+    caption="SigNoz UI showing the ingestion settings Tab"
+  />
 
 Step 3: Instrument Your Application
 
 SigNoz Cloud supports OpenTelemetry for instrumentation. To illustrate, let’s explore how to instrument a Node.js application, as detailed [in this article](https://signoz.io/docs/instrumentation/opentelemetry-javascript/#send-traces-to-signoz-cloud):
 
 - Install OpenTelemetry package:
-    
-    ```bash
-    npm install --save @opentelemetry/api
-    npm install --save @opentelemetry/auto-instrumentations-node
-    ```
-    
+  ```bash
+  npm install --save @opentelemetry/api
+  npm install --save @opentelemetry/auto-instrumentations-node
+  ```
 - Start the application on your terminal in order to generate the data(Your Request and Response Data) that needs to be sent to SigNoz cloud.
-    
-    ```bash
-    export OTEL_TRACES_EXPORTER="otlp"
-    export OTEL_EXPORTER_OTLP_ENDPOINT="<YOUR_SIGNOZ_ENDPOINT>"
-    export OTEL_NODE_RESOURCE_DETECTORS="env,host,os"
-    export OTEL_SERVICE_NAME="<YOUR_APP_NAME>"
-    export OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=<YOUR_INGESTION_KEY>"
-    export NODE_OPTIONS="--require @opentelemetry/auto-instrumentations-node/register"
-    <your_run_command>
-    ```
-    
-    Note: Replace `<your_run_command>` with the run command of your application
-    
+  ```bash
+  export OTEL_TRACES_EXPORTER="otlp"
+  export OTEL_EXPORTER_OTLP_ENDPOINT="<YOUR_SIGNOZ_ENDPOINT>"
+  export OTEL_NODE_RESOURCE_DETECTORS="env,host,os"
+  export OTEL_SERVICE_NAME="<YOUR_APP_NAME>"
+  export OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=<YOUR_INGESTION_KEY>"
+  export NODE_OPTIONS="--require @opentelemetry/auto-instrumentations-node/register"
+  <your_run_command>
+  ```
+  Note: Replace `<your_run_command>` with the run command of your application
 - Restart your application to start sending data to SigNoz.
 
 Step 4: Explore SigNoz Cloud Dashboard
@@ -439,23 +451,35 @@ Step 4: Explore SigNoz Cloud Dashboard
 Once your application is connected, the SigNoz Cloud dashboard starts displaying telemetry data. Here’s how to analyze key reliability metrics:
 
 - Click on the Traces tab to see a detailed log of application requests & performance data.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_002_-_SigNoz_-_Traces_Explorer_-_guiding-grub.us.signoz.cloud.webp" alt="SigNoz Cloud UI showing request data on the trace section" caption="SigNoz Cloud UI showing request data on the trace section" /> 
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_002_-_SigNoz_-_Traces_Explorer_-_guiding-grub.us.signoz.cloud.webp"
+    alt="SigNoz Cloud UI showing request data on the trace section"
+    caption="SigNoz Cloud UI showing request data on the trace section"
+  />
 - Use filters to analyze specific endpoints or services.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_004_-_SigNoz_-_Traces_Explorer_-_guiding-grub.us.signoz.cloud.webp" alt="A Trace Explorer showing traces based on time and other filters" caption="A Trace Explorer showing traces based on time and other filters" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_004_-_SigNoz_-_Traces_Explorer_-_guiding-grub.us.signoz.cloud.webp"
+    alt="A Trace Explorer showing traces based on time and other filters"
+    caption="A Trace Explorer showing traces based on time and other filters"
+  />
 - Navigate to the Exceptions section to identify and analyze application errors.
 - Drill down into specific errors to understand their root causes.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_005_-_SigNoz_-_Error_Detail_-_guiding-grub.us.signoz.cloud.webp" alt="SigNoz Cloud UI showing Exceptions section" caption="SigNoz Cloud UI showing Exceptions section" /> 
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_005_-_SigNoz_-_Error_Detail_-_guiding-grub.us.signoz.cloud.webp"
+    alt="SigNoz Cloud UI showing Exceptions section"
+    caption="SigNoz Cloud UI showing Exceptions section"
+  />
 - Open the Metrics section to track request latency across endpoints.
 - Identify bottlenecks and optimize slow-performing API.
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_006_-_Open_source_Observability_Platform_-_SigNoz_-_guiding-grub.us.signoz.cloud.webp" alt="Overview of the Metrics section" caption="Overview of the Metrics section" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-FireShot_Capture_006_-_Open_source_Observability_Platform_-_SigNoz_-_guiding-grub.us.signoz.cloud.webp"
+    alt="Overview of the Metrics section"
+    caption="Overview of the Metrics section"
+  />
 
 Step 5: Set Up Alerts
 
@@ -463,12 +487,15 @@ SigNoz allows you to configure alerts for [proactive monitoring](https://signoz.
 
 - Go to the "Alerts" section.
 - Create a new alert and specify:
-    - Condition: Error rate > 5%.
-    - Notification: Email or Slack integration.
+  - Condition: Error rate > 5%.
+  - Notification: Email or Slack integration.
 - Save the alert and test it with sample data
-    
-    <Figure src="/img/guides/2024/12/reliability-metrics-alerts-create-notification-channel.gif" alt="A short demo on how to navigate the Alert section" caption="A short demo on how to navigate the Alert section" /> 
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/12/reliability-metrics-alerts-create-notification-channel.gif"
+    alt="A short demo on how to navigate the Alert section"
+    caption="A short demo on how to navigate the Alert section"
+  />
 
 ### Advantages of SigNoz Over Traditional Monitoring Tools
 
@@ -484,16 +511,16 @@ SigNoz stands out from traditional monitoring tools for several reasons, particu
 As software systems grow more complex, several key trends are emerging in software reliability metrics:
 
 1. Emerging Metrics for Modern Architectures
-    - Metrics tailored for microservices, such as request latency and service dependency errors.
-    - Serverless-specific metrics, like *cold start time* and *invocation success rate*.
+   - Metrics tailored for microservices, such as request latency and service dependency errors.
+   - Serverless-specific metrics, like _cold start time_ and _invocation success rate_.
 2. AI & Machine Learning in Reliability
-    - Predictive analytics for forecasting system failures and reducing downtime.
-    - Anomaly detection algorithms for real-time issue identification.
-    - AI-powered self-healing systems that automate corrective actions.
+   - Predictive analytics for forecasting system failures and reducing downtime.
+   - Anomaly detection algorithms for real-time issue identification.
+   - AI-powered self-healing systems that automate corrective actions.
 3. Evolving Industry Standards
-    - Shift toward continuous reliability testing for ongoing stability validation.
-    - Inclusion of user-centric and security-integrated metrics in reliability assessments.
-    - Updates to global standards (e.g., ISO, IEEE) to align with modern practices.
+   - Shift toward continuous reliability testing for ongoing stability validation.
+   - Inclusion of user-centric and security-integrated metrics in reliability assessments.
+   - Updates to global standards (e.g., ISO, IEEE) to align with modern practices.
 
 ## Key Takeaways
 
@@ -519,4 +546,4 @@ Reliability metrics can be applied to most software systems, though their implem
 
 ### How do reliability metrics impact the software development lifecycle?
 
-Reliability metrics help to set performance goals in the planning phase, identify and resolve issues during development phase, track system availability and performance in deployment phase, and drive continuous improvement through metrics like MTTR in the maintenance phase.
\ No newline at end of file
+Reliability metrics help to set performance goals in the planning phase, identify and resolve issues during development phase, track system availability and performance in deployment phase, and drive continuous improvement through metrics like MTTR in the maintenance phase.
diff --git a/data/guides/remote-server-monitoring.mdx b/data/guides/remote-server-monitoring.mdx
index b25545781..b95aa18df 100644
--- a/data/guides/remote-server-monitoring.mdx
+++ b/data/guides/remote-server-monitoring.mdx
@@ -1,18 +1,25 @@
 ---
-
 title: Essential Guide to Remote Server Monitoring in 2025
-slug: remote-server-monitoring
 date: 2025-01-07
 tags: [monitoring]
 authors: [nitin_gouda]
 description: Discover essential strategies for effective remote server monitoring in 2024. Learn best practices, key metrics, and tools to optimize your IT infrastructure.
-keywords: [remote server monitoring, server performance, IT infrastructure, monitoring tools, SigNoz, network security, system metrics]
-
+keywords:
+  [
+    remote server monitoring,
+    server performance,
+    IT infrastructure,
+    monitoring tools,
+    SigNoz,
+    network security,
+    system metrics,
+  ]
 ---
 
-Remote server monitoring is the process of continuously observing the health and performance of servers and applications from an external location. It enables teams to track key metrics (like CPU usage, memory, and response times), collect error logs, trigger alerts on abnormal conditions, and even automate responses. At its core, monitoring provides visibility into a system, which is essential for judging service health and diagnosing issues​. 
+Remote server monitoring is the process of continuously observing the health and performance of servers and applications from an external location. It enables teams to track key metrics (like CPU usage, memory, and response times), collect error logs, trigger alerts on abnormal conditions, and even automate responses. At its core, monitoring provides visibility into a system, which is essential for judging service health and diagnosing issues​.
 
 **SREs and developers rely on monitoring to:**
+
 - **Track performance metrics:** CPU, memory, disk I/O, network throughput, and application-specific metrics (like request latency or throughput) over time.
 - **Log and analyze errors:** Collect application logs, system logs, and error traces to debug failures and exceptions.
 - **Alert on issues:** Automatically notify on-call engineers when defined thresholds are breached or anomalies are detected, so they can respond quickly.
@@ -20,7 +27,6 @@ Remote server monitoring is the process of continuously observing the health and
 
 In cloud environments, servers may be distributed across data centers or regions, making remote monitoring (often via network) the only way to gather telemetry. The goal is to detect problems early and minimize downtime or performance degradation for end users.
 
-
 ## Key Aspects of Remote Monitoring
 
 Effective remote server monitoring involves more than just tracking performance metrics; it requires a comprehensive approach encompassing system resources, application behavior, security measures, and rapid response mechanisms. By addressing these core components, organizations can ensure their IT infrastructure remains reliable, secure, and efficient.
@@ -98,19 +104,14 @@ Implementing an effective remote server monitoring strategy involves several key
 
 1. **Assess Your Infrastructure**
    Create an inventory of all servers, applications, and devices in your network. Identify critical systems and map dependencies between them to prioritize monitoring efforts.
-    
 2. **Define Monitoring Goals**
    Establish performance baselines representing normal operating conditions for your servers. Define measurable objectives like maintaining 99.9% uptime or ensuring application response times under 2 seconds during peak traffic.
-    
 3. **Select Appropriate Monitoring Tools**
    Choose solutions based on your infrastructure, needs, and budget. For small setups, tools like SigNoz, Nagios or Zabbix might suffice. Larger enterprises may need platforms like Datadog or SolarWinds that offer scalability and integration capabilities.
-    
 4. **Establish Baselines and Set Alerts**
    Use monitoring tools to determine typical performance metrics and configure alerts for significant deviations. For example, set notifications when CPU usage exceeds 90% for more than 10 minutes or free disk space falls below 15%.
-    
 5. **Develop Incident Response Procedures**
    Create clear escalation protocols and document troubleshooting steps for common issues. Specify who gets notified at each stage of an incident and outline resolution procedures.
-    
 6. **Train Your Team**
    Ensure staff understand how to use monitoring systems, interpret alerts, and follow response protocols. Run simulated drills to prepare for real-world scenarios and build confidence in handling incidents.
 
@@ -121,124 +122,132 @@ Implementing an effective remote server monitoring strategy involves several key
 
 Remote server monitoring is essential for maintaining the health, performance, and security of modern IT infrastructures. Whether your servers are hosted in the cloud, on-premises, or in a hybrid setup, having a comprehensive monitoring strategy ensures minimal downtime and efficient operations.
 
-SigNoz is a powerful observability platform that simplifies remote server monitoring. With its ability to monitor infrastructure, applications, and user experience in one unified platform, SigNoz provides the visibility teams need to keep their systems running smoothly. By the end of this walkthrough, you’ll have a clear understanding of how to use SigNoz to monitor your server resources, application performance, and system health in real-time. 
-
-Follow the steps outlined below to set up and leverage SigNoz effectively for advanced remote server monitoring: 
-
-1. **Create a SigNoz Cloud Account:** 
-[SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
-2. **Using SigNoz Infrastructure Monitoring:** 
-In the top left corner, click on `Get Started`. 
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
-    
-    You are redirected to “Get Started Page”. Choose `Infrastructure Monitoring` 
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-08-10_at_10.00.41_PM.webp" alt="Infrastructure Monitoring" caption="Infrastructure Monitoring" />
-    
-3. **Select Data Source:**
-You must select the Data Source. Since the metrics to be collected here are from the host system, select `HostMetrics`.
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-97d0507f-e640-4317-8f6a-6823fb2e15af.webp" alt="SigNoz Host Metrics" caption="SigNoz Host Metrics" />
-    
-    Choose the environment of your host system. For this demo, I am using Ubuntu AMD64.
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-01086e7b-4bdd-4752-88f5-e237ffd9565e.webp" alt="Host System Environment" caption="Host System Environment" />
-    
-4. **Setup [OTel Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) as an agent:** 
-For more information, refer to [OpenTelemetry Binary Usage in Virtual Machine(VM)](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to get your Otel [Collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) up and running.
-    
-    **Note:** Download the <a href="https://github.com/open-telemetry/opentelemetry-collector/releases" rel="noopener noreferrer nofollow" target="_blank">latest version</a> of the Otel Collector that matches your host operating system.
-    
-5. **Import Dashboard:** 
-Click `New Dashboard` and then import JSON file to create an existing dashboard. For this demo we are using SigNoz [Hostmetrics JSON](https://github.com/SigNoz/dashboards/blob/main/hostmetrics/hostmetrics.json) Dashboard. For more information, refer to [**Hostmetrics** documentation](https://signoz.io/docs/userguide/hostmetrics/#setup).
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.25.46.webp" alt="Dashboard View" caption="Dashboard View" />
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.25.41.webp" alt="Importing JSON File" caption="Importing JSON File" />
-    
-    Once done, click `Import and Next`. You will be directed to the dashboard you just created. 
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-2fa8b4cd-6ae9-4b9f-a523-48d7e1dd1a1a.webp" alt="Selecting host_name for dashboard view" caption="Selecting host_name for dashboard view" />
-    
-    On the `$host_name` select your environment, on which you downloaded the [OTel](https://signoz.io/blog/what-is-opentelemetry/)-collector exporter. If exporter is running properly you can see your Remote Server metrics.
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-76782e44-dea5-4218-96f4-b9b784f52935.webp" alt="Setting host_name" caption="Setting host_name" />
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.40.21.webp" alt="HostMetrics Full Dashboard" caption="HostMetrics Full Dashboard" />
-    
-    To learn more, refer to [Manage Dashboards and Panels](https://signoz.io/docs/userguide/manage-dashboards-and-panels/).
-    
-6. **Infrastructure Monitoring Support**: 
-    
-    Click SigNoz sidebar >> Infra Monitoring to view all the available hosts. SigNoz Cloud offers dedicated support for [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/). 
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-269bf300-b072-4858-af63-6281178cc638.webp" alt="Click on Infra Monitoring" caption="Click on Infra Monitoring" />
-    
+SigNoz is a powerful observability platform that simplifies remote server monitoring. With its ability to monitor infrastructure, applications, and user experience in one unified platform, SigNoz provides the visibility teams need to keep their systems running smoothly. By the end of this walkthrough, you’ll have a clear understanding of how to use SigNoz to monitor your server resources, application performance, and system health in real-time.
+
+Follow the steps outlined below to set up and leverage SigNoz effectively for advanced remote server monitoring:
+
+1.  **Create a SigNoz Cloud Account:**
+    [SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
+2.  **Using SigNoz Infrastructure Monitoring:**
+    In the top left corner, click on `Get Started`.
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+
+        You are redirected to “Get Started Page”. Choose `Infrastructure Monitoring`
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-08-10_at_10.00.41_PM.webp" alt="Infrastructure Monitoring" caption="Infrastructure Monitoring" />
+3.  **Select Data Source:**
+    You must select the Data Source. Since the metrics to be collected here are from the host system, select `HostMetrics`.
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-97d0507f-e640-4317-8f6a-6823fb2e15af.webp" alt="SigNoz Host Metrics" caption="SigNoz Host Metrics" />
+
+        Choose the environment of your host system. For this demo, I am using Ubuntu AMD64.
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-01086e7b-4bdd-4752-88f5-e237ffd9565e.webp" alt="Host System Environment" caption="Host System Environment" />
+4.  **Setup [OTel Collector](https://signoz.io/blog/opentelemetry-collector-complete-guide/) as an agent:**
+    For more information, refer to [OpenTelemetry Binary Usage in Virtual Machine(VM)](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) to get your Otel [Collector agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) up and running.
+        **Note:** Download the <a href="https://github.com/open-telemetry/opentelemetry-collector/releases" rel="noopener noreferrer nofollow" target="_blank">latest version</a> of the Otel Collector that matches your host operating system.
+5.  **Import Dashboard:**
+    Click `New Dashboard` and then import JSON file to create an existing dashboard. For this demo we are using SigNoz [Hostmetrics JSON](https://github.com/SigNoz/dashboards/blob/main/hostmetrics/hostmetrics.json) Dashboard. For more information, refer to [**Hostmetrics** documentation](https://signoz.io/docs/userguide/hostmetrics/#setup).
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.25.46.webp" alt="Dashboard View" caption="Dashboard View" />
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.25.41.webp" alt="Importing JSON File" caption="Importing JSON File" />
+
+        Once done, click `Import and Next`. You will be directed to the dashboard you just created.
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-2fa8b4cd-6ae9-4b9f-a523-48d7e1dd1a1a.webp" alt="Selecting host_name for dashboard view" caption="Selecting host_name for dashboard view" />
+
+        On the `$host_name` select your environment, on which you downloaded the [OTel](https://signoz.io/blog/what-is-opentelemetry/)-collector exporter. If exporter is running properly you can see your Remote Server metrics.
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-76782e44-dea5-4218-96f4-b9b784f52935.webp" alt="Setting host_name" caption="Setting host_name" />
+
+        <Figure src="/img/guides/2025/03/remote-server-monitoring-Screenshot_2024-12-28_at_23.40.21.webp" alt="HostMetrics Full Dashboard" caption="HostMetrics Full Dashboard" />
+
+        To learn more, refer to [Manage Dashboards and Panels](https://signoz.io/docs/userguide/manage-dashboards-and-panels/).
+6.  **Infrastructure Monitoring Support**:
+
+    Click SigNoz sidebar >> Infra Monitoring to view all the available hosts. SigNoz Cloud offers dedicated support for [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/).
+
+    <Figure
+      src="/img/guides/2025/03/remote-server-monitoring-269bf300-b072-4858-af63-6281178cc638.webp"
+      alt="Click on Infra Monitoring"
+      caption="Click on Infra Monitoring"
+    />
+
     Click on the desired **`Host Name`** to open its corresponding dashboard
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-3b6e2b2c-9fa8-47fb-a094-5f35c8de5924.webp" alt="Select your hostname" caption="Select your hostname" />
-    
-    The dashboard displays comprehensive host metrics data for your selected host. This feature ensures you can easily monitor and analyze infrastructure metrics for efficient system performance management. 
-    
-    <Figure src="/img/guides/2025/03/remote-server-monitoring-ac600f6d-9587-4b21-a5a5-533ca0787857.webp" alt="Infrastructure dashboard" caption="Infrastructure dashboard" />
-    
-    To learn more on how to send the Infra Metrics to SigNoz you can follow our [user guide here](https://signoz.io/docs/userguide/send-metrics-cloud/).
-    
 
+    <Figure
+      src="/img/guides/2025/03/remote-server-monitoring-3b6e2b2c-9fa8-47fb-a094-5f35c8de5924.webp"
+      alt="Select your hostname"
+      caption="Select your hostname"
+    />
+
+    The dashboard displays comprehensive host metrics data for your selected host. This feature ensures you can easily monitor and analyze infrastructure metrics for efficient system performance management.
+
+    <Figure
+      src="/img/guides/2025/03/remote-server-monitoring-ac600f6d-9587-4b21-a5a5-533ca0787857.webp"
+      alt="Infrastructure dashboard"
+      caption="Infrastructure dashboard"
+    />
+
+    To learn more on how to send the Infra Metrics to SigNoz you can follow our [user guide here](https://signoz.io/docs/userguide/send-metrics-cloud/).
 
 ## Key Benefits of Remote Server Monitoring
 
 - **Proactive Issue Detection**
-Remote monitoring enables early detection of potential issues, such as resource bottlenecks, failing hardware, or software errors. By identifying these problems before they escalate, IT teams can take preventive action to avoid costly disruptions. For example, monitoring disk usage can help identify when storage is nearing capacity, allowing for timely upgrades.
+  Remote monitoring enables early detection of potential issues, such as resource bottlenecks, failing hardware, or software errors. By identifying these problems before they escalate, IT teams can take preventive action to avoid costly disruptions. For example, monitoring disk usage can help identify when storage is nearing capacity, allowing for timely upgrades.
 - **Improved Uptime:** Server downtime can lead to significant revenue loss, especially for businesses dependent on 24/7 operations. Remote monitoring tools ensure IT teams receive instant alerts when performance drops or outages occur, enabling rapid responses. This minimizes the impact of downtime on customers and business operations.
 - **Resource Optimization:** Remote server monitoring enables IT teams to track CPU, memory, and network usage in real time, helping them optimize resource allocation. This prevents overprovisioning and reduces operational costs while ensuring critical applications have the resources they need. For example, detecting idle virtual machines through [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) allows teams to deallocate unnecessary resources, resulting in significant cost savings.
 - **Cost Reduction:** Remote monitoring reduces the need for on-site personnel and costly manual interventions. By automating routine monitoring tasks and enabling remote troubleshooting, businesses save time and money. This is particularly beneficial for organizations managing multiple data centers or remote sites.
 
-
 ## Best Practices for Remote Server Monitoring in 2025
 
 As IT infrastructure evolves, staying current with server monitoring practices is essential for reliability and performance. Here are key practices for effective monitoring in 2025:
 
 1. **Implement Agentless Monitoring:** This lightweight approach collects metrics using built-in protocols like SNMP or APIs without installing additional software.
-    - **Reduced Overhead**: Minimizes resource consumption on monitored systems
-    - **Simplified Deployment**: Easier to implement across diverse environments
+
+   - **Reduced Overhead**: Minimizes resource consumption on monitored systems
+   - **Simplified Deployment**: Easier to implement across diverse environments
 
 2. **Utilize AI and Machine Learning:** These technologies transform monitoring through:
-    - **Predictive Analytics**: Forecasting potential issues before they occur
-    - **Anomaly Detection**: Identifying unusual patterns that might indicate problems
+
+   - **Predictive Analytics**: Forecasting potential issues before they occur
+   - **Anomaly Detection**: Identifying unusual patterns that might indicate problems
 
 3. **Integrate with Automation Tools:** Enhances efficiency through:
-    - **ChatOps Integration**: Combining monitoring with platforms like Slack for collaborative troubleshooting
-    - **Auto-Remediation**: Configuring scripts to resolve common issues automatically
+
+   - **ChatOps Integration**: Combining monitoring with platforms like Slack for collaborative troubleshooting
+   - **Auto-Remediation**: Configuring scripts to resolve common issues automatically
 
 4. **Ensure Scalability:** Critical for growing infrastructures through:
-    - **Flexible Deployments**: Using containerized solutions that scale alongside your infrastructure
-    - **Future-Proof Solutions**: Selecting tools that handle hybrid environments
+
+   - **Flexible Deployments**: Using containerized solutions that scale alongside your infrastructure
+   - **Future-Proof Solutions**: Selecting tools that handle hybrid environments
 
 5. **Adopt a Unified Monitoring Approach:** Consolidates tools and data for:
-    - **Single Pane of Glass**: One dashboard for all metrics, logs, and alerts
-    - **Reduced Complexity**: Eliminating redundant tools to focus on key indicators
+   - **Single Pane of Glass**: One dashboard for all metrics, logs, and alerts
+   - **Reduced Complexity**: Eliminating redundant tools to focus on key indicators
 
 ## Overcoming Common Challenges in Remote Server Monitoring
 
 1. **Network Connectivity Issues:** Build resilience through redundant communication pathways and store-and-forward techniques that cache data during outages.
 
 2. **Data Volume Management:** Implement efficient storage through:
-    - [Metric aggregation](https://signoz.io/docs/metrics-management/types-and-aggregation/) instead of storing every data point
-    - Time-series databases like Prometheus or InfluxDB with compression techniques
+
+   - [Metric aggregation](https://signoz.io/docs/metrics-management/types-and-aggregation/) instead of storing every data point
+   - Time-series databases like Prometheus or InfluxDB with compression techniques
 
 3. **[Alert Fatigue](https://signoz.io/blog/alert-fatigue/):** Reduce noise by:
-    - Calibrating thresholds carefully (e.g., alert on 85% CPU usage for >5 minutes)
-    - Using tools with intelligent correlation to group related alerts
+
+   - Calibrating thresholds carefully (e.g., alert on 85% CPU usage for >5 minutes)
+   - Using tools with intelligent correlation to group related alerts
 
 4. **Security and Compliance:** Protect monitoring systems through:
-    - Encryption of monitoring traffic using protocols like TLS
-    - Regular audits of monitoring configurations to ensure compliance
+
+   - Encryption of monitoring traffic using protocols like TLS
+   - Regular audits of monitoring configurations to ensure compliance
 
 5. **Performance Impact:** Optimize monitoring load by:
-    - Adjusting data collection frequency based on operational needs
-    - Implementing sampling techniques for high-volume metrics
+   - Adjusting data collection frequency based on operational needs
+   - Implementing sampling techniques for high-volume metrics
 
 Addressing these challenges creates a more robust monitoring system that supports your operational goals without compromising performance.
 
@@ -267,4 +276,4 @@ Yes, remote monitoring helps prevent downtime by detecting anomalies like resour
 
 ### What security considerations should be taken into account for remote monitoring?
 
-To secure remote monitoring, use encrypted data transmission (e.g., HTTPS), implement multi-factor authentication (MFA), conduct regular security audits, and ensure compliance with data protection regulations like GDPR. These measures safeguard sensitive server data and prevent unauthorized access.
\ No newline at end of file
+To secure remote monitoring, use encrypted data transmission (e.g., HTTPS), implement multi-factor authentication (MFA), conduct regular security audits, and ensure compliance with data protection regulations like GDPR. These measures safeguard sensitive server data and prevent unauthorized access.
diff --git a/data/guides/security-observability.mdx b/data/guides/security-observability.mdx
index 5bf03ee85..3ffad121d 100644
--- a/data/guides/security-observability.mdx
+++ b/data/guides/security-observability.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Enhancing DevOps with Security Observability - A Guide
-slug: security-observability
 date: 2024-09-04
 tags: [observability]
 authors: [vivek_goswami]
 description: Learn how security observability enhances DevOps practices. Discover implementation strategies, benefits, and best practices for integrating security into your workflows.
-keywords: [security observability, DevOps, cloud security, CI/CD, threat modeling, incident response, SigNoz]
-
+keywords:
+  [
+    security observability,
+    DevOps,
+    cloud security,
+    CI/CD,
+    threat modeling,
+    incident response,
+    SigNoz,
+  ]
 ---
 
 Security observability is revolutionizing the approach DevOps teams take toward safeguarding applications and infrastructure. By embedding security monitoring and analysis throughout the development lifecycle, organizations can uncover deeper insights into potential vulnerabilities and threats. This article delves into the concept of security observability, its integration into DevOps practices, and its role in addressing the complexities of modern cloud-native security challenges.
@@ -82,7 +88,8 @@ To get started with SigNoz:
 3. Configure your applications to send observability data to SigNoz.
 4. Set up custom dashboards and alerts for your security use cases.
 
-<Figure src="/img/guides/2024/09/security-observability-image.webp" alt="" caption="" />## Best Practices for Implementing Security Observability
+<Figure src="/img/guides/2024/09/security-observability-image.webp" alt="" caption="" />
+## Best Practices for Implementing Security Observability
 
 Implementing effective security observability is crucial for safeguarding systems and data. Here are key practices to follow:
 
@@ -96,17 +103,17 @@ Implementing effective security observability is crucial for safeguarding system
 In today’s complex digital landscape, effective security observability is crucial for safeguarding systems and data. However, several challenges must be addressed to implement and maintain an efficient observability solution.
 
 - Addressing Data Privacy Concerns:
-    - Security observability often involves collecting and analyzing sensitive data. Implementing robust data anonymization techniques and encryption methods can help protect user privacy while still providing valuable insights.
-    - Example: A company uses data masking techniques to obscure sensitive information in logs, ensuring that personal data is not exposed during analysis.
+  - Security observability often involves collecting and analyzing sensitive data. Implementing robust data anonymization techniques and encryption methods can help protect user privacy while still providing valuable insights.
+  - Example: A company uses data masking techniques to obscure sensitive information in logs, ensuring that personal data is not exposed during analysis.
 - Managing Volume and Complexity:
-    - The sheer volume of security-related data can be overwhelming. Utilizing automated data processing and filtering techniques helps in focusing on critical security events.
-    - Example: Implementing a [log management system](https://signoz.io/blog/open-source-log-management/) that automatically filters out noise and prioritizes high-risk alerts can streamline security operations.
+  - The sheer volume of security-related data can be overwhelming. Utilizing automated data processing and filtering techniques helps in focusing on critical security events.
+  - Example: Implementing a [log management system](https://signoz.io/blog/open-source-log-management/) that automatically filters out noise and prioritizes high-risk alerts can streamline security operations.
 - Ensuring Scalability:
-    - As organizations grow, so do their security observability needs. Scalable solutions that can handle increasing data volumes and complexity are essential.
-    - Example: A cloud-based observability platform that scales automatically based on data influx ensures consistent performance and reliability as the organization expands.
+  - As organizations grow, so do their security observability needs. Scalable solutions that can handle increasing data volumes and complexity are essential.
+  - Example: A cloud-based observability platform that scales automatically based on data influx ensures consistent performance and reliability as the organization expands.
 - Balancing Performance and Cost:
-    - Effective observability should not compromise system performance or incur excessive costs. Opting for solutions with efficient data processing and storage options helps maintain a balance.
-    - Example: A company implements an observability solution that uses data sampling and compression techniques to reduce the volume of data being processed and stored. This approach minimizes costs while still providing enough data for effective monitoring, ensuring that system performance remains optimal without overspending on storage and processing.
+  - Effective observability should not compromise system performance or incur excessive costs. Opting for solutions with efficient data processing and storage options helps maintain a balance.
+  - Example: A company implements an observability solution that uses data sampling and compression techniques to reduce the volume of data being processed and stored. This approach minimizes costs while still providing enough data for effective monitoring, ensuring that system performance remains optimal without overspending on storage and processing.
 
 ## Key Takeaways
 
@@ -141,4 +148,4 @@ When implemented effectively, security observability can increase development ve
 ## Resources
 
 - [SigNoz Blog: Implementing Observability in Microservices](https://signoz.io/blog/microservices-observability-with-distributed-tracing/)
-- [SigNoz Docs: Security Best Practices for Observability](https://signoz.io/guides/observability-engineering/)
\ No newline at end of file
+- [SigNoz Docs: Security Best Practices for Observability](https://signoz.io/guides/observability-engineering/)
diff --git a/data/guides/sentry-observability.mdx b/data/guides/sentry-observability.mdx
index a9b99d6c0..743f29fc5 100644
--- a/data/guides/sentry-observability.mdx
+++ b/data/guides/sentry-observability.mdx
@@ -1,39 +1,47 @@
 ---
-
 title: Sentry Observability - Fantastic for Errors, But Is It Enough for Modern DevOps?
-slug: sentry-observability
 date: 2025-03-04
 tags: [observability]
 authors: [soumya_gupta]
 description: Explore Sentry's observability capabilities in modern DevOps. Learn its strengths, limitations, and how to augment it for comprehensive monitoring.
-keywords: [sentry observability, error tracking, devops monitoring, distributed tracing, application performance]
-
+keywords:
+  [
+    sentry observability,
+    error tracking,
+    devops monitoring,
+    distributed tracing,
+    application performance,
+  ]
 ---
 
-DevOps teams need deep visibility into their software, from frontend performance metrics to backend infrastructure health. Sentry has gained popularity for its robust error tracking and real-time notifications, but does it provide the complete observability modern teams require? 
+DevOps teams need deep visibility into their software, from frontend performance metrics to backend infrastructure health. Sentry has gained popularity for its robust error tracking and real-time notifications, but does it provide the complete observability modern teams require?
 
 In this article, we will dissect Sentry's observability offerings, highlight its strengths and limitations, and explore how to augment Sentry with complementary solutions for a more comprehensive DevOps toolchain.
 
 ## Quick Guide: Sentry Observability at a Glance
 
 1. **Sentry's Core Strength**
-    - Excellent for **application-level error tracking**, debugging, and performance monitoring.
-    - Provides **rich context** with stack traces, user sessions, and release tracking.
+   - Excellent for **application-level error tracking**, debugging, and performance monitoring.
+   - Provides **rich context** with stack traces, user sessions, and release tracking.
 2. **Major Gaps in Full-Stack Observability**
-    - Limited capabilities for **[infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/)**, **log aggregation**, and **network insights**.
-    - **Distributed tracing** support is present but not as robust for large microservice landscapes.
+   - Limited capabilities for **[infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/)**, **log aggregation**, and **network insights**.
+   - **Distributed tracing** support is present but not as robust for large microservice landscapes.
 3. **Combining Sentry with Other Tools**
-    - Integrate with **log management** (e.g., ELK) and **metrics tools** (e.g., Prometheus, Grafana) to gain deeper visibility.
-    - For complete end-to-end **distributed tracing**, consider specialized solutions or open-source platforms like **SigNoz**.
+   - Integrate with **log management** (e.g., ELK) and **metrics tools** (e.g., Prometheus, Grafana) to gain deeper visibility.
+   - For complete end-to-end **distributed tracing**, consider specialized solutions or open-source platforms like **SigNoz**.
 4. **Final Verdict**
-    - Sentry excels at error tracking and application monitoring but isn't a complete observability solution.
-    - For comprehensive DevOps observability, combine Sentry with specialized tools for infrastructure monitoring, log management, and advanced distributed tracing.
+   - Sentry excels at error tracking and application monitoring but isn't a complete observability solution.
+   - For comprehensive DevOps observability, combine Sentry with specialized tools for infrastructure monitoring, log management, and advanced distributed tracing.
 
 ## What is Sentry Observability and How Does It Work?
 
 Sentry is an application monitoring platform that focuses on error reporting and performance monitoring. It captures and aggregates exceptions, stack traces, and user feedback to streamline debugging and root-cause analysis.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%203.webp" alt="Sentry Dashboard" caption="Sentry Dashboard" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%203.webp"
+  alt="Sentry Dashboard"
+  caption="Sentry Dashboard"
+/>
 
 ### Core Features of Sentry
 
@@ -50,7 +58,11 @@ In summary, Sentry’s feature set centers on observing application behavior –
 
 ## Key Components of Sentry's Observability Offering
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%201.webp" alt="Key Components of Sentry's Observability Offering" caption="Key Components of Sentry's Observability Offering" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%201.webp"
+  alt="Key Components of Sentry's Observability Offering"
+  caption="Key Components of Sentry's Observability Offering"
+/>
 
 ### Error Tracking
 
@@ -81,18 +93,30 @@ This will send the captured exception to Sentry.
 
 Next, navigate to Sentry’s dashboard to view the captured issue.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%202.webp" alt="Issues on Sentry" caption="Issues on Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%202.webp"
+  alt="Issues on Sentry"
+  caption="Issues on Sentry"
+/>
 
 Click on the error to explore detailed insights, including stack traces, affected environments, and additional debugging information.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%203.webp" alt="Detailed Issues tab" caption="Detailed Issues tab" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%203.webp"
+  alt="Detailed Issues tab"
+  caption="Detailed Issues tab"
+/>
 
 2. **Groups similar errors to avoid alert fatigue**
 
-Sentry prevents [alert fatigue](https://signoz.io/blog/alert-fatigue/) by intelligently grouping similar errors using **fingerprints**. A fingerprint is a 
+Sentry prevents [alert fatigue](https://signoz.io/blog/alert-fatigue/) by intelligently grouping similar errors using **fingerprints**. A fingerprint is a
 way to uniquely identify an event, and all events have one. Events with the same fingerprint are grouped together into an issue.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%204.webp" alt="Fingerprinting on sentry" caption="Fingerprinting on sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%204.webp"
+  alt="Fingerprinting on sentry"
+  caption="Fingerprinting on sentry"
+/>
 
 You can set up custom grouping rules under **[Project] > Settings > Issue Grouping > Fingerprint Rules**. Sentry reviews all stack trace frames and applies the fingerprint if an event matches the rule's conditions.
 
@@ -116,11 +140,11 @@ sentry_sdk.init(
 
 def set_feature_flag_tag(user):
     # Tagging the 'show_widget' feature flag to track its state
-    show_widget = user.get("showWidget", False)  
+    show_widget = user.get("showWidget", False)
     set_tag("show_widget", show_widget)
-    
+
 # Simulating a user and checking their feature flag status
-user = {"id": 123, "username": "test_user", "showWidget": True}  
+user = {"id": 123, "username": "test_user", "showWidget": True}
 
 set_feature_flag_tag(user)
 
@@ -136,11 +160,19 @@ You can filter issues or transactions based on tags. For example, you can filter
 
 Let’s head to sentry’s dashboard in trace view
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%208.webp" alt="Trace View Sentry" caption="Trace View Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%208.webp"
+  alt="Trace View Sentry"
+  caption="Trace View Sentry"
+/>
 
 Similarly, you can also view it on the Transactions Summary page
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%209.webp" alt="Transaction Summary Sentry" caption="Transaction Summary Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%209.webp"
+  alt="Transaction Summary Sentry"
+  caption="Transaction Summary Sentry"
+/>
 
 By using the feature flag in tags, you can answer questions like:
 
@@ -152,21 +184,37 @@ This allows you to isolate the root cause of an issue based on the specific feat
 
 ### Crash Reporting
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2010.webp" alt="Feedback collected via the Crash-Report Modal" caption="Feedback collected via the Crash-Report Modal" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2010.webp"
+  alt="Feedback collected via the Crash-Report Modal"
+  caption="Feedback collected via the Crash-Report Modal"
+/>
 
 Sentry's Crash-Report Modal lets users submit feedback after they encounter errors. The modal collects the user's name, email address, and a description of what occurred, pairing this feedback with the original event for additional insights.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2011.webp" alt="User Feedback: Crash Reporting Modal" caption="User Feedback: Crash Reporting Modal" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2011.webp"
+  alt="User Feedback: Crash Reporting Modal"
+  caption="User Feedback: Crash Reporting Modal"
+/>
 
 ### Performance Monitoring
 
 While error tracking shows what went wrong, performance monitoring reveals why it happened and how it affects users. Sentry tracks slowdowns, measuring metrics like throughput and latency while mapping error impact across services. It also captures **[distributed traces](https://signoz.io/blog/distributed-tracing/)** to analyze service performance in depth.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2012.webp" alt="Performance Tab in Sentry" caption="Performance Tab in Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2012.webp"
+  alt="Performance Tab in Sentry"
+  caption="Performance Tab in Sentry"
+/>
 
 Using this information, you can trace issues back through services to identify poorly performing code, determine whether application performance is improving or degrading, and compare release performance over time.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2013.webp" alt="Sentry Performance Transactions Summary (Credit: Sentry)" caption="Sentry Performance Transactions Summary (Credit: Sentry)" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2013.webp"
+  alt="Sentry Performance Transactions Summary (Credit: Sentry)"
+  caption="Sentry Performance Transactions Summary (Credit: Sentry)"
+/>
 
 ### Tracing
 
@@ -188,7 +236,11 @@ with start_transaction(op="task", name="my_task"):
         print("Subtask 2 is being executed...")
 ```
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2015.webp" alt="Trace View Page" caption="Trace View Page" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2015.webp"
+  alt="Trace View Page"
+  caption="Trace View Page"
+/>
 
 The Trace View allows you to drill down into a single trace to visualize transactions and spans, making debugging slow services and identifying bottlenecks faster and easier.
 
@@ -207,7 +259,11 @@ Sentry provides two primary methods for collecting user feedback:
 
 Using **Session Replay** alongside the **User Feedback Widget** provides a visual representation of what the user experienced before submitting their feedback.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2018.webp" alt="User Feedback in Sentry (Credit: Sentry)" caption="User Feedback in Sentry (Credit: Sentry)" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2018.webp"
+  alt="User Feedback in Sentry (Credit: Sentry)"
+  caption="User Feedback in Sentry (Credit: Sentry)"
+/>
 
 **Compatibility and Integration**
 
@@ -223,11 +279,15 @@ The Sentry SDK injects the **User Feedback Widget** directly into the client’s
 
 Sentry excels in several areas that are crucial for modern DevOps teams:
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2019.webp" alt="Strengths of Sentry in Modern DevOps Practices" caption="Strengths of Sentry in Modern DevOps Practices" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2019.webp"
+  alt="Strengths of Sentry in Modern DevOps Practices"
+  caption="Strengths of Sentry in Modern DevOps Practices"
+/>
 
 ### Real-Time Visibility
 
-Sentry provides immediate error notifications, helping teams respond quickly to production issues and minimize mean time to detection (MTTD). 
+Sentry provides immediate error notifications, helping teams respond quickly to production issues and minimize mean time to detection (MTTD).
 
 If you have Sentry's default issue alert i.e. `Alert me on every new issue` turned on for the project(s) with user feedback set up, then you should automatically get alerted every time new user feedback comes in via the User Feedback Widget.
 
@@ -235,15 +295,27 @@ If you don't have Sentry's default issue alert turned on, follow these steps to
 
 **Step 1:** Create a New Alert Rule in Sentry.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2020.webp" alt="Sentry Alert" caption="Sentry Alert" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2020.webp"
+  alt="Sentry Alert"
+  caption="Sentry Alert"
+/>
 
 **Step 2:** Scroll to the "Set conditions" section, set the "IF" filter to your required condition, and choose which actions to perform in the “THEN” filter.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2021.webp" alt="Sentry New Alert Rule" caption="Sentry New Alert Rule" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2021.webp"
+  alt="Sentry New Alert Rule"
+  caption="Sentry New Alert Rule"
+/>
 
 **Step 3:** Add an alert name and owner. To get notifications when crash-report feedback comes in, make sure to turn on `Enable Crash Report Notifications` in Settings > Projects > [Your Project Name] > User Feedback.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2022.webp" alt="Sentry User Feedback" caption="Sentry User Feedback" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2022.webp"
+  alt="Sentry User Feedback"
+  caption="Sentry User Feedback"
+/>
 
 ### Detailed Debugging Context
 
@@ -257,17 +329,29 @@ sentry_sdk.add_breadcrumb(
 )
 ```
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2023.webp" alt="Sentry Breadcrumb section" caption="Sentry Breadcrumb section" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2023.webp"
+  alt="Sentry Breadcrumb section"
+  caption="Sentry Breadcrumb section"
+/>
 
 Trace context delivers crucial details that allow Sentry to link multiple transactions, spans, and errors into a unified trace.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2024.webp" alt="Trace View in Sentry" caption="Trace View in Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2024.webp"
+  alt="Trace View in Sentry"
+  caption="Trace View in Sentry"
+/>
 
 ### Cross-Platform Support
 
 Sentry provides robust SDKs for both front-end frameworks and back-end languages, along with mobile support. With code-level observability, Sentry simplifies diagnosing issues while offering continuous insights into your application's code health.
 
-<Figure src="/img/guides/2025/03/sentry-observability-image%2026.webp" alt="SKDs supported by sentry" caption="SKDs supported by sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry-observability-image%2026.webp"
+  alt="SKDs supported by sentry"
+  caption="SKDs supported by sentry"
+/>
 
 ### Integration with DevOps Toolchains
 
@@ -283,56 +367,55 @@ By integrating Sentry into your DevOps toolchain, you gain full visibility into
 While Sentry excels in error tracking and application performance monitoring, it has certain limitations in providing comprehensive observability across complex, distributed systems:
 
 1. **No Native Log Aggregation**
-    
-    Sentry lacks native log aggregation features, which are essential for analyzing large volumes of logs across various services. This necessitates the integration of dedicated log management solutions, such as the Elastic Stack or Loki, to achieve comprehensive log analysis and correlation
-    
+
+   Sentry lacks native log aggregation features, which are essential for analyzing large volumes of logs across various services. This necessitates the integration of dedicated log management solutions, such as the Elastic Stack or Loki, to achieve comprehensive log analysis and correlation
+
 2. **Primary Focus on Error Tracking and Application Performance**
-    
-    Sentry primarily concentrates on error tracking and application performance monitoring, without extending to infrastructure-level metrics like CPU, memory, or network usage. It also lacks built-in host monitoring capabilities for container orchestration platforms, such as Kubernetes node metrics, which are vital for maintaining the health and performance of the underlying infrastructure
-    
-3. **Limited Distributed Tracing:** 
-    
-    Sentry's distributed tracing capabilities are relatively basic compared to specialized tools like Jaeger or SigNoz. In intricate microservice architectures, this can hinder the ability to trace requests seamlessly across multiple services, making it challenging to diagnose performance bottlenecks and latency issues effectively.
+
+   Sentry primarily concentrates on error tracking and application performance monitoring, without extending to infrastructure-level metrics like CPU, memory, or network usage. It also lacks built-in host monitoring capabilities for container orchestration platforms, such as Kubernetes node metrics, which are vital for maintaining the health and performance of the underlying infrastructure
+
+3. **Limited Distributed Tracing:**
+
+   Sentry's distributed tracing capabilities are relatively basic compared to specialized tools like Jaeger or SigNoz. In intricate microservice architectures, this can hinder the ability to trace requests seamlessly across multiple services, making it challenging to diagnose performance bottlenecks and latency issues effectively.
 
 4. **Potential Over-Reliance on Client-Side Instrumentation**
-    
-    Implementing Sentry requires adding its SDKs to each service or client within the application. This approach can lead to potential gaps in monitoring if the instrumentation is incorrectly configured or omitted, resulting in missed critical data and incomplete observability
-    
+
+   Implementing Sentry requires adding its SDKs to each service or client within the application. This approach can lead to potential gaps in monitoring if the instrumentation is incorrectly configured or omitted, resulting in missed critical data and incomplete observability
 
 <KeyPointCallout title="Final Verdict">
 In short, Sentry’s limitations mean that **by itself** it provides an incomplete picture. It covers the application layer superbly but doesn’t give the birds-eye view of the entire system’s health. DevOps professionals often need to know not just that an error happened (which Sentry tells you), but also why – which might involve looking at database load, memory pressure, or a spike in user traffic, none of which Sentry tracks. Thus, Sentry is typically one piece of an observability suite, not the whole.
 
-To achieve full-stack observability, it's often necessary to complement Sentry with other specialized tools that offer advanced distributed tracing, log aggregation, and infrastructure monitoring capabilities. 
+To achieve full-stack observability, it's often necessary to complement Sentry with other specialized tools that offer advanced distributed tracing, log aggregation, and infrastructure monitoring capabilities.
+
 </KeyPointCallout>
 
 ## Comparing Sentry to Full-Stack Observability Solutions
 
 Sentry is a robust application monitoring tool that excels in error tracking and performance monitoring. To understand its position within the observability landscape, let's compare it to full-stack observability solutions:
 
-| **Feature** | **Sentry** | **Full-Stack Solutions (SigNoz, New Relic, Datadog, etc.)** |
-| --- | --- | --- |
-| Scope | Focuses on application-level error tracking and performance monitoring. | Provides end-to-end monitoring, including infrastructure, logs, and APM. |
-| Cost Model | Event-based pricing; cost-effective for small to mid-sized teams. | New Relic scales with data ingestion/users; advanced features can be costly. <br /> Datadog charges per host and feature usage; costs rise with infrastructure growth. <br /> SigNoz offers usage based [pricing](/pricing).|
-| Metrics | Limited to application-level performance data. | Collects system-wide, container, and infrastructure metrics. |
-| Logs | Captures exceptions but lacks full log management. | Provides centralized log aggregation and analysis. |
-| Tracing | Effective for app-level traces but not ideal for large, distributed systems. | Full distributed tracing across services and infrastructure. |
-| Extensibility | Can integrate with external tools like Prometheus, Grafana, or ELK for broader observability. | Built-in integrations for logs, traces, and metrics, reducing dependency on external tools. |
+| **Feature**   | **Sentry**                                                                                    | **Full-Stack Solutions (SigNoz, New Relic, Datadog, etc.)**                                                                                                                                                                  |
+| ------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Scope         | Focuses on application-level error tracking and performance monitoring.                       | Provides end-to-end monitoring, including infrastructure, logs, and APM.                                                                                                                                                     |
+| Cost Model    | Event-based pricing; cost-effective for small to mid-sized teams.                             | New Relic scales with data ingestion/users; advanced features can be costly. <br /> Datadog charges per host and feature usage; costs rise with infrastructure growth. <br /> SigNoz offers usage based [pricing](/pricing). |
+| Metrics       | Limited to application-level performance data.                                                | Collects system-wide, container, and infrastructure metrics.                                                                                                                                                                 |
+| Logs          | Captures exceptions but lacks full log management.                                            | Provides centralized log aggregation and analysis.                                                                                                                                                                           |
+| Tracing       | Effective for app-level traces but not ideal for large, distributed systems.                  | Full distributed tracing across services and infrastructure.                                                                                                                                                                 |
+| Extensibility | Can integrate with external tools like Prometheus, Grafana, or ELK for broader observability. | Built-in integrations for logs, traces, and metrics, reducing dependency on external tools.                                                                                                                                  |
 
 ## Exploring SigNoz as a Complementary Solution
 
 [SigNoz](https://signoz.io/) offers a [unified observability](https://signoz.io/unified-observability/) platform that complements Sentry's capabilities, providing comprehensive monitoring across all three [pillars of observability](https://signoz.io/blog/three-pillars-of-observability/):
 
 <div className="overflow-hidden rounded-xl shadow-2xl">
-    <video autoPlay muted loop className="lg:w-[120%]">
+  <video autoPlay muted loop className="lg:w-[120%]">
     <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
     Your browser does not support the video tag.
-    </video>
+  </video>
 </div>
 
 ### Key Features of SigNoz
 
 - **Unified Telemetry**: Collects metrics, traces, and logs in one platform, eliminating the need to switch between multiple tools when debugging issues
-  
 - **[OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/)-Native**: Built on the open-source OpenTelemetry standard, making it vendor-agnostic and compatible with various languages and frameworks
 
 - **Advanced Distributed Tracing**: Visualizes request flows across microservices with flamegraphs and Gantt charts, enabling deep performance analysis
@@ -359,15 +442,19 @@ In summary, Sentry vs SigNoz features can be thought of as depth vs breadth. Sen
 ## FAQs
 
 ### Is Sentry sufficient for all observability needs in DevOps?
+
 No. Sentry excels in error detection and performance tracing for your applications but lacks native capabilities for host-level metrics, log aggregation, and deep network insights. You'll typically need complementary tools for full-stack observability.
 
 ### How does Sentry compare to full-stack observability platforms?
+
 Sentry focuses on application errors and performance, while full-stack solutions like Datadog or New Relic include infrastructure monitoring, log management, and distributed tracing in a single platform. Sentry is often more cost-effective for error tracking but is less comprehensive overall.
 
 ### Can Sentry be integrated with other monitoring and observability tools?
+
 Absolutely. Sentry works well alongside log management (e.g., ELK Stack), metrics systems (e.g., Prometheus), and distributed tracing solutions (e.g., Jaeger, SigNoz). This combination yields a more holistic view of your system.
 
 ### What are the key considerations when choosing between Sentry and alternative solutions?
+
 Consider the following factors:
 
 - **Scope of Monitoring**: Do you need host-level metrics, logs, or just error tracking?
@@ -375,4 +462,4 @@ Consider the following factors:
 - **Integration**: Ensure the tool supports your language/framework stack and can integrate into your CI/CD and ChatOps workflows
 - **Open-Source vs. SaaS**: If on-premises or compliance considerations matter, an open-source alternative like SigNoz may be more attractive
 
-Sentry is an outstanding tool for application-level error tracking and performance insights. However, in modern DevOps environments—where distributed systems, container orchestration, and real-time data analysis are paramount—Sentry alone rarely suffices. By integrating Sentry with log aggregators, metrics dashboards, and robust tracing solutions, teams can achieve the full-spectrum observability needed to ship reliable software in complex, fast-paced ecosystems.
\ No newline at end of file
+Sentry is an outstanding tool for application-level error tracking and performance insights. However, in modern DevOps environments—where distributed systems, container orchestration, and real-time data analysis are paramount—Sentry alone rarely suffices. By integrating Sentry with log aggregators, metrics dashboards, and robust tracing solutions, teams can achieve the full-spectrum observability needed to ship reliable software in complex, fast-paced ecosystems.
diff --git a/data/guides/sentry-pricing.mdx b/data/guides/sentry-pricing.mdx
index 8c65fe32d..5c38b7ee8 100644
--- a/data/guides/sentry-pricing.mdx
+++ b/data/guides/sentry-pricing.mdx
@@ -1,12 +1,18 @@
 ---
 title: Understanding Sentry Pricing - Plans, Features, and Cost Breakdown
-slug: sentry-pricing
 date: 2025-03-05
 tags: [sentry, error tracking, application monitoring, pricing]
 authors: [soumya_gupta]
 description: "Explore Sentry's pricing plans, features, and costs to find the best fit for your application monitoring and error tracking needs."
-keywords: [sentry pricing, sentry pricing plans, sentry features, sentry cost, application monitoring pricing, error tracking pricing]
-
+keywords:
+  [
+    sentry pricing,
+    sentry pricing plans,
+    sentry features,
+    sentry cost,
+    application monitoring pricing,
+    error tracking pricing,
+  ]
 ---
 
 Sentry is a smart and reliable application monitoring and error-tracking platform that helps developers catch and fix issues before they escalate. It works behind the scenes, offering deep insights into errors, performance bottlenecks, and anomalies, enabling teams to diagnose and resolve problems quickly.
@@ -15,9 +21,13 @@ To make the most of Sentry, choosing the right pricing plan is key. With options
 
 ## Pricing Structure Overview
 
-<Figure src="/img/guides/2025/03/sentry.io-pricing-image.webp" alt="Included Monthly Quotas in Paid Plans" caption="Included Monthly Quotas in Paid Plans" />
+<Figure
+  src="/img/guides/2025/03/sentry.io-pricing-image.webp"
+  alt="Included Monthly Quotas in Paid Plans"
+  caption="Included Monthly Quotas in Paid Plans"
+/>
 
-Sentry's pricing model is influenced by several key factors, each tied to how much data your organization processes. Every plan includes a set quota for different components, and if you exceed those limits, you can pay for additional usage as needed. 
+Sentry's pricing model is influenced by several key factors, each tied to how much data your organization processes. Every plan includes a set quota for different components, and if you exceed those limits, you can pay for additional usage as needed.
 
 Here’s a breakdown of some key factors that influences the cost:
 
@@ -58,7 +68,7 @@ Sentry provides mechanisms to control which events are sent to their servers, al
 
 ### 4. Spike Protection
 
- Sentry's **Spike Protection** is a feature designed to help organizations manage unexpected surges in event volume, preventing sudden overages and maintaining cost control. It works by dynamically analyzing your project's typical event patterns and setting thresholds that, when exceeded, temporarily halt the ingestion of excessive events. This ensures that unforeseen spikes, such as those caused by a sudden influx of errors, don't lead to unexpected charges or exhaust your event quota prematurely. Once the spike subsides and event rates return to normal, Spike Protection automatically reactivates event ingestion. This proactive approach allows teams to maintain uninterrupted monitoring while safeguarding against unplanned expenses.
+Sentry's **Spike Protection** is a feature designed to help organizations manage unexpected surges in event volume, preventing sudden overages and maintaining cost control. It works by dynamically analyzing your project's typical event patterns and setting thresholds that, when exceeded, temporarily halt the ingestion of excessive events. This ensures that unforeseen spikes, such as those caused by a sudden influx of errors, don't lead to unexpected charges or exhaust your event quota prematurely. Once the spike subsides and event rates return to normal, Spike Protection automatically reactivates event ingestion. This proactive approach allows teams to maintain uninterrupted monitoring while safeguarding against unplanned expenses.
 
 ## Advanced Features and Add-Ons
 
@@ -92,18 +102,18 @@ For businesses and large-scale teams, Sentry offers advanced features designed t
 
 When choosing an application monitoring solution, it's essential to understand how different platforms compare in terms of features, pricing, and usability. Sentry offers a robust set of tools for error tracking, performance monitoring, and session replay, but how does it stack up against competitors? Below is a comparison of key features across various monitoring solutions to help you make an informed decision.
 
-| **Tool** | **Pricing** | **Pricing Model** | **Scalability & Resource Usage** | **Ideal For** |
-| --- | --- | --- | --- | --- |
-| **SigNoz** | $49/month | Usage-based / Self-hosted | Highly scalable, resource-efficient | Unified observability, teams valuing data control and customization |
-| **Better Stack** | $29 per month | Usage-based | Good for medium to large-scale apps | Log-centric monitoring approaches |
-| **LogRocket** | $69/month | Session-based tiers | Scales well for front-end heavy apps | Customer-facing application teams |
-| **Dynatrace** | $29/month | Consumption-based | Enterprise-grade scalability | Large, complex IT environments |
-| **AppSignal** | $23 per month | Tier-based | Efficient for Ruby/Elixir apps | Ruby and Elixir development teams |
-| **Bugsnag** | $59/month | Event-based tiers | Good for diverse platform support | Mobile and web development teams |
-| **New Relic** | $49 per month | Consumption-based | Highly scalable, resource-intensive | Organizations needing full-stack observability |
-| **Raygun** | $8.00 per month | Event-based tiers | Scales well for most applications | Teams focusing on user experience |
-| **Jaeger** | Free and open source | Self-hosted / Free | Highly scalable for tracing | Microservices architectures |
-| **Datadog** | $15 per month | Host-based + Features | Enterprise-grade scalability | DevOps-centric organizations |
+| **Tool**         | **Pricing**          | **Pricing Model**         | **Scalability & Resource Usage**     | **Ideal For**                                                       |
+| ---------------- | -------------------- | ------------------------- | ------------------------------------ | ------------------------------------------------------------------- |
+| **SigNoz**       | $49/month            | Usage-based / Self-hosted | Highly scalable, resource-efficient  | Unified observability, teams valuing data control and customization |
+| **Better Stack** | $29 per month        | Usage-based               | Good for medium to large-scale apps  | Log-centric monitoring approaches                                   |
+| **LogRocket**    | $69/month            | Session-based tiers       | Scales well for front-end heavy apps | Customer-facing application teams                                   |
+| **Dynatrace**    | $29/month            | Consumption-based         | Enterprise-grade scalability         | Large, complex IT environments                                      |
+| **AppSignal**    | $23 per month        | Tier-based                | Efficient for Ruby/Elixir apps       | Ruby and Elixir development teams                                   |
+| **Bugsnag**      | $59/month            | Event-based tiers         | Good for diverse platform support    | Mobile and web development teams                                    |
+| **New Relic**    | $49 per month        | Consumption-based         | Highly scalable, resource-intensive  | Organizations needing full-stack observability                      |
+| **Raygun**       | $8.00 per month      | Event-based tiers         | Scales well for most applications    | Teams focusing on user experience                                   |
+| **Jaeger**       | Free and open source | Self-hosted / Free        | Highly scalable for tracing          | Microservices architectures                                         |
+| **Datadog**      | $15 per month        | Host-based + Features     | Enterprise-grade scalability         | DevOps-centric organizations                                        |
 
 ## When and How to Upgrade?
 
@@ -127,15 +137,27 @@ If your company requires more **granular access controls, audit logs, or enhance
 
 To upgrade your Sentry plan, go to your organization's **Settings** and select **Subscription**. There, you'll find your current plan along with recommended higher-tier options. Simply click the **Upgrade Now** button to proceed.
 
-<Figure src="/img/guides/2025/03/sentry.io-pricing-image%201.webp" alt="Pricing Update: Sentry" caption="Pricing Update: Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry.io-pricing-image%201.webp"
+  alt="Pricing Update: Sentry"
+  caption="Pricing Update: Sentry"
+/>
 
 Clicking the button will open a new page where you’ll need to fill in six fields, as shown in the image below. Complete these fields based on your project requirements and then proceed for approval.
 
-<Figure src="/img/guides/2025/03/sentry.io-pricing-image%202.webp" alt="Change Subscription Page: Sentry" caption="Change Subscription Page: Sentry" />
+<Figure
+  src="/img/guides/2025/03/sentry.io-pricing-image%202.webp"
+  alt="Change Subscription Page: Sentry"
+  caption="Change Subscription Page: Sentry"
+/>
 
 ## Discounts and Incentives
 
-<Figure src="/img/guides/2025/03/sentry.io-pricing-image%203.webp" alt="Discounts and Incentives: Sentry Pricing" caption="Discounts and Incentives: Sentry Pricing" />
+<Figure
+  src="/img/guides/2025/03/sentry.io-pricing-image%203.webp"
+  alt="Discounts and Incentives: Sentry Pricing"
+  caption="Discounts and Incentives: Sentry Pricing"
+/>
 
 **Discounts and Incentives: Sentry Pricing**
 
@@ -155,8 +177,9 @@ Committing to an annual subscription can lead to significant savings. Sentry off
 
 To switch to an annual plan:
 
-<Figure src="/img/guides/2025/03/sentry.io-pricing-image%204.webp" alt="" caption="" />- Navigate to **Settings** > **Subscription** > **Manage Subscription**.
-- In the checkout flow, select the annual term.
+<Figure src="/img/guides/2025/03/sentry.io-pricing-image%204.webp" alt="" caption="" />- Navigate to
+**Settings** > **Subscription** > **Manage Subscription**. - In the checkout flow, select the annual
+term.
 
 This approach not only reduces costs but also streamlines billing.
 
@@ -197,10 +220,10 @@ While Sentry excels at error tracking and application performance monitoring, it
 - **Flexible Deployment**: Available as both self-hosted (for compliance and cost control) and cloud-managed options, SigNoz allows teams to choose the deployment model that best fits their **infrastructure, security, and compliance requirements**.
 
 <div className="overflow-hidden rounded-xl shadow-2xl">
-    <video autoPlay muted loop className="lg:w-[120%]">
+  <video autoPlay muted loop className="lg:w-[120%]">
     <source src="/img/unified-observability/showcase.mp4" type="video/mp4" />
     Your browser does not support the video tag.
-    </video>
+  </video>
 </div>
 
 By combining Sentry's robust error tracking with SigNoz's comprehensive observability platform, teams can achieve full-stack visibility across all [three pillars of observability](https://signoz.io/blog/three-pillars-of-observability/). This integration leads to **faster debugging, improved incident response, and enhanced system reliability**.
@@ -242,4 +265,4 @@ Sentry processes events based on several factors, such as having a valid **DSN (
 
 ### Can I adjust my data quotas after choosing a plan?
 
-Yes, you can adjust your reserved and pay-as-you-go quotas based on your needs. If you're on a developer plan and need additional volume, you can either upgrade to a higher plan or purchase extra data capacity.
\ No newline at end of file
+Yes, you can adjust your reserved and pay-as-you-go quotas based on your needs. If you're on a developer plan and need additional volume, you can either upgrade to a higher plan or purchase extra data capacity.
diff --git a/data/guides/server-health-monitoring.mdx b/data/guides/server-health-monitoring.mdx
index f1686189b..1c18a3c91 100644
--- a/data/guides/server-health-monitoring.mdx
+++ b/data/guides/server-health-monitoring.mdx
@@ -1,20 +1,27 @@
 ---
-
 title: Essential Guide to Server Health Monitoring - Tools and Best Practices
-slug: server-health-monitoring
 date: 2024-09-18
 tags: [monitoring]
 authors: [eromosele]
 description: Discover essential tools and best practices for server health monitoring. Learn how to optimize performance, prevent downtime, and ensure business continuity.
-keywords: [server health monitoring, server performance, monitoring tools, server maintenance, uptime management, IT infrastructure, network monitoring, system administration]
-
+keywords:
+  [
+    server health monitoring,
+    server performance,
+    monitoring tools,
+    server maintenance,
+    uptime management,
+    IT infrastructure,
+    network monitoring,
+    system administration,
+  ]
 ---
 
 Server health monitoring forms the backbone of a robust IT infrastructure. It's the vigilant guardian that keeps your digital operations running smoothly, preventing costly downtime and ensuring optimal performance, but what exactly does it entail, and why is it so crucial for your business? In this article, you'll learn the fundamentals of server health monitoring, key metrics to track, practical solutions to common server issues, and strategies for future-proofing your monitoring systems using AI and cloud integration.
 
 ## What is Server Health Monitoring?
 
-Server health monitoring is the continuous process of tracking and analyzing server performance metrics to ensure optimal functionality. It encompasses both hardware and software components, providing a comprehensive view of your server's well-being.  
+Server health monitoring is the continuous process of tracking and analyzing server performance metrics to ensure optimal functionality. It encompasses both hardware and software components, providing a comprehensive view of your server's well-being.
 
 Maintaining server health is crucial because servers are the backbone of many business operations. If a server goes down or performs poorly, it can lead to downtime, slow response times, or even loss of important data, all of which can impact a company’s productivity, revenue, and reputation.
 
@@ -26,14 +33,14 @@ Maintaining server health is crucial because servers are the backbone of many bu
 
 ### Difference between physical and virtual server monitoring
 
-| Aspect | Physical Server Monitoring | Virtual Server Monitoring |
-| --- | --- | --- |
-| Definition | Monitoring of actual, physical hardware servers in data centers. | Monitoring of virtual servers that exist as software simulations. |
-| Hardware Dependency | Relies on physical components like CPU, RAM, and hard drives. | Relies on virtualized hardware, sharing resources with others. |
-| Resource Management | Directly monitors the physical server’s resource usage. | Monitors resource allocation and performance in a virtual environment. |
-| Scalability | Requires adding or upgrading physical hardware to scale. | Can easily scale by adjusting resources in virtual infrastructure. |
-| Failure Impact | Physical hardware failure can lead to complete server downtime. | Virtual servers can be quickly moved or restarted on another host in case of failure. |
-| Cost | Typically higher due to the need for dedicated hardware. | Generally more cost-effective due to shared resources. |
+| Aspect              | Physical Server Monitoring                                       | Virtual Server Monitoring                                                             |
+| ------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| Definition          | Monitoring of actual, physical hardware servers in data centers. | Monitoring of virtual servers that exist as software simulations.                     |
+| Hardware Dependency | Relies on physical components like CPU, RAM, and hard drives.    | Relies on virtualized hardware, sharing resources with others.                        |
+| Resource Management | Directly monitors the physical server’s resource usage.          | Monitors resource allocation and performance in a virtual environment.                |
+| Scalability         | Requires adding or upgrading physical hardware to scale.         | Can easily scale by adjusting resources in virtual infrastructure.                    |
+| Failure Impact      | Physical hardware failure can lead to complete server downtime.  | Virtual servers can be quickly moved or restarted on another host in case of failure. |
+| Cost                | Typically higher due to the need for dedicated hardware.         | Generally more cost-effective due to shared resources.                                |
 
 ## Why is Server Health Monitoring Critical?
 
@@ -49,21 +56,21 @@ Server health monitoring is important for the following reasons:
 To effectively monitor the health of a server, tracking the following key performance indicators (KPIs) is essential:
 
 1. CPU Usage
-    - Monitor Overall Utilization: Keep an eye on how much of the CPU is being used across the server.
-    - Per-Core Performance: Check if specific CPU cores are overworked or underutilized.
-    - Track High-CPU Processes: Identify processes that are consuming an unusual amount of CPU resources, as this can indicate inefficiencies or potential issues.
+   - Monitor Overall Utilization: Keep an eye on how much of the CPU is being used across the server.
+   - Per-Core Performance: Check if specific CPU cores are overworked or underutilized.
+   - Track High-CPU Processes: Identify processes that are consuming an unusual amount of CPU resources, as this can indicate inefficiencies or potential issues.
 2. Memory Utilization
-    - Total Memory Usage: Measure how much memory (RAM) is being used versus how much is available.
-    - Watch for Memory Leaks: Some applications may consume memory without releasing it, leading to performance problems over time.
-    - Excessive Swapping: If the system uses swap memory (disk space used when RAM is full), it could be a sign that the server is running out of physical memory, which can slow down performance.
+   - Total Memory Usage: Measure how much memory (RAM) is being used versus how much is available.
+   - Watch for Memory Leaks: Some applications may consume memory without releasing it, leading to performance problems over time.
+   - Excessive Swapping: If the system uses swap memory (disk space used when RAM is full), it could be a sign that the server is running out of physical memory, which can slow down performance.
 3. Disk Space and I/O Performance
-    - Free Disk Space: Regularly monitor the available space on all storage devices to avoid running out, which can lead to system crashes or slowdowns.
-    - Read/Write Speeds: Measure how quickly the server reads from or writes to the disk.
-    - Queue Lengths: Monitor how many disk operations are waiting, as long queue lengths could signal bottlenecks in disk performance.
+   - Free Disk Space: Regularly monitor the available space on all storage devices to avoid running out, which can lead to system crashes or slowdowns.
+   - Read/Write Speeds: Measure how quickly the server reads from or writes to the disk.
+   - Queue Lengths: Monitor how many disk operations are waiting, as long queue lengths could signal bottlenecks in disk performance.
 4. Network Traffic
-    - Bandwidth Usage: Keep track of how much data is being transferred in and out of the server.
-    - Packet Loss: Measure how often data packets are lost, which can indicate network issues.
-    - Connection Status and Latency: Monitor the status of network connections and how long it takes for data to travel to its destination (latency). High latency or frequent disconnections can slow down services and disrupt operations.
+   - Bandwidth Usage: Keep track of how much data is being transferred in and out of the server.
+   - Packet Loss: Measure how often data packets are lost, which can indicate network issues.
+   - Connection Status and Latency: Monitor the status of network connections and how long it takes for data to travel to its destination (latency). High latency or frequent disconnections can slow down services and disrupt operations.
 
 ### Hardware-Specific Metrics
 
@@ -77,32 +84,32 @@ For physical servers, additional hardware-focused metrics are crucial to ensure
 ## How to Conduct a Comprehensive Server Health Check
 
 1. Establish a Baseline
-    - Determine Normal Performance Levels: Understand what normal performance looks like for your server by measuring key metrics like CPU, memory, disk, and network usage during typical operations.
-    - Document Resource Usage Patterns: Keep a record of how resources are typically used so that you can easily spot any unusual activity in the future.
+   - Determine Normal Performance Levels: Understand what normal performance looks like for your server by measuring key metrics like CPU, memory, disk, and network usage during typical operations.
+   - Document Resource Usage Patterns: Keep a record of how resources are typically used so that you can easily spot any unusual activity in the future.
 2. Implement Automated Monitoring
-    - Set Up Tools: Use server monitoring tools like [SigNoz](https://signoz.io/) to automatically track key metrics like CPU, memory, disk space, and network traffic.
-    - Configure Alerts: Set up alerts to notify you when something abnormal happens (e.g., high CPU usage, low disk space, network issues), so you can address problems quickly.
+   - Set Up Tools: Use server monitoring tools like [SigNoz](https://signoz.io/) to automatically track key metrics like CPU, memory, disk space, and network traffic.
+   - Configure Alerts: Set up alerts to notify you when something abnormal happens (e.g., high CPU usage, low disk space, network issues), so you can address problems quickly.
 3. Conduct Regular Manual Inspections
-    - Visual Checks on Physical Hardware: Periodically inspect the physical components of your server, like the power supply, cooling system, and cables, to ensure everything is in good condition.
-    - Review Log Files: Check server log files regularly for any error messages or warnings that may not trigger automated alerts but could indicate underlying problems.
+   - Visual Checks on Physical Hardware: Periodically inspect the physical components of your server, like the power supply, cooling system, and cables, to ensure everything is in good condition.
+   - Review Log Files: Check server log files regularly for any error messages or warnings that may not trigger automated alerts but could indicate underlying problems.
 4. Analyze Trends
-    - Look for Patterns: Review performance data over time to identify any patterns that could signal emerging problems, such as increasing CPU usage or declining network performance.
-    - Identify Gradual Degradation: Keep an eye on long-term trends to spot gradual wear and tear on hardware or software issues that occur repeatedly.
+   - Look for Patterns: Review performance data over time to identify any patterns that could signal emerging problems, such as increasing CPU usage or declining network performance.
+   - Identify Gradual Degradation: Keep an eye on long-term trends to spot gradual wear and tear on hardware or software issues that occur repeatedly.
 
 ## Best Practices for Server Health Monitoring
 
 1. Set up Real-Time Monitoring and Alerting
-    - Use Tools for Instant Notifications: Choose monitoring tools like [SigNoz](https://signoz.io/) that can send immediate alerts (via email, SMS, or messaging apps) whenever a critical issue arises.
-    - Configure Alert Thresholds: Set alert thresholds based on your server’s normal performance (baseline) so you’ll be notified when the system deviates from expected behavior.
+   - Use Tools for Instant Notifications: Choose monitoring tools like [SigNoz](https://signoz.io/) that can send immediate alerts (via email, SMS, or messaging apps) whenever a critical issue arises.
+   - Configure Alert Thresholds: Set alert thresholds based on your server’s normal performance (baseline) so you’ll be notified when the system deviates from expected behavior.
 2. Implement Predictive Maintenance
-    - Forecast Potential Failures: Leverage machine learning or advanced analytics to predict when hardware or software might fail based on historical data.
-    - Schedule Maintenance: Plan maintenance activities before issues occur, using predictions to avoid unexpected downtime and extend the lifespan of server components.
+   - Forecast Potential Failures: Leverage machine learning or advanced analytics to predict when hardware or software might fail based on historical data.
+   - Schedule Maintenance: Plan maintenance activities before issues occur, using predictions to avoid unexpected downtime and extend the lifespan of server components.
 3. Regularly Update and Patch Systems
-    - Keep Everything Up to Date: Ensure that your server’s operating system and applications are regularly updated to benefit from performance improvements and bug fixes.
-    - Apply Security Patches: Promptly install security patches to close vulnerabilities that attackers could exploit.
+   - Keep Everything Up to Date: Ensure that your server’s operating system and applications are regularly updated to benefit from performance improvements and bug fixes.
+   - Apply Security Patches: Promptly install security patches to close vulnerabilities that attackers could exploit.
 4. Document and Standardize Procedures
-    - Clear Guidelines for Monitoring: Create detailed, standardized procedures for monitoring and maintaining your server to ensure consistency across your team.
-    - Response Plans: Develop and document response plans for common server health issues so your team knows how to handle incidents quickly and effectively.
+   - Clear Guidelines for Monitoring: Create detailed, standardized procedures for monitoring and maintaining your server to ensure consistency across your team.
+   - Response Plans: Develop and document response plans for common server health issues so your team knows how to handle incidents quickly and effectively.
 
 ## Tools for Effective Server Health Monitoring
 
@@ -116,16 +123,16 @@ There are many server monitoring tools available, each offering various features
 
 ### Open-Source vs. Commercial Solutions
 
-| Aspect | Open-Source Solutions | Commercial Solutions |
-| --- | --- | --- |
-| Cost | Free to use, but may require additional costs for hardware, maintenance, and advanced features. | Subscription-based with varying pricing tiers depending on usage, features, and support. |
-| Customization | Highly customizable, with access to source code for deep modifications. | Typically less customizable; more focused on user-friendly features with limited flexibility. |
-| Support | Community-driven support, which can sometimes result in slower or less comprehensive help. | Professional support with dedicated teams available for quick issue resolution and troubleshooting. |
-| Ease of Setup | Can require technical expertise for installation, configuration, and maintenance. | Usually comes with easy setup, guided wizards, and streamlined management, ideal for non-technical users. |
-| Examples | SigNoz, Zabbix, Nagios. | Datadog, SolarWinds |
-| Data Ownership | Full control over data since it is self-hosted, offering privacy and compliance advantages. | Data is often hosted on third-party servers (cloud-based), which may lead to data privacy and control concerns. |
-| Scalability | Scalable but may require manual effort to configure and manage additional nodes or components. | Automatically scalable to handle larger infrastructure without much manual intervention. |
-| Integration | Requires manual configuration for integrations with other services or platforms. | Built-in integrations with a wide range of platforms and services, offering seamless functionality. |
+| Aspect         | Open-Source Solutions                                                                           | Commercial Solutions                                                                                            |
+| -------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| Cost           | Free to use, but may require additional costs for hardware, maintenance, and advanced features. | Subscription-based with varying pricing tiers depending on usage, features, and support.                        |
+| Customization  | Highly customizable, with access to source code for deep modifications.                         | Typically less customizable; more focused on user-friendly features with limited flexibility.                   |
+| Support        | Community-driven support, which can sometimes result in slower or less comprehensive help.      | Professional support with dedicated teams available for quick issue resolution and troubleshooting.             |
+| Ease of Setup  | Can require technical expertise for installation, configuration, and maintenance.               | Usually comes with easy setup, guided wizards, and streamlined management, ideal for non-technical users.       |
+| Examples       | SigNoz, Zabbix, Nagios.                                                                         | Datadog, SolarWinds                                                                                             |
+| Data Ownership | Full control over data since it is self-hosted, offering privacy and compliance advantages.     | Data is often hosted on third-party servers (cloud-based), which may lead to data privacy and control concerns. |
+| Scalability    | Scalable but may require manual effort to configure and manage additional nodes or components.  | Automatically scalable to handle larger infrastructure without much manual intervention.                        |
+| Integration    | Requires manual configuration for integrations with other services or platforms.                | Built-in integrations with a wide range of platforms and services, offering seamless functionality.             |
 
 ### Features to Look for in Server Health Monitoring Tools
 
@@ -139,34 +146,34 @@ There are many server monitoring tools available, each offering various features
 [SigNoz](https://signoz.io/) offers a comprehensive solution for server health tracking by providing a unified platform for monitoring applications, infrastructure, and logs. Here's how SigNoz enhances server monitoring:
 
 1. Full-Stack Observability
-    - Monitor Applications, Infrastructure, and Logs in One Platform: SigNoz allows you to keep an eye on your entire tech stack from a single dashboard. This means you can track the performance of your applications, monitor server health metrics like CPU and memory usage, and analyze log data all in one place.
-    - Benefits:
-        - Simplifies monitoring by eliminating the need for multiple tools.
-        - Provides a holistic view of system performance, making it easier to identify and troubleshoot issues.
-        - Enhances collaboration between development and operations teams through shared insights.
+   - Monitor Applications, Infrastructure, and Logs in One Platform: SigNoz allows you to keep an eye on your entire tech stack from a single dashboard. This means you can track the performance of your applications, monitor server health metrics like CPU and memory usage, and analyze log data all in one place.
+   - Benefits:
+     - Simplifies monitoring by eliminating the need for multiple tools.
+     - Provides a holistic view of system performance, making it easier to identify and troubleshoot issues.
+     - Enhances collaboration between development and operations teams through shared insights.
 2. Custom Dashboards
-    - Create Tailored Views of Your Server Health Metrics: With SigNoz, you can design custom dashboards that focus on the metrics most important to you. This includes arranging widgets, graphs, and charts to display real-time data relevant to your specific needs.
-    - Features:
-        - User-Friendly Interface: Drag-and-drop functionality makes it easy to build and modify dashboards without needing advanced technical skills.
-        - Real-Time Updates: Dashboards refresh automatically to provide the most current data, helping you react quickly to any changes.
-        - Sharing and Collaboration: Dashboards can be shared with team members, ensuring everyone has access to the same information.
+   - Create Tailored Views of Your Server Health Metrics: With SigNoz, you can design custom dashboards that focus on the metrics most important to you. This includes arranging widgets, graphs, and charts to display real-time data relevant to your specific needs.
+   - Features:
+     - User-Friendly Interface: Drag-and-drop functionality makes it easy to build and modify dashboards without needing advanced technical skills.
+     - Real-Time Updates: Dashboards refresh automatically to provide the most current data, helping you react quickly to any changes.
+     - Sharing and Collaboration: Dashboards can be shared with team members, ensuring everyone has access to the same information.
 3. Powerful Querying and Filtering
-    - Advanced Search Capabilities: SigNoz’s [query builder](https://signoz.io/blog/query-builder-v5/) allows for precise searches and filtering of data, making it easier to drill down into specific issues or trends.
-    - Features:
-        - Custom Queries: Write queries to fetch exactly the data you need, from high-level summaries to detailed transaction traces.
-        - Interactive Filtering: Apply filters on the fly to refine data and focus on particular aspects of server performance or application behavior.
-        - Historical Data Analysis: Analyze historical data to spot long-term trends and patterns.
+   - Advanced Search Capabilities: SigNoz’s [query builder](https://signoz.io/blog/query-builder-v5/) allows for precise searches and filtering of data, making it easier to drill down into specific issues or trends.
+   - Features:
+     - Custom Queries: Write queries to fetch exactly the data you need, from high-level summaries to detailed transaction traces.
+     - Interactive Filtering: Apply filters on the fly to refine data and focus on particular aspects of server performance or application behavior.
+     - Historical Data Analysis: Analyze historical data to spot long-term trends and patterns.
 4. Alerting and Notifications
-    - Set Up Custom Alerts for Critical Events: SigNoz enables you to configure alerts based on specific conditions or thresholds, ensuring you are notified immediately about critical issues.
-    - Features:
-        - Flexible Alerting: Define custom alert conditions based on metrics, logs, or traces.
-        - Multi-Channel Notifications: Receive notifications via email, Slack, or other integrations to ensure you don’t miss important updates.
+   - Set Up Custom Alerts for Critical Events: SigNoz enables you to configure alerts based on specific conditions or thresholds, ensuring you are notified immediately about critical issues.
+   - Features:
+     - Flexible Alerting: Define custom alert conditions based on metrics, logs, or traces.
+     - Multi-Channel Notifications: Receive notifications via email, Slack, or other integrations to ensure you don’t miss important updates.
 5. Performance Optimization
-    - Identify Bottlenecks and Optimize Performance: By providing insights into application performance and infrastructure metrics, SigNoz helps you pinpoint bottlenecks and optimize system performance.
-    - Features:
-        - Performance Metrics: Track key performance indicators such as response times, error rates, and resource utilization.
-        - Root Cause Analysis: Use detailed traces and logs to perform root cause analysis and address performance issues.
-        - Optimization Recommendations: Get actionable recommendations for improving performance based on data insights.
+   - Identify Bottlenecks and Optimize Performance: By providing insights into application performance and infrastructure metrics, SigNoz helps you pinpoint bottlenecks and optimize system performance.
+   - Features:
+     - Performance Metrics: Track key performance indicators such as response times, error rates, and resource utilization.
+     - Root Cause Analysis: Use detailed traces and logs to perform root cause analysis and address performance issues.
+     - Optimization Recommendations: Get actionable recommendations for improving performance based on data insights.
 
 ### Why Choose SigNoz for Server Monitoring?
 
@@ -206,17 +213,17 @@ Ensuring server health is key to maintaining performance and preventing downtime
 To keep your servers running efficiently, it's crucial to adopt a future-proof monitoring strategy. By leveraging AI, integrating with IT management systems, adapting to cloud environments, and staying updated with new technologies, you can ensure long-term reliability and performance.
 
 1. Embrace AI and Machine Learning
-    - Implement Predictive Analytics for Proactive Maintenance: By utilizing AI and machine learning, you can analyze past server data to predict when hardware or software issues are likely to occur, allowing for proactive maintenance and reducing downtime.
-    - Use Anomaly Detection to Identify Unusual Server Behavior: AI-based anomaly detection can help spot unusual patterns or performance dips that might indicate potential issues like security breaches or performance degradation before they become critical.
+   - Implement Predictive Analytics for Proactive Maintenance: By utilizing AI and machine learning, you can analyze past server data to predict when hardware or software issues are likely to occur, allowing for proactive maintenance and reducing downtime.
+   - Use Anomaly Detection to Identify Unusual Server Behavior: AI-based anomaly detection can help spot unusual patterns or performance dips that might indicate potential issues like security breaches or performance degradation before they become critical.
 2. Integrate with Broader IT Management
-    - Connect Server Monitoring with Service Desk and Asset Management Systems: Integrating your monitoring tools with IT management systems allows for streamlined workflows, making it easier to track issues, manage assets, and resolve problems quickly.
-    - Implement Automated Incident Response Workflows: Set up automated processes to respond to server issues. For example, if a disk is nearly full, the system could automatically clean up old logs or notify the IT team for further action.
+   - Connect Server Monitoring with Service Desk and Asset Management Systems: Integrating your monitoring tools with IT management systems allows for streamlined workflows, making it easier to track issues, manage assets, and resolve problems quickly.
+   - Implement Automated Incident Response Workflows: Set up automated processes to respond to server issues. For example, if a disk is nearly full, the system could automatically clean up old logs or notify the IT team for further action.
 3. Adapt to Cloud and Hybrid Infrastructures
-    - Extend Monitoring Capabilities to Cover Cloud-Based Resources: As businesses increasingly rely on cloud services, ensure that your monitoring tools can track not just on-premises servers but also cloud resources like AWS, Azure, or Google Cloud.
-    - Implement Unified Monitoring for On-Premises and Cloud Environments: Use tools that offer a single platform to monitor both physical servers and cloud-based infrastructure, ensuring comprehensive coverage of your entire IT environment.
+   - Extend Monitoring Capabilities to Cover Cloud-Based Resources: As businesses increasingly rely on cloud services, ensure that your monitoring tools can track not just on-premises servers but also cloud resources like AWS, Azure, or Google Cloud.
+   - Implement Unified Monitoring for On-Premises and Cloud Environments: Use tools that offer a single platform to monitor both physical servers and cloud-based infrastructure, ensuring comprehensive coverage of your entire IT environment.
 4. Stay Updated with Emerging Technologies
-    - Keep Abreast of New Server Technologies and Monitoring Techniques: Server technology and monitoring tools evolve quickly. Stay informed about new developments to ensure you’re using the latest and most effective tools for your environment.
-    - Regularly Assess and Update Your Monitoring Strategy: Periodically review your monitoring approach to ensure it aligns with current best practices and adapts to the growth of your infrastructure and changing business needs.
+   - Keep Abreast of New Server Technologies and Monitoring Techniques: Server technology and monitoring tools evolve quickly. Stay informed about new developments to ensure you’re using the latest and most effective tools for your environment.
+   - Regularly Assess and Update Your Monitoring Strategy: Periodically review your monitoring approach to ensure it aligns with current best practices and adapts to the growth of your infrastructure and changing business needs.
 
 ## Key Takeaways
 
@@ -241,4 +248,4 @@ While comprehensive monitoring can significantly reduce the risk of unexpected f
 
 ### What are the most critical metrics to monitor for virtual servers?
 
-For virtual servers, focus on CPU, memory, and storage utilization within the allocated resources. Also, monitor the hypervisor's performance and resource allocation to ensure the virtual environment is properly balanced.
\ No newline at end of file
+For virtual servers, focus on CPU, memory, and storage utilization within the allocated resources. Also, monitor the hypervisor's performance and resource allocation to ensure the virtual environment is properly balanced.
diff --git a/data/guides/slf4j-logger.mdx b/data/guides/slf4j-logger.mdx
index 950d2f8ec..eb9582a94 100644
--- a/data/guides/slf4j-logger.mdx
+++ b/data/guides/slf4j-logger.mdx
@@ -1,218 +1,227 @@
 ---
-
 title: SLF4J for Logging in Java
-slug:  slf4j-logger
-date:  2024-07-12
+date: 2024-07-12
 tags: [logging]
 authors: [nilesh_sinha]
 description: This article covers setting up SLF4J, Log4j2, Logback, and JCL, their architecture, features, and how to use them in Java code.
 keywords: [slf4j logger, slf4j logger example]
-
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "SLF4J for Logging in Java",
-  "description": "This article covers setting up SLF4J, Log4j2, Logback, and JCL, their architecture, features, and how to use them in Java code.",
-  "keywords": ["slf4j logger", "slf4j logger example", "logging", "java"],
-  "author": {
-    "@type": "Person",
-    "name": "Nilesh Sinha"
-  },
-  "datePublished": "2024-07-12T00:00:00Z",
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/slf4j-logger/"
-  },
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "SLF4J",
-      "description": "Simple Logging Facade for Java, an abstraction layer for various Java logging frameworks"
-    },
-    {
-      "@type": "Thing",
-      "name": "Log4j2",
-      "description": "A popular logging framework for Java"
-    },
-    {
-      "@type": "Thing",
-      "name": "Logback",
-      "description": "A logging framework for Java applications"
-    },
-    {
-      "@type": "Thing",
-      "name": "JCL",
-      "description": "Jakarta Commons Logging, another logging facade for Java"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Monitoring Software"
-    }
-  ],
-  "educationalLevel": "Intermediate",
-  "isAccessibleForFree": true,
-  "image": {
-    "@type": "ImageObject",
-    "url": "https://signoz.io/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.43.20.webp",
-    "caption": "Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback"
-  },
-  "hasPart": [
-    {
-      "@type": "HowTo",
-      "name": "Setting up SLF4J with Log4j2",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Add Dependencies",
-          "text": "Include SLF4J and Log4j2 dependencies in your project"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'SLF4J for Logging in Java',
+        description:
+          'This article covers setting up SLF4J, Log4j2, Logback, and JCL, their architecture, features, and how to use them in Java code.',
+        keywords: ['slf4j logger', 'slf4j logger example', 'logging', 'java'],
+        author: {
+          '@type': 'Person',
+          name: 'Nilesh Sinha',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configuration",
-          "text": "Create a log4j2.xml configuration file"
+        datePublished: '2024-07-12T00:00:00Z',
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use SLF4J in Code",
-          "text": "Use SLF4J Logger in your Java code to log messages"
-        }
-      ]
-    },
-    {
-      "@type": "HowTo",
-      "name": "Setting up SLF4J with Logback",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Add Dependencies",
-          "text": "Include SLF4J and Logback dependencies in your project"
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/slf4j-logger/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configuration",
-          "text": "Create a logback.xml configuration file"
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'SLF4J',
+            description:
+              'Simple Logging Facade for Java, an abstraction layer for various Java logging frameworks',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Log4j2',
+            description: 'A popular logging framework for Java',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logback',
+            description: 'A logging framework for Java applications',
+          },
+          {
+            '@type': 'Thing',
+            name: 'JCL',
+            description: 'Jakarta Commons Logging, another logging facade for Java',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Monitoring Software',
+          },
+        ],
+        educationalLevel: 'Intermediate',
+        isAccessibleForFree: true,
+        image: {
+          '@type': 'ImageObject',
+          url: 'https://signoz.io/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.43.20.webp',
+          caption:
+            'Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use SLF4J in Code",
-          "text": "Use SLF4J Logger in your Java code to log messages"
-        }
-      ]
-    }
-  ],
-  "citation": [
-    {
-      "@type": "CreativeWork",
-      "name": "Log Monitoring 101 Detailed Guide",
-      "url": "https://signoz.io/blog/log-monitoring/"
-    }
-  ],
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "What is SLF4J logger in Java?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "SLF4J (Simple Logging Facade for Java) is a logging facade that provides a simple abstraction for various logging frameworks (such as Log4j, Logback, and java.util.logging). It allows developers to write logging code that is independent of the underlying logging implementation, making it easier to switch between different logging frameworks without changing the application code."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What is SLF4J vs Log4j?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "SLF4J is a facade or abstraction layer for various logging frameworks. It does not perform actual logging but routes logging calls to the underlying framework. Log4j is a specific logging framework that provides actual logging functionality, including configuration, log message formatting, and output. Log4j can be used directly or via SLF4J as an underlying logging implementation."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "How to get logger from SLF4J?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "To obtain a logger instance from SLF4J, you use the LoggerFactory class provided by SLF4J. For example: Logger logger = LoggerFactory.getLogger(MyApp.class);"
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the advantages of SLF4J logger?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "The advantages of SLF4J logger include: 1) Abstraction Layer allowing easy switching between logging frameworks, 2) Parameterized Logging for efficient message construction, 3) Markers for attaching additional information to log messages, and 4) Compatibility with a wide range of logging frameworks."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Can I use SLF4J without Log4j?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Yes, you can use SLF4J without Log4j. SLF4J supports multiple underlying logging frameworks. For example, you can use SLF4J with Logback, java.util.logging, or any other supported framework by including the appropriate SLF4J binding."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Why logger is used in Java?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Loggers are used in Java to record information about the application's runtime behavior. This information can be critical for debugging, monitoring, and maintaining the application. Logging helps developers understand the flow of the application, capture errors and exceptions, and analyze performance issues."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Why use SLF4J in Spring Boot?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Spring Boot uses SLF4J as its logging facade for several reasons: 1) Flexibility in choosing logging frameworks, 2) Unified logging across the Spring ecosystem, and 3) Seamless integration with Spring Boot's default logging setup using Logback."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Is SLF4J thread-safe?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Yes, SLF4J is designed to be thread-safe. The underlying logging frameworks it delegates to (such as Logback and Log4j) are also thread-safe, ensuring that logging operations are safe to use in multithreaded applications."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What is the difference between Logstash and SLF4J?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "SLF4J is a logging facade that provides a simple abstraction for various logging frameworks. Logstash is an open-source data processing pipeline that ingests, transforms, and sends data (including logs) to various destinations. Logstash is part of the Elastic Stack and is used for log management and analysis, while SLF4J is used for generating logs within Java applications."
-      }
-    }
-  ]
-}) }}
+        hasPart: [
+          {
+            '@type': 'HowTo',
+            name: 'Setting up SLF4J with Log4j2',
+            step: [
+              {
+                '@type': 'HowToStep',
+                name: 'Add Dependencies',
+                text: 'Include SLF4J and Log4j2 dependencies in your project',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Configuration',
+                text: 'Create a log4j2.xml configuration file',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Use SLF4J in Code',
+                text: 'Use SLF4J Logger in your Java code to log messages',
+              },
+            ],
+          },
+          {
+            '@type': 'HowTo',
+            name: 'Setting up SLF4J with Logback',
+            step: [
+              {
+                '@type': 'HowToStep',
+                name: 'Add Dependencies',
+                text: 'Include SLF4J and Logback dependencies in your project',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Configuration',
+                text: 'Create a logback.xml configuration file',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Use SLF4J in Code',
+                text: 'Use SLF4J Logger in your Java code to log messages',
+              },
+            ],
+          },
+        ],
+        citation: [
+          {
+            '@type': 'CreativeWork',
+            name: 'Log Monitoring 101 Detailed Guide',
+            url: 'https://signoz.io/blog/log-monitoring/',
+          },
+        ],
+        mainEntity: [
+          {
+            '@type': 'Question',
+            name: 'What is SLF4J logger in Java?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'SLF4J (Simple Logging Facade for Java) is a logging facade that provides a simple abstraction for various logging frameworks (such as Log4j, Logback, and java.util.logging). It allows developers to write logging code that is independent of the underlying logging implementation, making it easier to switch between different logging frameworks without changing the application code.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What is SLF4J vs Log4j?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'SLF4J is a facade or abstraction layer for various logging frameworks. It does not perform actual logging but routes logging calls to the underlying framework. Log4j is a specific logging framework that provides actual logging functionality, including configuration, log message formatting, and output. Log4j can be used directly or via SLF4J as an underlying logging implementation.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'How to get logger from SLF4J?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'To obtain a logger instance from SLF4J, you use the LoggerFactory class provided by SLF4J. For example: Logger logger = LoggerFactory.getLogger(MyApp.class);',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the advantages of SLF4J logger?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'The advantages of SLF4J logger include: 1) Abstraction Layer allowing easy switching between logging frameworks, 2) Parameterized Logging for efficient message construction, 3) Markers for attaching additional information to log messages, and 4) Compatibility with a wide range of logging frameworks.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'Can I use SLF4J without Log4j?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Yes, you can use SLF4J without Log4j. SLF4J supports multiple underlying logging frameworks. For example, you can use SLF4J with Logback, java.util.logging, or any other supported framework by including the appropriate SLF4J binding.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'Why logger is used in Java?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: "Loggers are used in Java to record information about the application's runtime behavior. This information can be critical for debugging, monitoring, and maintaining the application. Logging helps developers understand the flow of the application, capture errors and exceptions, and analyze performance issues.",
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'Why use SLF4J in Spring Boot?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: "Spring Boot uses SLF4J as its logging facade for several reasons: 1) Flexibility in choosing logging frameworks, 2) Unified logging across the Spring ecosystem, and 3) Seamless integration with Spring Boot's default logging setup using Logback.",
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'Is SLF4J thread-safe?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Yes, SLF4J is designed to be thread-safe. The underlying logging frameworks it delegates to (such as Logback and Log4j) are also thread-safe, ensuring that logging operations are safe to use in multithreaded applications.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What is the difference between Logstash and SLF4J?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'SLF4J is a logging facade that provides a simple abstraction for various logging frameworks. Logstash is an open-source data processing pipeline that ingests, transforms, and sends data (including logs) to various destinations. Logstash is part of the Elastic Stack and is used for log management and analysis, while SLF4J is used for generating logs within Java applications.',
+            },
+          },
+        ],
+      }),
+    }}
   />
 </head>
 
-
 SLF4J logger or Simple Logging Facade for Java is a straightforward abstraction layer for various logging frameworks in Java. It simplifies the process of logging by allowing you to integrate with any logging framework like Log4j, Logback, or JUL (java.util.logging) using just a single dependency. This means you can switch to a different logging framework at runtime or during deployment without changing your code.
 
-Imagine you have multiple remote controls for different devices: one for your TV, another for your sound system, and another for your Blu-ray player. It’s a hassle to manage all of them, right? Now, think of SLF4J as that one smart remote that can control all your devices. 
+Imagine you have multiple remote controls for different devices: one for your TV, another for your sound system, and another for your Blu-ray player. It’s a hassle to manage all of them, right? Now, think of SLF4J as that one smart remote that can control all your devices.
 
-<Figure src="/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.40.352x.webp" alt="A universal TV remote that can be used for all devices." caption="A universal TV remote that can be used for all devices." />
+<Figure
+  src="/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.40.352x.webp"
+  alt="A universal TV remote that can be used for all devices."
+  caption="A universal TV remote that can be used for all devices."
+/>
 
 With SLF4J, you have a single, unified interface that works with various logging frameworks like Log4j, Logback, and JUL (java.util.logging).
 
-<Figure src="/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.43.20.webp" alt="Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback" caption="Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback" />
+<Figure
+  src="/img/guides/2024/07/slf4j-logger-CleanShot_2024-07-12_at_15.43.20.webp"
+  alt="Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback"
+  caption="Representation of SLF4J working as an abstraction layer for Log4j, JUL, Logback"
+/>
 
 ## SLF4J Setup
 
@@ -316,7 +325,7 @@ public class MyApp {
 }
 ```
 
-Output: 
+Output:
 
 ```java
 [INFO] Application started
@@ -557,9 +566,9 @@ When you run your application, the logging calls made using JCL will be routed t
 
 ## SLF4J Architecture
 
-### The  Facade and its Bindings
+### The Facade and its Bindings
 
-SLF4J (Simple Logging Facade for Java) acts as an abstraction layer that decouples application code from the underlying logging frameworks, providing a consistent and flexible logging interface. This design allows developers to write logging code that is independent of the actual logging framework used in deployment. When working with SLF4J, you’ll frequently use several key classes and methods. Think of these as the essential tools in your developer toolkit. Therefore, there’s a need to assimilate the need for referenced API. 
+SLF4J (Simple Logging Facade for Java) acts as an abstraction layer that decouples application code from the underlying logging frameworks, providing a consistent and flexible logging interface. This design allows developers to write logging code that is independent of the actual logging framework used in deployment. When working with SLF4J, you’ll frequently use several key classes and methods. Think of these as the essential tools in your developer toolkit. Therefore, there’s a need to assimilate the need for referenced API.
 
 ### What is a Referenced API?
 
@@ -570,7 +579,7 @@ Logger Interface
 The Logger interface in the org.slf4j package is your main entry point into the SLF4J API. It’s like the walkie-talkie you'll use to communicate your log messages.
 
 - void debug(String msg)
-Logs a message at the DEBUG level. Use this when you need to record detailed information for debugging purposes.
+  Logs a message at the DEBUG level. Use this when you need to record detailed information for debugging purposes.
 
 ```java
 Logger logger = LoggerFactory.getLogger(MyClass.class);
@@ -578,7 +587,7 @@ logger.debug("This is a debug message");
 ```
 
 - void error(String msg)
-Logs a message at the ERROR level. This is for when something has gone wrong, and you need to capture the error details.
+  Logs a message at the ERROR level. This is for when something has gone wrong, and you need to capture the error details.
 
 ```java
 Logger logger = LoggerFactory.getLogger(MyClass.class);
@@ -586,7 +595,7 @@ logger.error("An error occurred");
 ```
 
 - void info(String msg)
-Logs a message at the INFO level. Use this for general information about the application's running state.
+  Logs a message at the INFO level. Use this for general information about the application's running state.
 
 ```java
 Logger logger = LoggerFactory.getLogger(MyClass.class);
@@ -594,7 +603,7 @@ logger.info("This is an info message");
 ```
 
 - void trace(String msg)
-Logs a message at the TRACE level. This is for even more fine-grained details than DEBUG, useful for tracing program execution.
+  Logs a message at the TRACE level. This is for even more fine-grained details than DEBUG, useful for tracing program execution.
 
 ```java
 Logger logger = LoggerFactory.getLogger(MyClass.class);
@@ -602,7 +611,7 @@ logger.trace("This is a trace message");
 ```
 
 - void warn(String msg)
-Logs a message at the WARN level. Use this to indicate potential problems that aren’t necessarily errors.
+  Logs a message at the WARN level. Use this to indicate potential problems that aren’t necessarily errors.
 
 ```java
 Logger logger = LoggerFactory.getLogger(MyClass.class);
@@ -614,7 +623,7 @@ LoggerFactory Class
 The LoggerFactory class in the org.slf4j package is like your factory that produces walkie-talkies. It generates Logger instances that you’ll use throughout your application.
 
 - [Logger getLogger](https://signoz.io/guides/loggerFactory-getLogger-cannot-be-resolved-to-a-type/)(String name)
-Accepts a string (like a channel name for your walkie-talkie) and returns a Logger object. This allows you to create a logger with a specific name.
+  Accepts a string (like a channel name for your walkie-talkie) and returns a Logger object. This allows you to create a logger with a specific name.
 
 ```java
 Logger logger = LoggerFactory.getLogger("MyLogger");
@@ -625,7 +634,7 @@ Profiler Class
 The Profiler class in the org.slf4j package is a bit like a stopwatch for tracking how long tasks take. It’s known as a "poor man’s profiler," perfect for measuring performance without fancy tools.
 
 - void start(String name)
-Starts a new named stopwatch and stops any previous ones. Think of this as starting a new lap on your stopwatch while stopping the previous lap.
+  Starts a new named stopwatch and stops any previous ones. Think of this as starting a new lap on your stopwatch while stopping the previous lap.
 
 ```java
 Profiler profiler = new Profiler("MyProfiler");
@@ -633,28 +642,28 @@ profiler.start("task1");
 ```
 
 - TimeInstrument stop()
-Stops the current stopwatch and returns a Time Instrument representing the elapsed time. It's like hitting stop on your stopwatch and noting the time.
+  Stops the current stopwatch and returns a Time Instrument representing the elapsed time. It's like hitting stop on your stopwatch and noting the time.
 
 ```java
 TimeInstrument timeInstrument = profiler.stop();
 ```
 
 - void setLogger(Logger logger)
-Associates a Logger with the Profiler. Imagine assigning your stopwatch results to a specific walkie-talkie channel.
+  Associates a Logger with the Profiler. Imagine assigning your stopwatch results to a specific walkie-talkie channel.
 
 ```java
 profiler.setLogger(logger);
 ```
 
 - void log()
-Logs the results of the current time instrument to the associated logger. It's like broadcasting your stopwatch results over your walkie-talkie.
+  Logs the results of the current time instrument to the associated logger. It's like broadcasting your stopwatch results over your walkie-talkie.
 
 ```java
 profiler.log();
 ```
 
 - void print()
-Prints the results of the current time instrument. This is like showing the stopwatch results on a display screen.
+  Prints the results of the current time instrument. This is like showing the stopwatch results on a display screen.
 
 ```java
 profiler.print();
@@ -663,21 +672,21 @@ profiler.print();
 Now, let's create a code example step by step, making sure we understand each line as we add it.
 
 - Logger Initialization
-We need to create a Logger instance using `LoggerFactory`. This logger will be used to log messages from our application.
+  We need to create a Logger instance using `LoggerFactory`. This logger will be used to log messages from our application.
 
 ```
 private static final Logger logger = LoggerFactory.getLogger(MyClass.class);
 ```
 
 - Logging an Informational Message
-Let's log a message at the INFO level to indicate the application has started.
+  Let's log a message at the INFO level to indicate the application has started.
 
 ```java
 logger.info("Application started");
 ```
 
 - Profiler Initialization
-We'll create a `Profiler` instance named `MyProfiler`. We then associate the logger with this profiler to log profiling results.
+  We'll create a `Profiler` instance named `MyProfiler`. We then associate the logger with this profiler to log profiling results.
 
 ```java
 Profiler profiler = new Profiler("MyProfiler");
@@ -685,14 +694,14 @@ profiler.setLogger(logger);
 ```
 
 - Starting the Profiler
-Starts the profiler for a task named `Task1`. This is like starting a new stopwatch for this specific task.
+  Starts the profiler for a task named `Task1`. This is like starting a new stopwatch for this specific task.
 
 ```java
 profiler.start("Task1");
 ```
 
 - Simulating a Task
-We'll now simulate a task by making the thread sleep for 1 second. During this time, we log a debug message. If the task is interrupted, we log an error message.
+  We'll now simulate a task by making the thread sleep for 1 second. During this time, we log a debug message. If the task is interrupted, we log an error message.
 
 ```java
 try {
@@ -704,7 +713,7 @@ try {
 ```
 
 - Stopping the Profiler and Logging the Results
-We need to stop the profiler and get the `TimeInstrument`, which contains the elapsed time for `Task1`. We then log these results using the profiler.
+  We need to stop the profiler and get the `TimeInstrument`, which contains the elapsed time for `Task1`. We then log these results using the profiler.
 
 ```java
 TimeInstrument timeInstrument = profiler.stop();
@@ -712,7 +721,7 @@ profiler.log();
 ```
 
 - Logging an Informational Message
-We'll log a message at the INFO level to indicate the application has finished.
+  We'll log a message at the INFO level to indicate the application has finished.
 
 ```java
 logger.info("Application finished");
@@ -778,12 +787,12 @@ Output:
 
 Imagine you are a journalist covering a big event. You have different types of notes for different kinds of information: urgent alerts, important warnings, general news, detailed background information, and minute-by-minute updates. In programming, logging works similarly, where messages are categorized by their importance or verbosity. SLF4J supports logging at five different levels:
 
-| Type | Description |
-| --- | --- |
-| Error | Critical issues that need immediate attention, like a fire alarm. |
-| Warn | Important warnings that should be addressed soon, like a low battery warning. |
-| Info | General informational messages about the program's progress. |
-| Debug | Detailed information for diagnosing problems, like a detailed report on your workday. |
+| Type  | Description                                                                                       |
+| ----- | ------------------------------------------------------------------------------------------------- |
+| Error | Critical issues that need immediate attention, like a fire alarm.                                 |
+| Warn  | Important warnings that should be addressed soon, like a low battery warning.                     |
+| Info  | General informational messages about the program's progress.                                      |
+| Debug | Detailed information for diagnosing problems, like a detailed report on your workday.             |
 | Trace | Very detailed information for tracing the program execution, like a minute-by-minute diary entry. |
 
 Let's look at slf4j logger example example that demonstrates logging at different levels:
@@ -942,7 +951,7 @@ public class MyApp {
 - ConsoleHandler: This handler logs messages to the console.
 - FileHandler: This handler logs messages to a file named `app.log` with a maximum size of 34534 bytes. If the file exceeds this size, a new log file is created. `append` is set to `false`, meaning it will overwrite the existing file if it exists.
 - SocketHandler: This handler sends log messages to a network socket at `localhost` on port `5000`.
-    - Note: For this to work, a socket server needs to be running at this address and port.
+  - Note: For this to work, a socket server needs to be running at this address and port.
 - StreamHandler: This handler logs messages to an `OutputStream`, which in this case is the console (standard output), using a `SimpleFormatter`.
 - MemoryHandler: This handler logs messages to an in-memory buffer and flushes them to `ConsoleHandler` when the buffer reaches 100 records or when a log message of `Level.WARNING` or higher is logged.
 
@@ -957,35 +966,40 @@ public class MyApp {
 Output:
 
 1. ConsoleHandler and StreamHandler Output:
-    - Both `ConsoleHandler` and `StreamHandler` will output all the log messages to the console, formatted by the `SimpleFormatter`.
-    
-    ```
-    Jun 02, 2024 12:34:56 PM MyApp main
-    SEVERE: Severe level log
-    Jun 02, 2024 12:34:56 PM MyApp main
-    WARNING: Warning level log
-    Jun 02, 2024 12:34:56 PM MyApp main
-    INFO: Info level log
-    ```
-    
-    - Messages with `Level.FINE` and `Level.FINER` may not appear on the console if the default logging level is set higher than `FINE`.
+
+   - Both `ConsoleHandler` and `StreamHandler` will output all the log messages to the console, formatted by the `SimpleFormatter`.
+
+   ```
+   Jun 02, 2024 12:34:56 PM MyApp main
+   SEVERE: Severe level log
+   Jun 02, 2024 12:34:56 PM MyApp main
+   WARNING: Warning level log
+   Jun 02, 2024 12:34:56 PM MyApp main
+   INFO: Info level log
+   ```
+
+   - Messages with `Level.FINE` and `Level.FINER` may not appear on the console if the default logging level is set higher than `FINE`.
+
 2. FileHandler Output:
-    - All the log messages will be written to `app.log` with similar formatting.
-    
-    ```
-    Jun 02, 2024 12:34:56 PM MyApp main
-    SEVERE: Severe level log
-    Jun 02, 2024 12:34:56 PM MyApp main
-    WARNING: Warning level log
-    Jun 02, 2024 12:34:56 PM MyApp main
-    INFO: Info level log
-    ```
-    
-    - Messages with `Level.FINE` and `Level.FINER` will be logged to the file if the logging level allows it.
+
+   - All the log messages will be written to `app.log` with similar formatting.
+
+   ```
+   Jun 02, 2024 12:34:56 PM MyApp main
+   SEVERE: Severe level log
+   Jun 02, 2024 12:34:56 PM MyApp main
+   WARNING: Warning level log
+   Jun 02, 2024 12:34:56 PM MyApp main
+   INFO: Info level log
+   ```
+
+   - Messages with `Level.FINE` and `Level.FINER` will be logged to the file if the logging level allows it.
+
 3. SocketHandler Output:
-    - Logs will be sent to the network socket at `localhost:5000`. The exact output depends on the receiving application.
+   - Logs will be sent to the network socket at `localhost:5000`. The exact output depends on the receiving application.
 4. MemoryHandler Output:
-    - `MemoryHandler` will buffer log messages and flush them to `ConsoleHandler` when the buffer reaches 100 entries or when a `WARNING` or higher-level message is logged.
+   - `MemoryHandler` will buffer log messages and flush them to `ConsoleHandler` when the buffer reaches 100 entries or when a `WARNING` or higher-level message is logged.
+
 - Logging Levels: Ensure the logging configuration allows for the desired log levels to be displayed or saved.
 - Handlers Configuration: The behavior of each handler (like `FileHandler` limits, `SocketHandler` connections) can be adjusted as needed.
 - Error Handling: The try-catch block ensures any exceptions during logging setup are caught and handled.
@@ -1030,9 +1044,9 @@ Feature: SLF4J allows the use of various underlying logging frameworks by changi
 Example:
 
 - Using Logback as the underlying framework:
-    - Add `logback-classic.jar` and `logback-core.jar` to the classpath.
+  - Add `logback-classic.jar` and `logback-core.jar` to the classpath.
 - Using Log4j:
-    - Add `slf4j-log4j12.jar` and `log4j.jar` to the classpath.
+  - Add `slf4j-log4j12.jar` and `log4j.jar` to the classpath.
 
 3. Parameterization
 
@@ -1135,7 +1149,7 @@ Output:
 DEBUG  MyApp - User login: [username=johndoe, password=]
 ```
 
-Sensitive information such as the password is masked with  to avoid exposing it in the logs.
+Sensitive information such as the password is masked with to avoid exposing it in the logs.
 
 ### Use Structured Logging
 
diff --git a/data/guides/slf4j-vs-log4j.mdx b/data/guides/slf4j-vs-log4j.mdx
index 34712869d..0c9f10e13 100644
--- a/data/guides/slf4j-vs-log4j.mdx
+++ b/data/guides/slf4j-vs-log4j.mdx
@@ -1,22 +1,29 @@
 ---
-
 title: SLF4J vs LOG4J - Detailed Comparision
-slug: slf4j-vs-log4j
 date: 2024-07-25
 tags: [logging]
 authors: [niyati_thakkar]
 description: Master SLF4J & LOG4J - Compare, choose, and integrate with Signoz for efficient log management. Best practices, examples, and FAQs included.
-keywords: [SLF4J, Java logging, logging framework, logging API, simple logging facade, SLF4J tutorial, SLF4J vs LOG4J, SLF4J best practices]
-
+keywords:
+  [
+    SLF4J,
+    Java logging,
+    logging framework,
+    logging API,
+    simple logging facade,
+    SLF4J tutorial,
+    SLF4J vs LOG4J,
+    SLF4J best practices,
+  ]
 ---
 
-LOG4J and SLF4J are different components and focus on different areas of logging and are meant for different purposes. SLF4J is a logging facade, it depends on other logging libraries like LOG4J, Logback, JUL, etc. SLF4J is an API designed to log code across multiple logging frameworks. 
+LOG4J and SLF4J are different components and focus on different areas of logging and are meant for different purposes. SLF4J is a logging facade, it depends on other logging libraries like LOG4J, Logback, JUL, etc. SLF4J is an API designed to log code across multiple logging frameworks.
 
 LOG4J is a framework that is reliable, fast, and flexible for logging in Java. It is highly configurable, can log at various destinations such as databases, files, consoles, etc., and provides several levels of priorities. In this article, we will explore SLF4J and LOG4J along with their difference in greater detail.
 
 ## SLF4J
 
-SLF4J(Simple Logging Facade for Java) is only a logging API and provides an abstraction layer over many logging frameworks like LOG4J, logback, etc. It helps in decoupling the application code from the underlying logging implementation. 
+SLF4J(Simple Logging Facade for Java) is only a logging API and provides an abstraction layer over many logging frameworks like LOG4J, logback, etc. It helps in decoupling the application code from the underlying logging implementation.
 
 ### Features
 
@@ -24,11 +31,11 @@ SLF4J(Simple Logging Facade for Java) is only a logging API and provides an abst
 - Flexibility - SLF4J allows us to choose the logging framework at deployment time.
 - Code Readability - Irrespective of the framework, the code remains the same thus, the code is more readable.
 
-It provides a very clean and easy-to-use logging API. 
+It provides a very clean and easy-to-use logging API.
 
 ## LOG4J
 
-Unlike SLF4J, LOG4J is a framework, that provides a way to log application events, errors, and debugging information without requiring any dependencies. 
+Unlike SLF4J, LOG4J is a framework, that provides a way to log application events, errors, and debugging information without requiring any dependencies.
 
 ### Features
 
@@ -50,7 +57,7 @@ LOG4J is a logging framework, it is not flexible but provides extensive configur
 
 SLF4J delegates logging for the framework. Therefore, its performance depends on the respective framework.
 
-LOG4J gives a great performance especially LOG4J 2 which introduced an asynchronous logging feature implying that the overhead of logging is no more on the main rather the background thread handles the logging. 
+LOG4J gives a great performance especially LOG4J 2 which introduced an asynchronous logging feature implying that the overhead of logging is no more on the main rather the background thread handles the logging.
 
 ### Ease of Use
 
@@ -60,9 +67,9 @@ LOG4J is a more dedicated API that has its format of writing code and little com
 
 ### Flexibility and Extensibility
 
-SLF4J being an API is more flexible but requires a framework under the hood. It supports various logging backends like Logback, LOG4J, and JUL. It is extensible to new frameworks. 
+SLF4J being an API is more flexible but requires a framework under the hood. It supports various logging backends like Logback, LOG4J, and JUL. It is extensible to new frameworks.
 
-LOG4J is also flexible and offers various configuration options for developers like custom appenders, handlers, layouts, formats, etc. It also lets developers extend its functionality by creating custom components in Java Applications. 
+LOG4J is also flexible and offers various configuration options for developers like custom appenders, handlers, layouts, formats, etc. It also lets developers extend its functionality by creating custom components in Java Applications.
 
 ### Error Handling and Robustness
 
@@ -78,7 +85,7 @@ LOG4J offers advanced logging capabilities such as hierarchical loggers, custom
 
 ### Integration with Other Tools
 
-SLF4J supports integration with multiple frameworks and libraries making it suitable for normal and flexible projects. 
+SLF4J supports integration with multiple frameworks and libraries making it suitable for normal and flexible projects.
 
 LOG4J also supports integration with multiple Java-based frameworks and applications. LOG4J 2’s API makes it even more preferable for modern applications requiring advanced logging features.
 
@@ -124,38 +131,38 @@ public class LoggingExample {
 }
 ```
 
-By having a clear picture of each and understanding their differences developers can choose the right logging framework for their application needs. 
+By having a clear picture of each and understanding their differences developers can choose the right logging framework for their application needs.
 
-| Feature | SLF4J (Simple Logging Facade for Java) | LOG4J (Logging for Java) |
-| --- | --- | --- |
-| Design & Architecture | Abstract facade pattern, decoupled from implementation | API & Framework, hierarchical loggers, appenders, layouts |
-| Performance | Depends on the underlying framework | Generally good, especially LOG4J 2 with asynchronous logging |
-| Ease of Use | Simple API, easy to learn and use | More dedicated API, complex configuration |
-| Flexibility & Extensibility | Highly flexible, supports various backends | Flexible, offers custom appenders, layouts, etc. |
-| Error Handling & Robustness | Relies on an underlying framework, basic handling | Handles errors, LOG4J 2 has failover appenders |
-| Logging Capabilities | Basic levels (trace, debug, info, warn, error), framework-dependent for others | Advanced capabilities: hierarchical loggers, custom levels, filtering |
-| Integration with Other Tools | Supports multiple frameworks and libraries | Integrates with Java frameworks and applications |
-| Maintenance & Updates | Actively maintained with regular updates | Actively maintained (LOG4J 2), focuses on performance and features |
+| Feature                      | SLF4J (Simple Logging Facade for Java)                                         | LOG4J (Logging for Java)                                              |
+| ---------------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
+| Design & Architecture        | Abstract facade pattern, decoupled from implementation                         | API & Framework, hierarchical loggers, appenders, layouts             |
+| Performance                  | Depends on the underlying framework                                            | Generally good, especially LOG4J 2 with asynchronous logging          |
+| Ease of Use                  | Simple API, easy to learn and use                                              | More dedicated API, complex configuration                             |
+| Flexibility & Extensibility  | Highly flexible, supports various backends                                     | Flexible, offers custom appenders, layouts, etc.                      |
+| Error Handling & Robustness  | Relies on an underlying framework, basic handling                              | Handles errors, LOG4J 2 has failover appenders                        |
+| Logging Capabilities         | Basic levels (trace, debug, info, warn, error), framework-dependent for others | Advanced capabilities: hierarchical loggers, custom levels, filtering |
+| Integration with Other Tools | Supports multiple frameworks and libraries                                     | Integrates with Java frameworks and applications                      |
+| Maintenance & Updates        | Actively maintained with regular updates                                       | Actively maintained (LOG4J 2), focuses on performance and features    |
 
 ## Why Use SLF4J over LOG4J?
 
-SLF4J has various advantages over LOG4J, especially in terms of flexibility and creating future-proof applications. 
+SLF4J has various advantages over LOG4J, especially in terms of flexibility and creating future-proof applications.
 
 ### Dependency Injection
 
-SLF4J provides an abstraction layer that enables dependency injection. Using SLF4J, we can easily switch between different logging frameworks (LOG4J, Logback, etc.) without making changes to the application code. This flexibility is invaluable for maintaining applications for evolving coding and design patterns. 
+SLF4J provides an abstraction layer that enables dependency injection. Using SLF4J, we can easily switch between different logging frameworks (LOG4J, Logback, etc.) without making changes to the application code. This flexibility is invaluable for maintaining applications for evolving coding and design patterns.
 
 ### Future-Proofing
 
-SLF4J helps write future-proof code, it relies on binding implementations to connect with actual logging frameworks. A separate library is used for bridging SLF4J calls to a specific logging framework. The logging code is written once using the SLF4J API and SLF4J routes the logging calls to the chosen logging framework at runtime. 
+SLF4J helps write future-proof code, it relies on binding implementations to connect with actual logging frameworks. A separate library is used for bridging SLF4J calls to a specific logging framework. The logging code is written once using the SLF4J API and SLF4J routes the logging calls to the chosen logging framework at runtime.
 
 ## Best Practices for Using SLF4J and LOG4J
 
 ### Choosing the Right Framework
 
-Choosing the right framework is crucial for the success of the application considering the importance of logging in to an application. 
+Choosing the right framework is crucial for the success of the application considering the importance of logging in to an application.
 
-These three steps can help you decide on the right framework for your project: 
+These three steps can help you decide on the right framework for your project:
 
 - Evaluate Requirements - Initially understand the specific needs of your application. For instance, if high performance is needed along with asynchronous logging then LOG4J 2 might be the right framework.
 - Community and Support - If you think you will need support for logging, choose the framework with good community support like Logback and LOG4J2.
@@ -171,7 +178,7 @@ New logging frameworks like LOG4J2 provide options for configurations. By enabli
 
 ### Common Pitfalls to Avoid
 
-Here are the cautions to be taken while logging: 
+Here are the cautions to be taken while logging:
 
 - Logging is important and appropriate logs must be added to the application but avoid overlogging, if some things are intuitive and not important avoid logging them. Overlogging can make it harder to track the important events.
 - Also, make sure to choose the right log levels for the log and use severe levels for important events only.
@@ -243,4 +250,4 @@ public class MyExample {
 
 SLF4J providers are the actual logging implementations (like LOG4J, and Logback) that work with SLF4J. They handle the actual logging process.
 
-<GetStartedSigNoz />
\ No newline at end of file
+<GetStartedSigNoz />
diff --git a/data/guides/slo-monitoring.mdx b/data/guides/slo-monitoring.mdx
index 95d2b452d..a62dbcfd9 100644
--- a/data/guides/slo-monitoring.mdx
+++ b/data/guides/slo-monitoring.mdx
@@ -1,136 +1,157 @@
 ---
-
 title: SLO Monitoring - A Guide to Measuring Service Reliability
-slug: slo-monitoring
 date: 2024-12-19
 tags: [monitoring]
 authors: [manjunath_irukulla]
 description: Learn how SLO monitoring enhances service reliability. Discover key components, implementation strategies, and best practices for effective SLO tracking.
-keywords: [SLO monitoring, service reliability, SLIs, error budgets, DevOps, observability, performance metrics, SigNoz]
-
+keywords:
+  [
+    SLO monitoring,
+    service reliability,
+    SLIs,
+    error budgets,
+    DevOps,
+    observability,
+    performance metrics,
+    SigNoz,
+  ]
 ---
 
-In today’s fast-paced digital world, service reliability is non-negotiable. Users expect applications to be available, responsive and error-free at all times. How can organizations meet those lofty expectations? SLO monitoring is the answer, a powerful framework for measuring and maintaining service reliability. 
+In today’s fast-paced digital world, service reliability is non-negotiable. Users expect applications to be available, responsive and error-free at all times. How can organizations meet those lofty expectations? SLO monitoring is the answer, a powerful framework for measuring and maintaining service reliability.
 
-<Figure src="/img/guides/2024/12/slo-monitoring-CleanShot_2024-12-19_at_15.52.072x.webp" alt="" caption="" />This guide unpacks the essentials of SLO monitoring, from understanding its core concepts to implementing it effectively. You’ll also discover how tools like SigNoz can simplify the process, making SLO monitoring accessible to everyone. 
+<Figure
+  src="/img/guides/2024/12/slo-monitoring-CleanShot_2024-12-19_at_15.52.072x.webp"
+  alt=""
+  caption=""
+/>
+This guide unpacks the essentials of SLO monitoring, from understanding its core concepts to
+implementing it effectively. You’ll also discover how tools like SigNoz can simplify the process,
+making SLO monitoring accessible to everyone.{' '}
 
 ## What is SLO Monitoring?
 
-SLO monitoring refers to the practice of setting, measuring, and tracking Service Level Objectives (SLOs) for systems, applications, or services. SLOs are specific measurable targets that define the acceptable performance and reliability of service from the user’s perspective. These targets are typically derived from Service Level Indicators (SLIs) such as uptime, latency, or error rates. 
+SLO monitoring refers to the practice of setting, measuring, and tracking Service Level Objectives (SLOs) for systems, applications, or services. SLOs are specific measurable targets that define the acceptable performance and reliability of service from the user’s perspective. These targets are typically derived from Service Level Indicators (SLIs) such as uptime, latency, or error rates.
 
 - Effective SLO monitoring enables teams to understand how their services perform against predefined expectations, helping to ensure they meet business goals and customer satisfaction.
 - By continuously observing these metrics, organizations can proactively identify and address performance issues before they escalate.
 
 ## Why is SLO Monitoring Important?
 
-SLO monitoring is crucial because it bridges the gap between technical performance and business outcomes. Here are some key reasons why it’s important: 
+SLO monitoring is crucial because it bridges the gap between technical performance and business outcomes. Here are some key reasons why it’s important:
 
-<Figure src="/img/guides/2024/12/slo-monitoring-image.webp" alt="SLO Monitoring Importance" caption="SLO Monitoring Importance" /> 
+<Figure
+  src="/img/guides/2024/12/slo-monitoring-image.webp"
+  alt="SLO Monitoring Importance"
+  caption="SLO Monitoring Importance"
+/>{' '}
 
-1. Customer Satisfaction: SLOs focus on what matters to the end user, ensuring that services meet their expectations for availability and performance. 
-2. Proactive Problem Detection: Monitoring SLOs helps detect and resolve issues before they impact users, minimizing downtime and preserving reputation. 
-3. Data-Driven Decision Making: SLOs provide concrete metrics that guide prioritization of engineering tasks, balancing innovation with reliability. 
-4. Operational Efficiency: Teams can focus on addressing the most critical reliability risks rather than overengineering solutions. 
-5. Alignment with Business Goals: SLO monitoring ties technical performance to organizational objectives, fostering collaboration between engineering and business teams. 
+1. Customer Satisfaction: SLOs focus on what matters to the end user, ensuring that services meet their expectations for availability and performance.
+2. Proactive Problem Detection: Monitoring SLOs helps detect and resolve issues before they impact users, minimizing downtime and preserving reputation.
+3. Data-Driven Decision Making: SLOs provide concrete metrics that guide prioritization of engineering tasks, balancing innovation with reliability.
+4. Operational Efficiency: Teams can focus on addressing the most critical reliability risks rather than overengineering solutions.
+5. Alignment with Business Goals: SLO monitoring ties technical performance to organizational objectives, fostering collaboration between engineering and business teams.
 
 ### Why Should You Care About SLO Monitoring?
 
-SLO monitoring isn’t just a technical practice, it’s a strategic asset for businesses, engineering teams, and decision-makers. Here’s why it matters to you: 
+SLO monitoring isn’t just a technical practice, it’s a strategic asset for businesses, engineering teams, and decision-makers. Here’s why it matters to you:
 
-1. Clear Performance Benchmarks: SLOs set well-defined, measurable targets for service reliability and performance, enabling your team to stay aligned with business and user expectations. 
-2. User-Centric Priorities: By focusing on metrics that impact end-user experiences, such as latency, availability, or error rates, you ensure your efforts directly enhance customer satisfaction. 
-3. Reduced Firefighting: SLO monitoring empowers teams to proactively address issues before they escalate, saving time and resources spent on reactive firefighting. 
-4. Optimized Engineering Efforts: Instead of overengineering or guessing priorities, SLOs guide teams to invest in improvements that deliver maximum impact on user experience and business outcomes.  
-5. Data-Driven Confidence: Having reliable SLO data fosters confidence in your decision-making processes, whether it’s about launching new features, allocation budgets, or scaling infrastructure. 
-6. Competitive Advantage: Organizations with robust SLO monitoring gain an edge by delivering consistent, high-quality services and building customer trust and loyalty. 
+1. Clear Performance Benchmarks: SLOs set well-defined, measurable targets for service reliability and performance, enabling your team to stay aligned with business and user expectations.
+2. User-Centric Priorities: By focusing on metrics that impact end-user experiences, such as latency, availability, or error rates, you ensure your efforts directly enhance customer satisfaction.
+3. Reduced Firefighting: SLO monitoring empowers teams to proactively address issues before they escalate, saving time and resources spent on reactive firefighting.
+4. Optimized Engineering Efforts: Instead of overengineering or guessing priorities, SLOs guide teams to invest in improvements that deliver maximum impact on user experience and business outcomes.
+5. Data-Driven Confidence: Having reliable SLO data fosters confidence in your decision-making processes, whether it’s about launching new features, allocation budgets, or scaling infrastructure.
+6. Competitive Advantage: Organizations with robust SLO monitoring gain an edge by delivering consistent, high-quality services and building customer trust and loyalty.
 
 ## Key Components of Effective SLO Monitoring
 
-To implement effective SLO monitoring, organizations must focus on its foundational components: 
+To implement effective SLO monitoring, organizations must focus on its foundational components:
 
-<Figure src="/img/guides/2024/12/slo-monitoring-74516f08-f46b-4450-9941-1b1c93edff0b.webp" alt="Key Components of SLO Monitoring" caption="Key Components of SLO Monitoring" /> 
+<Figure
+  src="/img/guides/2024/12/slo-monitoring-74516f08-f46b-4450-9941-1b1c93edff0b.webp"
+  alt="Key Components of SLO Monitoring"
+  caption="Key Components of SLO Monitoring"
+/>{' '}
 
-1. Service Level Indicators (SLIs): These are the measurable metrics that reflect the performance or reliability of a service, such as latency, throughput, or error rates. Choosing the right SLIs is critical to meaningful SLO monitoring. 
-2. Service Level Objectives (SLOs): These are the targets derived from SLIs that define acceptable levels of service. For example, an SLO might state that 99.9% of requests must be served within 200 milliseconds. 
-3. Error Budgets: This represents the allowable level of service degradation within a specific time period. Error budgets provide a structured way to balance reliability with innovation, helping teams decide when to prioritize reliability work over new features. 
-4. Monitoring Tools: Tools like SigNoz, Prometheus, or Grafana are essential for collecting and visualizing data related to SLIs. These tools help automate tracking and alerting based on SLO thresholds. 
-5. Dashboards and Alerts: Comprehensive dashboards provide centralized visibility into SLO compliance. Coupled with alerting systems, they notify teams when performance approaches or exceeds acceptable thresholds, enabling swift responses. 
+1. Service Level Indicators (SLIs): These are the measurable metrics that reflect the performance or reliability of a service, such as latency, throughput, or error rates. Choosing the right SLIs is critical to meaningful SLO monitoring.
+2. Service Level Objectives (SLOs): These are the targets derived from SLIs that define acceptable levels of service. For example, an SLO might state that 99.9% of requests must be served within 200 milliseconds.
+3. Error Budgets: This represents the allowable level of service degradation within a specific time period. Error budgets provide a structured way to balance reliability with innovation, helping teams decide when to prioritize reliability work over new features.
+4. Monitoring Tools: Tools like SigNoz, Prometheus, or Grafana are essential for collecting and visualizing data related to SLIs. These tools help automate tracking and alerting based on SLO thresholds.
+5. Dashboards and Alerts: Comprehensive dashboards provide centralized visibility into SLO compliance. Coupled with alerting systems, they notify teams when performance approaches or exceeds acceptable thresholds, enabling swift responses.
 
 ### Choosing the Right SLIs for Your Service
 
-When selecting SLIs (Service Level Indicators), focus on metrics directly affecting the user experience and system performance. 
+When selecting SLIs (Service Level Indicators), focus on metrics directly affecting the user experience and system performance.
 
-1. Latency: Measures how quickly your service responds to user requests. The lower the latency, the better the user experience. 
-2. Availability: Tracks whether your service is up and accessible. High availability ensures users can rely on your service. 
-3. Error Rate: Monitors how often requests or operations fail. A low error rate reflects a reliable service. 
-4. Throughput: It Evaluates how much load your system can handle. Higher throughput indicates better performance under demand. 
+1. Latency: Measures how quickly your service responds to user requests. The lower the latency, the better the user experience.
+2. Availability: Tracks whether your service is up and accessible. High availability ensures users can rely on your service.
+3. Error Rate: Monitors how often requests or operations fail. A low error rate reflects a reliable service.
+4. Throughput: It Evaluates how much load your system can handle. Higher throughput indicates better performance under demand.
 
 ## How to Implement SLO Monitoring in Your Organization
 
-Implementing SLO monitoring is a strategic process that requires careful planning and execution. Here’s a step-by-step guide to get started: 
+Implementing SLO monitoring is a strategic process that requires careful planning and execution. Here’s a step-by-step guide to get started:
 
 1. Establish Baselines:
-    - Analyze historical data to understand your current performance metrics.
-    - Identify trends, patterns, and areas of improvement to set realistic, achievable targets.
-    - Example: Review your past three months’ uptime and downtime logs to determine your current availability rate (e.g., 99.7%) as a starting point.
-2. Define SLOs: 
-    - Collaborate with stakeholders to set measurable, user-focused objectives that align with business goals.
-    - Ensure SLOs are specific, actionable, and relevant to your customer’s experiences.
-    - Example: If your e-commerce platform needs to ensure fast checkout times, define an SLO such as “95% of checkout transactions must be completed within 2 months.”
-3. Choose SLIs: 
-    - Select metrics (SLIs) that directly reflect user experience, such as latency, error rate, throughput, or availability.
-    - Ensure SLIs are meaningful and quantifiable, avoiding metrics that don’t provide actionable insights.
-    - Example: For a video streaming service, choose the buffering rate (e.g., “less than 0.5% of streamed video segments experience buffering”) as a critical SLI.
-4. Set Up Monitoring: 
-    - Implement robust monitoring tools that collect, process, and visualize SLI data in real-time.
-    - Integrate these tools with dashboards for easy tracking of SLO compliance.
-    - Example: Use a tool like [SigNoz](https://signoz.io/docs/introduction/) or Prometheus to monitor application response times and visualize the percentage of requests meeting your SLO in a dashboard.
-5. Create Alerts: 
-    - Configure alerts to notify teams when an SLO is at risk of being violated.
-    - Use actionable thresholds to avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/), such as “Trigger an alert if error rate exceeds 1% for 10 consecutive minutes.”
-    - Ensure alerts are routed to the appropriate teams for quick resolution.
-    - Example: For an online payment system, create an alert: “Trigger an incident if payment failure rates exceed 2% for more than 5 minutes.”
-6. Review and Iterate: 
-    - Regularly evaluate your SLOs to ensure they remain relevant as your system and user needs evolve.
-    - Use insights from SLO compliance reports to refine objectives and optimize your processes.
-    - Example: After a product update, review the SLO for login success rates and adjust if new features affect user authentication speed.
+   - Analyze historical data to understand your current performance metrics.
+   - Identify trends, patterns, and areas of improvement to set realistic, achievable targets.
+   - Example: Review your past three months’ uptime and downtime logs to determine your current availability rate (e.g., 99.7%) as a starting point.
+2. Define SLOs:
+   - Collaborate with stakeholders to set measurable, user-focused objectives that align with business goals.
+   - Ensure SLOs are specific, actionable, and relevant to your customer’s experiences.
+   - Example: If your e-commerce platform needs to ensure fast checkout times, define an SLO such as “95% of checkout transactions must be completed within 2 months.”
+3. Choose SLIs:
+   - Select metrics (SLIs) that directly reflect user experience, such as latency, error rate, throughput, or availability.
+   - Ensure SLIs are meaningful and quantifiable, avoiding metrics that don’t provide actionable insights.
+   - Example: For a video streaming service, choose the buffering rate (e.g., “less than 0.5% of streamed video segments experience buffering”) as a critical SLI.
+4. Set Up Monitoring:
+   - Implement robust monitoring tools that collect, process, and visualize SLI data in real-time.
+   - Integrate these tools with dashboards for easy tracking of SLO compliance.
+   - Example: Use a tool like [SigNoz](https://signoz.io/docs/introduction/) or Prometheus to monitor application response times and visualize the percentage of requests meeting your SLO in a dashboard.
+5. Create Alerts:
+   - Configure alerts to notify teams when an SLO is at risk of being violated.
+   - Use actionable thresholds to avoid [alert fatigue](https://signoz.io/blog/alert-fatigue/), such as “Trigger an alert if error rate exceeds 1% for 10 consecutive minutes.”
+   - Ensure alerts are routed to the appropriate teams for quick resolution.
+   - Example: For an online payment system, create an alert: “Trigger an incident if payment failure rates exceed 2% for more than 5 minutes.”
+6. Review and Iterate:
+   - Regularly evaluate your SLOs to ensure they remain relevant as your system and user needs evolve.
+   - Use insights from SLO compliance reports to refine objectives and optimize your processes.
+   - Example: After a product update, review the SLO for login success rates and adjust if new features affect user authentication speed.
 
 ## Best Practices for SLO Monitoring
 
-Implementing SLO monitoring effectively requires adherence to proven strategies: 
+Implementing SLO monitoring effectively requires adherence to proven strategies:
 
-1. Define Meaningful SLIs and SLOs: Focus on metrics that truly impact user’s experience. Avoid vanity metrics and ensure SLOs align with user needs and business objectives. 
+1. Define Meaningful SLIs and SLOs: Focus on metrics that truly impact user’s experience. Avoid vanity metrics and ensure SLOs align with user needs and business objectives.
 2. Involve Stakeholders: Collaborate with both technical and business teams to set realistic and meaningful objectives. This ensures alignment and buy-in across the organization.
-3. Leverage Error Budgets:  Use error budgets as a tool to balance reliability and feature development. When error budgets are exhausted, prioritize reliability tasks until the service stabilizes. 
-4. Automate Monitoring and Reporting: Implementing automated systems to track SLI performance, generate reports, and send alerts. This reduces manual overhead and ensures timely detection of issues. 
-5. Iterate and Improve: Regularly review and adjust SLOs based on user feedback, service evolution, and changing business priorities. 
-6. Ensure Observability: Invest in robust observability systems that provide deep insights into system behaviour, helping diagnose and resolve issues efficiently. 
-7. Foster a Culture of Accountability: Encourage teams to take ownership of SLOs and use them as a framework for continuous improvement. Celebrate success when targets are met and analyze failures to drive learning. 
+3. Leverage Error Budgets: Use error budgets as a tool to balance reliability and feature development. When error budgets are exhausted, prioritize reliability tasks until the service stabilizes.
+4. Automate Monitoring and Reporting: Implementing automated systems to track SLI performance, generate reports, and send alerts. This reduces manual overhead and ensures timely detection of issues.
+5. Iterate and Improve: Regularly review and adjust SLOs based on user feedback, service evolution, and changing business priorities.
+6. Ensure Observability: Invest in robust observability systems that provide deep insights into system behaviour, helping diagnose and resolve issues efficiently.
+7. Foster a Culture of Accountability: Encourage teams to take ownership of SLOs and use them as a framework for continuous improvement. Celebrate success when targets are met and analyze failures to drive learning.
 
 ## Challenges in SLO Monitoring and How to Overcome Them
 
-[SLO monitoring](https://signoz.io/guides/slo-monitoring/#slo-monitoring-with-signoz-a-practical-approach) presents various challenges that can hinder its effectiveness, but these challenges can be addressed with structured and thoughtful approaches:  
-
-1. Complex Systems: In environments like microservices architectures, services are often interconnected and dependent on one another. This interdependency makes it challenging to define SLOs that capture the overall user experience while accounting for the contributions of multiple components. 
-    
-    *Solution*: Begin by defining high-level SLOs that reflect the end user’s experience, such as application response time or availability. Gradually work your way down to individual components, breaking down the broader SLOs into sub-objectives that measure the contributions of each service. This layered approach ensures clarity while tackling the complexity of interconnected systems. 
-    
-2. Data Overload: Modern systems generate an overwhelming amount of metrics and logs, making it difficult to identify which data points are relevant for meaningful SLO monitoring. This overload often leads to confusion and inefficiency in monitoring efforts. 
-    
-    *Solution*: Narrow the focus to a small, carefully chosen set of Service Level Indicators (SLIs) that directly impact the user’s experience. Prioritize metrics such as latency, error rates, and availability, and use these as the foundation for your SLOs. By concentrating on the metrics that truly matter, you avoid unnecessary noise and ensure actionable insights. 
-    
-3. Stakeholder Alignment: Conflicting priorities between different teams, such as engineering, operations, and business stakeholders, can make it challenging to define SLOs that are both realistic and aligned with overall objectives. These misalignments can slow down the SLO implementation process and lead to dissatisfaction. 
-    
-    *Solution*: Establish an inclusive process for SLO creation by involving representatives from all relevant teams. Facilitate open discussions to understand each team’s needs and constraints, and tie the SLOs to clear business outcomes. When SLOs are framed as essential to achieving organizational goals, it becomes easier to gain buy-in and foster collaboration.  
-    
-4. Unrealistic Targets: Overly ambitious SLOs, whether due to lack of experience or external pressure, can lead to unsustainable workloads, team burnout, and disappointment when targets are consistently missed. Unrealistic objectives also risk demotivating teams and harming the overall reliability strategy. 
-    
-    *Solution*: Rely on historical performance data, system behaviour patterns, and industry standards to set realistic and achievable SLO targets. Start with conservative objectives and iterate based on [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and feedback. This adaptive approach allows teams to improve gradually while maintaining morale and a sense of accomplishment. 
-    
+[SLO monitoring](https://signoz.io/guides/slo-monitoring/#slo-monitoring-with-signoz-a-practical-approach) presents various challenges that can hinder its effectiveness, but these challenges can be addressed with structured and thoughtful approaches:
+
+1. Complex Systems: In environments like microservices architectures, services are often interconnected and dependent on one another. This interdependency makes it challenging to define SLOs that capture the overall user experience while accounting for the contributions of multiple components.
+
+   _Solution_: Begin by defining high-level SLOs that reflect the end user’s experience, such as application response time or availability. Gradually work your way down to individual components, breaking down the broader SLOs into sub-objectives that measure the contributions of each service. This layered approach ensures clarity while tackling the complexity of interconnected systems.
+
+2. Data Overload: Modern systems generate an overwhelming amount of metrics and logs, making it difficult to identify which data points are relevant for meaningful SLO monitoring. This overload often leads to confusion and inefficiency in monitoring efforts.
+
+   _Solution_: Narrow the focus to a small, carefully chosen set of Service Level Indicators (SLIs) that directly impact the user’s experience. Prioritize metrics such as latency, error rates, and availability, and use these as the foundation for your SLOs. By concentrating on the metrics that truly matter, you avoid unnecessary noise and ensure actionable insights.
+
+3. Stakeholder Alignment: Conflicting priorities between different teams, such as engineering, operations, and business stakeholders, can make it challenging to define SLOs that are both realistic and aligned with overall objectives. These misalignments can slow down the SLO implementation process and lead to dissatisfaction.
+
+   _Solution_: Establish an inclusive process for SLO creation by involving representatives from all relevant teams. Facilitate open discussions to understand each team’s needs and constraints, and tie the SLOs to clear business outcomes. When SLOs are framed as essential to achieving organizational goals, it becomes easier to gain buy-in and foster collaboration.
+
+4. Unrealistic Targets: Overly ambitious SLOs, whether due to lack of experience or external pressure, can lead to unsustainable workloads, team burnout, and disappointment when targets are consistently missed. Unrealistic objectives also risk demotivating teams and harming the overall reliability strategy.
+
+   _Solution_: Rely on historical performance data, system behaviour patterns, and industry standards to set realistic and achievable SLO targets. Start with conservative objectives and iterate based on [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) and feedback. This adaptive approach allows teams to improve gradually while maintaining morale and a sense of accomplishment.
 
 ## Leveraging SLO Monitoring for Continuous Improvement
 
-SLO monitoring transcends the basic objective of maintaining service performance, it serves as a strategic framework to propel continuous improvement across technical, operational, and cultural dimensions of your organization. By integrating SLO monitoring into your processes, you can unlock actionable insights that drive better decisions and outcomes. 
+SLO monitoring transcends the basic objective of maintaining service performance, it serves as a strategic framework to propel continuous improvement across technical, operational, and cultural dimensions of your organization. By integrating SLO monitoring into your processes, you can unlock actionable insights that drive better decisions and outcomes.
 
 - Identify and Address Technical Debt: SLO data provides a clear picture of where systems are underperforming or approaching the limits of reliability. This information allows teams to prioritize technical debt that directly impacts user experience, ensuring reliability efforts are focused where they matter most.
 - Optimize Capacity Planning and Resource Allocation: Trends observed in SLO data can offer predictive insights into future resource requirements. For example, analyzing patterns in latency or throughput can guide infrastructure scaling decisions, ensuring adequate capacity to meet growing user demands while avoiding unnecessary expenditure.
@@ -140,41 +161,52 @@ SLO monitoring transcends the basic objective of maintaining service performance
 
 ## SLO Monitoring with SigNoz: A Practical Approach
 
-SigNoz, an open-source observability platform, makes SLO monitoring accessible and efficient. Follow these steps to set up SLO tracking with SigNoz. 
+SigNoz, an open-source observability platform, makes SLO monitoring accessible and efficient. Follow these steps to set up SLO tracking with SigNoz.
 
 1. Sign Up for SigNoz Cloud or Self-Host
-    
-    <GetStartedSigNoz />
-    
+
+   <GetStartedSigNoz />
+
 2. Access SigNoz and Choose [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/)
-    - Once you have access to SigNoz, navigate to the Get Started section.
-    - Select Infrastructure Monitoring as your monitoring category.
-    - Choose your data sources (e.g., Host Metrics for monitoring server resources).
-    - Proceed by selecting your host machine for deployment.
-        
-        <Figure src="/img/guides/2024/12/slo-monitoring-image%201.webp" alt="Select the Appropriate Data Source for Implementing SLO Monitoring" caption="Select the Appropriate Data Source for Implementing SLO Monitoring" /> 
-        
+   - Once you have access to SigNoz, navigate to the Get Started section.
+   - Select Infrastructure Monitoring as your monitoring category.
+   - Choose your data sources (e.g., Host Metrics for monitoring server resources).
+   - Proceed by selecting your host machine for deployment.
+     {' '}
+     <Figure
+       src="/img/guides/2024/12/slo-monitoring-image%201.webp"
+       alt="Select the Appropriate Data Source for Implementing SLO Monitoring"
+       caption="Select the Appropriate Data Source for Implementing SLO Monitoring"
+     />
 3. Install and Configure the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Agent
-    - Follow the provided instructions to install the OpenTelemetry (Otel) agent on your host machine.
-    - Run the necessary commands to configure the [Otel agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) to send telemetry data (like metrics and logs) to your SigNoz instance.
-    - Ensure the data pipeline is correctly set up by verifying incoming metrics in SigNoz.
+   - Follow the provided instructions to install the OpenTelemetry (Otel) agent on your host machine.
+   - Run the necessary commands to configure the [Otel agent](https://signoz.io/comparisons/opentelemetry-collector-vs-agent/) to send telemetry data (like metrics and logs) to your SigNoz instance.
+   - Ensure the data pipeline is correctly set up by verifying incoming metrics in SigNoz.
 4. Build and Import Dashboards
-    - After successful setup, navigate to Dashboards on the SigNoz homepage and select Import JSON. (You can find Dashboard’s JSON Templates [here](https://signoz.io/dashboards))
-    - Upload your desired [dashboard configuration file.](https://signoz.io/dashboards)
-    - Once imported, choose the relevant hostname (e.g., your VM or server name) to visualize metrics.
-    - View key infrastructure metrics, including CPU usage, memory consumption, system load averages, and network activity.
-
-<Figure src="/img/guides/2024/12/slo-monitoring-image%202.webp" alt="Host Metrics Dashboard" caption="Host Metrics Dashboard" />
-
-<Figure src="/img/guides/2024/12/slo-monitoring-image%203.webp" alt="Host Metrics Dashboard" caption="Host Metrics Dashboard" />
+   - After successful setup, navigate to Dashboards on the SigNoz homepage and select Import JSON. (You can find Dashboard’s JSON Templates [here](https://signoz.io/dashboards))
+   - Upload your desired [dashboard configuration file.](https://signoz.io/dashboards)
+   - Once imported, choose the relevant hostname (e.g., your VM or server name) to visualize metrics.
+   - View key infrastructure metrics, including CPU usage, memory consumption, system load averages, and network activity.
+
+<Figure
+  src="/img/guides/2024/12/slo-monitoring-image%202.webp"
+  alt="Host Metrics Dashboard"
+  caption="Host Metrics Dashboard"
+/>
+
+<Figure
+  src="/img/guides/2024/12/slo-monitoring-image%203.webp"
+  alt="Host Metrics Dashboard"
+  caption="Host Metrics Dashboard"
+/>
 
 1. Set Up Alerts for SLO Monitoring
-    - Create multi-level actionable alerts in SigNoz to monitor SLO compliance effectively.
-    - Refer to the [official SigNoz alert setup documentation](https://signoz.io/docs/setup-alerts-notification/) for detailed instructions on configuring and refining alerts tailored to your SLOs.
+   - Create multi-level actionable alerts in SigNoz to monitor SLO compliance effectively.
+   - Refer to the [official SigNoz alert setup documentation](https://signoz.io/docs/setup-alerts-notification/) for detailed instructions on configuring and refining alerts tailored to your SLOs.
 2. Analyze Trends and Optimize for Continuous Improvement
-    - Continously refine your SLOs by identifying areas for improvement in service delivery.
+   - Continously refine your SLOs by identifying areas for improvement in service delivery.
 3. Iterate and Automate
-    - As your system evolves, revisit your SLOs, refine alert thresholds, and adapt dashboards to reflect changing business priorities.
+   - As your system evolves, revisit your SLOs, refine alert thresholds, and adapt dashboards to reflect changing business priorities.
 
 <GetStartedSigNoz />
 
@@ -192,31 +224,31 @@ SigNoz, an open-source observability platform, makes SLO monitoring accessible a
 
 ### What's the difference between SLOs, SLAs, and SLIs?
 
-| Term  | Definition | Purpose |
-| --- | --- | --- |
-| SLO (Service Level Objective)  | Internal targets for service performance and reliability | Sets benchmarks to maintain operational excellence and monitor performance goals.  |
-| SLA (Service Level Agreement) | Contractual commitments made to customers about service performance.  | Protects customer interests by legally defining the minimum acceptable level of service.  |
-| SLI (Service Level Indicator)  | Specific metrics used to measure and evaluate SLOs and SLAs.  | Provides measurable data points, such as latency, uptime, or error rates, to assess service levels.  |
+| Term                          | Definition                                                           | Purpose                                                                                             |
+| ----------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| SLO (Service Level Objective) | Internal targets for service performance and reliability             | Sets benchmarks to maintain operational excellence and monitor performance goals.                   |
+| SLA (Service Level Agreement) | Contractual commitments made to customers about service performance. | Protects customer interests by legally defining the minimum acceptable level of service.            |
+| SLI (Service Level Indicator) | Specific metrics used to measure and evaluate SLOs and SLAs.         | Provides measurable data points, such as latency, uptime, or error rates, to assess service levels. |
 
 ### How often should we review and update our SLOs?
 
-Review SLOs at least quarterly. However, you may need to update them more frequently during periods of rapid growth, new feature rollouts, or changes in user expectations. Regular reviews ensure alignment with evolving business needs and customer requirements. 
+Review SLOs at least quarterly. However, you may need to update them more frequently during periods of rapid growth, new feature rollouts, or changes in user expectations. Regular reviews ensure alignment with evolving business needs and customer requirements.
 
 ### Can SLO monitoring be applied to all types of services?
 
-Yes, SLO monitoring can be applied to a wide range of services, including: 
+Yes, SLO monitoring can be applied to a wide range of services, including:
 
 - User-Facing Applications: To ensure responsiveness and availability for end users.
 - Internal APIs: To guarantee seamless integrations between systems.
 - Infrastructure Components: To maintain the reliability of the foundational elements of your services.
 
-The key is identifying relevant SLIs that align with the service’s nature and user experience.  
+The key is identifying relevant SLIs that align with the service’s nature and user experience.
 
 ### How do error budgets relate to SLO monitoring?
 
-Error budgets are the permissible amount of unreliability within your SLO. They play a critical role in balancing innovation and reliability. 
+Error budgets are the permissible amount of unreliability within your SLO. They play a critical role in balancing innovation and reliability.
 
 - If your error budget is underutilized, you can confidently focus on feature development or experiments.
 - If your error budget is exhausted, it signals a need to prioritize stability and fix reliability issues before proceeding with new development.
 
-Error budgets provide actionable insights to maintain a balance between delivering new capabilities and ensuring a dependable service.
\ No newline at end of file
+Error budgets provide actionable insights to maintain a balance between delivering new capabilities and ensuring a dependable service.
diff --git a/data/guides/slo-vs-sla.mdx b/data/guides/slo-vs-sla.mdx
index 1ca066269..395b98f52 100644
--- a/data/guides/slo-vs-sla.mdx
+++ b/data/guides/slo-vs-sla.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: SLO vs SLA - Key Differences for Service Management
-slug: slo-vs-sla
 date: 2024-11-20
 tags: [monitoring]
 authors: [sushant_gaurav]
 description: Explore the crucial differences between SLOs and SLAs in service management. Learn how to implement and balance these metrics for optimal performance.
-keywords: [slo vs sla, service level objectives, service level agreements, service management, performance metrics, it operations]
-
+keywords:
+  [
+    slo vs sla,
+    service level objectives,
+    service level agreements,
+    service management,
+    performance metrics,
+    it operations,
+  ]
 ---
 
 In modern service management, Service Level Objectives (SLOs) and Service Level Agreements (SLAs) provide a core framework for establishing, measuring, and sustaining service quality. These notions govern service delivery and guarantee that technical teams and consumer expectations are aligned.
@@ -81,22 +86,23 @@ Crafting an Effective Understanding of the fundamental components of Service Lev
 Understanding the fundamental components of Service Level Objectives (SLOs) is essential for ensuring their effectiveness. Each part of an SLO must be clear, measurable, and aligned with your operational goals to track and enhance service reliability. Let’s now look at the key components of an SLO.
 
 1. Service Level Indicator (SLI)
-    
-    A Service Level Indicator (SLI) is the specific metric used to measure the performance of a service. Common SLIs include metrics like latency (response time), uptime (availability), and error rates (reliability issues).
-    
-    SLIs play a crucial role in bridging the gap between service performance and SLOs by quantifying the user’s experience. For instance, if users often complain about slow application response times, latency might be chosen as the key SLI. By monitoring this metric, organizations gain actionable insights into areas for improvement.
-    
-    How SLIs Measure SLOs:
-    
-    SLIs are the foundation of SLOs, as they provide the measurable data necessary to assess whether a service is meeting its goals. The better the quality and relevance of the SLI chosen, the more accurately it reflects the actual performance experienced by users.
-    
-    Example SLI: The percentage of API requests completed within 200 milliseconds. This metric captures both speed and reliability in real-world conditions.
-    
-    When setting SLIs, it is important to:
-    
-    - Focus on what matters most to your users (e.g., response time for an API or uptime for a website).
-    - Use reliable tools for measuring the SLI, such as observability platforms or logs.
-    - Ensure the SLI is simple to understand and easy to track.
+
+   A Service Level Indicator (SLI) is the specific metric used to measure the performance of a service. Common SLIs include metrics like latency (response time), uptime (availability), and error rates (reliability issues).
+
+   SLIs play a crucial role in bridging the gap between service performance and SLOs by quantifying the user’s experience. For instance, if users often complain about slow application response times, latency might be chosen as the key SLI. By monitoring this metric, organizations gain actionable insights into areas for improvement.
+
+   How SLIs Measure SLOs:
+
+   SLIs are the foundation of SLOs, as they provide the measurable data necessary to assess whether a service is meeting its goals. The better the quality and relevance of the SLI chosen, the more accurately it reflects the actual performance experienced by users.
+
+   Example SLI: The percentage of API requests completed within 200 milliseconds. This metric captures both speed and reliability in real-world conditions.
+
+   When setting SLIs, it is important to:
+
+   - Focus on what matters most to your users (e.g., response time for an API or uptime for a website).
+   - Use reliable tools for measuring the SLI, such as observability platforms or logs.
+   - Ensure the SLI is simple to understand and easy to track.
+
 2. Performance Target: This is the desired level of performance you aim to achieve. For example, "99.9% of requests must be completed within 200 milliseconds." The performance target specifies what “good enough” means for your service and sets a clear expectation for teams and stakeholders.
 3. Time Window: The time window is the duration over which the SLI is measured. Common windows include a rolling 30-day period or a calendar month. Defining the time window ensures consistency in evaluation and accountability.
 4. Error Budget: The error budget represents the permissible amount of failure or deviation from the target before corrective measures are taken. For example, with a 99.9% target, your error budget is the remaining 0.1%—meaning 0.1% of requests can take longer than 200 milliseconds.
@@ -138,43 +144,43 @@ graph TD
 
 ### Implementing Effective SLOs
 
-Let’s now look at the steps to create actionable SLOs, along with explanations of why each step is important and how they contribute to long-term success: 
+Let’s now look at the steps to create actionable SLOs, along with explanations of why each step is important and how they contribute to long-term success:
 
 1. Identify Key Services and User Journeys: You should begin by prioritizing the critical services and user interactions that directly affect customer satisfaction, such as login functionality or payment processing.
-    - Why This Matters: Focusing on these key areas ensures that your SLOs address the most impactful aspects of your service. For example, slow checkout processing in an e-commerce platform can lead to abandoned carts, negatively affecting both revenue and user trust.
-    - How to Do It:
-        - Map user journeys to understand the critical touchpoints (e.g., checkout, search functionality).
-        - Use data from analytics or customer feedback to identify services with the highest user impact.
+   - Why This Matters: Focusing on these key areas ensures that your SLOs address the most impactful aspects of your service. For example, slow checkout processing in an e-commerce platform can lead to abandoned carts, negatively affecting both revenue and user trust.
+   - How to Do It:
+     - Map user journeys to understand the critical touchpoints (e.g., checkout, search functionality).
+     - Use data from analytics or customer feedback to identify services with the highest user impact.
 2. Define Relevant SLIs: You should choose Service Level Indicators (SLIs) that closely represent the user experience, such as page load times, error rates, or latency.
-    - Why This Matters: An irrelevant or poorly chosen SLI may not accurately reflect what users care about, leading to misaligned efforts. For example, measuring uptime alone might overlook performance issues like slow page loads.
-    - How to Do It:
-        - Ensure the chosen SLI aligns with your business goals. For instance, a fast-loading homepage directly supports an e-commerce business’s objective to boost user engagement.
-        - Test the measurability of the SLI to ensure it can be tracked consistently.
+   - Why This Matters: An irrelevant or poorly chosen SLI may not accurately reflect what users care about, leading to misaligned efforts. For example, measuring uptime alone might overlook performance issues like slow page loads.
+   - How to Do It:
+     - Ensure the chosen SLI aligns with your business goals. For instance, a fast-loading homepage directly supports an e-commerce business’s objective to boost user engagement.
+     - Test the measurability of the SLI to ensure it can be tracked consistently.
 3. Set Realistic Targets: You should balance ambition with system capabilities by defining achievable performance levels. For example, rather than aiming for 100% availability, a more realistic target could be 99.95% uptime.
-    - Why This Matters: Unrealistic targets can demoralize teams and lead to overpromised service levels that are ultimately unsustainable. On the other hand, a target that is too lenient fails to challenge the system, missing opportunities for improvement.
-    - How to Do It:
-        - Assess historical performance data to set achievable benchmarks.
-        - Start with a conservative target and raise it incrementally based on system improvements.
+   - Why This Matters: Unrealistic targets can demoralize teams and lead to overpromised service levels that are ultimately unsustainable. On the other hand, a target that is too lenient fails to challenge the system, missing opportunities for improvement.
+   - How to Do It:
+     - Assess historical performance data to set achievable benchmarks.
+     - Start with a conservative target and raise it incrementally based on system improvements.
 4. Align SLOs with Business Objectives: You must ensure that your SLOs are directly tied to your company’s strategic goals. For example, if a streaming platform's goal is to increase user retention, an SLO focused on buffering time or playback interruptions would be ideal.
-    - Why This Matters: When SLOs are aligned with business goals, they become a tool for both technical teams and leadership to work toward shared priorities. Misaligned SLOs can result in wasted resources and efforts on metrics that don’t impact the bottom line.
-    - How to Do It:
-        - Collaborate with stakeholders to understand how service performance influences business KPIs.
-        - Regularly communicate how SLOs contribute to achieving broader objectives.
+   - Why This Matters: When SLOs are aligned with business goals, they become a tool for both technical teams and leadership to work toward shared priorities. Misaligned SLOs can result in wasted resources and efforts on metrics that don’t impact the bottom line.
+   - How to Do It:
+     - Collaborate with stakeholders to understand how service performance influences business KPIs.
+     - Regularly communicate how SLOs contribute to achieving broader objectives.
 5. Involve Stakeholders: You should work closely with technical, product, and business teams to define and maintain SLOs.
-    - Why This Matters: Cross-team collaboration ensures that SLOs are practical, achievable, and aligned with the needs of both users and the business. For instance, developers may provide insights into technical feasibility, while product teams can highlight user priorities.
-    - How to Do It:
-        - Organize workshops or meetings with representatives from all relevant teams.
-        - Clearly define roles and responsibilities for monitoring and revising SLOs.
+   - Why This Matters: Cross-team collaboration ensures that SLOs are practical, achievable, and aligned with the needs of both users and the business. For instance, developers may provide insights into technical feasibility, while product teams can highlight user priorities.
+   - How to Do It:
+     - Organize workshops or meetings with representatives from all relevant teams.
+     - Clearly define roles and responsibilities for monitoring and revising SLOs.
 6. Monitor Proactively: You should use robust monitoring tools such as [SigNoz](https://signoz.io/) to track SLO metrics and detect anomalies in real-time.
-    - Why This Matters: [Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps identify potential issues before they escalate, minimizing downtime and preserving user satisfaction. For example, detecting a rise in latency during high-traffic periods allows teams to act before it affects users.
-    - How to Do It:
-        - Set up alerts for metrics that deviate from defined thresholds.
-        - Use dashboards to visualize trends and track historical performance.
+   - Why This Matters: [Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps identify potential issues before they escalate, minimizing downtime and preserving user satisfaction. For example, detecting a rise in latency during high-traffic periods allows teams to act before it affects users.
+   - How to Do It:
+     - Set up alerts for metrics that deviate from defined thresholds.
+     - Use dashboards to visualize trends and track historical performance.
 7. Review and Iterate Regularly: You should periodically evaluate and update your SLOs to reflect changes in your service or evolving user expectations.
-    - Why This Matters: A static SLO can quickly become irrelevant as user needs and business priorities shift. Continuous improvement ensures that your SLOs remain both relevant and effective.
-    - How to Do It:
-        - Conduct quarterly or biannual reviews to assess whether the SLOs are still aligned with business goals.
-        - Use incident data to identify areas for adjustment or improvement.
+   - Why This Matters: A static SLO can quickly become irrelevant as user needs and business priorities shift. Continuous improvement ensures that your SLOs remain both relevant and effective.
+   - How to Do It:
+     - Conduct quarterly or biannual reviews to assess whether the SLOs are still aligned with business goals.
+     - Use incident data to identify areas for adjustment or improvement.
 
 ### Tips for Continuous Improvement of SLOs
 
@@ -199,18 +205,18 @@ Let us now look at the various key components of an SLA
 
 - Service Description: This section outlines what services will be delivered, including a detailed explanation of the features and functionalities offered. It ensures clarity on what the customer can expect.
 - Performance Metrics: These are measurable targets that define the service quality, such as:
-    - Uptime: The percentage of time the service remains operational.
-    - Response Time: How quickly the provider acknowledges issues.
-    - Resolution Time: The time taken to fix problems.
+  - Uptime: The percentage of time the service remains operational.
+  - Response Time: How quickly the provider acknowledges issues.
+  - Resolution Time: The time taken to fix problems.
 - Responsibilities: It specifies the roles and obligations of both the service provider and the customer. For example:
-    - The provider may handle system maintenance and updates.
-    - The client may need to report issues promptly or maintain their end of the infrastructure.
+  - The provider may handle system maintenance and updates.
+  - The client may need to report issues promptly or maintain their end of the infrastructure.
 - Penalties and Remedies: It defines what happens if the agreed performance standards are not met. This could include:
-    - Service Credits: Compensation like extended service periods.
-    - Reimbursements: Refunds for certain failures.
+  - Service Credits: Compensation like extended service periods.
+  - Reimbursements: Refunds for certain failures.
 - Exclusions: It lists situations where the SLA does not apply, such as:
-    - Natural Disasters: Events like earthquakes or floods.
-    - Scheduled Maintenance: Pre-planned downtime for updates or repairs.
+  - Natural Disasters: Events like earthquakes or floods.
+  - Scheduled Maintenance: Pre-planned downtime for updates or repairs.
 
 Example SLA Metric:
 
@@ -223,7 +229,7 @@ The service will be available 99.95% of the time, measured monthly. Any downtime
 Let’s now take a look at the things that you should keep in mind to create a robust SLA.
 
 1. Be Specific and Measurable: You should use exact measures that do not allow for ambiguity.
-    - For example, "Critical tickets will be resolved within 4 hours" is more effective than "Issues will be resolved quickly".
+   - For example, "Critical tickets will be resolved within 4 hours" is more effective than "Issues will be resolved quickly".
 2. Set Realistic Expectations: You must not over-promise. SLA terms should be based on attainable SLOs, with a buffer for unanticipated difficulties.
 3. Include Review Processes: You should schedule frequent SLA reviews to accommodate changing demands or infrastructure.
 4. Define Communication Channels: You should establish a clear escalation mechanism for reporting and resolving concerns.
@@ -238,7 +244,7 @@ Breaching an SLA can have serious consequences, let’s now look at such consequ
 - Financial Penalties: Refunds or credits for the affected period.
 - Contract Termination: If repeated breaches occur.
 - Reputation Damage: Loss of trust can hurt customer retention.
-For example, if an SLA claims 99.9% uptime but the actual uptime is 99.7%, the service provider may owe the customer service credits for the difference.
+  For example, if an SLA claims 99.9% uptime but the actual uptime is 99.7%, the service provider may owe the customer service credits for the difference.
 
 Example: If an SLA claims 99.9% uptime but the actual uptime is 99.7%, the service provider may owe the customer service credits for the difference.
 
@@ -257,40 +263,40 @@ Although Service Level Objectives (SLOs) and Service Level Agreements (SLAs) are
 So far we have learnt what are SLOs and SLAs. So, let’s now compare them side by side for more clarity.
 
 1. Focus:
-    - SLOs: It is internal performance benchmarks focused on operational efficiency.
-    - SLAs: It is a customer-facing commitment that ensures service reliability.
+   - SLOs: It is internal performance benchmarks focused on operational efficiency.
+   - SLAs: It is a customer-facing commitment that ensures service reliability.
 2. Stakeholders:
-    - SLOs: It primarily concerns internal teams like engineering and operations.
-    - SLAs: It involves both service providers and customers, often including legal teams.
+   - SLOs: It primarily concerns internal teams like engineering and operations.
+   - SLAs: It involves both service providers and customers, often including legal teams.
 3. Flexibility:
-    - SLOs: It is easier to modify based on internal factors, such as changing business priorities.
-    - SLAs: It requires formal renegotiation, often involving legal processes.
+   - SLOs: It is easier to modify based on internal factors, such as changing business priorities.
+   - SLAs: It requires formal renegotiation, often involving legal processes.
 4. Consequences of Non-Compliance:
-    - SLOs: It has internal repercussions, such as initiating reviews and corrective measures.
-    - SLAs: It has external consequences like financial penalties, service credits, or reputational harm.
+   - SLOs: It has internal repercussions, such as initiating reviews and corrective measures.
+   - SLAs: It has external consequences like financial penalties, service credits, or reputational harm.
 5. Metrics:
-    - SLOs: It is typically more granular and technical, focusing on backend metrics like [API latency](https://signoz.io/guides/open-ai-api-latency/).
-    - SLAs: It is broad and customer-centric, emphasizing high-level metrics like uptime.
+   - SLOs: It is typically more granular and technical, focusing on backend metrics like [API latency](https://signoz.io/guides/open-ai-api-latency/).
+   - SLAs: It is broad and customer-centric, emphasizing high-level metrics like uptime.
 6. Enforcement:
-    - SLOs: It is monitored internally without legal obligations.
-    - SLAs: It is legally enforceable, with specific remedies outlined for breaches.
+   - SLOs: It is monitored internally without legal obligations.
+   - SLAs: It is legally enforceable, with specific remedies outlined for breaches.
 7. Timeframe:
-    - SLOs: It is more short-term and adaptable to changing operational needs.
-    - SLAs: It is aligned with contractual agreements, typically long-term.
+   - SLOs: It is more short-term and adaptable to changing operational needs.
+   - SLAs: It is aligned with contractual agreements, typically long-term.
 8. Purpose:
-    - SLOs: It helps to guide internal teams in maintaining and improving system performance.
-    - SLAs: It provides formal assurances to customers regarding service quality.
-
-| Aspect | SLOs (Service Level Objectives) | SLAs (Service Level Agreements) |
-| --- | --- | --- |
-| Focus | Internal performance benchmarks focused on operational efficiency. | Customer-facing commitments ensuring service reliability. |
-| Stakeholders | Primarily concern internal teams like engineering and operations. | Involve service providers, customers, and often legal teams. |
-| Flexibility | Easier to modify based on internal factors (e.g., business priorities). | Require formal renegotiation, often involving legal processes. |
-| Consequences of Non-Compliance | Internal repercussions, such as reviews and corrective measures. | External consequences like financial penalties or service credits. |
-| Metrics | More granular and technical, focusing on backend metrics (e.g., API latency). | Broad, customer-centric metrics like uptime. |
-| Enforcement | Monitored internally with no legal obligations. | Legally enforceable with clear remedies for breaches. |
-| Timeframe | Typically short-term, adaptable to changing operational needs. | Long-term, aligned with contractual periods. |
-| Purpose | Guides internal teams to maintain and improve system performance. | Provides a formal assurance of service quality to customers. |
+   - SLOs: It helps to guide internal teams in maintaining and improving system performance.
+   - SLAs: It provides formal assurances to customers regarding service quality.
+
+| Aspect                         | SLOs (Service Level Objectives)                                               | SLAs (Service Level Agreements)                                    |
+| ------------------------------ | ----------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| Focus                          | Internal performance benchmarks focused on operational efficiency.            | Customer-facing commitments ensuring service reliability.          |
+| Stakeholders                   | Primarily concern internal teams like engineering and operations.             | Involve service providers, customers, and often legal teams.       |
+| Flexibility                    | Easier to modify based on internal factors (e.g., business priorities).       | Require formal renegotiation, often involving legal processes.     |
+| Consequences of Non-Compliance | Internal repercussions, such as reviews and corrective measures.              | External consequences like financial penalties or service credits. |
+| Metrics                        | More granular and technical, focusing on backend metrics (e.g., API latency). | Broad, customer-centric metrics like uptime.                       |
+| Enforcement                    | Monitored internally with no legal obligations.                               | Legally enforceable with clear remedies for breaches.              |
+| Timeframe                      | Typically short-term, adaptable to changing operational needs.                | Long-term, aligned with contractual periods.                       |
+| Purpose                        | Guides internal teams to maintain and improve system performance.             | Provides a formal assurance of service quality to customers.       |
 
 ### The Interrelationship Between SLOs and SLAs
 
@@ -348,9 +354,9 @@ Finding the equilibrium between internal goals (SLOs) and external promises (SLA
 ### Strategies for Alignment
 
 1. Use SLOs to Inform SLAs: Set SLOs slightly higher than SLA commitments to create a buffer.
-    - Example: If your SLA guarantees 99.9% uptime, set your SLO at 99.95%.
+   - Example: If your SLA guarantees 99.9% uptime, set your SLO at 99.95%.
 2. Incorporate Error Budgets: Define acceptable failure thresholds to balance innovation and reliability.
-    - Example: Allocate 0.1% of uptime for maintenance or unexpected issues.
+   - Example: Allocate 0.1% of uptime for maintenance or unexpected issues.
 3. Align Metrics: Ensure internal metrics (SLOs) are directly translatable to customer-facing terms (SLAs).
 4. Continuous Improvement: Use [SLO performance](https://signoz.io/guides/slo-monitoring/) data to adjust SLAs, ensuring customer needs are met.
 5. Transparent Communication: Regularly inform customers about SLA performance to build trust and manage expectations.
@@ -392,7 +398,7 @@ Monitoring and reporting play a critical role in maintaining SLO and SLA complia
 ### How to Set Up SLO Tracking in SigNoz Cloud
 
 1. Sign Up: First, create a SigNoz cloud account.
-<GetStartedSigNoz />
+   <GetStartedSigNoz />
 2. Install the Agent: After creating an account, you can deploy the SigNoz agent on your servers or containers.
 3. Define SLIs and SLOs: Configure performance indicators and objectives in the SigNoz dashboard.
 4. Configure Alerts: Set up automated alerts to notify teams about potential risks.
@@ -405,15 +411,15 @@ For self-hosting enthusiasts: SigNoz also offers an open-source version with sim
 While SLOs and SLAs are powerful tools for service management, their implementation can pose several challenges. Below are common issues and actionable solutions:
 
 1. Setting Realistic Targets: Balancing ambitious goals with achievable performance.
-    - *Solution*: Begin with conservative targets informed by historical data and refine them over time.
+   - _Solution_: Begin with conservative targets informed by historical data and refine them over time.
 2. Aligning Metrics with Business Outcomes: Bridging the gap between technical metrics and business impact.
-    - *Solution*: Collaborate with business stakeholders to identify the metrics that matter most to them.
+   - _Solution_: Collaborate with business stakeholders to identify the metrics that matter most to them.
 3. Ensuring Data Accuracy: Maintaining consistent and reliable SLI measurements across systems.
-    - *Solution*: Standardize monitoring processes and invest in robust tools for accurate tracking.
+   - _Solution_: Standardize monitoring processes and invest in robust tools for accurate tracking.
 4. Managing Customer Expectations: Effectively communicating performance metrics to customers.
-    - *Solution*: Educate customers on SLA metrics, provide transparent updates, and set realistic expectations.
+   - _Solution_: Educate customers on SLA metrics, provide transparent updates, and set realistic expectations.
 5. Adapting to Change: Keeping SLOs and SLAs relevant in dynamic environments.
-    - *Solution*: Regularly review objectives and agreements, building flexibility into SLA terms where possible.
+   - _Solution_: Regularly review objectives and agreements, building flexibility into SLA terms where possible.
 
 ### Example: Overcoming Challenges in a Dynamic Environment
 
@@ -465,9 +471,6 @@ While not every SLO has a matching SLA, establishing strong SLOs creates a solid
 
 ### How do SLOs and SLAs impact customer satisfaction?
 
-SLOs and SLAs improve customer satisfaction by providing explicit and quantifiable expectations for service performance.
-2. Providing openness in service delivery to build confidence.
-3. Showing a dedication to satisfying consumer demands.
-4. Serving as benchmarks for maintaining and exceeding service standards.
+SLOs and SLAs improve customer satisfaction by providing explicit and quantifiable expectations for service performance. 2. Providing openness in service delivery to build confidence. 3. Showing a dedication to satisfying consumer demands. 4. Serving as benchmarks for maintaining and exceeding service standards.
 
-Organizations with well-defined and managed SLOs frequently fulfil or exceed their SLA promises, resulting in high levels of customer confidence and loyalty.
\ No newline at end of file
+Organizations with well-defined and managed SLOs frequently fulfil or exceed their SLA promises, resulting in high levels of customer confidence and loyalty.
diff --git a/data/guides/snmp-monitoring.mdx b/data/guides/snmp-monitoring.mdx
index f682a102e..19dce57b0 100644
--- a/data/guides/snmp-monitoring.mdx
+++ b/data/guides/snmp-monitoring.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: SNMP Monitoring - A Comprehensive Guide for Network Admins
-slug: snmp-monitoring
 date: 2024-08-06
 tags: [monitoring]
 authors: [simran_kumari]
 description: Discover the essentials of SNMP monitoring for network admins. Learn about SNMP versions, implementation best practices, and advanced techniques.
 keywords: [SNMP monitoring, network management, SNMP versions, network metrics, SNMP implementation]
-
 ---
 
 SNMP monitoring forms the backbone of effective network management. As a network admin, you must understand this protocol to maintain optimal network performance. This guide delves into the intricacies of SNMP monitoring, covering everything from its basic principles to advanced implementation techniques.
@@ -20,11 +17,15 @@ SNMP is pivotal in network management because it monitors network performance, d
 
 SNMP (Simple Network Management Protocol) is used to collect data from network devices like routers, switches, and servers. The collected data is then used to monitor and manage these devices to ensure network health and performance.
 
-<Figure src="/img/guides/2024/08/snmp-monitoring-napkin-selection_(14).webp" alt="SNMP Monitoring" caption="SNMP Monitoring" />
+<Figure
+  src="/img/guides/2024/08/snmp-monitoring-napkin-selection_(14).webp"
+  alt="SNMP Monitoring"
+  caption="SNMP Monitoring"
+/>
 
 SNMP Monitoring
 
-SNMP's history dates back to 1988 when it was introduced to address the growing complexity of network management. Since then, it has evolved through several versions, each improving on its predecessor's capabilities and security features. 
+SNMP's history dates back to 1988 when it was introduced to address the growing complexity of network management. Since then, it has evolved through several versions, each improving on its predecessor's capabilities and security features.
 
 ### Key Benefits of Implementing SNMP Monitoring
 
@@ -51,7 +52,11 @@ SNMP relies on three primary operations to manage and monitor network devices:
 
 The overall working of SNMP monitoring can be understood using the architecture diagram below:
 
-<Figure src="/img/guides/2024/08/snmp-monitoring-Untitled.webp" alt="How SNMP Monitoring Works" caption="How SNMP Monitoring Works" />
+<Figure
+  src="/img/guides/2024/08/snmp-monitoring-Untitled.webp"
+  alt="How SNMP Monitoring Works"
+  caption="How SNMP Monitoring Works"
+/>
 
 ### SNMP Data Organization
 
@@ -99,7 +104,11 @@ Key Features:
 
 Use Case: Recommended for most modern networks, especially those requiring stringent security measures. Ideal for enterprises and organizations that need to protect sensitive network management data.
 
-<Figure src="/img/guides/2024/08/snmp-monitoring-Untitled%201.webp" alt="SNMP v1 VS v2 VS v3" caption="SNMP v1 VS v2 VS v3" /> 
+<Figure
+  src="/img/guides/2024/08/snmp-monitoring-Untitled%201.webp"
+  alt="SNMP v1 VS v2 VS v3"
+  caption="SNMP v1 VS v2 VS v3"
+/>{' '}
 
 ### Choosing the Right SNMP Version for Your Network
 
@@ -130,7 +139,11 @@ SNMP allows you to monitor a wide range of network metrics. Here are some essent
 - Disk space: Alerts you to storage capacity issues
 - Environmental metrics: Monitors temperature, fan speeds, and power supply status
 
-<Figure src="/img/guides/2024/08/snmp-monitoring-napkin-selection_(7).webp" alt="SNMP metrics for network monitoring" caption="SNMP metrics for network monitoring" />
+<Figure
+  src="/img/guides/2024/08/snmp-monitoring-napkin-selection_(7).webp"
+  alt="SNMP metrics for network monitoring"
+  caption="SNMP metrics for network monitoring"
+/>
 
 SNMP metrics for network monitoring
 
@@ -138,17 +151,17 @@ By tracking these metrics, you can preemptively identify potential issues and op
 
 ## Implementing SNMP Monitoring: Best Practices
 
- Listed below are some of the best practices for setting up effective SNMP monitoring:
+Listed below are some of the best practices for setting up effective SNMP monitoring:
 
 - Enable SNMP agents on all network devices
 - Configure SNMP managers with appropriate polling intervals
 - Establish secure SNMP communities or user accounts
 - Implement access control lists (ACLs) to restrict SNMP traffic
 - When troubleshooting SNMP issues:
-    - Verify network connectivity between the manager and agents
-    - Check SNMP community strings or authentication credentials
-    - Ensure firewall rules allow SNMP traffic
-    - Review device logs for SNMP-related errors
+  - Verify network connectivity between the manager and agents
+  - Check SNMP community strings or authentication credentials
+  - Ensure firewall rules allow SNMP traffic
+  - Review device logs for SNMP-related errors
 
 ## SNMP Monitoring Tools
 
@@ -184,7 +197,7 @@ While SNMP is a fundamental protocol for network monitoring, it has its limitati
 
 <GetStartedSigNoz />
 
-You can leverage the power of [SigNoz](https://signoz.io/docs/introduction/) alongside SNMP, you gain a more holistic view of your network and applications. 
+You can leverage the power of [SigNoz](https://signoz.io/docs/introduction/) alongside SNMP, you gain a more holistic view of your network and applications.
 
 ## Key Takeaways
 
diff --git a/data/guides/spring-boot-how-to-log-all-requests-and-responses-with-exceptions-in-single-place.mdx b/data/guides/spring-boot-how-to-log-all-requests-and-responses-with-exceptions-in-single-place.mdx
index 227509e1b..64f1544ee 100644
--- a/data/guides/spring-boot-how-to-log-all-requests-and-responses-with-exceptions-in-single-place.mdx
+++ b/data/guides/spring-boot-how-to-log-all-requests-and-responses-with-exceptions-in-single-place.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: How to Log All Spring Boot Requests and Responses - A Guide
-slug: spring-boot-how-to-log-all-requests-and-responses-with-exceptions-in-single-place
 date: 2024-09-11
 tags: [faq]
 authors: [nilesh_sinha]
 description: Learn how to implement comprehensive logging for all requests, responses, and exceptions in Spring Boot applications. A step-by-step guide with advanced techniques.
-keywords: [Spring Boot logging, request logging, response logging, exception handling, centralized logging, observability, SigNoz integration]
-
+keywords:
+  [
+    Spring Boot logging,
+    request logging,
+    response logging,
+    exception handling,
+    centralized logging,
+    observability,
+    SigNoz integration,
+  ]
 ---
 
 Logging is a critical aspect of any robust Spring Boot application. It provides invaluable insights into application behavior, aids in debugging, and enhances overall system observability. But how do you effectively log all requests, responses, and exceptions in a single place? This guide walks you through the process, from basic setup to advanced techniques, ensuring you have a comprehensive logging strategy for your Spring Boot application.
@@ -147,7 +153,7 @@ To log all requests and responses, create a custom interceptor:
 public class LoggingInterceptor implements HandlerInterceptor {
 
 // Logger for this class
-    private static final Logger logger = LoggerFactory.getLogger(LoggingInterceptor.class);  
+    private static final Logger logger = LoggerFactory.getLogger(LoggingInterceptor.class);
 
     @Override
     // Logs HTTP method and URI before the request is handled
@@ -162,7 +168,7 @@ public class LoggingInterceptor implements HandlerInterceptor {
         logger.info("Response: {} {}", response.getStatus(), request.getRequestURI());
         if (ex != null) {
         // Logs any exception
-            logger.error("Exception: ", ex); 
+            logger.error("Exception: ", ex);
         }
     }
 }
@@ -207,11 +213,11 @@ public class LoggingFilter extends OncePerRequestFilter {
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
             throws ServletException, IOException {
-        
+
         // Log request details before processing the request.
-        logger.info("Request: Method={}, URI={}, Headers={}", 
-                    request.getMethod(), 
-                    request.getRequestURI(), 
+        logger.info("Request: Method={}, URI={}, Headers={}",
+                    request.getMethod(),
+                    request.getRequestURI(),
                     getRequestHeaders(request));
 
         long startTime = System.currentTimeMillis();  // Capture the start time to measure processing duration.
@@ -222,15 +228,15 @@ public class LoggingFilter extends OncePerRequestFilter {
             long duration = System.currentTimeMillis() - startTime;  // Calculate how long the request took.
 
             // Log response details after request processing.
-            logger.info("Response: Status={}, URI={}, Duration={}ms, Headers={}", 
-                        response.getStatus(), 
-                        request.getRequestURI(), 
+            logger.info("Response: Status={}, URI={}, Duration={}ms, Headers={}",
+                        response.getStatus(),
+                        request.getRequestURI(),
                         duration,
                         getResponseHeaders(response));
 
             // Log any exceptions that occurred during processing.
             if (request.getAttribute("javax.servlet.error.exception") != null) {
-                logger.error("Exception during request processing", 
+                logger.error("Exception during request processing",
                              (Exception) request.getAttribute("javax.servlet.error.exception"));
             }
         }
@@ -424,7 +430,7 @@ public class LoggingFilter extends OncePerRequestFilter {
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
             throws ServletException, IOException {
-        
+
         try {
             filterChain.doFilter(request, response);
         } finally {
@@ -472,26 +478,25 @@ logger.info("Response time: {} ms", executionTime);
 
 Handling Streaming Responses and Partial Content
 
-1. Streaming Responses:
+1.  Streaming Responses:
+
     - Log Initial Response Information: Log basic details like status and URI before the stream starts.
-    - Track Streaming Progress:  For long-running streams, consider logging periodic updates to track progress. However, be cautious about how often you log these updates, as excessive logging can degrade performance. Rate-limiting your logging (e.g., every few seconds or after certain data thresholds) can help balance the need for information with performance. It has been explained later in the upcoming section how you can ensure logging updates are done in a better way.
-    
+    - Track Streaming Progress: For long-running streams, consider logging periodic updates to track progress. However, be cautious about how often you log these updates, as excessive logging can degrade performance. Rate-limiting your logging (e.g., every few seconds or after certain data thresholds) can help balance the need for information with performance. It has been explained later in the upcoming section how you can ensure logging updates are done in a better way.
+
     ```java
     logger.info("Streaming response started: Status={}, URI={}", response.getStatus(), request.getRequestURI());
     ```
-    
-2. Partial Content:
-When serving partial content (e.g., large file downloads or video streaming), the HTTP 206 status code is used, often accompanied by the `Content-Range` header. Logging this information is crucial for understanding what portion of the content was delivered, especially in case of errors or interruptions.
-    
-    ```java
-    String contentRange = response.getHeader("Content-Range");
-    if (contentRange != null) {
-        logger.info("Partial Content: Range={}", contentRange);
-    }
-    ```
-    
-     Logging partial content is particularly important in scenarios like large file transfers or video streaming, where only a portion of the content is sent at a time. This helps in debugging issues related to incomplete or interrupted content delivery.
-    
+
+2.  Partial Content:
+    When serving partial content (e.g., large file downloads or video streaming), the HTTP 206 status code is used, often accompanied by the `Content-Range` header. Logging this information is crucial for understanding what portion of the content was delivered, especially in case of errors or interruptions.
+        ```java
+        String contentRange = response.getHeader("Content-Range");
+        if (contentRange != null) {
+            logger.info("Partial Content: Range={}", contentRange);
+        }
+        ```
+
+         Logging partial content is particularly important in scenarios like large file transfers or video streaming, where only a portion of the content is sent at a time. This helps in debugging issues related to incomplete or interrupted content delivery.
 
 ## Exception Handling and Logging
 
@@ -515,7 +520,7 @@ public class GlobalExceptionHandler {
 }
 ```
 
-As in the above example, using a `GlobalExceptionHandler`  ensures that all exceptions are handled uniformly, improving the maintainability and reliability of your application.
+As in the above example, using a `GlobalExceptionHandler` ensures that all exceptions are handled uniformly, improving the maintainability and reliability of your application.
 
 ### Logging Stack Traces and Custom Error Messages:
 
@@ -620,7 +625,7 @@ It is important to enhance your logging strategy to improve traceability, perfor
 
 AOP is a programming paradigm that allows you to separate cross-cutting concerns, such as logging, from your main business logic. It helps in applying the same behavior (like logging or security) across multiple methods or classes without duplicating code.
 
-AOP allows you to add logging behavior to your methods without modifying their code. Here’s an example for it where we have used `ProceedingJoinPoint` interface that extends `JoinPoint` . 
+AOP allows you to add logging behavior to your methods without modifying their code. Here’s an example for it where we have used `ProceedingJoinPoint` interface that extends `JoinPoint` .
 A `JoinPoint` is a specific point in the execution of a program where an aspect's advice can be applied. `ProceedingJoinPoint` is a key object in Aspect-Oriented Programming (AOP) used in Spring. It provides access to the method that is being advised and allows you to control its execution.
 
 ```java
@@ -729,91 +734,89 @@ The pattern `%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n` formats log
 ## Performance Considerations and Optimization
 
 1. Balancing Logging Detail with Application Performance: Maintain the right balance between the amount of logging detail and application performance is crucial. Excessive logging can degrade performance due to increased I/O operations and processing overhead.
-For instance, logging every method entry and exit might slow down the application, especially in high-throughput systems. To optimize, log only essential information and use appropriate logging levels (e.g., `INFO`, `DEBUG`, `ERROR`).
+   For instance, logging every method entry and exit might slow down the application, especially in high-throughput systems. To optimize, log only essential information and use appropriate logging levels (e.g., `INFO`, `DEBUG`, `ERROR`).
 2. Implementing Log Sampling for High-Traffic Applications: To handle high traffic without overloading your logging system, you can log a small percentage of events. Here's how you can do it:
-    
-    ```java
-    // Log sampling example: 1% of events
-    import java.util.Random;
-    
-    public class LogSampler {
-        private static final double SAMPLING_RATE = 0.01; // 1% chance
-        private static final Random RANDOM = new Random();
-        private static final Logger logger = LoggerFactory.getLogger(LogSampler.class);
-    
-        public void handleRequest(String requestData) {
-            if (RANDOM.nextDouble() < SAMPLING_RATE) {
-                logger.info("Sampled request: {}", requestData);
-            }
-        }
-    }
-    ```
-    
-    Here, `RANDOM.nextDouble()` checks if a request should be logged based on a 1% probability. This approach helps keep the log volume manageable while still capturing important events.
-    
-3. Using Buffered Logging to Reduce I/O Overhead: Buffered logging boosts performance by temporarily storing log entries in memory and writing them to disk in chunks. This reduces the number of I/O operations, which can slow down your application. 
-    
-    Here’s how you can set it up in Logback:
-    
-    ```xml
-    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
-        <file>logs/myapp.log</file>
-        <encoder>
-            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-        <bufferSize>8192</bufferSize> <!-- 8KB buffer -->
-    </appender>
-    ```
-    
-    This configuration uses an 8KB buffer to collect logs before writing them to disk, improving overall performance.
-    
+
+   ```java
+   // Log sampling example: 1% of events
+   import java.util.Random;
+
+   public class LogSampler {
+       private static final double SAMPLING_RATE = 0.01; // 1% chance
+       private static final Random RANDOM = new Random();
+       private static final Logger logger = LoggerFactory.getLogger(LogSampler.class);
+
+       public void handleRequest(String requestData) {
+           if (RANDOM.nextDouble() < SAMPLING_RATE) {
+               logger.info("Sampled request: {}", requestData);
+           }
+       }
+   }
+   ```
+
+   Here, `RANDOM.nextDouble()` checks if a request should be logged based on a 1% probability. This approach helps keep the log volume manageable while still capturing important events.
+
+3. Using Buffered Logging to Reduce I/O Overhead: Buffered logging boosts performance by temporarily storing log entries in memory and writing them to disk in chunks. This reduces the number of I/O operations, which can slow down your application.
+
+   Here’s how you can set it up in Logback:
+
+   ```xml
+   <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+       <file>logs/myapp.log</file>
+       <encoder>
+           <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
+       </encoder>
+       <bufferSize>8192</bufferSize> <!-- 8KB buffer -->
+   </appender>
+   ```
+
+   This configuration uses an 8KB buffer to collect logs before writing them to disk, improving overall performance.
+
 4. Optimizing Log Storage and Retrieval: In order to keep your logs manageable, you should use tools that support efficient indexing and querying. Regularly archive old logs and ensure your system handles your log volume and access needs. Using structured formats like JSON makes logs easier to search and analyze.
 
 ## Security and Compliance in Logging
 
-1. Mask Sensitive Data: Always mask or redact personally identifiable information (PII), passwords, tokens, and other sensitive data before logging to prevent exposure.
-Let’s consider an example of a `request` that represents an instance of `HttpServletRequest`, which is provided by the servlet container in a Java web application. It encapsulates all the information related to an HTTP request made by the client.
-    
-    Here’s how you can mask sensitive data while logging:
-    
-    ```java
-    // Mask sensitive data before logging
-    String password = request.getParameter("password");
-    String maskedPassword = password != null ? "**" : null;
-    
-    // Log the request with the masked password
-    logger.info("User login attempt: username={}, password={}", username, maskedPassword);
-    ```
-    
-    The `password` is masked by replacing it with asterisks (`**`) before logging.
-    
-2. Implementing Log Encryption: Encrypt logs in transit and at rest in sensitive areas to prevent unwanted access and guarantee data integrity.
-    
+1.  Mask Sensitive Data: Always mask or redact personally identifiable information (PII), passwords, tokens, and other sensitive data before logging to prevent exposure.
+    Let’s consider an example of a `request` that represents an instance of `HttpServletRequest`, which is provided by the servlet container in a Java web application. It encapsulates all the information related to an HTTP request made by the client.
+        Here’s how you can mask sensitive data while logging:
+
+        ```java
+        // Mask sensitive data before logging
+        String password = request.getParameter("password");
+        String maskedPassword = password != null ? "**" : null;
+
+        // Log the request with the masked password
+        logger.info("User login attempt: username={}, password={}", username, maskedPassword);
+        ```
+
+        The `password` is masked by replacing it with asterisks (`**`) before logging.
+2.  Implementing Log Encryption: Encrypt logs in transit and at rest in sensitive areas to prevent unwanted access and guarantee data integrity.
+
     Here’s a simple example using Base64 encoding to simulate encryption. However, in a real application, you would require a stronger encryption method.
-    
+
     ```java
     // Encrypt the log message before logging
     String logMessage = "Sensitive data to log";
     String encryptedMessage = Base64.getEncoder().encodeToString(logMessage.getBytes());
-    
+
     // Log the encrypted message
     logger.info("Encrypted log: {}", encryptedMessage);
     ```
-    
+
     The method `Base64.getEncoder().encodeToString(logMessage.getBytes())` is used to encode a string into its Base64 representation.
     Output:
-    
+
     ```java
     U2Vuc2l0aXZlIGRhdGEgdG8gbG9n
     ```
-    
+
     The encrypted message is logged, ensuring sensitive data is protected.
-    
-3. Making Sure There’s Compliance: Adhere to GDPR, HIPAA, and other relevant regulations by limiting the data logged, obtaining necessary consent, and providing the ability to delete logs containing personal data if required.
-4. Log Retention Policies: Establish clear log retention policies that define how long logs are stored, ensuring they are securely archived and eventually purged according to compliance requirements.
-    
+
+3.  Making Sure There’s Compliance: Adhere to GDPR, HIPAA, and other relevant regulations by limiting the data logged, obtaining necessary consent, and providing the ability to delete logs containing personal data if required.
+4.  Log Retention Policies: Establish clear log retention policies that define how long logs are stored, ensuring they are securely archived and eventually purged according to compliance requirements.
+
     Here’s a way to establish [log retention](https://signoz.io/guides/log-retention/) policies using `Logback` in `logback-spring.xml` :
-    
+
     ```xml
     <configuration>
         <appender name="FILE" class="ch.qos.logback.core.FileAppender">
@@ -827,17 +830,16 @@ Let’s consider an example of a `request` that represents an instance of `HttpS
                 <totalSizeCap>5GB</totalSizeCap> <!-- Maximum size of log files -->
             </rollingPolicy>
         </appender>
-    
+
         <root level="INFO">
             <appender-ref ref="FILE"/>
         </root>
     </configuration>
     ```
-    
+
     This configuration ensures that logs are rolled daily and retains them for 30 days, with a total size cap of 5GB.
     The `<maxHistory>` setting ensures that only the logs from the past 30 days are retained. Logs older than 30 days will be automatically deleted.
     The `<totalSizeCap>` setting limits the combined size of all log files. If the total exceeds 5GB, older logs will be purged to stay within this limit.
-    
 
 ## Key Takeaways
 
@@ -866,4 +868,4 @@ Mask or omit sensitive personal data in logs. Ensure logs are stored securely an
 
 ### Can I use the same logging approach for both monoliths and microservices?
 
-The basic principles remain the same, but microservices require centralized and correlated logging across services. In monoliths, local logging might suffice, but distributed tracing becomes essential in microservices.
\ No newline at end of file
+The basic principles remain the same, but microservices require centralized and correlated logging across services. In monoliths, local logging might suffice, but distributed tracing becomes essential in microservices.
diff --git a/data/guides/sql-server-monitoring.mdx b/data/guides/sql-server-monitoring.mdx
index 2529be77a..bd45dcce9 100644
--- a/data/guides/sql-server-monitoring.mdx
+++ b/data/guides/sql-server-monitoring.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: Top SQL Server Monitoring Tools - A Comprehensive Guide
-slug: sql-server-monitoring
 date: 2024-08-23
 tags: [monitoring]
 authors: [eromosele]
 description: Discover the best SQL Server monitoring tools and practices to optimize database performance, prevent issues, and ensure smooth operations.
-keywords: [SQL Server monitoring, database performance, monitoring tools, performance optimization, database management]
-
+keywords:
+  [
+    SQL Server monitoring,
+    database performance,
+    monitoring tools,
+    performance optimization,
+    database management,
+  ]
 ---
 
 SQL Server monitoring is a critical aspect of database management that ensures optimal performance, prevents issues, and maintains the health of your database systems. As a database administrator or developer, you need to stay on top of your SQL Server's performance to guarantee smooth operations and minimize downtime. This comprehensive guide will walk you through the essentials of SQL Server monitoring, introduce you to built-in tools like SQL Server Profiler, as well as third-party solutions like SigNoz, and provide best practices for implementation.
@@ -24,7 +28,11 @@ Key areas of SQL Server monitoring include:
 - Blocking and Deadlocks: Monitoring for blocking sessions and deadlocks is vital to ensure that transactions are processed smoothly. Addressing these issues promptly can prevent disruptions in database operations.
 - Database Growth and Capacity: Tracking the growth of your databases and ensuring sufficient storage capacity helps avoid unexpected outages or performance degradation due to space constraints.
 
-<Figure src="/img/guides/2024/08/sql-server-monitoring-image.webp" alt="Key factors for optimizing SQL Server" caption="Key factors for optimizing SQL Server" />
+<Figure
+  src="/img/guides/2024/08/sql-server-monitoring-image.webp"
+  alt="Key factors for optimizing SQL Server"
+  caption="Key factors for optimizing SQL Server"
+/>
 
 Effective SQL Server monitoring is crucial for several reasons:
 
@@ -58,90 +66,96 @@ When evaluating SQL Server monitoring tools, look for these key features:
 SQL Server includes several built-in tools that offer valuable monitoring capabilities, helping administrators manage and optimize database performance. Here are the key tools:
 
 1. SQL Server Management Studio (SSMS) Activity Monitor:
-    
-    Activity Monitor is a user-friendly tool within SSMS that provides a quick snapshot of the current state of your SQL Server instance.
-    
-    Key Features:
-    
-    - Displays real-time information on active processes, resource utilization (CPU, memory, disk I/O), and recent expensive queries.
-    - Helps in identifying performance bottlenecks, such as high CPU usage or long-running queries.
-    - Allows quick access to detailed information about specific processes, such as blocking sessions.
+
+   Activity Monitor is a user-friendly tool within SSMS that provides a quick snapshot of the current state of your SQL Server instance.
+
+   Key Features:
+
+   - Displays real-time information on active processes, resource utilization (CPU, memory, disk I/O), and recent expensive queries.
+   - Helps in identifying performance bottlenecks, such as high CPU usage or long-running queries.
+   - Allows quick access to detailed information about specific processes, such as blocking sessions.
+
 2. Extended Events:
-    
-    Extended Events is a highly customizable and lightweight event-handling system built into SQL Server.
-    
-    Key Features:
-    
-    - Allows for fine-grained monitoring of specific events, such as query execution, deadlocks, or errors.
-    - Provides a more efficient alternative to SQL Server Profiler, with less performance overhead.
-    - Enables the creation of custom event sessions to track and log specific actions or conditions within SQL Server.
-    - Supports integration with tools like SSMS and SQL Server Data Tools for advanced monitoring and analysis.
+
+   Extended Events is a highly customizable and lightweight event-handling system built into SQL Server.
+
+   Key Features:
+
+   - Allows for fine-grained monitoring of specific events, such as query execution, deadlocks, or errors.
+   - Provides a more efficient alternative to SQL Server Profiler, with less performance overhead.
+   - Enables the creation of custom event sessions to track and log specific actions or conditions within SQL Server.
+   - Supports integration with tools like SSMS and SQL Server Data Tools for advanced monitoring and analysis.
+
 3. Dynamic Management Views (DMVs) and Functions (DMFs):
-    
-    DMVs and DMFs are powerful tools that expose detailed server state information, allowing administrators to monitor the health, diagnose issues, and tune performance. Examples include `sys.dm_exec_query_stats` for query performance statistics and `sys.dm_os_wait_stats` for identifying wait types affecting server performance.
-    
-    Key Features:
-    
-    - Provide insights into a wide range of metrics, including session activity, query performance, index usage, and resource allocation.
-    - Allow for real-time performance monitoring as well as historical analysis by querying the views.
-    - Offer a programmatic way to access detailed information that can be used in scripts or automated monitoring solutions.
+
+   DMVs and DMFs are powerful tools that expose detailed server state information, allowing administrators to monitor the health, diagnose issues, and tune performance. Examples include `sys.dm_exec_query_stats` for query performance statistics and `sys.dm_os_wait_stats` for identifying wait types affecting server performance.
+
+   Key Features:
+
+   - Provide insights into a wide range of metrics, including session activity, query performance, index usage, and resource allocation.
+   - Allow for real-time performance monitoring as well as historical analysis by querying the views.
+   - Offer a programmatic way to access detailed information that can be used in scripts or automated monitoring solutions.
+
 4. SQL Server Profiler:
-    
-    SQL Server Profiler is a legacy tool that captures and analyzes SQL Server events, such as query execution, transaction start/end, and login/logout activities.
-    
-    Key Features:
-    
-    - Useful for troubleshooting complex performance issues by capturing detailed event traces.
-    - Enables deep analysis of specific queries or workloads to identify causes of performance degradation.
-    - Supports security auditing by capturing login attempts and permission changes.
+
+   SQL Server Profiler is a legacy tool that captures and analyzes SQL Server events, such as query execution, transaction start/end, and login/logout activities.
+
+   Key Features:
+
+   - Useful for troubleshooting complex performance issues by capturing detailed event traces.
+   - Enables deep analysis of specific queries or workloads to identify causes of performance degradation.
+   - Supports security auditing by capturing login attempts and permission changes.
 
 While these built-in tools are powerful, they often require significant expertise to use effectively and may not provide the comprehensive monitoring capabilities that third-party solutions offer. It is generally recommended to use Extended Events for most scenarios due to Profiler's higher resource consumption.
 
 ## Popular Third-Party SQL Server Monitoring Solutions
 
-For those seeking advanced monitoring capabilities beyond the built-in tools provided by SQL Server, several third-party solutions offer robust features tailored to a variety of needs. 
+For those seeking advanced monitoring capabilities beyond the built-in tools provided by SQL Server, several third-party solutions offer robust features tailored to a variety of needs.
 
 1. SigNoz:
-    
-     [SigNoz](https://signoz.io) is an open-source application performance monitoring (APM) tool that includes comprehensive database monitoring capabilities, including support for SQL Server.
-    
-    Key Features:
-    
-    - Provides real-time performance tracking, allowing for immediate detection and resolution of issues.
-    - Includes detailed query analysis tools to help identify and optimize slow-performing queries.
-    - Offers customizable dashboards that enable users to focus on the most critical metrics relevant to their environment.
-    - Supports both [cloud-based](https://signoz.io/docs/cloud/) and [self-hosted](https://signoz.io/docs/install) deployments, offering flexibility depending on organizational needs.
-    - Integrates seamlessly with other parts of the infrastructure, providing a unified view of application and database performance.
+
+   [SigNoz](https://signoz.io) is an open-source application performance monitoring (APM) tool that includes comprehensive database monitoring capabilities, including support for SQL Server.
+
+   Key Features:
+
+   - Provides real-time performance tracking, allowing for immediate detection and resolution of issues.
+   - Includes detailed query analysis tools to help identify and optimize slow-performing queries.
+   - Offers customizable dashboards that enable users to focus on the most critical metrics relevant to their environment.
+   - Supports both [cloud-based](https://signoz.io/docs/cloud/) and [self-hosted](https://signoz.io/docs/install) deployments, offering flexibility depending on organizational needs.
+   - Integrates seamlessly with other parts of the infrastructure, providing a unified view of application and database performance.
+
 2. SolarWinds Database Performance Analyzer:
-    
-    SolarWinds Database Performance Analyzer (DPA) is a widely used tool focused on improving query performance and optimizing database operations.
-    
-    Key Features:
-    
-    - Emphasizes query performance analysis with detailed wait-time data, helping to pinpoint the root cause of slowdowns.
-    - Uses machine learning to detect anomalies, allowing for proactive management of potential issues before they impact performance.
-    - Offers a user-friendly interface with visualizations that make complex performance data easier to understand and act upon.
-    - Supports multiple database platforms, making it a good choice for heterogeneous environments.
+
+   SolarWinds Database Performance Analyzer (DPA) is a widely used tool focused on improving query performance and optimizing database operations.
+
+   Key Features:
+
+   - Emphasizes query performance analysis with detailed wait-time data, helping to pinpoint the root cause of slowdowns.
+   - Uses machine learning to detect anomalies, allowing for proactive management of potential issues before they impact performance.
+   - Offers a user-friendly interface with visualizations that make complex performance data easier to understand and act upon.
+   - Supports multiple database platforms, making it a good choice for heterogeneous environments.
+
 3. Redgate SQL Monitor:
-    
-    Redgate SQL Monitor is a specialized tool for monitoring SQL Server and Azure SQL Database environments, providing detailed insights into performance and health across your database estate.
-    
-    Key Features:
-    
-    - Estate-wide monitoring allows for centralized management of all SQL Server instances, making it easier to manage large environments.
-    - Customizable alerts and dashboards provide targeted monitoring and quick access to critical information.
-    - Detailed reporting capabilities support performance reviews, audits, and compliance efforts.
-    - Integrates with other Redgate tools, offering a comprehensive solution for database management and DevOps practices.
+
+   Redgate SQL Monitor is a specialized tool for monitoring SQL Server and Azure SQL Database environments, providing detailed insights into performance and health across your database estate.
+
+   Key Features:
+
+   - Estate-wide monitoring allows for centralized management of all SQL Server instances, making it easier to manage large environments.
+   - Customizable alerts and dashboards provide targeted monitoring and quick access to critical information.
+   - Detailed reporting capabilities support performance reviews, audits, and compliance efforts.
+   - Integrates with other Redgate tools, offering a comprehensive solution for database management and DevOps practices.
+
 4. IDERA SQL Diagnostic Manager:
-    
-    IDERA SQL Diagnostic Manager offers comprehensive performance monitoring and diagnostics for SQL Server, with a focus on deep-dive analytics and proactive management.
-    
-    Key Features:
-    
-    - Provides real-time monitoring of SQL Server performance, with detailed insights into query execution, resource utilization, and more.
-    - Includes advanced diagnostic tools such as query plan analysis and index optimization recommendations.
-    - Offers capacity planning and forecasting tools, helping organizations plan for future growth and avoid resource shortages.
-    - Supports a wide range of SQL Server environments, including on-premises, cloud, and hybrid setups.
+
+   IDERA SQL Diagnostic Manager offers comprehensive performance monitoring and diagnostics for SQL Server, with a focus on deep-dive analytics and proactive management.
+
+   Key Features:
+
+   - Provides real-time monitoring of SQL Server performance, with detailed insights into query execution, resource utilization, and more.
+   - Includes advanced diagnostic tools such as query plan analysis and index optimization recommendations.
+   - Offers capacity planning and forecasting tools, helping organizations plan for future growth and avoid resource shortages.
+   - Supports a wide range of SQL Server environments, including on-premises, cloud, and hybrid setups.
 
 ### Considerations for Choosing a Third-Party Tool
 
@@ -153,30 +167,34 @@ When selecting a third-party SQL Server monitoring solution, it's important to c
 - Pricing Models and Total Cost of Ownership: Evaluate the cost structure of the tool, including licensing, maintenance, and any additional costs. Open-source solutions like [SigNoz](https://signoz.io) may offer cost advantages over commercial tools.
 - Support and Community Resources: Assess the availability of vendor support, community forums, and other resources to assist with troubleshooting and optimization.
 
-<Figure src="/img/guides/2024/08/sql-server-monitoring-image%201.webp" alt="Choosing a third party SQL Server Monitoring Tool" caption="Choosing a third party SQL Server Monitoring Tool" />
+<Figure
+  src="/img/guides/2024/08/sql-server-monitoring-image%201.webp"
+  alt="Choosing a third party SQL Server Monitoring Tool"
+  caption="Choosing a third party SQL Server Monitoring Tool"
+/>
 
 ## Best Practices for Effective SQL Server Monitoring
 
 To get the most out of your SQL Server monitoring efforts, follow these best practices:
 
 1. Establish baseline performance metrics:
-    - Measure normal performance levels during peak and off-peak hours
-    - Use these baselines to identify deviations and potential issues
+   - Measure normal performance levels during peak and off-peak hours
+   - Use these baselines to identify deviations and potential issues
 2. Set up proactive alerts and thresholds:
-    - Configure alerts for critical performance indicators
-    - Use intelligent thresholds that adapt to your server's typical behavior
+   - Configure alerts for critical performance indicators
+   - Use intelligent thresholds that adapt to your server's typical behavior
 3. Regularly review and analyze monitoring data:
-    - Schedule time to review performance trends and reports
-    - Look for patterns that may indicate emerging issues or areas for optimization
+   - Schedule time to review performance trends and reports
+   - Look for patterns that may indicate emerging issues or areas for optimization
 4. Implement a continuous improvement process:
-    - Use monitoring insights to drive ongoing performance optimization
-    - Regularly update monitoring configurations to align with changing business needs
+   - Use monitoring insights to drive ongoing performance optimization
+   - Regularly update monitoring configurations to align with changing business needs
 5. Monitor from the application perspective:
-    - Track end-user experience and application performance
-    - Correlate database performance with overall application health
+   - Track end-user experience and application performance
+   - Correlate database performance with overall application health
 6. Balance monitoring overhead:
-    - Ensure that monitoring activities don't significantly impact server performance
-    - Use lightweight monitoring methods for continuous tracking and more intensive tools for deep-dive analysis
+   - Ensure that monitoring activities don't significantly impact server performance
+   - Use lightweight monitoring methods for continuous tracking and more intensive tools for deep-dive analysis
 
 ## Implementing SQL Server Monitoring with SigNoz
 
@@ -201,46 +219,49 @@ SigNoz's cloud offering provides a hassle-free setup and managed infrastructure,
 Despite its importance, SQL Server monitoring comes with several challenges:
 
 1. Dealing with large volumes of monitoring data:
-    
-    Solution: 
-    
-    - Use efficient data storage and aggregation techniques
-    - Implement data retention policies to manage historical data effectively
+
+   Solution:
+
+   - Use efficient data storage and aggregation techniques
+   - Implement data retention policies to manage historical data effectively
+
 2. Balancing monitoring overhead with performance impact:
-    
-    Solution:
-    
-    - Use lightweight monitoring methods for continuous tracking
-    - Schedule resource-intensive monitoring tasks during off-peak hours
+
+   Solution:
+
+   - Use lightweight monitoring methods for continuous tracking
+   - Schedule resource-intensive monitoring tasks during off-peak hours
+
 3. Interpreting complex monitoring metrics:
-    
-    Solution: 
-    
-    - Invest in training for your database team
-    - Use monitoring tools that provide clear visualizations and explanations of metrics
+
+   Solution:
+
+   - Invest in training for your database team
+   - Use monitoring tools that provide clear visualizations and explanations of metrics
+
 4. Addressing security concerns in monitoring practices:
-    
-    Solution: 
-    
-    - Implement robust access controls for monitoring tools
-    - Ensure sensitive data is masked or encrypted in monitoring outputs
+
+   Solution:
+
+   - Implement robust access controls for monitoring tools
+   - Ensure sensitive data is masked or encrypted in monitoring outputs
 
 ## Future Trends in SQL Server Monitoring
 
 The field of SQL Server monitoring is experiencing rapid advancements, driven by emerging technologies and evolving best practices. Here are some key trends to watch:
 
 1. AI and Machine Learning in Predictive Monitoring:
-    - Automated Anomaly Detection and Root Cause Analysis: AI-driven tools are increasingly being used to detect anomalies in SQL Server performance metrics automatically. These systems can identify unusual patterns or deviations from normal behavior, helping administrators address potential issues before they escalate. Additionally, AI can assist in pinpointing the root cause of performance problems, reducing the time spent on troubleshooting.
-    - Predictive Capacity Planning and Performance Optimization: Machine learning models are being leveraged to predict future resource needs based on historical data. This allows organizations to plan for capacity upgrades and optimize performance proactively, ensuring that their SQL Server environments can handle growing workloads without performance degradation.
+   - Automated Anomaly Detection and Root Cause Analysis: AI-driven tools are increasingly being used to detect anomalies in SQL Server performance metrics automatically. These systems can identify unusual patterns or deviations from normal behavior, helping administrators address potential issues before they escalate. Additionally, AI can assist in pinpointing the root cause of performance problems, reducing the time spent on troubleshooting.
+   - Predictive Capacity Planning and Performance Optimization: Machine learning models are being leveraged to predict future resource needs based on historical data. This allows organizations to plan for capacity upgrades and optimize performance proactively, ensuring that their SQL Server environments can handle growing workloads without performance degradation.
 2. Cloud-Based and Hybrid Monitoring Solutions:
-    - Seamless Monitoring of On-Premises, Cloud, and Hybrid SQL Server Environments: As more organizations adopt cloud and hybrid infrastructures, the demand for monitoring solutions that can seamlessly track performance across different environments is increasing. These tools provide a unified view of SQL Server performance, whether the database is hosted on-premises, in the cloud, or in a hybrid setup.
-    - Integration with Cloud-Native Monitoring and Observability Platforms: Cloud-native monitoring platforms, such as those provided by major cloud service providers (e.g., Azure Monitor), are becoming more integrated with SQL Server monitoring. This integration allows for enhanced observability, combining application performance monitoring (APM) with database metrics to provide a comprehensive view of system health.
+   - Seamless Monitoring of On-Premises, Cloud, and Hybrid SQL Server Environments: As more organizations adopt cloud and hybrid infrastructures, the demand for monitoring solutions that can seamlessly track performance across different environments is increasing. These tools provide a unified view of SQL Server performance, whether the database is hosted on-premises, in the cloud, or in a hybrid setup.
+   - Integration with Cloud-Native Monitoring and Observability Platforms: Cloud-native monitoring platforms, such as those provided by major cloud service providers (e.g., Azure Monitor), are becoming more integrated with SQL Server monitoring. This integration allows for enhanced observability, combining application performance monitoring (APM) with database metrics to provide a comprehensive view of system health.
 3. Integration with DevOps and Continuous Deployment Practices:
-    - Incorporation of Database Performance Metrics into CI/CD Pipelines: As DevOps practices become more prevalent, there is a growing trend to include database performance monitoring as part of the continuous integration and deployment (CI/CD) pipeline. This integration ensures that performance issues are detected early in the development process, reducing the risk of deploying problematic code to production.
-    - Automated Performance Testing and Validation: Tools are being developed to automate performance testing as part of the deployment process. These tools validate that new code or database changes do not negatively impact performance, ensuring that only optimized, high-performing configurations are released.
+   - Incorporation of Database Performance Metrics into CI/CD Pipelines: As DevOps practices become more prevalent, there is a growing trend to include database performance monitoring as part of the continuous integration and deployment (CI/CD) pipeline. This integration ensures that performance issues are detected early in the development process, reducing the risk of deploying problematic code to production.
+   - Automated Performance Testing and Validation: Tools are being developed to automate performance testing as part of the deployment process. These tools validate that new code or database changes do not negatively impact performance, ensuring that only optimized, high-performing configurations are released.
 4. Automated Remediation and Self-Healing Database Systems:
-    - Intelligent Systems that Can Automatically Resolve Common Issues: Advances in AI and automation are leading to the development of self-healing systems that can automatically resolve common SQL Server issues. For example, these systems might automatically restart a service, reallocate resources, or apply a hotfix when an issue is detected, reducing the need for manual intervention.
-    - Self-Tuning Databases that Optimize Performance Based on Monitoring Insights: Self-tuning databases are becoming more sophisticated, using [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) data to adjust configurations, optimize queries, and manage resources dynamically. This leads to improved performance and efficiency without the need for constant manual tuning by database administrators.
+   - Intelligent Systems that Can Automatically Resolve Common Issues: Advances in AI and automation are leading to the development of self-healing systems that can automatically resolve common SQL Server issues. For example, these systems might automatically restart a service, reallocate resources, or apply a hotfix when an issue is detected, reducing the need for manual intervention.
+   - Self-Tuning Databases that Optimize Performance Based on Monitoring Insights: Self-tuning databases are becoming more sophisticated, using [continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) data to adjust configurations, optimize queries, and manage resources dynamically. This leads to improved performance and efficiency without the need for constant manual tuning by database administrators.
 
 By staying informed about these trends and adopting advanced monitoring practices, you can ensure that your SQL Server environments remain performant, reliable, and ready to meet future challenges.
 
@@ -267,4 +288,4 @@ Yes, monitoring tools can impact performance, especially if not configured prope
 
 ### What's the difference between reactive and proactive monitoring?
 
-Reactive monitoring involves responding to issues after they occur, while [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) aims to identify and address potential problems before they impact users or operations. Proactive monitoring typically involves setting up alerts, analyzing trends, and taking preventive actions based on monitoring data.
\ No newline at end of file
+Reactive monitoring involves responding to issues after they occur, while [proactive monitoring](https://signoz.io/guides/proactive-monitoring/) aims to identify and address potential problems before they impact users or operations. Proactive monitoring typically involves setting up alerts, analyzing trends, and taking preventive actions based on monitoring data.
diff --git a/data/guides/sre-best-practices.mdx b/data/guides/sre-best-practices.mdx
index 3bd621aa0..c855a203d 100644
--- a/data/guides/sre-best-practices.mdx
+++ b/data/guides/sre-best-practices.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: 10 Essential SRE Best Practices for Reliable Systems
-slug: sre-best-practices
 date: 2024-12-05
 tags: [monitoring, SRE]
 authors: [sushant_gaurav]
 description: Discover 10 essential Site Reliability Engineering (SRE) best practices to build and maintain reliable systems. Learn how to implement SRE principles effectively.
-keywords: [SRE best practices, site reliability engineering, system reliability, DevOps, observability, incident management, automation]
-
+keywords:
+  [
+    SRE best practices,
+    site reliability engineering,
+    system reliability,
+    DevOps,
+    observability,
+    incident management,
+    automation,
+  ]
 ---
 
 Site Reliability Engineering (SRE) has become an essential part of modern software development and operations. As systems get advanced and user expectations for dependability rise, organizations must develop strong plans to guarantee their services remain available, performant, and resilient. This post examines 10 fundamental SRE best practices to help you design and manage dependable systems. Whether you're new to SRE or want to improve your current processes, these actionable insights can help you achieve operational excellence.
@@ -20,28 +26,26 @@ Site Reliability Engineering (SRE) is a field that uses software engineering app
 
 1. Embracing Risk: Balancing system dependability and innovation through managed risk-taking for speedier development cycles.
 2. Service Level Objectives (SLOs):
-    - Establishing quantifiable objectives for reliability.
-    - To measure performance, use metrics such as Service Level Indicators (SLIs) and error budgets.
+   - Establishing quantifiable objectives for reliability.
+   - To measure performance, use metrics such as Service Level Indicators (SLIs) and error budgets.
 3. Eliminating Toil
-    - Automating repetitious chores without long-term benefit.
-    - Allowing teams to focus on strategic improvements.
+   - Automating repetitious chores without long-term benefit.
+   - Allowing teams to focus on strategic improvements.
 4. Monitoring and Observability
-    - Obtaining detailed insights into system behaviour via logs, metrics, and traces.
-    - Providing actionable notifications to prevent "alert fatigue".
+   - Obtaining detailed insights into system behaviour via logs, metrics, and traces.
+   - Providing actionable notifications to prevent "alert fatigue".
 
 ### How SRE Differs from Traditional IT Operations
 
-| Aspect | SRE | Traditional IT Operations |
-| --- | --- | --- |
-| Focus | Proactive design and maintenance | Reactive issue resolution |
-| Tools | Automation, observability platforms | Manual processes, monitoring tools |
-| Involvement | Embedded in system architecture | Limited to operational roles |
+| Aspect      | SRE                                 | Traditional IT Operations          |
+| ----------- | ----------------------------------- | ---------------------------------- |
+| Focus       | Proactive design and maintenance    | Reactive issue resolution          |
+| Tools       | Automation, observability platforms | Manual processes, monitoring tools |
+| Involvement | Embedded in system architecture     | Limited to operational roles       |
 
 > Example:
-> 
-> 
+>
 > In a usual IT environment, downtime can result in lengthy resolution periods while teams investigate and manually restore services. In contrast, SRE employs automated rollback techniques and predictive monitoring to proactively reduce downtime.
-> 
 
 ### How Does SRE Integrate with DevOps?
 
@@ -58,7 +62,11 @@ The complexity of modern software systems requires a systematic approach to depe
 
 Microservices, containerization, and distributed architectures have created challenging interdependencies to manage manually. SRE methods such as distributed tracing and [centralized logging](https://signoz.io/blog/centralized-logging/) aid in maintaining visibility.
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image.webp" alt="Interconnections in a microservices architecture" caption="Interconnections in a microservices architecture" />
+<Figure
+  src="/img/guides/2024/12/sre-best-practices-image.webp"
+  alt="Interconnections in a microservices architecture"
+  caption="Interconnections in a microservices architecture"
+/>
 
 The above diagram demonstrates interconnections in a microservices architecture.
 
@@ -76,7 +84,11 @@ As systems grow, manual tasks become a bottleneck. Automation is essential for S
 - Automated incident response.
 - Continuous deployment pipelines.
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%201.webp" alt="An automated incident resolution process." caption="An automated incident resolution process." />
+<Figure
+  src="/img/guides/2024/12/sre-best-practices-image%201.webp"
+  alt="An automated incident resolution process."
+  caption="An automated incident resolution process."
+/>
 
 This sequence diagram illustrates an automated incident resolution process.
 
@@ -98,23 +110,24 @@ Service Level Objectives (SLOs) are important to SRE methods, serving as a commo
 Steps to Set Effective SLOs:
 
 1. Identify Key User Journeys
-    - This includes identifying essential interactions that users experience with your service. For example, in an e-commerce platform, procedures like as product searches, adding products to the basket, and completing checkout are critical.
+   - This includes identifying essential interactions that users experience with your service. For example, in an e-commerce platform, procedures like as product searches, adding products to the basket, and completing checkout are critical.
 2. Determine Metrics: Metrics should appropriately reflect user experiences, including:
-    - Availability: The percentage of time the service is available.
-    - Latency: Response time for critical transactions.
-    - Error Rate is the percentage of unsuccessful requests or activities.
-    - Durability: Storage services that maintain data integrity over time.
+   - Availability: The percentage of time the service is available.
+   - Latency: Response time for critical transactions.
+   - Error Rate is the percentage of unsuccessful requests or activities.
+   - Durability: Storage services that maintain data integrity over time.
 3. Set Realistic Targets
-    - Targets must balance ambition with feasibility.
-    - For example, a startup with minimal resources may strive for 99.5% uptime, but a multinational corporation may aim for 99.99% or higher to fulfil severe SLAs.
+   - Targets must balance ambition with feasibility.
+   - For example, a startup with minimal resources may strive for 99.5% uptime, but a multinational corporation may aim for 99.99% or higher to fulfil severe SLAs.
 4. Regularly Review
-    - Users' requirements and company priorities shift over time.
-    - SLOs must be reviewed regularly to ensure they remain relevant.
+   - Users' requirements and company priorities shift over time.
+   - SLOs must be reviewed regularly to ensure they remain relevant.
 5. Tracking and Visualizing SLOs:
-    - Tools like SigNoz, Prometheus, Datadog, and Grafana let teams track metrics in real time.
-    - Create dynamic dashboards to show trends and notify on breaches. For example, a live SLO dashboard that displays rolling mistake rates over the previous 30 days might offer engineering teams relevant data.
+   - Tools like SigNoz, Prometheus, Datadog, and Grafana let teams track metrics in real time.
+   - Create dynamic dashboards to show trends and notify on breaches. For example, a live SLO dashboard that displays rolling mistake rates over the previous 30 days might offer engineering teams relevant data.
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%202.webp" alt="" caption="" />### Using SLOs to Drive Decisions
+<Figure src="/img/guides/2024/12/sre-best-practices-image%202.webp" alt="" caption="" />
+### Using SLOs to Drive Decisions
 
 SLOs are not only technical measures; they have a direct influence on decision-making.
 
@@ -131,23 +144,24 @@ Incidents are unavoidable, but effective incident management techniques may miti
 ### Building a Comprehensive Incident Response Plan
 
 1. Define Severity Levels
-    - Establish severity levels based on impact.
-        - P0: Complete outage affecting all users.
-        - P1: Partial outage affecting critical features.
-        - P2: Minor issues with no user impact.
+   - Establish severity levels based on impact.
+     - P0: Complete outage affecting all users.
+     - P1: Partial outage affecting critical features.
+     - P2: Minor issues with no user impact.
 2. Assign Clear Roles
-    - Incident Commander: Oversees the response, ensuring coordination.
-    - Scribe: Documents all actions taken during the incident.
-    - Subject Matter Experts (SMEs): Provide specialized technical expertise.
+   - Incident Commander: Oversees the response, ensuring coordination.
+   - Scribe: Documents all actions taken during the incident.
+   - Subject Matter Experts (SMEs): Provide specialized technical expertise.
 3. Establish Communication Protocols
-    - Use tools like Slack, PagerDuty, or Microsoft Teams to centralize communication.
-    - Notify stakeholders (e.g., product managers, customer support) promptly via email or dashboards.
+   - Use tools like Slack, PagerDuty, or Microsoft Teams to centralize communication.
+   - Notify stakeholders (e.g., product managers, customer support) promptly via email or dashboards.
 4. Ensure 24/7 Coverage
-    - Create well-structured on-call schedules with fair rotation to avoid burnout.
+   - Create well-structured on-call schedules with fair rotation to avoid burnout.
 
 Incident Response Workflow
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%203.webp" alt="" caption="" />### Best Practices During Incidents
+<Figure src="/img/guides/2024/12/sre-best-practices-image%203.webp" alt="" caption="" />
+### Best Practices During Incidents
 
 - Triage Efficiently: Quickly analyze the breadth and give severity.
 - Centralized Communication: Use a single, dedicated channel for updates and cooperation.
@@ -171,11 +185,11 @@ Manual, repetitive activities cost valuable engineering time and cause operation
 
 ### Strategies for Automation
 
-| Task | Tool | Example |
-| --- | --- | --- |
-| System Configuration | Ansible, Puppet | Automate VM or container setup |
-| Deployment Processes | Jenkins, GitHub Actions | Automate CI/CD pipelines |
-| Self-Healing Mechanisms | Kubernetes | Automatically restart unhealthy pods |
+| Task                    | Tool                    | Example                              |
+| ----------------------- | ----------------------- | ------------------------------------ |
+| System Configuration    | Ansible, Puppet         | Automate VM or container setup       |
+| Deployment Processes    | Jenkins, GitHub Actions | Automate CI/CD pipelines             |
+| Self-Healing Mechanisms | Kubernetes              | Automatically restart unhealthy pods |
 
 Examples of Self-Healing Systems:
 
@@ -183,7 +197,8 @@ Examples of Self-Healing Systems:
 - Service Restarts: Health probes will automatically restart failing processes.
 - Rollbacks: If a deployment fails, automatically revert to a previous stable version.
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%204.webp" alt="" caption="" />### Balancing Automation with Oversight
+<Figure src="/img/guides/2024/12/sre-best-practices-image%204.webp" alt="" caption="" />
+### Balancing Automation with Oversight
 
 - Automate routine processes, but need human participation for important situations like major incident escalation. Regularly assess automated systems to maintain effectiveness and alignment with growing corporate goals.
 
@@ -202,13 +217,13 @@ Infrastructure as Code (IaC) transforms manual operations into automated workflo
 
 ### Popular IaC Tools
 
-| Tool | Key Features |
-| --- | --- |
-| Terraform | Cloud-agnostic, modular templates |
-| AWS CloudFormation | AWS-specific templates |
-| Ansible | Orchestration and configuration |
-| ARM Templates | Azure-native declarative JSON templates |
-| Bicep Files | Simplified syntax for authoring ARM templates |
+| Tool               | Key Features                                  |
+| ------------------ | --------------------------------------------- |
+| Terraform          | Cloud-agnostic, modular templates             |
+| AWS CloudFormation | AWS-specific templates                        |
+| Ansible            | Orchestration and configuration               |
+| ARM Templates      | Azure-native declarative JSON templates       |
+| Bicep Files        | Simplified syntax for authoring ARM templates |
 
 ### Adopting IaC
 
@@ -221,11 +236,13 @@ Infrastructure as Code (IaC) transforms manual operations into automated workflo
 
 - Validate infrastructure setups using tools such as Terratest and InSpec.
 - Create disposable environments to test changes without interrupting production: Use Infrastructure as Code (IaC) tools to automate the creation of isolated testing environments that mirror production. For instance:
-    1. Use Terraform or CloudFormation to define a staging environment with identical configurations to production.
-    2. Deploy and test your changes in this environment using CI/CD pipelines. This can include functional, performance, or security tests.
-    3. After testing is complete, destroy the environment automatically to minimize costs or clean up scripts in your pipeline.
+  1. Use Terraform or CloudFormation to define a staging environment with identical configurations to production.
+  2. Deploy and test your changes in this environment using CI/CD pipelines. This can include functional, performance, or security tests.
+  3. After testing is complete, destroy the environment automatically to minimize costs or clean up scripts in your pipeline.
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%205.webp" alt="" caption="" />Example: A firm that manages hundreds of microservices utilizes Terraform to create and provision Kubernetes clusters, guaranteeing consistency across staging, testing, and production environments.
+<Figure src="/img/guides/2024/12/sre-best-practices-image%205.webp" alt="" caption="" />
+Example: A firm that manages hundreds of microservices utilizes Terraform to create and provision
+Kubernetes clusters, guaranteeing consistency across staging, testing, and production environments.
 
 ## 5: Implement Gradual and Controlled Rollouts
 
@@ -234,29 +251,35 @@ Gradual rollouts allow teams to release upgrades in phases rather than all at on
 ### Techniques for Progressive Delivery:
 
 1. Canary Releases
-    - Updates are initially given out to a limited number of users or servers, serving as a "canary in a coal mine" for detecting possible problems.
-    - For example, an e-commerce website can test a new payment method with 5% of users to assess success and problems before growing.
-    
-    <Figure src="/img/guides/2024/12/sre-best-practices-image%206.webp" alt="" caption="" />2. Blue-Green Deployments:
-    - Two identical production environments, blue and green, are maintained. Blue represents the current version, while green represents the upgrade.
-    - For example, after certifying the update in green, all user traffic is converted from blue to green, guaranteeing a smooth transition with no downtime.
-    
-    <Figure src="/img/guides/2024/12/sre-best-practices-image%207.webp" alt="" caption="" />3. Feature Flags:
-    - Enable or disable features for certain users or groups without deploying additional code.
-    - For example, a streaming platform might utilize feature flags to launch a new recommendation algorithm exclusively for premium customers, gradually expanding it depending on feedback.
-    
-    <Figure src="/img/guides/2024/12/sre-best-practices-image%208.webp" alt="" caption="" />### Best Practices for Rollout
+
+   - Updates are initially given out to a limited number of users or servers, serving as a "canary in a coal mine" for detecting possible problems.
+   - For example, an e-commerce website can test a new payment method with 5% of users to assess success and problems before growing.
+
+   <Figure src="/img/guides/2024/12/sre-best-practices-image%206.webp" alt="" caption="" />
+   2. Blue-Green Deployments: - Two identical production environments, blue and green, are
+   maintained. Blue represents the current version, while green represents the upgrade. - For
+   example, after certifying the update in green, all user traffic is converted from blue to green,
+   guaranteeing a smooth transition with no downtime.
+
+   <Figure src="/img/guides/2024/12/sre-best-practices-image%207.webp" alt="" caption="" />
+   3. Feature Flags: - Enable or disable features for certain users or groups without deploying
+   additional code. - For example, a streaming platform might utilize feature flags to launch a new
+   recommendation algorithm exclusively for premium customers, gradually expanding it depending on
+   feedback.
+
+   <Figure src="/img/guides/2024/12/sre-best-practices-image%208.webp" alt="" caption="" />
+   ### Best Practices for Rollout
 
 - Define Clear Metrics: Determine what "success" entails—low mistake rates, great user happiness, or consistent performance. Some of the key metrics can be:
-    - Error rates (e.g., a 1% error threshold might trigger a rollback).
-    - Response times (e.g., if the average response time exceeds 2 seconds for more than 10% of requests, trigger a rollback).
-    - User satisfaction (e.g., user complaints or negative feedback surpassing a predefined number).
+  - Error rates (e.g., a 1% error threshold might trigger a rollback).
+  - Response times (e.g., if the average response time exceeds 2 seconds for more than 10% of requests, trigger a rollback).
+  - User satisfaction (e.g., user complaints or negative feedback surpassing a predefined number).
 - Automated Rollbacks: Configure systems to revert changes automatically if mistakes exceed a certain level. The threshold can be defined using:
-    - Error rates: For instance, if the error rate exceeds 5% over a 10-minute window, the system can trigger an automatic rollback.
-    - Performance degradation: If performance metrics (e.g., CPU usage or latency) degrade past a specific threshold, roll back to the previous stable state.
-    - Business KPIs: If specific KPIs (e.g., conversion rates, revenue) drop below a defined threshold within a specified timeframe, initiate the rollback process.
+  - Error rates: For instance, if the error rate exceeds 5% over a 10-minute window, the system can trigger an automatic rollback.
+  - Performance degradation: If performance metrics (e.g., CPU usage or latency) degrade past a specific threshold, roll back to the previous stable state.
+  - Business KPIs: If specific KPIs (e.g., conversion rates, revenue) drop below a defined threshold within a specified timeframe, initiate the rollback process.
 - User feedback: Encourage early adopters to identify the pain points for the mass deployment. Collect user feedback based on the following:
-    - Surveys: Immediate post-deployment surveys will be used to gauge user sentiment.
+  - Surveys: Immediate post-deployment surveys will be used to gauge user sentiment.
 
 Feature Flags in Action:
 
@@ -268,7 +291,7 @@ Feature Flags in Action:
 
 Use tools such as [SigNoz](https://signoz.io/) to compare performance metrics between previous and new releases. Using visual dashboards, you can monitor latency, error rates, and user engagement simultaneously.
 
-Preparing for Rollbacks: 
+Preparing for Rollbacks:
 
 - Test rollback processes before deployments.
 - Automate the rollback method to reduce delays if problems occur.
@@ -281,18 +304,21 @@ In distributed systems, failures are unavoidable. Designing for failure guarante
 
 ### Designing for Failure Principles
 
-<Figure src="/img/guides/2024/12/sre-best-practices-8fa572bb-942f-4cf7-bbe0-d860d2cd5d98.webp" alt="" caption="" />1. Redundancy:
-    - Maintain backup components to guarantee availability.
-    - For example, an online bank replicates user data across different areas, ensuring that even if one fails, it is still available from the others.
-2. Circuit Breakers:
-    - Stop forwarding requests to failing services to avoid further pressure.
-    - For example, if a payment gateway fails, orders can be deferred to avoid overloading the system with retries.
-3. Graceful Degradation:
-    - When system components fail, ensuring essential functionality remains operational.
-    - Example: A streaming service might have a lower video quality when bandwidth is low, rather than stopping playback entirely.
-4. Retry Mechanisms with Backoff:
-    - To avoid overloading services, retries should be made at increasing intervals (backoff).
-    - For example, a messaging app will retry to deliver a message after 2 seconds, 4 seconds, and so on to avoid flooding the server.
+<Figure
+  src="/img/guides/2024/12/sre-best-practices-8fa572bb-942f-4cf7-bbe0-d860d2cd5d98.webp"
+  alt=""
+  caption=""
+/>
+1. Redundancy: - Maintain backup components to guarantee availability. - For example, an online bank
+replicates user data across different areas, ensuring that even if one fails, it is still available
+from the others. 2. Circuit Breakers: - Stop forwarding requests to failing services to avoid
+further pressure. - For example, if a payment gateway fails, orders can be deferred to avoid
+overloading the system with retries. 3. Graceful Degradation: - When system components fail,
+ensuring essential functionality remains operational. - Example: A streaming service might have a
+lower video quality when bandwidth is low, rather than stopping playback entirely. 4. Retry
+Mechanisms with Backoff: - To avoid overloading services, retries should be made at increasing
+intervals (backoff). - For example, a messaging app will retry to deliver a message after 2 seconds,
+4 seconds, and so on to avoid flooding the server.
 
 ### What is chaos engineering?
 
@@ -315,19 +341,23 @@ When an incident occurs, the focus should be on determining what went wrong and
 
 ### Steps for a Blameless Postmortem:
 
-<Figure src="/img/guides/2024/12/sre-best-practices-image%209.webp" alt="Steps for a Blameless Postmortem" caption="Steps for a Blameless Postmortem" />
+<Figure
+  src="/img/guides/2024/12/sre-best-practices-image%209.webp"
+  alt="Steps for a Blameless Postmortem"
+  caption="Steps for a Blameless Postmortem"
+/>
 
 1. Establish a Safe Environment:
-    - Promote openness without fear of penalty.
-    - For example, a team member acknowledges that they pushed defective code without considering the consequences.
+   - Promote openness without fear of penalty.
+   - For example, a team member acknowledges that they pushed defective code without considering the consequences.
 2. Focus on Events, Not People:
-    - Analyze decisions and their context, rather than assigning fault.
-    - For example, "The system allowed deployment without enough tests" rather than "X forgot to test the code."
+   - Analyze decisions and their context, rather than assigning fault.
+   - For example, "The system allowed deployment without enough tests" rather than "X forgot to test the code."
 3. Identify Contributing Factors:
-    - Consider systemic concerns such as lack of automation, confusing processes, and tool restrictions.
+   - Consider systemic concerns such as lack of automation, confusing processes, and tool restrictions.
 4. Define Actionable Items:
-    - Provide specific recommendations to prevent future occurrences.
-    - For example, add automated tests for edge cases causing issues.
+   - Provide specific recommendations to prevent future occurrences.
+   - For example, add automated tests for edge cases causing issues.
 
 ### Key Elements
 
@@ -345,11 +375,11 @@ Observability refers to the ability to comprehend why something is occurring in
 ### Key Observability Components
 
 1. Metrics:
-    - Numerical data representing system performance, such as server CPU usage or API response times.
+   - Numerical data representing system performance, such as server CPU usage or API response times.
 2. Logs:
-    - Detailed event records, useful for debugging issues.
+   - Detailed event records, useful for debugging issues.
 3. Traces:
-    - Tracks the journey of a request across services in a distributed system.
+   - Tracks the journey of a request across services in a distributed system.
 
 ### Building an Observability Stack
 
@@ -372,30 +402,30 @@ Example: A SaaS firm sets an alert for login failures that surpass 1% of total t
 ### Benefits of Using SigNoz
 
 1. [Distributed Tracing](https://signoz.io/distributed-tracing/):
-    - Identify bottlenecks in your system by seeing how requests flow across microservices.
-    - For example, identify a single microservice that slows down the checkout process in an e-commerce application.
+   - Identify bottlenecks in your system by seeing how requests flow across microservices.
+   - For example, identify a single microservice that slows down the checkout process in an e-commerce application.
 2. Metrics Monitoring:
-    - Real-time monitoring of important performance metrics such as CPU, memory, and request latencies.
+   - Real-time monitoring of important performance metrics such as CPU, memory, and request latencies.
 3. Log Management:
-    - Centralize and analyze logs for efficient debugging and issue resolution.
+   - Centralize and analyze logs for efficient debugging and issue resolution.
 4. Custom Dashboards:
-    - Create dashboards that measure crucial indicators and correspond with your service level goals (SLOs).
+   - Create dashboards that measure crucial indicators and correspond with your service level goals (SLOs).
 
 ### Getting Started with SigNoz
 
 1. Install SigNoz.
-<GetStartedSigNoz />
+   <GetStartedSigNoz />
 2. Instrument Your Applications:
-    - Add [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) to your codebase for easy data collecting.
+   - Add [OpenTelemetry SDK](https://signoz.io/comparisons/opentelemetry-api-vs-sdk/) to your codebase for easy data collecting.
 3. Configure Data Sources:
-    - Identify problems in your system by seeing how requests flow across microservices.
-    - For example, identify a single microservice that slows down the checkout process in an e-commerce application.
+   - Identify problems in your system by seeing how requests flow across microservices.
+   - For example, identify a single microservice that slows down the checkout process in an e-commerce application.
 4. Metrics Monitoring:
-    - Real-time monitoring of important performance metrics such as CPU, memory, and request latencies.
+   - Real-time monitoring of important performance metrics such as CPU, memory, and request latencies.
 5. Log Management:
-    - Centralize and analyze logs for efficient debugging and issue resolution.
+   - Centralize and analyze logs for efficient debugging and issue resolution.
 6. Custom Dashboards:
-    - Create dashboards that measure crucial indicators and correspond with your service level goals (SLOs).
+   - Create dashboards that measure crucial indicators and correspond with your service level goals (SLOs).
 
 ### How SigNoz Enhances SRE Practices
 
@@ -436,26 +466,26 @@ Capacity planning guarantees that your systems can effectively manage current de
 ### Key Aspects of Capacity Planning:
 
 1. Forecasting Resource Needs:
-    - Use previous data to estimate future requirements.
-    - For example, use seasonal traffic trends to plan for Christmas sales on an e-commerce site.
+   - Use previous data to estimate future requirements.
+   - For example, use seasonal traffic trends to plan for Christmas sales on an e-commerce site.
 2. Implement Auto-Scaling:
-    - Automatically adjust resources based on real-time requirements.
-    - For example, scale servers up for a product launch and down during off-peak hours.
+   - Automatically adjust resources based on real-time requirements.
+   - For example, scale servers up for a product launch and down during off-peak hours.
 3. Optimize Resource Utilization:
-    - Reallocate unused resources to vital services.
+   - Reallocate unused resources to vital services.
 4. Regularly Review Plans:
-    - Adjust predictions weekly and quarterly to reflect new data and growth patterns.
+   - Adjust predictions weekly and quarterly to reflect new data and growth patterns.
 
 ### Techniques for Capacity Planning
 
 1. Historical Analysis:
-    - Research historical use trends to predict future demands.
-    - For example, a video streaming business predicts increased demand on weekend evenings.
+   - Research historical use trends to predict future demands.
+   - For example, a video streaming business predicts increased demand on weekend evenings.
 2. Machine Learning Models:
-    - Apply ML algorithms to properly estimate resource demands, taking into account complicated factors.
+   - Apply ML algorithms to properly estimate resource demands, taking into account complicated factors.
 3. Scenario Simulations:
-    - Run simulations to prepare for unforeseen surges or breakdowns.
-    - For example, a ticketing platform replicates traffic during a huge concert sale.
+   - Run simulations to prepare for unforeseen surges or breakdowns.
+   - For example, a ticketing platform replicates traffic during a huge concert sale.
 
 To balance cost and performance, use cost management tools like AWS Cost Explorer and Google Cloud Cost Management to identify inefficiencies.
 
@@ -472,20 +502,24 @@ Example: A media platform uses auto-scaling to handle peak traffic during live e
 
 ## Summary Table: 10 Best Practices in SRE
 
-| Practice | Key Focus Areas |
-| --- | --- |
-| 1. Establish and Measure SLOs | Define realistic SLOs, track progress, and use them to guide engineering priorities. |
-| 2. Effective Incident Management | Create response plans, define roles, establish communication channels, and conduct post-incident reviews. |
-| 3. Automate Repetitive Tasks | Reduce toil, automate common tasks, implement self-healing systems, and balance automation. |
-| 4. Adopt Infrastructure as Code (IaC) | Treat infrastructure as code, manage with version control, and validate changes with testing. |
-| 5. Controlled Rollouts | Use canary releases, blue-green deployments, feature flags, and monitoring to ensure smooth rollouts. |
-| 6. Design for Failure and Chaos Engineering | Implement redundancy, graceful degradation, chaos engineering, and disaster simulations. |
-| 7. Blameless Postmortems | Focus on root causes, create psychological safety, and extract actionable insights from failures. |
-| 8. Monitoring and Observability | Measure key metrics, implement tracing/log aggregation, and leverage tools like SigNoz for visibility. |
-| 9. Foster DevOps Collaboration | Break silos, align incentives, and encourage shared reliability responsibility between teams. |
-| 10. Optimize Capacity Planning | Forecast resource needs, use auto-scaling, balance costs, and review capacity regularly. |
-
-<Figure src="/img/guides/2024/12/sre-best-practices-image%2010.webp" alt="10 Best Practices in SRE" caption="10 Best Practices in SRE" />
+| Practice                                    | Key Focus Areas                                                                                           |
+| ------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| 1. Establish and Measure SLOs               | Define realistic SLOs, track progress, and use them to guide engineering priorities.                      |
+| 2. Effective Incident Management            | Create response plans, define roles, establish communication channels, and conduct post-incident reviews. |
+| 3. Automate Repetitive Tasks                | Reduce toil, automate common tasks, implement self-healing systems, and balance automation.               |
+| 4. Adopt Infrastructure as Code (IaC)       | Treat infrastructure as code, manage with version control, and validate changes with testing.             |
+| 5. Controlled Rollouts                      | Use canary releases, blue-green deployments, feature flags, and monitoring to ensure smooth rollouts.     |
+| 6. Design for Failure and Chaos Engineering | Implement redundancy, graceful degradation, chaos engineering, and disaster simulations.                  |
+| 7. Blameless Postmortems                    | Focus on root causes, create psychological safety, and extract actionable insights from failures.         |
+| 8. Monitoring and Observability             | Measure key metrics, implement tracing/log aggregation, and leverage tools like SigNoz for visibility.    |
+| 9. Foster DevOps Collaboration              | Break silos, align incentives, and encourage shared reliability responsibility between teams.             |
+| 10. Optimize Capacity Planning              | Forecast resource needs, use auto-scaling, balance costs, and review capacity regularly.                  |
+
+<Figure
+  src="/img/guides/2024/12/sre-best-practices-image%2010.webp"
+  alt="10 Best Practices in SRE"
+  caption="10 Best Practices in SRE"
+/>
 
 ## Key takeaways
 
@@ -504,16 +538,16 @@ Example: A media platform uses auto-scaling to handle peak traffic during live e
 To succeed as an SRE, you need a combination of technical and interpersonal abilities, including:
 
 - Technical Skills:
-    - Include programming and scripting (e.g., Python, Go, and Bash).
-    - Linux/Unix system administration.
-    - network and cloud platforms (AWS, GCP, Azure)
-    - Frameworks for observing and monitoring
-    - Automation and Infrastructure as Code (e.g., Terraform and Ansible)
-    - Incident management and performance modification.
+  - Include programming and scripting (e.g., Python, Go, and Bash).
+  - Linux/Unix system administration.
+  - network and cloud platforms (AWS, GCP, Azure)
+  - Frameworks for observing and monitoring
+  - Automation and Infrastructure as Code (e.g., Terraform and Ansible)
+  - Incident management and performance modification.
 - Soft Skills:
-    - Clear communication and teamwork
-    - Problem-solving and critical thinking
-    - Capability to manage high-pressure circumstances.
+  - Clear communication and teamwork
+  - Problem-solving and critical thinking
+  - Capability to manage high-pressure circumstances.
 
 ### How does SRE differ from traditional IT operations?
 
@@ -551,4 +585,4 @@ Adopting SRE has its own set of challenges:
 6. Managing Toil: Reducing repetitious manual work is a continual process that needs continuous review.
 7. Scaling Practices: Adjusting SRE methodologies to accommodate organizational growth and complexity is a challenging process.
 
-To address these challenges, firms must invest in education, leadership buy-in, and tailored solutions that fit their unique needs.
\ No newline at end of file
+To address these challenges, firms must invest in education, leadership buy-in, and tailored solutions that fit their unique needs.
diff --git a/data/guides/sre-metrics.mdx b/data/guides/sre-metrics.mdx
index faffa1a69..2587f6f98 100644
--- a/data/guides/sre-metrics.mdx
+++ b/data/guides/sre-metrics.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: 10 Essential SRE Metrics for Reliable Systems
-slug: sre-metrics
 date: 2024-12-19
 tags: [SRE, DevOps, Monitoring, Observability]
 authors: [niyati_thakkar]
 description: Discover the 10 essential SRE metrics that ensure system reliability. Learn how to implement and leverage these metrics for optimal performance.
-keywords: [sre metrics, site reliability engineering, system monitoring, devops, observability, performance metrics]
-
+keywords:
+  [
+    sre metrics,
+    site reliability engineering,
+    system monitoring,
+    devops,
+    observability,
+    performance metrics,
+  ]
 ---
 
 Site Reliability Engineering (SRE) metrics guide your system's performance and reliability. In the fast-paced world of DevOps, success begins with effective monitoring. By blending software development with IT operations, SRE builds resilient, scalable systems that balance speed with reliability. SRE ensures visibility into system health and performance through data-driven metrics and cross-team collaboration.
@@ -30,7 +35,6 @@ SRE metrics are quantifiable measures that provide actionable insights into a sy
 By fostering a data-driven culture, SRE metrics empower teams to communicate effectively and prioritize reliability without compromising development speed. This approach has been popularized by companies like Google, where SRE originated in 2003 under Ben Treynor, who described it as:
 
 > “What happens when you ask a software engineer to design an operations function.”
-> 
 
 Modern [SRE practices](https://signoz.io/guides/sre-best-practices/) leverage tools to monitor Service-Level Indicators (SLIs), Service-Level Objectives (SLOs), and Service-Level Agreements (SLAs)—the pillars of measuring system reliability. By embedding these metrics into DevOps workflows, organizations can better navigate the complexities of distributed systems and ensure long-term resilience.
 
@@ -38,7 +42,11 @@ Modern [SRE practices](https://signoz.io/guides/sre-best-practices/) leverage to
 
 Google's SRE team introduced the concept of Four Golden Signals — a set of metrics that provide a holistic view of system health. These signals form the cornerstone of effective SRE practices:
 
-<Figure src="/img/guides/2024/12/sre-metrics-image.webp" alt="The four golden Signals" caption="The four golden Signals" />
+<Figure
+  src="/img/guides/2024/12/sre-metrics-image.webp"
+  alt="The four golden Signals"
+  caption="The four golden Signals"
+/>
 
 1. Latency: How long does it take to serve a request?
 2. Traffic: How many requests is your system handling?
@@ -51,7 +59,7 @@ Let's dive deeper into each of these signals:
 
 Latency measures the time it takes for a system to respond to a request. High latency can frustrate users and lead to churn, especially in applications like e-commerce or streaming, where speed is crucial.
 
-<Figure src="/img/guides/2024/12/sre-metrics-Request.webp" alt="Latency" caption="Latency" /> 
+<Figure src="/img/guides/2024/12/sre-metrics-Request.webp" alt="Latency" caption="Latency" />{' '}
 
 Imagine a streaming service with latency exceeding 3 seconds. Users may perceive buffering as a failure, leading to subscription cancellations. It's critical to monitor average latency and focus on percentiles (e.g., 95th or 99th) to capture edge cases that affect user experience.
 
@@ -92,7 +100,11 @@ Tools & Implementation:
 
 Example: Configuring autoscaling for application servers based on traffic patterns ensures your system adapts to demand fluctuations.
 
-<Figure src="/img/guides/2024/12/sre-metrics-Request_(5).webp" alt="Auto-Scaling" caption="Auto-Scaling" />
+<Figure
+  src="/img/guides/2024/12/sre-metrics-Request_(5).webp"
+  alt="Auto-Scaling"
+  caption="Auto-Scaling"
+/>
 
 Auto-Scaling
 
@@ -102,7 +114,11 @@ Errors track the rate of failed requests, whether they’re caused by server-sid
 
 A 5% error rate in payment gateway requests can lead to significant revenue loss and user dissatisfaction. Categorizing errors (e.g., payment failures vs. UI glitches) helps in prioritizing resolutions effectively.
 
-<Figure src="/img/guides/2024/12/sre-metrics-Request_(4).webp" alt="Error Rate" caption="Error Rate" />
+<Figure
+  src="/img/guides/2024/12/sre-metrics-Request_(4).webp"
+  alt="Error Rate"
+  caption="Error Rate"
+/>
 
 Error Rate
 
@@ -127,9 +143,13 @@ Saturation measures resource usage, such as CPU, memory, and disk space, relativ
 
 A database server operating at 90% disk I/O capacity may slow down application queries, causing latency spikes and failed transactions. [Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) of saturation can prevent such issues.
 
-<Figure src="/img/guides/2024/12/sre-metrics-Request_(6).webp" alt="Saturation" caption="Saturation" />
+<Figure
+  src="/img/guides/2024/12/sre-metrics-Request_(6).webp"
+  alt="Saturation"
+  caption="Saturation"
+/>
 
-Saturation 
+Saturation
 
 Key Considerations:
 
@@ -199,7 +219,9 @@ Consider three incidents:
 
 Calculation:
 
-<Figure src="/img/guides/2024/12/sre-metrics-image%201.webp" alt="" caption="" />This means, on average, issues were detected within 36.67 minutes, highlighting the monitoring system’s efficiency.
+<Figure src="/img/guides/2024/12/sre-metrics-image%201.webp" alt="" caption="" />
+This means, on average, issues were detected within 36.67 minutes, highlighting the monitoring
+system’s efficiency.
 
 To improve MTTD:
 
@@ -213,7 +235,7 @@ MTTR tracks how long it takes to resolve issues once they're detected. It's a ke
 
 Strategies to reduce MTTR:
 
-- Develop and refine incident response playbooks.  For example, create a database outage playbook that includes steps for failing over to a replica and notifying stakeholders.
+- Develop and refine incident response playbooks. For example, create a database outage playbook that includes steps for failing over to a replica and notifying stakeholders.
 - Implement automation for common remediation tasks. For instance, automatically restart a crashed service when CPU utilization exceeds a defined threshold.
 - Conduct thorough post-mortems to prevent recurring issues. For example, after a server crash caused by memory leaks, deploy monitoring to alert the team when memory usage spikes.
 
@@ -239,7 +261,11 @@ Selecting the right metrics for your system requires careful consideration:
 6. Prioritize Actionable Metrics: Choose metrics that not only indicate problems but also provide insights into how to fix them. Metrics like mean time to repair (MTTR) or error rates can guide actionable responses.
 7. Benchmarking and Coverage: Ensure your metrics are comprehensive, covering all critical components of your infrastructure. Use them to benchmark against industry standards while maintaining alignment with internal goals.
 
-<Figure src="/img/guides/2024/12/sre-metrics-How_to_Choose_the_Right_SRE_Metrics_for_Your_System.webp" alt="Choosing right SRE metrics" caption="Choosing right SRE metrics" />
+<Figure
+  src="/img/guides/2024/12/sre-metrics-How_to_Choose_the_Right_SRE_Metrics_for_Your_System.webp"
+  alt="Choosing right SRE metrics"
+  caption="Choosing right SRE metrics"
+/>
 
 Remember, the goal is to have a set of metrics that provide actionable insights, not just data for data's sake.
 
@@ -247,15 +273,15 @@ Remember, the goal is to have a set of metrics that provide actionable insights,
 
 To get the most value from your SRE metrics:
 
-| Practice | Key Action | Example/Benefit |
-| --- | --- | --- |
-| Implement Monitoring & Observability | Use tools like Prometheus, Datadog, Grafana for tracking metrics, logs, and traces. | Get real-time system visibility and early issue detection. |
-| Set Clear SLOs | Define realistic Service Level Objectives aligned with business goals. | Example: Set a 99.9% uptime SLO for critical services. |
-| Regular Post-Mortems & Improvement Cycles | Analyze incidents, identify root causes, and adjust processes. | Review trends to improve response and reduce bottlenecks. |
-| Automate Monitoring | Automate data collection, metric analysis, and incident responses. | Example: Auto-remediate memory issues by restarting services. |
-| Foster a Blameless Culture | Encourage open discussions on failures without assigning blame. | Focus on solutions and collective ownership of reliability. |
-| Provide Continuous Education | Train the team on SRE tools, practices, and techniques regularly. | Access resources like SRE books, blogs, and workshops. |
-| Encourage Shared Responsibility | Promote collaboration between development and operations teams. | Adopt a DevOps mindset; developers monitor their apps in production. |
+| Practice                                  | Key Action                                                                          | Example/Benefit                                                      |
+| ----------------------------------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| Implement Monitoring & Observability      | Use tools like Prometheus, Datadog, Grafana for tracking metrics, logs, and traces. | Get real-time system visibility and early issue detection.           |
+| Set Clear SLOs                            | Define realistic Service Level Objectives aligned with business goals.              | Example: Set a 99.9% uptime SLO for critical services.               |
+| Regular Post-Mortems & Improvement Cycles | Analyze incidents, identify root causes, and adjust processes.                      | Review trends to improve response and reduce bottlenecks.            |
+| Automate Monitoring                       | Automate data collection, metric analysis, and incident responses.                  | Example: Auto-remediate memory issues by restarting services.        |
+| Foster a Blameless Culture                | Encourage open discussions on failures without assigning blame.                     | Focus on solutions and collective ownership of reliability.          |
+| Provide Continuous Education              | Train the team on SRE tools, practices, and techniques regularly.                   | Access resources like SRE books, blogs, and workshops.               |
+| Encourage Shared Responsibility           | Promote collaboration between development and operations teams.                     | Adopt a DevOps mindset; developers monitor their apps in production. |
 
 Following these practices creates a feedback loop that continuously improves your system's reliability.
 
@@ -304,8 +330,13 @@ Visualizing SRE metrics is crucial for making informed, data-driven decisions. S
 
 SigNoz allows you to track latency across various endpoints and services in real-time. You can set up detailed dashboards to monitor:
 
-<Figure src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.09.272x.webp" alt="" caption="" />- Average Latency: Provides a general overview of system responsiveness.
-- Percentile Metrics (e.g., 95th, 99th): Focus on edge cases that might negatively impact user experience.
+<Figure
+  src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.09.272x.webp"
+  alt=""
+  caption=""
+/>
+- Average Latency: Provides a general overview of system responsiveness. - Percentile Metrics (e.g.,
+95th, 99th): Focus on edge cases that might negatively impact user experience.
 
 Using SigNoz, you can create alerts for latency thresholds, such as response times exceeding 500ms for critical services. With its OpenTelemetry integration, you can pinpoint high-latency endpoints and analyze [distributed traces](https://signoz.io/blog/distributed-tracing/) to identify bottlenecks.
 
@@ -313,14 +344,25 @@ Using SigNoz, you can create alerts for latency thresholds, such as response tim
 
 Monitor system traffic to understand the volume of requests and user interactions. SigNoz enables you to:
 
-<Figure src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.34.072x.webp" alt="" caption="" />- Visualize Traffic Trends: Analyze request rates over time to detect peaks and anomalies.
-- Correlate Metrics: Connect traffic patterns with other metrics like latency and saturation to diagnose issues.
+<Figure
+  src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.34.072x.webp"
+  alt=""
+  caption=""
+/>
+- Visualize Traffic Trends: Analyze request rates over time to detect peaks and anomalies. -
+Correlate Metrics: Connect traffic patterns with other metrics like latency and saturation to
+diagnose issues.
 
 For example, during a flash sale, use SigNoz to ensure your system scales dynamically and handles increased demand seamlessly.
 
 ### Errors
 
-<Figure src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.41.322x.webp" alt="" caption="" />SigNoz provides robust error tracking capabilities, allowing you to:
+<Figure
+  src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.41.322x.webp"
+  alt=""
+  caption=""
+/>
+SigNoz provides robust error tracking capabilities, allowing you to:
 
 - Categorize Errors: Distinguish between client-side, server-side, and third-party issues.
 - Analyze Trends: Identify recurring error patterns over time to proactively resolve issues.
@@ -330,9 +372,14 @@ With its detailed logs and trace data, SigNoz helps you trace the root cause of
 
 ### Saturation
 
-Stay ahead of resource exhaustion by monitoring saturation metrics such as CPU, memory, and disk utilization. 
+Stay ahead of resource exhaustion by monitoring saturation metrics such as CPU, memory, and disk utilization.
 
-<Figure src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.42.162x.webp" alt="" caption="" />SigNoz enables you to:
+<Figure
+  src="/img/guides/2024/12/sre-metrics-CleanShot_2024-12-19_at_14.42.162x.webp"
+  alt=""
+  caption=""
+/>
+SigNoz enables you to:
 
 - Set Resource Alerts: Receive notifications when resources approach critical thresholds (e.g., 80% CPU usage).
 - Plan for Scaling: Use saturation trends to forecast capacity needs and plan resource allocation effectively.
@@ -381,4 +428,4 @@ Absolutely. SRE metrics can help teams of any size improve their system reliabil
 
 ### How do SRE metrics relate to customer satisfaction and business outcomes?
 
-SRE metrics directly impact user experience. For example, low latency and high availability translate to satisfied customers, while frequent errors can lead to frustration and churn. By improving these metrics, you directly enhance customer satisfaction and business outcomes.
\ No newline at end of file
+SRE metrics directly impact user experience. For example, low latency and high availability translate to satisfied customers, while frequent errors can lead to frustration and churn. By improving these metrics, you directly enhance customer satisfaction and business outcomes.
diff --git a/data/guides/sre-principles.mdx b/data/guides/sre-principles.mdx
index 87b9b3abd..cf2e46cfe 100644
--- a/data/guides/sre-principles.mdx
+++ b/data/guides/sre-principles.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: 10 Essential SRE Principles for Reliable Systems
-slug: sre-principles
 date: 2024-11-29
 tags: [monitoring]
 authors: [soumya_gupta]
 description: Discover 10 essential SRE principles to build and maintain reliable systems. Learn how to implement these practices for improved system performance and user satisfaction.
-keywords: [SRE Principles, Site Reliability Engineering, System Reliability, DevOps, Observability, Automation, SLOs]
-
+keywords:
+  [
+    SRE Principles,
+    Site Reliability Engineering,
+    System Reliability,
+    DevOps,
+    Observability,
+    Automation,
+    SLOs,
+  ]
 ---
 
 Site Reliability Engineering (SRE) transforms how organizations build and maintain reliable systems. As software becomes increasingly complex, the need for robust, scalable, and resilient systems grows. SRE principles provide a framework for achieving these goals. This article explores 10 essential SRE principles that form the foundation of reliable systems. You'll learn how to implement these practices to improve system performance, reduce downtime, and enhance user satisfaction.
@@ -67,22 +73,30 @@ Site Reliability Engineering is a discipline that applies software engineering p
 
 ### SRE v/s traditional IT operations
 
-<Figure src="/img/guides/2024/11/sre-principles-image.webp" alt="Venn Diagram of DEV, SRE, OPS" caption="Venn Diagram of DEV, SRE, OPS" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image.webp"
+  alt="Venn Diagram of DEV, SRE, OPS"
+  caption="Venn Diagram of DEV, SRE, OPS"
+/>
 
 Let’s look at a tabular comparison for the same:
 
-| Aspect | Site Reliability Engineering (SRE) | Traditional IT Operations |
-| --- | --- | --- |
-| Primary Goal | Focuses on reliability, scalability, and automation | Emphasizes availability and incident resolution |
-| Responsibility | Shared accountability with development teams (DevOps-oriented) | Dedicated operations team, often separate from developers |
-| Key Metric | Service Level Objectives (SLOs) and Error Budgets | Service Level Agreements (SLAs) |
-| Approach to Incidents | Blameless postmortems to learn and improve | Root cause analysis to prevent recurrence |
-| Automation | High priority on automation and self-healing systems | Often manual processes and reliance on monitoring tools |
-| Tooling | Uses advanced observability tools, automation, and CI/CD | Traditional monitoring tools, incident management systems |
+| Aspect                | Site Reliability Engineering (SRE)                             | Traditional IT Operations                                 |
+| --------------------- | -------------------------------------------------------------- | --------------------------------------------------------- |
+| Primary Goal          | Focuses on reliability, scalability, and automation            | Emphasizes availability and incident resolution           |
+| Responsibility        | Shared accountability with development teams (DevOps-oriented) | Dedicated operations team, often separate from developers |
+| Key Metric            | Service Level Objectives (SLOs) and Error Budgets              | Service Level Agreements (SLAs)                           |
+| Approach to Incidents | Blameless postmortems to learn and improve                     | Root cause analysis to prevent recurrence                 |
+| Automation            | High priority on automation and self-healing systems           | Often manual processes and reliance on monitoring tools   |
+| Tooling               | Uses advanced observability tools, automation, and CI/CD       | Traditional monitoring tools, incident management systems |
 
 ## Why SRE Principles Matter for System Reliability
 
-<Figure src="/img/guides/2024/11/sre-principles-image%201.webp" alt="SRE Principles" caption="SRE Principles" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%201.webp"
+  alt="SRE Principles"
+  caption="SRE Principles"
+/>
 
 SRE principles significantly impact system performance and user satisfaction. By implementing these principles, organizations can:
 
@@ -103,7 +117,11 @@ Initial investments in [SRE tools](https://signoz.io/comparisons/sre-tools/) and
 
 You might think aiming for 100% reliable services is ideal, but past a certain point, extreme reliability does more harm than good. Pushing for perfection slows down feature development, delays product delivery, and drives up costs, limiting what teams can offer. Interestingly, users often can’t distinguish between high and near-perfect reliability because other factors dominate their experience. For instance, a streaming platform that works flawlessly won’t matter much if the user’s internet connection buffers every few minutes.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%202.webp" alt="Key aspects of embracing risk" caption="Key aspects of embracing risk" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%202.webp"
+  alt="Key aspects of embracing risk"
+  caption="Key aspects of embracing risk"
+/>
 
 That’s why Site Reliability Engineering focuses on balancing availability with rapid innovation and efficient operations, optimizing overall user satisfaction across features, performance, and service.
 
@@ -136,7 +154,7 @@ Error Budget = (1 - 0.999) * 30 days
 
 This means the service can afford up to 43.2 minutes of downtime in a month while still meeting its SLO
 
-In essence, SLIs provide the data, SLOs set the targets based on that data, and error budgets allow teams to balance reliability with the need for rapid innovation. 
+In essence, SLIs provide the data, SLOs set the targets based on that data, and error budgets allow teams to balance reliability with the need for rapid innovation.
 
 To effectively manage risk:
 
@@ -148,14 +166,18 @@ To effectively manage risk:
 
 To manage a service effectively, it’s essential to understand the key behaviors that matter and how to measure them. This involves defining and delivering a specific level of service to users, whether through an internal API or a public product.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%203.webp" alt="Service Reliability: SLA, SLO, SLI" caption="Service Reliability: SLA, SLO, SLI" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%203.webp"
+  alt="Service Reliability: SLA, SLO, SLI"
+  caption="Service Reliability: SLA, SLO, SLI"
+/>
 
 Service Level Objectives (SLOs) are a critical component of SRE practices. They are a tool to help determine what engineering work to prioritize. These metrics outline what matters, the desired values, and the response if expectations aren’t met. Properly chosen metrics guide corrective actions during issues and assure SRE teams of a service’s health.
 
-| Term | Definition | Example |
-| --- | --- | --- |
-| SLI (Service Level Indicator) | A quantitative measure of service performance or reliability. | Request latency, error rate, uptime percentage. |
-| SLO (Service Level Objective) | A target value or range for an SLI that defines acceptable performance. | 99.9% of requests should have latency < 200ms. |
+| Term                          | Definition                                                                        | Example                                                 |
+| ----------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| SLI (Service Level Indicator) | A quantitative measure of service performance or reliability.                     | Request latency, error rate, uptime percentage.         |
+| SLO (Service Level Objective) | A target value or range for an SLI that defines acceptable performance.           | 99.9% of requests should have latency < 200ms.          |
 | SLA (Service Level Agreement) | A formal agreement between provider and customer specifying service expectations. | Uptime of 99.5% per month, with penalties for breaches. |
 
 ### Establish Effective SLOs:
@@ -167,18 +189,18 @@ Service Level Objectives (SLOs) are a critical component of SRE practices. They
 
 ## 3. Eliminating Toil Through Automation
 
-Toil is the kind of work tied to running a production service that tends to be manual, repetitive, automatable, tactical, devoid of enduring value, and that scales linearly as a service grows. Not every task deemed toil has all these attributes. So then, how do we identify it? 
+Toil is the kind of work tied to running a production service that tends to be manual, repetitive, automatable, tactical, devoid of enduring value, and that scales linearly as a service grows. Not every task deemed toil has all these attributes. So then, how do we identify it?
 
-  The following descriptions should provide some insight: 
+The following descriptions should provide some insight:
 
-| Title | Description |
-| --- | --- |
-| Manual | Automation should replace manual tasks, not just speed them up. For example, running a script to automate a series of processes might save time compared to doing each step manually. However, if a person still needs to actively execute the script, the time spent doing so counts as toil, since the goal is to eliminate human involvement in repetitive tasks |
-| Repetitive | If you're tackling a task for the first time—or even the second time—this isn't considered toil. Toil refers to repetitive work you do repeatedly. If you're addressing a new problem or coming up with a unique solution, that work isn't toil either. |
-| Automatable | If a machine could perform the task as effectively as a human, or if the task could be eliminated through better design, then it's considered toil. |
-| Tactical | Toil is reactive and often driven by interruptions, rather than being proactive or aligned with strategy. For example, responding to pager alerts is toil—urgent and disruptive. While it’s hard to eliminate entirely, the goal is to minimize its impact and focus on more strategic work |
-| No enduring value | If completing a task leaves your service unchanged, it's likely toil. However, if the task results in a lasting improvement to your service, it probably wasn't toil, even if it involved some tedious work, like cleaning up legacy code and configurations. |
-| O(n) with service growth | If the effort required for a task increases in direct proportion to the size of the service, traffic, or user base, it’s likely toil. An optimally designed and managed service should be able to scale by at least an order of magnitude with minimal additional work, aside from one-time efforts to add resources. |
+| Title                    | Description                                                                                                                                                                                                                                                                                                                                                         |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Manual                   | Automation should replace manual tasks, not just speed them up. For example, running a script to automate a series of processes might save time compared to doing each step manually. However, if a person still needs to actively execute the script, the time spent doing so counts as toil, since the goal is to eliminate human involvement in repetitive tasks |
+| Repetitive               | If you're tackling a task for the first time—or even the second time—this isn't considered toil. Toil refers to repetitive work you do repeatedly. If you're addressing a new problem or coming up with a unique solution, that work isn't toil either.                                                                                                             |
+| Automatable              | If a machine could perform the task as effectively as a human, or if the task could be eliminated through better design, then it's considered toil.                                                                                                                                                                                                                 |
+| Tactical                 | Toil is reactive and often driven by interruptions, rather than being proactive or aligned with strategy. For example, responding to pager alerts is toil—urgent and disruptive. While it’s hard to eliminate entirely, the goal is to minimize its impact and focus on more strategic work                                                                         |
+| No enduring value        | If completing a task leaves your service unchanged, it's likely toil. However, if the task results in a lasting improvement to your service, it probably wasn't toil, even if it involved some tedious work, like cleaning up legacy code and configurations.                                                                                                       |
+| O(n) with service growth | If the effort required for a task increases in direct proportion to the size of the service, traffic, or user base, it’s likely toil. An optimally designed and managed service should be able to scale by at least an order of magnitude with minimal additional work, aside from one-time efforts to add resources.                                               |
 
 ### Automating Repetitive Tasks: Strategies
 
@@ -203,52 +225,58 @@ Monitoring and alerting allow a system to notify us when something is broken or
 
 If you measure all four golden signals and page a human when one signal is problematic (or, in the case of saturation, nearly problematic), your service will be at least decently covered by monitoring.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%204.webp" alt="Four Golden Signals" caption="Four Golden Signals" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%204.webp"
+  alt="Four Golden Signals"
+  caption="Four Golden Signals"
+/>
 
 - Latency: Measures the time to process a request. It's important to separate successful and failed request latencies. For instance, an HTTP 500 error might be served quickly but still counts as a failure, skewing latency calculations. Tracking error latency specifically is crucial since slow errors are worse than fast ones.
 - Traffic: Reflects system demand, measured in a high-level metric specific to your service. For a web service, it might be HTTP requests per second, while for a streaming platform, it could be networking I/O or concurrent sessions. Tailor this metric to your system's nature, like transactions per second for storage systems.
 - Errors: The rate of failed requests, whether explicit (like HTTP 500s), implicit (e.g., wrong content served), or policy-based (e.g., requests exceeding a committed response time). While load balancers can track failures like HTTP 500s, deeper issues like incorrect content often require end-to-end tests or secondary protocols.
 - Saturation: Indicates how "full" your system is, focusing on its most constrained resources (e.g., memory or I/O). Many systems degrade before reaching full utilization, so setting a target is key. Metrics like CPU usage or network bandwidth can signal limits, with latency spikes often being an early warning. Additionally, predicting saturation, such as disk space running out, helps avoid failures.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%205.webp" alt="Use monitoring data to drive continuous improvement:" caption="Use monitoring data to drive continuous improvement:" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%205.webp"
+  alt="Use monitoring data to drive continuous improvement:"
+  caption="Use monitoring data to drive continuous improvement:"
+/>
 
 ### Key Components of Comprehensive Monitoring Strategy
 
 1. Metrics Collection
-    
-    Metrics are the backbone of any monitoring system. They provide quantitative data on how the system is performing, such as CPU usage, memory utilization, request latency, and user interactions. Collect metrics at various levels: application, infrastructure, and end-user. High-frequency metrics can help detect anomalies faster, while aggregated metrics give a broader performance overview. Tools like Prometheus or OpenTelemetry can aid in collecting and exporting these metrics effectively.
-    
+
+   Metrics are the backbone of any monitoring system. They provide quantitative data on how the system is performing, such as CPU usage, memory utilization, request latency, and user interactions. Collect metrics at various levels: application, infrastructure, and end-user. High-frequency metrics can help detect anomalies faster, while aggregated metrics give a broader performance overview. Tools like Prometheus or OpenTelemetry can aid in collecting and exporting these metrics effectively.
+
 2. Log Aggregation
-    
-    Logs capture detailed records of events within your system, including errors, transactions, and user actions. Aggregating logs into a centralized platform allows for easier searching, filtering, and correlation across components. This is critical for troubleshooting and root cause analysis. Tools like Elasticsearch or Loki can help consolidate logs, while [structured logging](https://signoz.io/blog/structured-logs/) ensures consistency and readability.
-    
+
+   Logs capture detailed records of events within your system, including errors, transactions, and user actions. Aggregating logs into a centralized platform allows for easier searching, filtering, and correlation across components. This is critical for troubleshooting and root cause analysis. Tools like Elasticsearch or Loki can help consolidate logs, while [structured logging](https://signoz.io/blog/structured-logs/) ensures consistency and readability.
+
 3. Alerting
-    
-    Alerting transforms monitoring data into actionable insights. By setting thresholds or conditions tied to service-level objectives (SLOs), you can proactively address potential issues before they impact users. For example, if the latency exceeds a set value, or the error rate breaches acceptable limits, alerts notify the appropriate teams. Tools like Alertmanager or PagerDuty integrate seamlessly with monitoring systems to automate alert dispatching.
-    
+
+   Alerting transforms monitoring data into actionable insights. By setting thresholds or conditions tied to service-level objectives (SLOs), you can proactively address potential issues before they impact users. For example, if the latency exceeds a set value, or the error rate breaches acceptable limits, alerts notify the appropriate teams. Tools like Alertmanager or PagerDuty integrate seamlessly with monitoring systems to automate alert dispatching.
+
 4. Dashboards
-    
-    Dashboards provide a real-time visual representation of system health and key metrics. They simplify complex datasets, enabling teams to quickly spot trends or anomalies. Use dashboards to display metrics like latency, error rates, and resource usage, tailored to different audiences such as developers, SREs, or management. Tools like Grafana allow for customizable and interactive dashboards.
-    
+
+   Dashboards provide a real-time visual representation of system health and key metrics. They simplify complex datasets, enabling teams to quickly spot trends or anomalies. Use dashboards to display metrics like latency, error rates, and resource usage, tailored to different audiences such as developers, SREs, or management. Tools like Grafana allow for customizable and interactive dashboards.
 
 ### Implement Effective Monitoring
 
 1. Select Appropriate Metrics
-    
-    Start by identifying metrics that directly reflect user experience and system reliability. For example, prioritize latency, error rates, and resource utilization. Avoid drowning in data by focusing on metrics aligned with your SLOs. Use techniques like the Four Golden Signals that we just discussed earlier in this section. 
-    
+
+   Start by identifying metrics that directly reflect user experience and system reliability. For example, prioritize latency, error rates, and resource utilization. Avoid drowning in data by focusing on metrics aligned with your SLOs. Use techniques like the Four Golden Signals that we just discussed earlier in this section.
+
 2. Implement a Robust Monitoring Stack
-    
-    A well-integrated stack is essential for observability. Use tools like Prometheus for collecting and storing metrics, Grafana for visualization, and SigNoz for end-to-end observability. Open-source tools combined with proprietary solutions can provide flexibility and depth, ensuring scalability as your system grows.
-    
+
+   A well-integrated stack is essential for observability. Use tools like Prometheus for collecting and storing metrics, Grafana for visualization, and SigNoz for end-to-end observability. Open-source tools combined with proprietary solutions can provide flexibility and depth, ensuring scalability as your system grows.
+
 3. Set Up Meaningful Alerts
-    
-    Alerts should be actionable and tied to SLO violations or critical thresholds, ensuring they aren’t ignored due to [alert fatigue](https://signoz.io/blog/alert-fatigue/). Categorize alerts by severity (e.g., warnings vs. critical) and ensure clear escalation paths. Use runbooks to guide teams on responding to specific alerts, minimizing downtime and confusion.
-    
+
+   Alerts should be actionable and tied to SLO violations or critical thresholds, ensuring they aren’t ignored due to [alert fatigue](https://signoz.io/blog/alert-fatigue/). Categorize alerts by severity (e.g., warnings vs. critical) and ensure clear escalation paths. Use runbooks to guide teams on responding to specific alerts, minimizing downtime and confusion.
+
 4. Establish On-Call Rotations
-    
-    Timely responses to alerts are vital. Rotate on-call responsibilities among team members to distribute the workload fairly and avoid burnout. Use tools like Opsgenie or PagerDuty to manage schedules and escalation policies. Incorporate post-incident reviews to continuously refine the on-call process and improve response times.
-    
+
+   Timely responses to alerts are vital. Rotate on-call responsibilities among team members to distribute the workload fairly and avoid burnout. Use tools like Opsgenie or PagerDuty to manage schedules and escalation policies. Incorporate post-incident reviews to continuously refine the on-call process and improve response times.
 
 ## 5. Simplicity as a Core SRE Principle
 
@@ -262,7 +290,11 @@ Simplicity, a core SRE principle, advocates for building systems that are easy t
 4. Clear Documentation: Provide concise, accurate, and regularly updated documentation to guide developers and operators. Good documentation eliminates guesswork, simplifies onboarding, and ensures that systems remain accessible and understandable as they evolve.
 5. Regular Refactoring: Periodically review code and infrastructure to identify unnecessary complexity and simplify where possible. Continuous refactoring prevents technical debt from accumulating and ensures the system remains scalable, efficient, and easy to maintain.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%206.webp" alt="Benefits of Simplicity in SRE" caption="Benefits of Simplicity in SRE" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%206.webp"
+  alt="Benefits of Simplicity in SRE"
+  caption="Benefits of Simplicity in SRE"
+/>
 
 ### Balance Simplicity with Feature Requirements:
 
@@ -282,7 +314,11 @@ Embracing failure is a crucial SRE principle that recognizes incidents as opport
 2. Continuous Learning: Treat incidents as learning opportunities to improve processes and systems. Analyzing what went wrong helps teams adapt and grow stronger over time.
 3. Proactive Improvement: Implement changes based on postmortem findings to prevent future incidents. Proactive updates to processes and monitoring enhance system reliability and reduce the chance of recurrence.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%207.webp" alt="Steps to conduct effective blameless postmortems" caption="Steps to conduct effective blameless postmortems" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%207.webp"
+  alt="Steps to conduct effective blameless postmortems"
+  caption="Steps to conduct effective blameless postmortems"
+/>
 
 ### Implement a Systematic Approach to Incident Analysis
 
@@ -297,7 +333,11 @@ By embracing failure and learning from incidents, organizations can continuously
 
 Release engineering is a critical aspect of SRE that focuses on the processes and tools used to deliver software updates reliably and efficiently.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%208.webp" alt="Key components of effective release engineering" caption="Key components of effective release engineering" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%208.webp"
+  alt="Key components of effective release engineering"
+  caption="Key components of effective release engineering"
+/>
 
 ### Implementing Robust Release Processes
 
@@ -308,13 +348,17 @@ Release engineering is a critical aspect of SRE that focuses on the processes an
 
 ### Strategies for Gradual Rollouts
 
-<Figure src="/img/guides/2024/11/sre-principles-image%209.webp" alt="Types of Gradual Rollouts" caption="Types of Gradual Rollouts" />
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%209.webp"
+  alt="Types of Gradual Rollouts"
+  caption="Types of Gradual Rollouts"
+/>
 
-| Strategy | Description |
-| --- | --- |
-| Canary Releases | Set up canary deployments with tools like Kubernetes’ rolling updates or services like AWS Elastic Beanstalk and Google Cloud Run. Start by releasing the update to a small group of users, monitor performance with tools like Prometheus or Datadog, and gradually increase traffic if all looks good. This reduces the risk of widespread issues. |
-| Blue-Green Deployments | Use blue-green deployment with load balancers like AWS ELB or Nginx to direct traffic to the "green" environment (the updated version), while the "blue" environment runs the stable version. Once the green environment is validated, switch the load balancer to send all traffic there. This allows for zero-downtime updates and minimizes deployment risks. |
-| Feature Flags | Manage feature releases with feature flagging tools like LaunchDarkly or Unleash. This lets you deploy code with features hidden or disabled, then gradually enable them for specific user groups or environments without needing to redeploy. Feature flags make it easier to test new features in production, control rollouts, and quickly disable any problematic features. |
+| Strategy               | Description                                                                                                                                                                                                                                                                                                                                                                     |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Canary Releases        | Set up canary deployments with tools like Kubernetes’ rolling updates or services like AWS Elastic Beanstalk and Google Cloud Run. Start by releasing the update to a small group of users, monitor performance with tools like Prometheus or Datadog, and gradually increase traffic if all looks good. This reduces the risk of widespread issues.                            |
+| Blue-Green Deployments | Use blue-green deployment with load balancers like AWS ELB or Nginx to direct traffic to the "green" environment (the updated version), while the "blue" environment runs the stable version. Once the green environment is validated, switch the load balancer to send all traffic there. This allows for zero-downtime updates and minimizes deployment risks.                |
+| Feature Flags          | Manage feature releases with feature flagging tools like LaunchDarkly or Unleash. This lets you deploy code with features hidden or disabled, then gradually enable them for specific user groups or environments without needing to redeploy. Feature flags make it easier to test new features in production, control rollouts, and quickly disable any problematic features. |
 
 ### Monitoring and Validating Releases
 
@@ -337,11 +381,11 @@ Effective capacity planning and demand forecasting are essential for maintaining
 
 ### Proactive Scaling Strategies:
 
-| Strategy | Description |
-| --- | --- |
-| Auto-scaling | Configure systems to automatically adjust resources based on demand. |
-| Load testing | Regularly test systems under various load conditions to identify bottlenecks. |
-| Capacity buffers | Maintain extra capacity to handle unexpected spikes in demand. |
+| Strategy         | Description                                                                   |
+| ---------------- | ----------------------------------------------------------------------------- |
+| Auto-scaling     | Configure systems to automatically adjust resources based on demand.          |
+| Load testing     | Regularly test systems under various load conditions to identify bottlenecks. |
+| Capacity buffers | Maintain extra capacity to handle unexpected spikes in demand.                |
 
 ### Tools for Effective Demand Forecasting:
 
@@ -382,16 +426,20 @@ Observability is a crucial SRE principle that provides deep insights into system
 3. Implement a Tracing Backend: Set up a backend (Jaeger, Zipkin, AWS X-Ray) to collect and store trace data. Ensure its scalable to handle large volumes and integrates with monitoring tools for comprehensive analysis.
 4. Visualize Traces to Identify Bottlenecks: Use trace visualization tools to map request flows and spot performance bottlenecks. This helps pinpoint slow or failing services, improving troubleshooting and optimization.
 
-<Figure src="/img/guides/2024/11/sre-principles-image%2010.webp" alt="Resolve performance bottlenecks using observability data." caption="Resolve performance bottlenecks using observability data." /> 
+<Figure
+  src="/img/guides/2024/11/sre-principles-image%2010.webp"
+  alt="Resolve performance bottlenecks using observability data."
+  caption="Resolve performance bottlenecks using observability data."
+/>{' '}
 
 ### Comprehensive System Observability: Best practices
 
-| Best Practices | Techniques |
-| --- | --- |
-| Implement a robust observability stack | Use tools like SigNoz for end-to-end observability. |
-| Standardize instrumentation | Ensure consistent data collection across all system components. |
-| Implement context propagation |  Maintain request context across service boundaries. |
-| Use sampling techniques | For high-volume systems, implement intelligent sampling to manage data volume while maintaining visibility. |
+| Best Practices                         | Techniques                                                                                                  |
+| -------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| Implement a robust observability stack | Use tools like SigNoz for end-to-end observability.                                                         |
+| Standardize instrumentation            | Ensure consistent data collection across all system components.                                             |
+| Implement context propagation          | Maintain request context across service boundaries.                                                         |
+| Use sampling techniques                | For high-volume systems, implement intelligent sampling to manage data volume while maintaining visibility. |
 
 ## Implementing Observability with SigNoz
 
@@ -430,4 +478,4 @@ Yes, SRE principles can be scaled to fit organizations of any size. Even small t
 
 ### How does embracing failure lead to more reliable systems?
 
-By treating failures as learning opportunities and conducting blameless postmortems, teams can identify and address systemic issues, leading to continuous improvement in system reliability.
\ No newline at end of file
+By treating failures as learning opportunities and conducting blameless postmortems, teams can identify and address systemic issues, leading to continuous improvement in system reliability.
diff --git a/data/guides/sre-roles-and-responsibilities.mdx b/data/guides/sre-roles-and-responsibilities.mdx
index 341d95209..e263aa9db 100644
--- a/data/guides/sre-roles-and-responsibilities.mdx
+++ b/data/guides/sre-roles-and-responsibilities.mdx
@@ -1,16 +1,23 @@
 ---
-
 title: SRE Roles and Responsibilities - A Comprehensive Guide
-slug: sre-roles-and-responsibilities
 date: 2024-11-29
 tags: [SRE, DevOps]
 authors: [niyati_thakkar]
 description: Explore the key roles and responsibilities of Site Reliability Engineers (SREs) in modern software engineering, including skills, tools, and best practices.
-keywords: [SRE, site reliability engineering, DevOps, system reliability, automation, observability, incident response, performance optimization]
-
+keywords:
+  [
+    SRE,
+    site reliability engineering,
+    DevOps,
+    system reliability,
+    automation,
+    observability,
+    incident response,
+    performance optimization,
+  ]
 ---
 
-Site Reliability Engineering (SRE) is a cornerstone of modern software development, ensuring systems are reliable and scalable in an ever-changing tech landscape. Rooted in the need to balance innovation with operational stability, SRE has transformed how organizations approach software reliability. 
+Site Reliability Engineering (SRE) is a cornerstone of modern software development, ensuring systems are reliable and scalable in an ever-changing tech landscape. Rooted in the need to balance innovation with operational stability, SRE has transformed how organizations approach software reliability.
 
 This comprehensive guide delves into the key responsibilities, essential skills, and best practices that define the role of SREs while highlighting their critical position as the bridge between development and operations.
 
@@ -36,7 +43,11 @@ At its core, SRE bridges the gap between development and operations, ensuring a
 
 SREs play a crucial role in ensuring the reliability and performance of software systems. Their responsibilities span various aspects of system operations and development:
 
-<Figure src="/img/guides/2024/11/sre-roles-and-responsibilities-Pink_Modern_Abstract_Mind_Map_Connection_Diagram_Brainstorm__(1).webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/11/sre-roles-and-responsibilities-Pink_Modern_Abstract_Mind_Map_Connection_Diagram_Brainstorm__(1).webp"
+  alt=""
+  caption=""
+/>
 
 ### Ensuring System Reliability and Performance
 
@@ -107,8 +118,8 @@ To excel in their role, SREs need a diverse skill set that combines technical ex
 Automation is at the heart of SRE practices. Proficiency in scripting saves time and reduces errors.
 
 - How to Build This Skill:
-    - Start with Python or Go, which are widely used for automation and tool development.
-    - Automate daily tasks using Bash or Python, such as [log parsing](https://signoz.io/guides/log-parsing/) or generating system health reports.
+  - Start with Python or Go, which are widely used for automation and tool development.
+  - Automate daily tasks using Bash or Python, such as [log parsing](https://signoz.io/guides/log-parsing/) or generating system health reports.
 - Tools to Learn: Python, Go, Shell scripting, AWK, sed.
 - Tip: Create reusable scripts with parameters to adapt to different scenarios (e.g., a disk-space monitoring script that works across servers).
 
@@ -117,8 +128,8 @@ Automation is at the heart of SRE practices. Proficiency in scripting saves time
 Modern systems are distributed and complex, requiring you to think about consistency, fault tolerance, and latency.
 
 - How to Build This Skill:
-    - Read resources like *Designing Data-Intensive Applications* by Martin Kleppmann.
-    - Explore concepts like the CAP theorem and consistency models by implementing small-scale distributed systems in Kubernetes.
+  - Read resources like _Designing Data-Intensive Applications_ by Martin Kleppmann.
+  - Explore concepts like the CAP theorem and consistency models by implementing small-scale distributed systems in Kubernetes.
 - Tip: Use a tool like Minikube or Docker Compose to simulate distributed system behavior locally for hands-on learning.
 
 ### 3. Mastering Cloud Technologies
@@ -126,8 +137,8 @@ Modern systems are distributed and complex, requiring you to think about consist
 Most modern systems run on cloud infrastructure, requiring expertise in cloud-based tools.
 
 - How to Build This Skill:
-    - Practice Infrastructure as Code (IaC) with tools like Terraform.
-    - Get certified in a major platform (e.g., AWS Certified Solutions Architect).
+  - Practice Infrastructure as Code (IaC) with tools like Terraform.
+  - Get certified in a major platform (e.g., AWS Certified Solutions Architect).
 - Tip: Experiment with auto-scaling features in Kubernetes or AWS to handle dynamic workloads.
 
 ### 4. Developing Monitoring and Observability Practices
@@ -135,8 +146,8 @@ Most modern systems run on cloud infrastructure, requiring expertise in cloud-ba
 You can’t fix what you can’t see. Monitoring tools provide insight into system health and help diagnose issues.
 
 - How to Build This Skill:
-    - Start with Prometheus for metric collection and Grafana for dashboards.
-    - Define SLIs and SLOs for your application; for instance, monitor API response times and error rates.
+  - Start with Prometheus for metric collection and Grafana for dashboards.
+  - Define SLIs and SLOs for your application; for instance, monitor API response times and error rates.
 - Tip: Avoid alert fatigue by setting up actionable alerts. For example, alert only when CPU usage exceeds 85% for more than 5 minutes.
 
 ### 5. Problem-Solving and Analytical Thinking
@@ -144,8 +155,8 @@ You can’t fix what you can’t see. Monitoring tools provide insight into syst
 Solving issues in complex systems requires structured analysis and logical thinking.
 
 - How to Build This Skill:
-    - Practice root cause analysis by studying past incidents in your organization.
-    - Engage in war games or incident simulations to build quick thinking under pressure.
+  - Practice root cause analysis by studying past incidents in your organization.
+  - Engage in war games or incident simulations to build quick thinking under pressure.
 - Tip: Use diagrams (like dependency maps) to visualize interconnected systems and pinpoint potential weak spots.
 
 ### 6. Communication and Collaboration
@@ -153,8 +164,8 @@ Solving issues in complex systems requires structured analysis and logical think
 SREs must be the glue between development, operations, and business teams.
 
 - How to Build This Skill:
-    - Practice writing post-mortem reports that explain complex technical issues in plain language.
-    - Participate in cross-functional meetings to align priorities.
+  - Practice writing post-mortem reports that explain complex technical issues in plain language.
+  - Participate in cross-functional meetings to align priorities.
 - Tip: Focus on blameless communication. Use phrases like “How can we improve this process?” instead of assigning blame during retrospectives.
 
 ### 7. Incident Management Expertise
@@ -162,8 +173,8 @@ SREs must be the glue between development, operations, and business teams.
 During outages, time is of the essence, and well-defined processes save critical time.
 
 - How to Build This Skill:
-    - Join an on-call rotation to experience real-world incident handling.
-    - Study and implement runbooks for common scenarios like database failures or high-latency incidents.
+  - Join an on-call rotation to experience real-world incident handling.
+  - Study and implement runbooks for common scenarios like database failures or high-latency incidents.
 - Tip: Use tools like PagerDuty to automate escalations and integrate them with ChatOps for seamless communication.
 
 ### Actionable Next Steps for Aspiring SREs
@@ -194,17 +205,17 @@ Both SRE and DevOps aim to:
 
 ### SRE vs. DevOps
 
-| Aspect | Site Reliability Engineering (SRE) | DevOps |
-| --- | --- | --- |
-| Origin | Introduced by Google in 2003 | Emerged from the IT community in the late 2000s |
-| Philosophy | Applies software engineering principles to operations | Promotes a cultural shift to bridge development and operations |
-| Key Focus | System reliability and performance; reducing toil | Faster delivery through collaboration and automation |
-| Core Practices | Error budgets, SLIs/SLOs, automation of repetitive tasks | Continuous integration, delivery, and deployment (CI/CD) |
-| Team Structure | Often involves dedicated SRE teams responsible for specific systems | Advocates for cross-functional, unified DevOps teams |
-| Quantitative Approach | Uses metrics like reliability targets, error budgets, and SLAs | Focuses on feedback loops, process improvement |
-| Scope | Primarily targets the reliability and scalability of large-scale systems | Encompasses the entire software development lifecycle |
-| Automation Emphasis | Automates toil and incident response | Automates deployment pipelines and testing |
-| Cultural Shift | Promotes reliability-focused engineering culture within specific teams | Encourages organization-wide collaboration and shared ownership |
+| Aspect                | Site Reliability Engineering (SRE)                                       | DevOps                                                          |
+| --------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------- |
+| Origin                | Introduced by Google in 2003                                             | Emerged from the IT community in the late 2000s                 |
+| Philosophy            | Applies software engineering principles to operations                    | Promotes a cultural shift to bridge development and operations  |
+| Key Focus             | System reliability and performance; reducing toil                        | Faster delivery through collaboration and automation            |
+| Core Practices        | Error budgets, SLIs/SLOs, automation of repetitive tasks                 | Continuous integration, delivery, and deployment (CI/CD)        |
+| Team Structure        | Often involves dedicated SRE teams responsible for specific systems      | Advocates for cross-functional, unified DevOps teams            |
+| Quantitative Approach | Uses metrics like reliability targets, error budgets, and SLAs           | Focuses on feedback loops, process improvement                  |
+| Scope                 | Primarily targets the reliability and scalability of large-scale systems | Encompasses the entire software development lifecycle           |
+| Automation Emphasis   | Automates toil and incident response                                     | Automates deployment pipelines and testing                      |
+| Cultural Shift        | Promotes reliability-focused engineering culture within specific teams   | Encourages organization-wide collaboration and shared ownership |
 
 Organizations can benefit greatly by integrating both DevOps and SRE practices. DevOps fosters a culture of cross-functional collaboration, enabling faster delivery cycles and breaking down silos between teams. SRE, on the other hand, brings structured reliability practices like error budgets, SLOs, and automation to ensure stable operations. By combining DevOps’ agility with SRE’s focus on system reliability, organizations can strike a balance between innovation and stability, scaling their systems effectively while maintaining high performance and rapid delivery.
 
@@ -215,50 +226,50 @@ SREs (Site Reliability Engineers) utilize various tools to ensure systems are re
 ### Monitoring and Observability Platforms
 
 - Prometheus
-    - Open-source monitoring system and time series database.
-    - Use Case: Collecting and storing metrics from various services.
+  - Open-source monitoring system and time series database.
+  - Use Case: Collecting and storing metrics from various services.
 - Grafana
-    - Visualization tool for metrics, logs, and traces.
-    - Use Case: Creating dashboards to visualize system performance.
+  - Visualization tool for metrics, logs, and traces.
+  - Use Case: Creating dashboards to visualize system performance.
 - ELK Stack (Elasticsearch, Logstash, Kibana)
-    - Log management and analysis suite.
-    - Use Case: Centralized log collection and search.
+  - Log management and analysis suite.
+  - Use Case: Centralized log collection and search.
 
 ### Configuration Management and Infrastructure as Code
 
 - Ansible
-    - Automation tool for configuration management and application deployment.
-    - Use Case: Automating server configuration and application updates.
+  - Automation tool for configuration management and application deployment.
+  - Use Case: Automating server configuration and application updates.
 - Terraform
-    - Infrastructure as Code tool for provisioning and managing cloud resources.
-    - Use Case: Defining and versioning infrastructure in a declarative manner.
+  - Infrastructure as Code tool for provisioning and managing cloud resources.
+  - Use Case: Defining and versioning infrastructure in a declarative manner.
 
 ### Continuous Integration and Deployment Tools
 
 - Jenkins
-    - Open-source automation server.
-    - Use Case: Building, testing, and deploying applications.
+  - Open-source automation server.
+  - Use Case: Building, testing, and deploying applications.
 - GitLab CI
-    - Integrated CI/CD platform.
-    - Use Case: Automating the software delivery pipeline.
+  - Integrated CI/CD platform.
+  - Use Case: Automating the software delivery pipeline.
 
 ### Incident Management and Communication Systems
 
 - PagerDuty
-    - Incident response platform.
-    - Use Case: Managing on-call schedules and alert routing.
+  - Incident response platform.
+  - Use Case: Managing on-call schedules and alert routing.
 - Slack
-    - Team collaboration and communication platform.
-    - Use Case: Real-time communication during incidents and for ChatOps integrations.
+  - Team collaboration and communication platform.
+  - Use Case: Real-time communication during incidents and for ChatOps integrations.
 
 ### Chaos Engineering Tools
 
 - Chaos Monkey
-    - Tool for randomly terminating instances in production.
-    - Use Case: Testing system resilience and failover mechanisms.
+  - Tool for randomly terminating instances in production.
+  - Use Case: Testing system resilience and failover mechanisms.
 - Gremlin
-    - Chaos engineering as a service platform.
-    - Use Case: Running controlled experiments to identify system weaknesses.
+  - Chaos engineering as a service platform.
+  - Use Case: Running controlled experiments to identify system weaknesses.
 
 By mastering these tools, SREs can effectively monitor, manage, and enhance the reliability of complex systems.
 
@@ -276,7 +287,7 @@ Adopting Site Reliability Engineering (SRE) practices requires a structured, str
 
 - Define clear roles within the SRE team, including SREs, software engineers, and reliability engineers.
 - Blend experience: Combine seasoned SREs with engineers who have a development or operational background to bring diverse perspectives.
-- Prioritize both technical expertise and cultural fit:  A strong SRE team requires deep technical skills and the ability to work well with other teams.
+- Prioritize both technical expertise and cultural fit: A strong SRE team requires deep technical skills and the ability to work well with other teams.
 
 ### 3. Establish Service Level Objectives (SLOs) and Error Budgets
 
@@ -313,29 +324,29 @@ Adopting Site Reliability Engineering (SRE) practices requires a structured, str
 Organizations use various Key Performance Indicators (KPIs) to gauge the effectiveness of SRE practices. These metrics help track progress and identify areas for improvement:
 
 - Service Level Indicators (SLIs) and Service Level Objectives (SLOs):
-    - Measure: The actual performance of a service against its defined objectives
-    - Example: If your SLO is 99.9% availability, track the actual uptime percentage
+  - Measure: The actual performance of a service against its defined objectives
+  - Example: If your SLO is 99.9% availability, track the actual uptime percentage
 - Mean Time to Detect (MTTD) and Mean Time to Resolve (MTTR):
-    - Measure: How quickly issues are identified and resolved
-    - Goal: Decrease both MTTD and MTTR over time through improved monitoring and incident response processes
+  - Measure: How quickly issues are identified and resolved
+  - Goal: Decrease both MTTD and MTTR over time through improved monitoring and incident response processes
 - Change Failure Rate:
-    - Measure: Percentage of changes that result in degraded service or require remediation
-    - Target: Reduce this rate by improving testing, deployment processes, and rollback mechanisms
+  - Measure: Percentage of changes that result in degraded service or require remediation
+  - Target: Reduce this rate by improving testing, deployment processes, and rollback mechanisms
 - Deployment Frequency:
-    - Measure: How often new code or changes are deployed to production
-    - Goal: Increase frequency while maintaining or improving reliability
+  - Measure: How often new code or changes are deployed to production
+  - Goal: Increase frequency while maintaining or improving reliability
 - Toil Reduction:
-    - Measure: Time spent on manual, repetitive tasks
-    - Objective: Decrease toil through automation, freeing up time for more valuable work
+  - Measure: Time spent on manual, repetitive tasks
+  - Objective: Decrease toil through automation, freeing up time for more valuable work
 - Error Budget Burn Rate:
-    - Measure: How quickly the error budget is being consumed
-    - Use: To balance between pushing new features and maintaining stability
+  - Measure: How quickly the error budget is being consumed
+  - Use: To balance between pushing new features and maintaining stability
 - Customer-impacting Incidents:
-    - Measure: Number and severity of incidents that affect users
-    - Aim: Reduce the frequency and impact of such incidents over time
+  - Measure: Number and severity of incidents that affect users
+  - Aim: Reduce the frequency and impact of such incidents over time
 - Time Spent on Unplanned Work:
-    - Measure: Percentage of time spent responding to incidents vs. planned project work
-    - Goal: Reduce unplanned work to allow more focus on proactive improvements
+  - Measure: Percentage of time spent responding to incidents vs. planned project work
+  - Goal: Reduce unplanned work to allow more focus on proactive improvements
 
 By tracking these KPIs, SRE teams can demonstrate their impact on system reliability and overall business performance. Regularly reviewing these metrics helps identify trends and areas that need attention.
 
@@ -355,22 +366,23 @@ SigNoz is an open-source, full-stack observability platform that provides metric
 ### How SigNoz Supports SRE Practices
 
 - [Unified Observability](https://signoz.io/unified-observability/):
-    - Consolidates metrics, traces, and logs in one platform
-    - Reduces context switching and speeds up troubleshooting
+  - Consolidates metrics, traces, and logs in one platform
+  - Reduces context switching and speeds up troubleshooting
 - Custom Dashboards:
-    - Create tailored views for different services or teams
-    - Visualize SLIs and track SLO compliance
+  - Create tailored views for different services or teams
+  - Visualize SLIs and track SLO compliance
 - Anomaly Detection:
-    - Leverage machine learning to identify unusual patterns
-    - Proactively address potential issues before they impact users
+  - Leverage machine learning to identify unusual patterns
+  - Proactively address potential issues before they impact users
 - Root Cause Analysis:
-    - Drill down from high-level metrics to individual traces
-    - Quickly identify the source of performance bottlenecks
+  - Drill down from high-level metrics to individual traces
+  - Quickly identify the source of performance bottlenecks
 - Collaborative Troubleshooting:
-    - Share links to specific views or traces
-    - Facilitate communication between SRE and development teams
+  - Share links to specific views or traces
+  - Facilitate communication between SRE and development teams
 
-<GetStartedSigNoz />### Leveraging SigNoz for Effective Incident Response
+<GetStartedSigNoz />
+### Leveraging SigNoz for Effective Incident Response
 
 During an incident, SigNoz can be invaluable:
 
@@ -475,4 +487,4 @@ SRE practices can be adapted for small organizations or startups by starting wit
 
 ### What are the biggest challenges faced by SREs in their day-to-day work?
 
-SREs face several challenges, including balancing system reliability with new feature development, scaling systems efficiently, managing complex distributed systems, and reducing [alert fatigue](https://signoz.io/blog/alert-fatigue/). They must keep up with rapid technological changes, collaborate across teams, and handle on-call responsibilities. These challenges require a blend of technical expertise, strategic thinking, and strong communication skills.
\ No newline at end of file
+SREs face several challenges, including balancing system reliability with new feature development, scaling systems efficiently, managing complex distributed systems, and reducing [alert fatigue](https://signoz.io/blog/alert-fatigue/). They must keep up with rapid technological changes, collaborate across teams, and handle on-call responsibilities. These challenges require a blend of technical expertise, strategic thinking, and strong communication skills.
diff --git a/data/guides/ssh-logs.mdx b/data/guides/ssh-logs.mdx
index c288a9907..bab1ee12d 100644
--- a/data/guides/ssh-logs.mdx
+++ b/data/guides/ssh-logs.mdx
@@ -1,11 +1,21 @@
 ---
-title: "SSH Logs: Complete Guide to Security Monitoring and Analysis in 2025"
-slug: "ssh-logs"
-date: "2025-07-23"
+title: 'SSH Logs: Complete Guide to Security Monitoring and Analysis in 2025'
+date: '2025-07-23'
 tags: [ssh, logging]
 authors: [nilesh_sinha]
-description: "Master SSH log monitoring with this comprehensive guide covering log locations, analysis techniques, security threat detection, and modern tools for effective SSH access management."
-keywords: [ssh logs, sshd logs, ssh log monitoring, ssh security, authentication logs, brute force detection, journalctl ssh, ssh log analysis, linux security monitoring]
+description: 'Master SSH log monitoring with this comprehensive guide covering log locations, analysis techniques, security threat detection, and modern tools for effective SSH access management.'
+keywords:
+  [
+    ssh logs,
+    sshd logs,
+    ssh log monitoring,
+    ssh security,
+    authentication logs,
+    brute force detection,
+    journalctl ssh,
+    ssh log analysis,
+    linux security monitoring,
+  ]
 ---
 
 SSH logs are critical for detecting unauthorized access attempts and maintaining system security. If you're managing servers, you know how proper SSH log monitoring can mean the difference between catching a breach early and discovering it weeks later.
@@ -30,8 +40,9 @@ Jan 23 14:30:15 server01 sshd[12345]: Accepted publickey for admin from 192.168.
 ```
 
 Breaking this down:
+
 - **Timestamp**: `Jan 23 14:30:15`
-- **Hostname**: `server01` 
+- **Hostname**: `server01`
 - **Process**: `sshd[12345]` (daemon with PID)
 - **Event**: `Accepted publickey`
 - **User**: `admin`
@@ -45,6 +56,7 @@ Finding SSH logs depends on your OS and logging setup:
 ### Linux Systems
 
 **Debian/Ubuntu:**
+
 ```bash
 # Primary location
 tail -f /var/log/auth.log
@@ -54,8 +66,9 @@ journalctl -u ssh -f
 ```
 
 **RHEL/CentOS/Rocky:**
+
 ```bash
-# Primary location  
+# Primary location
 tail -f /var/log/secure
 
 # Using systemd journal
@@ -63,6 +76,7 @@ journalctl -u sshd -f
 ```
 
 **Arch Linux:**
+
 ```bash
 # Primarily systemd journal
 journalctl -u sshd.service -f
@@ -74,11 +88,13 @@ tail -f /var/log/auth.log
 ### Other Platforms
 
 **macOS:**
+
 ```bash
 tail -f /var/log/system.log | grep ssh
 ```
 
 **FreeBSD:**
+
 ```bash
 tail -f /var/log/auth.log
 ```
@@ -110,7 +126,8 @@ LogLevel VERBOSE
 ```
 
 **Recommendations:**
-- **Production**: `INFO` or `VERBOSE` 
+
+- **Production**: `INFO` or `VERBOSE`
 - **Security monitoring**: `VERBOSE`
 - **Troubleshooting**: `DEBUG` (temporarily)
 
@@ -126,6 +143,7 @@ SyslogFacility AUTHPRIV
 ```
 
 Restart SSH after changes:
+
 ```bash
 systemctl restart sshd
 ```
@@ -159,12 +177,14 @@ journalctl -u ssh.service -o short-iso
 ### Identifying Brute Force Attacks
 
 Find IPs with multiple failed attempts:
+
 ```bash
 grep "Failed password" /var/log/auth.log | \
 awk '{print $(NF-3)}' | sort | uniq -c | sort -nr | head -10
 ```
 
 Show recent failed attempts:
+
 ```bash
 grep "Failed password" /var/log/auth.log | \
 grep "$(date --date='1 day ago' '+%b %d')\|$(date '+%b %d')"
@@ -173,12 +193,14 @@ grep "$(date --date='1 day ago' '+%b %d')\|$(date '+%b %d')"
 ### Detecting Unusual Patterns
 
 Check off-hours access:
+
 ```bash
 grep "Accepted" /var/log/auth.log | \
 awk '$3 < "09:00:00" || $3 > "17:00:00" {print}'
 ```
 
 Monitor direct root logins (should be disabled):
+
 ```bash
 grep "root" /var/log/auth.log | grep "Accepted"
 ```
@@ -186,6 +208,7 @@ grep "root" /var/log/auth.log | grep "Accepted"
 ### Privilege Escalation Monitoring
 
 Track sudo usage after SSH login:
+
 ```bash
 grep -E "(Accepted|sudo)" /var/log/auth.log | grep -A5 -B5 "sudo"
 ```
@@ -253,17 +276,20 @@ journalctl -u fail2ban -f
 ### Missing Log Files
 
 Check SSH service status:
+
 ```bash
 systemctl status sshd
 journalctl -u sshd --no-pager
 ```
 
 Verify logging configuration:
+
 ```bash
 grep -E "^(SyslogFacility|LogLevel)" /etc/ssh/sshd_config
 ```
 
 Test with verbose SSH:
+
 ```bash
 ssh -v user@localhost
 ```
@@ -271,6 +297,7 @@ ssh -v user@localhost
 ### Permission Issues
 
 Check log file permissions:
+
 ```bash
 ls -la /var/log/auth.log
 
@@ -282,6 +309,7 @@ sudo usermod -a -G wheel username  # RHEL/CentOS
 ### High Log Volume
 
 Configure size-based rotation:
+
 ```bash
 # /etc/logrotate.d/ssh-size
 /var/log/ssh.log {
@@ -293,6 +321,7 @@ Configure size-based rotation:
 ```
 
 Reduce verbosity:
+
 ```bash
 sed -i 's/LogLevel VERBOSE/LogLevel INFO/' /etc/ssh/sshd_config
 systemctl restart sshd
@@ -311,8 +340,8 @@ SigNoz provides comprehensive SSH log monitoring through [OpenTelemetry](https:/
 receivers:
   filelog:
     include:
-      - /var/log/auth.log    # Ubuntu/Debian
-      - /var/log/secure      # RHEL/CentOS
+      - /var/log/auth.log # Ubuntu/Debian
+      - /var/log/secure # RHEL/CentOS
     operators:
       - type: regex_parser
         regex: '^(?P<timestamp>\w+\s+\d+\s+\d+:\d+:\d+)\s+(?P<hostname>\S+)\s+(?P<process>\S+?)(\[(?P<pid>\d+)\])?:\s+(?P<message>.*)$'
@@ -325,9 +354,9 @@ processors:
 
 exporters:
   otlp:
-    endpoint: "https://ingest.{region}.signoz.cloud:443"
+    endpoint: 'https://ingest.{region}.signoz.cloud:443'
     headers:
-      "signoz-ingestion-key": "{SIGNOZ_INGESTION_KEY}"
+      'signoz-ingestion-key': '{SIGNOZ_INGESTION_KEY}'
 
 service:
   pipelines:
@@ -341,7 +370,7 @@ service:
 
 - **Real-time analysis**: Monitor authentication patterns instantly
 - **Advanced queries**: Filter by IP, user, timeframe with powerful query builder
-- **Automated alerting**: Set up alerts for brute force attempts or anomalous behavior  
+- **Automated alerting**: Set up alerts for brute force attempts or anomalous behavior
 - **Correlation**: Connect SSH events with system metrics and traces
 - **Compliance**: Long-term storage for audit requirements
 
@@ -411,23 +440,25 @@ iptables -A INPUT -p tcp --dport 2222 -m recent --name ssh --rcheck --seconds 60
 
 [SigNoz](https://signoz.io/docs/introduction/) provides real-time log analysis, intelligent alerting, and correlation with system metrics - perfect for modern infrastructure security.
 
-
-<figure data-zoomable align='center'>
-    <video 
-        className="box-shadowed-image" 
-        src="/img/docs/logs-management/signoz-log-management-overview.mp4" 
-        controls={false}
-        width="100%" 
-        autoPlay 
-        muted 
-        loop
-    >
-        Your browser does not support the video tag.
-    </video>
-    <figcaption><i>SigNoz Logs Management Overview</i></figcaption>
+<figure data-zoomable align="center">
+  <video
+    className="box-shadowed-image"
+    src="/img/docs/logs-management/signoz-log-management-overview.mp4"
+    controls={false}
+    width="100%"
+    autoPlay
+    muted
+    loop
+  >
+    Your browser does not support the video tag.
+  </video>
+  <figcaption>
+    <i>SigNoz Logs Management Overview</i>
+  </figcaption>
 </figure>
 
 Key SSH monitoring features:
+
 - **Centralized collection** from multiple servers with efficient storage
 - **Real-time alerting** for brute force attacks and anomalous patterns
 - **Advanced filtering** for forensic analysis and compliance reporting
diff --git a/data/guides/structlog.mdx b/data/guides/structlog.mdx
index f6e46c8c9..385003d2c 100644
--- a/data/guides/structlog.mdx
+++ b/data/guides/structlog.mdx
@@ -1,167 +1,170 @@
 ---
-
 title: Complete Guide to Logging with StructLog in Python
-slug: structlog
 date: 2024-07-12
 tags: [logging]
 authors: [sushant_gaurav]
 description: Discover how to leverage StructLog for advanced logging in Python. Learn setup, configuration, and best practices for structured logging to enhance your application's observability.
 keywords: [structlog, structlog github, structlog python, structlog vs logging, structlog fastapi]
-
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Complete Guide to Logging with StructLog in Python",
-  "alternativeHeadline": "Master structured logging in Python with StructLog - Learn setup, configuration, and best practices",
-  "author": {
-    "@type": "Person",
-    "name": "Sushant Gaurav"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-12T00:00:00Z",
-  "dateModified": "2024-07-12T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/structlog/"
-  },
-  "description": "Discover how to leverage StructLog for advanced logging in Python. Learn setup, configuration, and best practices for structured logging to enhance your application's observability.",
-  "keywords": "structlog, structlog github, structlog python, structlog vs logging, structlog fastapi",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "StructLog",
-      "description": "A structured logging package for Python"
-    },
-    {
-      "@type": "Thing",
-      "name": "Python",
-      "description": "A high-level programming language"
-    },
-    {
-      "@type": "Thing",
-      "name": "Structured Logging",
-      "description": "A logging approach that treats log entries as data structures rather than plain text"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Monitoring Software"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "FastAPI",
-      "applicationCategory": "Web Framework"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "Django",
-      "applicationCategory": "Web Framework"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What does StructLog do?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "StructLog is a Python logging package that simplifies structured logging. It enables developers to log detailed data rather than plain text messages, resulting in improved log analysis and troubleshooting."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is a structured log?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "A structured log entry contains key-value pairs rather than unstructured, plain text. This format facilitates the programmatic parsing, searching, and analysis of log data."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What are the benefits of structured logging?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Structured logging has various advantages, including greater searchability, better integration with log analysis tools, simpler debugging, and improved monitoring capabilities. It enables more exact filtering and querying of log data."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the best format for a structured log?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "The most suitable format for structured logs is frequently determined by the application and log analysis tools. JSON is a popular format because it is human-readable and can be easily interpreted by most logging and monitoring systems."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Use StructLog in Python",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install StructLog",
-        "text": "Install StructLog using pip: pip install structlog"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure StructLog",
-        "text": "Set up StructLog with desired processors and renderers"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create a Logger",
-        "text": "Create a logger instance using structlog.get_logger()"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Add Context to Logs",
-        "text": "Use bound loggers or context variables to add persistent context to logs"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Log Messages",
-        "text": "Use logger methods like info(), error() to log structured messages"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Integrate with Frameworks",
-        "text": "Integrate StructLog with web frameworks like FastAPI or Django"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Monitor Logs",
-        "text": "Send logs to a monitoring tool like SigNoz for analysis and alerting"
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to Logging with StructLog in Python',
+        alternativeHeadline:
+          'Master structured logging in Python with StructLog - Learn setup, configuration, and best practices',
+        author: {
+          '@type': 'Person',
+          name: 'Sushant Gaurav',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-12T00:00:00Z',
+        dateModified: '2024-07-12T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/structlog/',
+        },
+        description:
+          "Discover how to leverage StructLog for advanced logging in Python. Learn setup, configuration, and best practices for structured logging to enhance your application's observability.",
+        keywords:
+          'structlog, structlog github, structlog python, structlog vs logging, structlog fastapi',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'StructLog',
+            description: 'A structured logging package for Python',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Python',
+            description: 'A high-level programming language',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Structured Logging',
+            description:
+              'A logging approach that treats log entries as data structures rather than plain text',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Monitoring Software',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'FastAPI',
+            applicationCategory: 'Web Framework',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Django',
+            applicationCategory: 'Web Framework',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What does StructLog do?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'StructLog is a Python logging package that simplifies structured logging. It enables developers to log detailed data rather than plain text messages, resulting in improved log analysis and troubleshooting.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is a structured log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'A structured log entry contains key-value pairs rather than unstructured, plain text. This format facilitates the programmatic parsing, searching, and analysis of log data.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the benefits of structured logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Structured logging has various advantages, including greater searchability, better integration with log analysis tools, simpler debugging, and improved monitoring capabilities. It enables more exact filtering and querying of log data.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the best format for a structured log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The most suitable format for structured logs is frequently determined by the application and log analysis tools. JSON is a popular format because it is human-readable and can be easily interpreted by most logging and monitoring systems.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use StructLog in Python',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install StructLog',
+              text: 'Install StructLog using pip: pip install structlog',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure StructLog',
+              text: 'Set up StructLog with desired processors and renderers',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Logger',
+              text: 'Create a logger instance using structlog.get_logger()',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Context to Logs',
+              text: 'Use bound loggers or context variables to add persistent context to logs',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Log Messages',
+              text: 'Use logger methods like info(), error() to log structured messages',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with Frameworks',
+              text: 'Integrate StructLog with web frameworks like FastAPI or Django',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Monitor Logs',
+              text: 'Send logs to a monitoring tool like SigNoz for analysis and alerting',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
-Logging is an essential component of software development. It helps developers understand how programs behave and identify potential errors. A well-structured logging procedures are essential for debugging, monitoring, performance optimization, and regulatory compliance. 
+Logging is an essential component of software development. It helps developers understand how programs behave and identify potential errors. A well-structured logging procedures are essential for debugging, monitoring, performance optimization, and regulatory compliance.
 
 StructLog is a Python library that provides an innovative approach to structured logging in Python, improving the logging experience with powerful features and flexibility. This article goes into the complexities of StructLog, demonstrating how it can be efficiently used in Python programs.
 
@@ -280,11 +283,11 @@ logger.info("custom_log", action="test_action")
 Explanation
 
 1. Custom Processor Function:
-    - `add_user_id(_, __, event_dict)`: This function adds a `user_id` key with a value of `'12345'` to the `event_dict`, which represents the log entry.
+   - `add_user_id(_, __, event_dict)`: This function adds a `user_id` key with a value of `'12345'` to the `event_dict`, which represents the log entry.
 2. Configuration:
-    - `processors=[add_user_id, structlog.processors.JSONRenderer()]`: The `structlog.configure` function is called with a list of processors. The first processor is our custom `add_user_id` function, and the second is `JSONRenderer`, which outputs logs in JSON format.
+   - `processors=[add_user_id, structlog.processors.JSONRenderer()]`: The `structlog.configure` function is called with a list of processors. The first processor is our custom `add_user_id` function, and the second is `JSONRenderer`, which outputs logs in JSON format.
 3. Logging a Message:
-    - `logger.info("custom_log", action="test_action")`: This line logs a message with an additional `action` context. The custom processor automatically includes `user_id` in the log entry.
+   - `logger.info("custom_log", action="test_action")`: This line logs a message with an additional `action` context. The custom processor automatically includes `user_id` in the log entry.
 
 The resulting log output will be in JSON format and include the `user_id`, making it more informative and easier to analyze.
 
@@ -349,9 +352,9 @@ In this example, the request context (`request_id="abc123"`) is included in both
 Explanation:
 
 1. Creating a Bound Logger:
-    - `logger = structlog.get_logger().bind(request_id="abc123")`: Creates a logger and binds the `request_id` context to it.
+   - `logger = structlog.get_logger().bind(request_id="abc123")`: Creates a logger and binds the `request_id` context to it.
 2. Logging Messages:
-    - `logger.info("request_started")` and `logger.info("request_ended")`: Logs messages with the bound context. The `request_id` is included in each log entry automatically.
+   - `logger.info("request_started")` and `logger.info("request_ended")`: Logs messages with the bound context. The `request_id` is included in each log entry automatically.
 
 ### Combining Contexts
 
@@ -372,9 +375,9 @@ logger.info("user_action", user_id="12345", action="clicked_button")
 ### Explanation
 
 1. Bound Logger:
-    - `logger = structlog.get_logger().bind(request_id="abc123")`: Binds the `request_id` to the logger.
+   - `logger = structlog.get_logger().bind(request_id="abc123")`: Binds the `request_id` to the logger.
 2. Dynamic Context:
-    - `logger.info("user_action", user_id="12345", action="clicked_button")`: Logs a message with additional context such as `user_id` and `action`, alongside the bound `request_id`.
+   - `logger.info("user_action", user_id="12345", action="clicked_button")`: Logs a message with additional context such as `user_id` and `action`, alongside the bound `request_id`.
 
 We can use both the bound loggers and dynamic context to ensure that critical information is consistently included in the logs. It still allows for the flexibility to add context-specific details.
 
@@ -505,7 +508,7 @@ In this example, the exception details are included in the log entry, and the lo
 
 Integrating StructLog with FastAPI for structured logging in web applications is simple. You can configure StructLog in your FastAPI application to log-structured data for each request.
 
-Note: 
+Note:
 
 FastAPI is a modern, fast (high-performance) web framework that is used for building APIs with Python (version 3.7+). FastAPI is designed for quick development and it offers numerous features like asynchronous request handling, automatic interactive API documentation, and excellent performance that is close to languages like: NodeJS and Go. So, FastAPI can be an ideal choice for high-performance applications.
 
@@ -671,7 +674,7 @@ Here are the key reasons why [monitoring logs](https://signoz.io/blog/log-monito
 7. Proactive maintenance
 8. Support and customer service
 
-To cover all the above major components, you can make use of tools like [SigNoz](https://signoz.io/). 
+To cover all the above major components, you can make use of tools like [SigNoz](https://signoz.io/).
 
 StructLog is easily connected with a variety of monitoring systems to improve observability. This allows you to better understand your application's behaviour and performance.
 
@@ -682,13 +685,9 @@ SigNoz is a full-stack open-source application performance monitoring and obser
 Key architecture features:
 
 - Logs, Metrics, and traces under a single dashboard
-    
-    SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
-    
+  SigNoz provides logs, metrics, and traces all under a single dashboard. You can also correlate these telemetry signals to debug your application issues quickly.
 - Native OpenTelemetry support
-    
-    SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
-    
+  SigNoz is built to support <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry</a> natively, which is quietly becoming the world standard for generating and managing telemetry data.
 
 ### Setup SigNoz
 
@@ -707,9 +706,13 @@ For detailed steps and configurations on how to send logs to SigNoz, refer to th
 
 ### Resources
 
-- <a href="https://www.structlog.org/" rel="noopener noreferrer nofollow" target="_blank">`StructLog` Documentation</a>
+- <a href="https://www.structlog.org/" rel="noopener noreferrer nofollow" target="_blank">
+    `StructLog` Documentation
+  </a>
 - [SigNoz Documentation](https://signoz.io/docs/)
-- <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">OpenTelemetry Documentation</a>
+- <a href="https://opentelemetry.io/" rel="noopener noreferrer nofollow" target="_blank">
+    OpenTelemetry Documentation
+  </a>
 
 ## FAQs
 
diff --git a/data/guides/syslog-levels.mdx b/data/guides/syslog-levels.mdx
index b44c73aaf..60f946cb3 100644
--- a/data/guides/syslog-levels.mdx
+++ b/data/guides/syslog-levels.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Understanding Syslog Severity Levels - A Quick Guide
-slug: syslog-levels
 date: 2024-07-26
 tags: [logging]
 authors: [manjunath_irukulla]
 description: Discover the 8 syslog severity levels, their meanings, and how to use them effectively for system logging and network management. Learn best practices and implementation tips.
-keywords: [syslog levels, system logging, network management, log analysis, syslog configuration, syslog facilities, log monitoring]
-
+keywords:
+  [
+    syslog levels,
+    system logging,
+    network management,
+    log analysis,
+    syslog configuration,
+    syslog facilities,
+    log monitoring,
+  ]
 ---
 
 Syslog severity levels are crucial components of system logging that help prioritize and categorize log messages. These levels range from 0 (Emergency) to 7 (Debug), providing a standardized way to assess the importance and urgency of system events. Understanding syslog levels is essential for effective system monitoring, troubleshooting, and maintaining network health.
@@ -27,16 +33,16 @@ These levels serve several key purposes:
 
 Here's a comprehensive table of the eight standard syslog severity levels:
 
-| Level | Severity | Keyword | Description |
-| --- | --- | --- | --- |
-| 0 | Emergency | emerg | System is unusable |
-| 1 | Alert | alert | Action must be taken immediately |
-| 2 | Critical | crit | Critical conditions |
-| 3 | Error | err | Error conditions |
-| 4 | Warning | warning | Warning conditions |
-| 5 | Notice | notice | Normal but significant condition |
-| 6 | Informational | info | Informational messages |
-| 7 | Debug | debug  | Debug-level messages |
+| Level | Severity      | Keyword | Description                      |
+| ----- | ------------- | ------- | -------------------------------- |
+| 0     | Emergency     | emerg   | System is unusable               |
+| 1     | Alert         | alert   | Action must be taken immediately |
+| 2     | Critical      | crit    | Critical conditions              |
+| 3     | Error         | err     | Error conditions                 |
+| 4     | Warning       | warning | Warning conditions               |
+| 5     | Notice        | notice  | Normal but significant condition |
+| 6     | Informational | info    | Informational messages           |
+| 7     | Debug         | debug   | Debug-level messages             |
 
 ## How Syslog Severity Levels Work in Practice
 
@@ -45,9 +51,9 @@ Syslog daemons process messages based on their severity levels. Here's how it ty
 1. A device or application generates a log message with a specific severity level.
 2. The syslog daemon receives the message and processes it according to predefined rules.
 3. Based on the severity level, the daemon may take different actions, such as:
-    - Storing the message in a specific log file
-    - Forwarding the message to another server
-    - Triggering an alert or notification
+   - Storing the message in a specific log file
+   - Forwarding the message to another server
+   - Triggering an alert or notification
 
 ### Real-world examples of events corresponding to each severity level include
 
@@ -130,26 +136,25 @@ To test and verify syslog configurations:
 Tools and techniques for monitoring and analyzing syslog messages:
 
 - Use log management platforms like [SigNoz](https://signoz.io/docs/introduction/) for centralized [log collection and analysis](https://signoz.io/comparisons/log-analysis-tools/#graylog).
-    
-    <GetStartedSigNoz />
-    
+  {' '}
+  <GetStartedSigNoz />
 - Implement real-time log monitoring and alerting.
 - Regularly review log data to identify trends and potential issues.
 
 ## Importance of Syslog Levels
 
-Having discussed Syslog levels, we can now explore how applying these levels enhances system management through prioritizing alerts, improving monitoring, facilitating proactive maintenance, and more. 
+Having discussed Syslog levels, we can now explore how applying these levels enhances system management through prioritizing alerts, improving monitoring, facilitating proactive maintenance, and more.
 
-1. Filtering and Prioritising: By filtering and prioritising issues, you can tackle the critical ones first, leaving minor hiccups for later. For example, during a system outage, you can prioritise Emergency and Alert-level communications shortly to identify and address the cause of the problem. 
-2. Alerting Based on Severity Levels: Setting alerts for certain levels ensures that critical issues are brought to your attention immediately. For instance, you might set up email or Slack notifications for Alert and Critical levels, so your team can respond promptly to prevent downtime or data loss.  
-3. Alerting for Proactive Maintenance and Troubleshooting: By sorting logs based on severity, you can find patterns and trends crucial for maintaining system health, optimising performance, and enhancing security using Syslog. For example, you can resolve recurring or performance degradation issues, improving system performance and better service your consumers. 
-4. Monitoring System Health: Regularly analysing Syslog lets you acquire insights into overall system performance and fix issues before they become more severe. [Monitoring logs](https://signoz.io/blog/log-monitoring/), for example, can help you discover trends that indicate system stress or potential breakdowns, allowing you to schedule maintenance or upgrades ahead of time. 
+1. Filtering and Prioritising: By filtering and prioritising issues, you can tackle the critical ones first, leaving minor hiccups for later. For example, during a system outage, you can prioritise Emergency and Alert-level communications shortly to identify and address the cause of the problem.
+2. Alerting Based on Severity Levels: Setting alerts for certain levels ensures that critical issues are brought to your attention immediately. For instance, you might set up email or Slack notifications for Alert and Critical levels, so your team can respond promptly to prevent downtime or data loss.
+3. Alerting for Proactive Maintenance and Troubleshooting: By sorting logs based on severity, you can find patterns and trends crucial for maintaining system health, optimising performance, and enhancing security using Syslog. For example, you can resolve recurring or performance degradation issues, improving system performance and better service your consumers.
+4. Monitoring System Health: Regularly analysing Syslog lets you acquire insights into overall system performance and fix issues before they become more severe. [Monitoring logs](https://signoz.io/blog/log-monitoring/), for example, can help you discover trends that indicate system stress or potential breakdowns, allowing you to schedule maintenance or upgrades ahead of time.
 5. Spotting performance bottlenecks: Syslog can detect resource spikes and slowdowns that may affect system performance. By analysing these logs, you can find bottlenecks and take preventive actions to ensure constant performance and minimal degradation.
-6. Troubleshooting Issues: Detailed Syslog data provides insight into service interruptions or unexpected reboots, allowing you to swiftly identify the root cause. This allows you faster and more effective troubleshooting, decreasing downtime and increasing system dependability. 
-7. Securing the Network: Syslog can log security-related events including failed login attempts or odd traffic patterns. This allows for rapid identification and response to any security threats, which improves your network’s overall security posture. 
-8. Regulatory Compliance: Syslog gives a thorough record of system and network activities, which is required to comply with regulations such as GIDPR, HIPPA, and PCI-DSS. This ensures that your organization complies with data protection and privacy regulations. 
-9. Auditing Critical Activities: Syslog can track critical events like unauthorised login attempts. This auditing capacity ensures compliance with security protocols and data protection requirements, making it an important tool for maintaining security standards. 
-10. Investigating Security Breaches: During a security incident, Syslog provide a detailed trail of system activity. Analyzing this trail helps you understand the nature of the breach, how it occurred, and how to prevent similar incidents in the future. 
+6. Troubleshooting Issues: Detailed Syslog data provides insight into service interruptions or unexpected reboots, allowing you to swiftly identify the root cause. This allows you faster and more effective troubleshooting, decreasing downtime and increasing system dependability.
+7. Securing the Network: Syslog can log security-related events including failed login attempts or odd traffic patterns. This allows for rapid identification and response to any security threats, which improves your network’s overall security posture.
+8. Regulatory Compliance: Syslog gives a thorough record of system and network activities, which is required to comply with regulations such as GIDPR, HIPPA, and PCI-DSS. This ensures that your organization complies with data protection and privacy regulations.
+9. Auditing Critical Activities: Syslog can track critical events like unauthorised login attempts. This auditing capacity ensures compliance with security protocols and data protection requirements, making it an important tool for maintaining security standards.
+10. Investigating Security Breaches: During a security incident, Syslog provide a detailed trail of system activity. Analyzing this trail helps you understand the nature of the breach, how it occurred, and how to prevent similar incidents in the future.
 
 ## Key Takeaways
 
@@ -182,7 +187,7 @@ Syslog levels, or severity levels, indicate the importance or urgency of log mes
 
 ### What is Syslog 0 to 7?
 
-Syslog 0 to 7 are the severity levels, with 0 being Emergency (most severe) and 7 being Debug (least severe). 
+Syslog 0 to 7 are the severity levels, with 0 being Emergency (most severe) and 7 being Debug (least severe).
 
 ### Which Syslog severity level is level number 7?
 
@@ -190,15 +195,15 @@ Level number 7 is Debug
 
 ### What layer is Syslog?
 
-Syslog operates at the application layer of the OSI model. 
+Syslog operates at the application layer of the OSI model.
 
 ### Why is Syslog used?
 
-Syslog is used for [centralized logging](https://signoz.io/blog/centralized-logging/) of messages from various devices and applications, aiding in monitoring, troubleshooting, and security analysis. 
+Syslog is used for [centralized logging](https://signoz.io/blog/centralized-logging/) of messages from various devices and applications, aiding in monitoring, troubleshooting, and security analysis.
 
 ### What are log levels?
 
-Log levels are categories that indicate the severity or importance of log messages, helping prioritize responses and actions. 
+Log levels are categories that indicate the severity or importance of log messages, helping prioritize responses and actions.
 
 ### Is Syslog UDP or TCP?
 
@@ -206,11 +211,11 @@ Syslog can use both UDP and TCP, but traditionally it uses UDP on port 514.
 
 ### What is local 7 Syslog?
 
-Local 7 is one of the custom facility codes in Syslog, used for local use and categorization of log messages. 
+Local 7 is one of the custom facility codes in Syslog, used for local use and categorization of log messages.
 
 ### What is the log level 7?
 
-Log level 7 corresponds to Debug, which is used for detailed information typically needed for diagnosing problems. 
+Log level 7 corresponds to Debug, which is used for detailed information typically needed for diagnosing problems.
 
 ### What are severity levels?
 
@@ -218,7 +223,7 @@ Severity levels indicate the criticality of log messages, ranging from Emergency
 
 ### What is the Syslog format?
 
-A typical Syslog message format includes the PRI (priority), HEADER (timestamp and hostname), and MSG (the log message). 
+A typical Syslog message format includes the PRI (priority), HEADER (timestamp and hostname), and MSG (the log message).
 
 ### How many severity levels are there?
 
@@ -226,4 +231,4 @@ There are eight severity levels in Syslog, from 0 to 7
 
 ### What are Syslog standards?
 
-Syslog standards include RFC 3164 (for the original syslog protocol) and RFC 5424 (for the updated protocol with additional features).
\ No newline at end of file
+Syslog standards include RFC 3164 (for the original syslog protocol) and RFC 5424 (for the updated protocol with additional features).
diff --git a/data/guides/systemctl-logs.mdx b/data/guides/systemctl-logs.mdx
index a6ca6c4d7..46e255057 100644
--- a/data/guides/systemctl-logs.mdx
+++ b/data/guides/systemctl-logs.mdx
@@ -1,11 +1,22 @@
 ---
-title: "Complete Guide to systemctl Logs: View, Filter, and Troubleshoot Linux System Logs"
-slug: systemctl-logs
+title: 'Complete Guide to systemctl Logs: View, Filter, and Troubleshoot Linux System Logs'
 date: 2025-07-23
 tags: [systemctl, logging]
 authors: [manjunath_irukulla]
-description: "Master systemctl logs with this comprehensive guide. Learn journalctl commands, advanced filtering techniques, troubleshooting workflows, and centralized log management solutions for Linux system administrators."
-keywords: [systemctl logs, journalctl commands, systemd logs, linux logging, log troubleshooting, service monitoring, journald configuration, log management, system administration, linux monitoring]
+description: 'Master systemctl logs with this comprehensive guide. Learn journalctl commands, advanced filtering techniques, troubleshooting workflows, and centralized log management solutions for Linux system administrators.'
+keywords:
+  [
+    systemctl logs,
+    journalctl commands,
+    systemd logs,
+    linux logging,
+    log troubleshooting,
+    service monitoring,
+    journald configuration,
+    log management,
+    system administration,
+    linux monitoring,
+  ]
 ---
 
 With over 70% of Linux distributions using systemd as their default init system, understanding [systemctl logs](https://signoz.io/guides/systemctl-logs/#essential-service-management-commands) has become essential for monitoring services, troubleshooting failures, and maintaining system reliability. This comprehensive guide explores systemctl logs from fundamentals to advanced techniques, addressing common challenges like performance issues with large log files, disk space management, and complex troubleshooting workflows.
@@ -41,17 +52,20 @@ These logs are stored in `/var/log/journal/` (persistent) or `/run/log/journal/`
 Here are the fundamental systemctl commands every administrator should master:
 
 **Check service status and recent logs:**
+
 ```bash
 sudo systemctl status <service-name>
 ```
 
 This command displays:
+
 - Current service state (active, inactive, failed)
 - Process information and PID
 - Recent log entries (last 10 lines by default)
 - Service unit file location
 
 **Manage service lifecycle:**
+
 ```bash
 # Start a service
 sudo systemctl start <service-name>
@@ -73,6 +87,7 @@ sudo systemctl disable <service-name>
 ```
 
 **List and inspect services:**
+
 ```bash
 # List all active services
 sudo systemctl list-units --type=service
@@ -114,6 +129,7 @@ Jul 23 10:30:15 server systemd[1]: Started The nginx HTTP and reverse proxy serv
 ```
 
 This output provides:
+
 - **Service state**: Active status and runtime duration
 - **Unit file**: Location and enablement status
 - **Process information**: PIDs and execution status
@@ -127,6 +143,7 @@ While systemctl provides basic log access, `journalctl` offers comprehensive log
 ### Basic journalctl Commands
 
 **View all logs:**
+
 ```bash
 # Show all journal entries
 sudo journalctl
@@ -139,6 +156,7 @@ sudo journalctl -r
 ```
 
 **Service-specific log viewing:**
+
 ```bash
 # View logs for a specific service
 sudo journalctl -u nginx
@@ -155,6 +173,7 @@ sudo journalctl -u nginx -f
 One of journalctl's most powerful features is precise time-based filtering:
 
 **Recent time periods:**
+
 ```bash
 # Show logs from the last hour
 sudo journalctl --since "1 hour ago"
@@ -170,6 +189,7 @@ sudo journalctl --since "30 minutes ago"
 ```
 
 **Specific date ranges:**
+
 ```bash
 # Show logs from a specific date
 sudo journalctl --since "2025-07-23"
@@ -203,6 +223,7 @@ sudo journalctl -u nginx -p err
 ```
 
 Priority levels in order of severity:
+
 - `emerg` (0): System unusable
 - `alert` (1): Action must be taken immediately
 - `crit` (2): Critical conditions
@@ -215,6 +236,7 @@ Priority levels in order of severity:
 ### Advanced Filtering Techniques
 
 **Filter by process ID or user:**
+
 ```bash
 # Show logs for specific PID
 sudo journalctl _PID=1234
@@ -227,6 +249,7 @@ sudo journalctl /usr/sbin/nginx
 ```
 
 **Combine multiple filters:**
+
 ```bash
 # Service logs with time range and priority
 sudo journalctl -u nginx --since "1 hour ago" -p warning
@@ -236,6 +259,7 @@ sudo journalctl -u nginx -u apache2 --since "1 day ago" -p err
 ```
 
 **Output formatting options:**
+
 ```bash
 # Show logs in JSON format
 sudo journalctl -u nginx -o json
@@ -257,16 +281,19 @@ sudo journalctl -u nginx --output=json | jq '.'
 When a service fails, follow this systematic approach:
 
 **1. Initial status check:**
+
 ```bash
 sudo systemctl status <service-name>
 ```
 
 Look for:
+
 - Exit codes and signal information
 - Recent error messages
 - Process state and timing
 
 **2. Examine detailed logs:**
+
 ```bash
 # View comprehensive service logs
 sudo journalctl -u <service-name> --no-pager
@@ -276,6 +303,7 @@ sudo journalctl -u <service-name> --since "1 hour ago" -p err
 ```
 
 **3. Check service configuration:**
+
 ```bash
 # Verify service unit file
 sudo systemctl cat <service-name>
@@ -286,6 +314,7 @@ sudo apache2ctl configtest  # for Apache
 ```
 
 **4. Analyze dependencies:**
+
 ```bash
 # Check service dependencies
 sudo systemctl list-dependencies <service-name>
@@ -299,6 +328,7 @@ sudo systemctl list-dependencies <service-name> --reverse
 Boot problems require special attention and specific journalctl techniques:
 
 **Analyze current boot:**
+
 ```bash
 # Show all logs from current boot
 sudo journalctl -b
@@ -314,6 +344,7 @@ systemd-analyze blame
 ```
 
 **Analyze previous boots:**
+
 ```bash
 # List available boot sessions
 sudo journalctl --list-boots
@@ -326,6 +357,7 @@ sudo journalctl -b -1 --failed
 ```
 
 **Boot performance analysis:**
+
 ```bash
 # Generate boot performance plot
 systemd-analyze plot > boot-analysis.svg
@@ -340,6 +372,7 @@ systemd-analyze blame | head -20
 ### Performance and Resource Monitoring
 
 **Monitor service resource usage:**
+
 ```bash
 # Show current resource usage
 systemctl status <service-name>
@@ -353,6 +386,7 @@ sudo systemctl show <service-name> --property=LimitNOFILE,LimitNPROC,MemoryLimit
 ```
 
 **Analyze log performance issues:**
+
 ```bash
 # Check journal size and usage
 sudo journalctl --disk-usage
@@ -392,6 +426,7 @@ ForwardToConsole=no        # Forward to console
 ### Manual Log Cleanup
 
 **Check current journal usage:**
+
 ```bash
 # Show disk usage
 sudo journalctl --disk-usage
@@ -402,6 +437,7 @@ ls -lah /var/log/journal/*/
 ```
 
 **Clean up logs:**
+
 ```bash
 # Delete logs older than 2 weeks
 sudo journalctl --vacuum-time=2weeks
@@ -417,6 +453,7 @@ sudo systemctl kill --kill-who=main --signal=SIGUSR2 systemd-journald
 ```
 
 **Verify log integrity:**
+
 ```bash
 # Check journal file integrity
 sudo journalctl --verify
@@ -434,28 +471,36 @@ sudo journalctl --header
 **Investigation steps:**
 
 1. **Initial assessment:**
+
    ```bash
    sudo systemctl status webapp.service
    ```
+
    Output shows: `failed (Result: exit-code)`
 
 2. **Examine recent logs:**
+
    ```bash
    sudo journalctl -u webapp.service --since "boot" -p err
    ```
+
    Reveals: `bind: Address already in use`
 
 3. **Check port usage:**
+
    ```bash
    sudo netstat -tlnp | grep :8080
    sudo journalctl _COMM=webapp --since "boot"
    ```
+
    Finds another process using port 8080
 
 4. **Analyze service dependencies:**
+
    ```bash
    sudo systemctl list-dependencies webapp.service
    ```
+
    Shows missing database dependency
 
 5. **Resolution:**
@@ -472,36 +517,40 @@ sudo journalctl --header
 **Investigation:**
 
 1. **Check journal size:**
+
    ```bash
    sudo journalctl --disk-usage
    # Output: Archived and active journals take up 15.2G in the file system.
    ```
 
 2. **Identify problematic services:**
+
    ```bash
    # Find services generating most logs
    sudo journalctl --since "1 day ago" | awk '{print $5}' | sort | uniq -c | sort -nr | head -10
    ```
 
 3. **Examine specific service:**
+
    ```bash
    sudo journalctl -u chatty-service --since "1 hour ago" | wc -l
    # Output: 50000 (excessive logging)
    ```
 
 4. **Implement solution:**
+
    ```bash
    # Immediate cleanup
    sudo journalctl --vacuum-time=3days
    sudo journalctl --vacuum-size=2G
-   
+
    # Configure rate limiting in /etc/systemd/journald.conf
    RateLimitInterval=10s
    RateLimitBurst=200
-   
+
    # Restart journald
    sudo systemctl restart systemd-journald
-   
+
    # Fix application logging level
    # Configure chatty-service to use less verbose logging
    ```
@@ -513,39 +562,43 @@ sudo journalctl --header
 **Investigation:**
 
 1. **Check container service status:**
+
    ```bash
    sudo systemctl status docker-myapp.service
    ```
 
 2. **Analyze container logs:**
+
    ```bash
    # systemd service logs
    sudo journalctl -u docker-myapp.service -f
-   
+
    # Docker container logs
    sudo docker logs myapp-container
-   
+
    # Combine both perspectives
    sudo journalctl -u docker.service -u docker-myapp.service --since "1 hour ago"
    ```
 
 3. **Monitor resource constraints:**
+
    ```bash
    # Check for OOM kills
    sudo journalctl -k | grep -i "killed process"
-   
+
    # Monitor memory usage
    sudo systemctl show docker-myapp.service --property=MemoryCurrent,MemoryMax
    ```
 
 4. **Resolution:**
+
    ```bash
    # Increase memory limits in service unit file
    sudo systemctl edit docker-myapp.service
    # Add:
    # [Service]
    # MemoryLimit=2G
-   
+
    sudo systemctl daemon-reload
    sudo systemctl restart docker-myapp.service
    ```
@@ -555,26 +608,33 @@ sudo journalctl --header
 ### Service State Messages
 
 **Service started successfully:**
+
 ```bash
 Started [service-name].service
 ```
-*Meaning*: Service initialization completed successfully.
-*Action*: None required - normal operation.
+
+_Meaning_: Service initialization completed successfully.
+_Action_: None required - normal operation.
 
 **Service stopped:**
+
 ```bash
-Stopped [service-name].service  
+Stopped [service-name].service
 ```
-*Meaning*: Service shutdown completed normally.
-*Action*: Check if shutdown was intended.
+
+_Meaning_: Service shutdown completed normally.
+_Action_: Check if shutdown was intended.
 
 **Service failed to start:**
+
 ```bash
 Failed to start [service-name].service
 Job for [service-name].service failed because the control process exited with error code
 ```
-*Meaning*: Service startup failed due to configuration or dependency issues.
-*Action*: 
+
+_Meaning_: Service startup failed due to configuration or dependency issues.
+_Action_:
+
 ```bash
 sudo journalctl -u [service-name] --no-pager
 sudo systemctl status [service-name] -l
@@ -583,32 +643,41 @@ sudo systemctl status [service-name] -l
 ### Process and Exit Code Messages
 
 **Main process exited:**
+
 ```bash
 [service-name]: Main process exited, code=exited, status=1/FAILURE
 ```
-*Meaning*: Service process terminated with non-zero exit code.
-*Action*: Check application logs and configuration:
+
+_Meaning_: Service process terminated with non-zero exit code.
+_Action_: Check application logs and configuration:
+
 ```bash
 sudo journalctl -u [service-name] -p err
 ```
 
 **Process killed by signal:**
+
 ```bash
 [service-name]: Main process exited, code=killed, status=9/KILL
 ```
-*Meaning*: Process was forcibly terminated (often due to OOM or manual kill).
-*Action*: Check system resources and memory usage:
+
+_Meaning_: Process was forcibly terminated (often due to OOM or manual kill).
+_Action_: Check system resources and memory usage:
+
 ```bash
 sudo journalctl -k | grep -i "killed process"
 dmesg | grep -i "out of memory"
 ```
 
 **Start operation timed out:**
+
 ```bash
 [service-name]: start operation timed out. Terminating.
 ```
-*Meaning*: Service took too long to initialize.
-*Action*: Increase timeout or check for blocking operations:
+
+_Meaning_: Service took too long to initialize.
+_Action_: Increase timeout or check for blocking operations:
+
 ```bash
 sudo systemctl edit [service-name]
 # Add: [Service]
@@ -618,32 +687,41 @@ sudo systemctl edit [service-name]
 ### Dependency and Configuration Issues
 
 **Dependency failed:**
+
 ```bash
 Dependency failed for [service-name].service
 ```
-*Meaning*: A required service or resource is unavailable.
-*Action*: Check dependencies:
+
+_Meaning_: A required service or resource is unavailable.
+_Action_: Check dependencies:
+
 ```bash
 sudo systemctl list-dependencies [service-name]
 sudo systemctl status [dependency-name]
 ```
 
 **Unit file syntax error:**
+
 ```bash
 [service-name].service: Failed to parse service file
 ```
-*Meaning*: Syntax error in the systemd unit file.
-*Action*: Validate unit file:
+
+_Meaning_: Syntax error in the systemd unit file.
+_Action_: Validate unit file:
+
 ```bash
 sudo systemd-analyze verify /etc/systemd/system/[service-name].service
 ```
 
 **Permission denied:**
+
 ```bash
 [service-name]: Failed to execute command: Permission denied
 ```
-*Meaning*: Service lacks necessary permissions.
-*Action*: Check file permissions and SELinux/AppArmor:
+
+_Meaning_: Service lacks necessary permissions.
+_Action_: Check file permissions and SELinux/AppArmor:
+
 ```bash
 ls -la /path/to/executable
 sudo journalctl | grep -i selinux
@@ -654,6 +732,7 @@ sudo journalctl | grep -i selinux
 ### Complex Query Construction
 
 **Multi-dimensional filtering:**
+
 ```bash
 # Combine service, time, and priority filters
 sudo journalctl -u nginx -u apache2 --since "2 hours ago" --until "1 hour ago" -p warning..err
@@ -666,6 +745,7 @@ sudo journalctl SYSLOG_IDENTIFIER=kernel --since "boot" -p crit
 ```
 
 **Pattern matching and grep integration:**
+
 ```bash
 # Find specific error patterns
 sudo journalctl -u webapp.service | grep -i "database\|connection\|timeout"
@@ -680,6 +760,7 @@ sudo journalctl -u sshd.service | grep "Failed password"
 ### Log Export and Processing
 
 **Export logs for analysis:**
+
 ```bash
 # Export to JSON for processing
 sudo journalctl -u nginx --since today -o json > nginx-logs.json
@@ -692,6 +773,7 @@ sudo journalctl -u nginx --since today -o json | jq -r '[.__REALTIME_TIMESTAMP,
 ```
 
 **Automated log analysis scripts:**
+
 ```bash
 #!/bin/bash
 # analyze-service-errors.sh
@@ -714,6 +796,7 @@ sudo journalctl -u "$SERVICE" --since "$TIME_RANGE" -p err -o short-iso
 ### Setting Up Log-Based Alerts
 
 **Using systemd OnFailure for immediate alerts:**
+
 ```ini
 # /etc/systemd/system/myapp.service
 [Unit]
@@ -731,6 +814,7 @@ WantedBy=multi-user.target
 ```
 
 **Create alert handler service:**
+
 ```ini
 # /etc/systemd/system/alert-handler@.service
 [Unit]
@@ -758,6 +842,7 @@ While systemctl and journalctl provide excellent local log management, modern in
 Here's how you can integrate systemd logs with SigNoz using [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector:
 
 1. **Install and configure OpenTelemetry Collector**:
+
 ```yaml
 # otel-collector-config.yaml
 receivers:
@@ -766,7 +851,7 @@ receivers:
       - /var/log/journal/*/*.journal
     operators:
       - type: journal_parser
-        
+
 processors:
   batch:
     timeout: 1s
@@ -774,7 +859,7 @@ processors:
 
 exporters:
   otlp:
-    endpoint: "http://your-signoz-endpoint:4317"
+    endpoint: 'http://your-signoz-endpoint:4317'
     insecure: true
 
 service:
@@ -786,6 +871,7 @@ service:
 ```
 
 2. **Configure systemd to forward logs**:
+
 ```bash
 # Enable persistent journal storage
 sudo mkdir -p /var/log/journal
@@ -797,6 +883,7 @@ sudo chmod 2755 /var/log/journal
 ```
 
 3. **Use journalctl to stream logs to SigNoz** (alternative approach):
+
 ```bash
 # Stream specific service logs
 journalctl -u your-service -f --output=json | \
@@ -807,7 +894,11 @@ curl -X POST "http://your-signoz-endpoint:8080/logs" \
 
 ## Getting Started with SigNoz
 
-<Figure src="/img/unified-observability/unified-observability-logs.webp" alt="SigNoz Logs Management Dashboard" caption="SigNoz Logs Management Dashboard" />
+<Figure
+  src="/img/unified-observability/unified-observability-logs.webp"
+  alt="SigNoz Logs Management Dashboard"
+  caption="SigNoz Logs Management Dashboard"
+/>
 
 SigNoz enhances Linux system monitoring by integrating with standard logging tools like systemctl and journalctl, providing [comprehensive log management](https://signoz.io/docs/userguide/logs/), real-time streaming, and analytical capabilities beyond native systemd logs.
 
@@ -817,12 +908,12 @@ Those who have data privacy concerns and can't send their data outside their inf
 
 Those who have the expertise to manage SigNoz themselves or just want to start with a free self-hosted option can use our [community edition](https://signoz.io/docs/install/self-host/).
 
-
 ## Best Practices and Security Considerations
 
 ### Log Security and Access Control
 
 **Protect sensitive information in logs:**
+
 ```bash
 # Configure journald to limit log access
 sudo chmod 640 /var/log/journal/*/*
@@ -834,6 +925,7 @@ journalctl --user -u user-service
 ```
 
 **Implement log rotation policies:**
+
 ```ini
 # /etc/systemd/journald.conf
 [Journal]
@@ -849,6 +941,7 @@ Seal=yes
 ### Performance Optimization
 
 **Optimize journal performance:**
+
 ```bash
 # Monitor journal performance impact
 systemctl status systemd-journald
@@ -863,6 +956,7 @@ SyslogLevel=info  # Reduce verbosity
 ```
 
 **Efficient log querying practices:**
+
 ```bash
 # Use specific time ranges to limit data processing
 sudo journalctl -u service --since "1 hour ago" --until "30 minutes ago"
@@ -879,12 +973,14 @@ sudo journalctl _SYSTEMD_UNIT=nginx.service --since today
 ### Performance Problems
 
 **Slow systemctl status commands:**
+
 1. Check journal size: `sudo journalctl --disk-usage`
 2. Clean up old logs: `sudo journalctl --vacuum-time=1week`
 3. Configure size limits in `/etc/systemd/journald.conf`
 4. Monitor I/O impact: `sudo iotop` during log operations
 
 **High disk usage from logs:**
+
 1. Implement automatic retention: `SystemMaxUse=1G` in journald.conf
 2. Use compression: `Compress=yes`
 3. Monitor with: `sudo journalctl --disk-usage`
@@ -893,6 +989,7 @@ sudo journalctl _SYSTEMD_UNIT=nginx.service --since today
 ### Access and Permission Issues
 
 **Permission denied errors:**
+
 ```bash
 # Add user to systemd-journal group
 sudo usermod -a -G systemd-journal username
@@ -903,6 +1000,7 @@ journalctl --user -u user-service
 ```
 
 **Missing logs or delayed updates:**
+
 ```bash
 # Force journal sync
 sudo systemctl kill --kill-who=main --signal=SIGUSR1 systemd-journald
@@ -918,22 +1016,26 @@ sudo journalctl --verify
 
 Mastering systemctl logs requires understanding the relationship between systemctl, systemd, and journalctl, along with practical troubleshooting workflows that address real-world challenges:
 
-**Essential Skills**: 
+**Essential Skills**:
+
 - Use `systemctl status` for quick service overview and recent logs
 - Leverage `journalctl` for comprehensive log analysis with time-based, priority, and field-specific filtering
 - Implement systematic troubleshooting workflows for service failures and performance issues
 
 **Performance Management**:
+
 - Configure journal storage limits to prevent disk space issues
 - Use rate limiting to control verbose services
 - Implement efficient querying practices for large log volumes
 
 **Advanced Capabilities**:
+
 - Combine multiple filtering criteria for precise log analysis
 - Export logs in structured formats for external processing
 - Integrate with monitoring systems for proactive incident management
 
 **Operational Excellence**:
+
 - Establish [log retention](https://signoz.io/guides/log-retention/) policies that balance storage costs with troubleshooting needs
 - Implement [centralized logging solutions](https://signoz.io/blog/centralized-logging/#3-splunk) like [SigNoz](https://signoz.io/docs/introduction/) for multi-server environments
 - Create automated alerting based on service state changes and log patterns
diff --git a/data/guides/throw-exception-vs-logging.mdx b/data/guides/throw-exception-vs-logging.mdx
index e9048116a..5b47b7450 100644
--- a/data/guides/throw-exception-vs-logging.mdx
+++ b/data/guides/throw-exception-vs-logging.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: When to Throw Exceptions vs. Log Errors in Code
-slug: throw-exception-vs-logging
 date: 2024-09-24
 tags: [logging]
 authors: [sushant_gaurav]
 description: Learn when to throw exceptions vs. log errors in your code. Discover best practices for effective error handling and debugging in software development.
-keywords: [Throw exception vs Logging, Error handling, Exception handling, Logging best practices, Debugging, Software development, Error management]
-
+keywords:
+  [
+    Throw exception vs Logging,
+    Error handling,
+    Exception handling,
+    Logging best practices,
+    Debugging,
+    Software development,
+    Error management,
+  ]
 ---
 
 Error management is an essential aspect of software development since it directly impacts your application's reliability, maintainability, and user experience. As a developer, one key decision in error management is whether to throw an exception or report the problem. This option affects your code's performance, behaviour, and debugability. In this post, we'll look at the distinctions between throwing exceptions and reporting mistakes and how to best include both strategies in your error management strategy.
@@ -85,14 +91,14 @@ In this example:
 Both exceptions and logging have different implications for how your application runs and performs. Here's a breakdown:
 
 1. Flow Interruption:
-    - Exceptions immediately halt the current execution path until handled. In the case of unhandled exceptions, they can even crash the entire application. This makes exceptions critical for addressing unexpected errors quickly.
-    - Logging, on the other hand, records errors or other relevant information without stopping or changing the current execution. It allows the application to continue running while issues are logged for future review.
+   - Exceptions immediately halt the current execution path until handled. In the case of unhandled exceptions, they can even crash the entire application. This makes exceptions critical for addressing unexpected errors quickly.
+   - Logging, on the other hand, records errors or other relevant information without stopping or changing the current execution. It allows the application to continue running while issues are logged for future review.
 2. Performance Considerations:
-    - Exceptions are expensive operations in terms of performance, especially when thrown frequently. They involve creating new stack traces, rolling back execution, and searching for catch blocks, which consumes more resources than regular code execution.
-    - Logging has a lower performance overhead compared to exceptions. However, excessive logging, especially at high verbosity levels like DEBUG or TRACE, can still slow down your application and fill up disk space quickly, making log rotation essential.
+   - Exceptions are expensive operations in terms of performance, especially when thrown frequently. They involve creating new stack traces, rolling back execution, and searching for catch blocks, which consumes more resources than regular code execution.
+   - Logging has a lower performance overhead compared to exceptions. However, excessive logging, especially at high verbosity levels like DEBUG or TRACE, can still slow down your application and fill up disk space quickly, making log rotation essential.
 3. Usability and Troubleshooting:
-    - Exceptions are suited for scenarios where the program must respond immediately to an error and either retry, fail gracefully, or notify the user.
-    - Logging is more useful for long-term monitoring, providing insights into not just errors but also warnings and general runtime behaviours that can be crucial for diagnosing performance bottlenecks, user behaviour, or subtle bugs that don’t immediately cause crashes.
+   - Exceptions are suited for scenarios where the program must respond immediately to an error and either retry, fail gracefully, or notify the user.
+   - Logging is more useful for long-term monitoring, providing insights into not just errors but also warnings and general runtime behaviours that can be crucial for diagnosing performance bottlenecks, user behaviour, or subtle bugs that don’t immediately cause crashes.
 
 ## When to Throw an Exception: Best Practices
 
@@ -102,7 +108,7 @@ Exceptions should be reserved for genuinely unusual circumstances—those that p
 2. Use suitable exception types: Depending on the nature of the mistake, select either verified or unchecked exceptions. Checked exceptions should be used when the caller expects to be able to recover the error. Unchecked exceptions (such as 'RuntimeException') should be used to indicate code issues.
 3. Deliver meaningful exception messages: The message in an exception should explain what went wrong and give enough information to help with troubleshooting.
 4. Add custom exceptions: Built-in exceptions may not always convey the specific issue your application encounters. In such cases, creating custom exceptions can help make your code more expressive, improve readability, and facilitate debugging by clearly communicating what went wrong.
-A custom exception should extend from an appropriate base class, such as `Exception` or `RuntimeException`, and it should include relevant information about the error. Let’s look at an example.
+   A custom exception should extend from an appropriate base class, such as `Exception` or `RuntimeException`, and it should include relevant information about the error. Let’s look at an example.
 
 Example of a Custom Exception:
 
@@ -175,11 +181,11 @@ When using exceptions, avoid the following common pitfalls:
 Logging is an important tool for analyzing and debugging your application's behaviour. Effective logging procedures may significantly increase your capacity to control mistakes and track system health over time.
 
 1. Choose appropriate log levels:
-    - `DEBUG`: Detailed information for diagnosing issues.
-    - `INFO`: General operational events to track the application’s flow.
-    - `WARN`: Potentially harmful situations that aren’t errors yet.
-    - `ERROR`: Errors that occur during runtime but don’t stop the application.
-    - `FATAL`: Critical errors that might cause the application to terminate.
+   - `DEBUG`: Detailed information for diagnosing issues.
+   - `INFO`: General operational events to track the application’s flow.
+   - `WARN`: Potentially harmful situations that aren’t errors yet.
+   - `ERROR`: Errors that occur during runtime but don’t stop the application.
+   - `FATAL`: Critical errors that might cause the application to terminate.
 2. Structure log messages for clarity Include timestamps, thread IDs, log levels, and class names in your log messages. Well-structured logs may make a significant difference when debugging complicated systems.
 3. Include context in log entries: To improve logs' usefulness during troubleshooting, include important contexts such as user IDs, request parameters, or system conditions.
 4. Implement log rotation and retention policies: To minimize performance difficulties and bloated log files, use log rotation and retention policies to archive or remove older logs as needed.
@@ -210,15 +216,15 @@ Too much logging can overload your system, slow down application performance, an
 Choosing the correct logging framework is determined by your language, system needs, and if you operate in a distributed setting. Here are a few often-used tools:
 
 - Java:
-    - Log4j: A powerful, flexible logging library widely used in enterprise applications.
-    - SLF4J: A simple logging facade that works with various logging backends.
-    - java.util.logging: The built-in logging library in the Java standard library.
+  - Log4j: A powerful, flexible logging library widely used in enterprise applications.
+  - SLF4J: A simple logging facade that works with various logging backends.
+  - java.util.logging: The built-in logging library in the Java standard library.
 - Python:
-    - Logging module: Python’s built-in logging module provides flexibility for setting up handlers and formatters, and it integrates well with various libraries.
-    - To learn about logging in Python, different levels of logging, formatters, etc. in more detail, you can refer to this article [Python Logging - From Setup to Monitoring with Best Practices](https://signoz.io/guides/logging-in-python/). You can also check out [Python Logging Best Practices - Expert Tips with Practical Examples](https://signoz.io/guides/python-logging-best-practices/).
+  - Logging module: Python’s built-in logging module provides flexibility for setting up handlers and formatters, and it integrates well with various libraries.
+  - To learn about logging in Python, different levels of logging, formatters, etc. in more detail, you can refer to this article [Python Logging - From Setup to Monitoring with Best Practices](https://signoz.io/guides/logging-in-python/). You can also check out [Python Logging Best Practices - Expert Tips with Practical Examples](https://signoz.io/guides/python-logging-best-practices/).
 - JavaScript:
-    - Winston: A popular, multi-transport logging tool for Node.js applications.
-    - Bunyan: A JSON-based logging library designed for Node.js applications with a focus on speed.
+  - Winston: A popular, multi-transport logging tool for Node.js applications.
+  - Bunyan: A JSON-based logging library designed for Node.js applications with a focus on speed.
 
 ### Centralized Logging in Distributed Systems
 
@@ -268,26 +274,25 @@ Error management in distributed systems is substantially more difficult due to t
 ## Key Strategies for Error Handling in Distributed Systems:
 
 1. Use correlation IDs: A correlation ID is a unique identification given to each request. It allows you to follow and trace the request as it moves through various services. By providing this ID in logs and error messages, you may track a request across several microservices, making distributed issues easier to troubleshoot.
-    
-    ```java
-    // Example of adding a correlation ID to logs
-    String correlationId = UUID.randomUUID().toString();
-    logger.info("Starting process with correlationId {}", correlationId);
-    ```
-    
+
+   ```java
+   // Example of adding a correlation ID to logs
+   String correlationId = UUID.randomUUID().toString();
+   logger.info("Starting process with correlationId {}", correlationId);
+   ```
+
 2. Implement circuit breakers: A circuit breaker prevents cascading failures by interrupting calls to a service that is down or under severe demand. This guarantees that dependent services are not swamped by several failed attempts.
-    - Libraries such as Hystrix and Resilience4j provide circuit breaker patterns in Java.
+   - Libraries such as Hystrix and Resilience4j provide circuit breaker patterns in Java.
 3. Design for failure: In distributed systems, always account for service outages, network timeouts, and unavailability. Use timeouts, retries, and fallbacks to gracefully manage errors without cascading into other services.
 4. Standardize error responses: Create a uniform error response style for your microservices, guaranteeing that when something goes wrong, all services return a standard payload. This simplifies error handling in client applications.
-    
-    ```json
-    {
-        "error": "Service Unavailable",
-        "message": "The payment service is currently down",
-        "status": 503
-    }
-    ```
-    
+
+   ```json
+   {
+     "error": "Service Unavailable",
+     "message": "The payment service is currently down",
+     "status": 503
+   }
+   ```
 
 ## Monitoring and Alerting: Beyond Logging and Exceptions
 
@@ -296,14 +301,14 @@ While logging and exception management are vital, they alone cannot assure an ap
 ### Key Practices for Monitoring and Alerting
 
 1. Set up alerts: Alerts should be triggered depending on exceptions, error rates, or certain log patterns. This guarantees that your team is alerted of concerns in real-time, resulting in faster remedies. Establish thresholds for essential metrics, such as:
-    - High mistake rates.
-    - Unusually sluggish reaction times.
-    - Frequently timed out or retried.
+   - High mistake rates.
+   - Unusually sluggish reaction times.
+   - Frequently timed out or retried.
 2. Implement health checks: Use health checks to constantly monitor the status of essential services and dependencies. Services should offer health endpoints (e.g., '/health') that give status information that monitoring systems may poll.
 3. Use metrics: Gather metrics to measure key performance indicators such as response times, CPU/memory use, and error rates. These metrics give insight into how the application performs over time and assist in finding bottlenecks. Track metrics such as:
-    - Latency, which measures average response times across services.
-    - Error rate: The percentage of unsuccessful requests.
-    - Resource usage: CPU and memory utilization by service.
+   - Latency, which measures average response times across services.
+   - Error rate: The percentage of unsuccessful requests.
+   - Resource usage: CPU and memory utilization by service.
 4. Integrate with incident management systems: Tools like PagerDuty, OpsGenie, or ServiceNow can help automate incident response by integrating with your monitoring tools. Alerts can be routed to the appropriate teams with clear severity levels.
 
 ### Leveraging SigNoz for Advanced Error Tracking
@@ -320,7 +325,7 @@ SigNoz's key features include real-time error tracking, which enables fast diagn
 
 ### Getting Started with SigNoz
 
-<GetStartedSigNoz /> 
+<GetStartedSigNoz />{' '}
 
 ### Best Practices for Exception and Logging Documentation
 
@@ -363,16 +368,16 @@ Create custom exceptions for situations that require additional context. Custom
 Error handling in asynchronous code (for example, utilizing futures, promises, or callbacks) differs from synchronous code:
 
 1. Use completion handlers to capture exceptions in asynchronous functions. For example, Java's `CompletableFuture` offers error handling methods such as `handle` and `exceptionally`.
-    
-    ```java
-    CompletableFuture.supplyAsync(() -> {
-        // Do some work
-        return result;
-    }).exceptionally(e -> {
-        // Handle exception
-        return fallbackResult;
-    });
-    ```
-    
+
+   ```java
+   CompletableFuture.supplyAsync(() -> {
+       // Do some work
+       return result;
+   }).exceptionally(e -> {
+       // Handle exception
+       return fallbackResult;
+   });
+   ```
+
 2. Log exceptions appropriately without disrupting the execution of other duties.
-3. Rethrow exceptions only if the fault impacts future operations. Otherwise, handle the problem using an asynchronous callback or future.
\ No newline at end of file
+3. Rethrow exceptions only if the fault impacts future operations. Otherwise, handle the problem using an asynchronous callback or future.
diff --git a/data/guides/time-series-from-prometheus-source-how-to-set-nulls-as-zero.mdx b/data/guides/time-series-from-prometheus-source-how-to-set-nulls-as-zero.mdx
index ab951a441..d3d639fa4 100644
--- a/data/guides/time-series-from-prometheus-source-how-to-set-nulls-as-zero.mdx
+++ b/data/guides/time-series-from-prometheus-source-how-to-set-nulls-as-zero.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: How to Handle Null Values in Prometheus Time Series Data
-slug: time-series-from-prometheus-source-how-to-set-nulls-as-zero
 date: 2024-10-14
-tags: [prometheus,missing values, time-series]
+tags: [prometheus, missing values, time-series]
 authors: [simran_kumari]
 description: Learn how to handle null values in Prometheus time series data. Discover methods to set nulls as zero, improve data visualization, and enhance analysis accuracy.
-keywords: [Prometheus, null values, time series data, PromQL, Grafana, data visualization, SigNoz, metrics]
-
+keywords:
+  [Prometheus, null values, time series data, PromQL, Grafana, data visualization, SigNoz, metrics]
 ---
 
 When working with Prometheus time series data, encountering gaps or missing data points can be frustrating. These absences can disrupt visualizations and skew your analysis. However, setting these missing data points (or gaps) to zero can help maintain continuity in your dashboards, though it’s essential to understand when to apply this solution to avoid misleading interpretations.
@@ -18,7 +16,11 @@ In this article, we’ll explore why gaps occur in [Prometheus data](https://sig
 
 In Prometheus, a "null value" doesn’t exist in the typical database sense. Instead, when we talk about missing data, we mean the absence of a data point at a specific time. This absence shows up as a gap in your time series graphs.
 
-<Figure src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image.webp" alt="Gaps in Prometheus Data" caption="Gaps in Prometheus Data" />
+<Figure
+  src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image.webp"
+  alt="Gaps in Prometheus Data"
+  caption="Gaps in Prometheus Data"
+/>
 
 ### Common Causes of Missing Data:
 
@@ -72,7 +74,7 @@ Filling in missing data with zero isn’t always the right solution. For certain
 - Counter metrics: Zero might imply a reset or sudden drop, which could skew your understanding of system behavior.
 - Sporadic metrics: For metrics that are emitted only under specific conditions, setting missing points to zero can distort the truth, making it seem like nothing happened when the data should just remain absent.
 
-For example, if you look back to the previous scenario where missing data points existed for CPU usage data.  Without proper handling, you might configure the graph to default missing data to zero. Now, your graph looks like this:
+For example, if you look back to the previous scenario where missing data points existed for CPU usage data. Without proper handling, you might configure the graph to default missing data to zero. Now, your graph looks like this:
 
 ```sql
 Time:   |--------|--------|--------|--------|--------|--------|
@@ -88,81 +90,99 @@ Handling missing data points in Prometheus is crucial for ensuring accurate visu
 ### Basic Methods for Handling Missing Data
 
 1. Using `or vector(0)`
-    - This technique allows you to replace missing values with zero.
-    
-    ```
-    custom_metric or vector(0)
-    ```
-    
-    - Explanation: This query returns the value of `custom_metric`, and if it’s absent, it defaults to `0`.
-    
-    <Figure src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%201.webp" alt="Handling missing data using vector(0)" caption="Handling missing data using vector(0)" />
-    
-    Use Case: Imagine monitoring server CPU usage. If the server goes offline, rather than seeing a confusing gap, you can treat the missing data as `0`, indicating that the server wasn’t active.
-    
+
+   - This technique allows you to replace missing values with zero.
+
+   ```
+   custom_metric or vector(0)
+   ```
+
+   - Explanation: This query returns the value of `custom_metric`, and if it’s absent, it defaults to `0`.
+
+   <Figure
+     src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%201.webp"
+     alt="Handling missing data using vector(0)"
+     caption="Handling missing data using vector(0)"
+   />
+
+   Use Case: Imagine monitoring server CPU usage. If the server goes offline, rather than seeing a confusing gap, you can treat the missing data as `0`, indicating that the server wasn’t active.
+
 2. Utilizing the `absent()` Function
-    - The `absent()` function helps identify completely missing metrics.
-    
-    ```
-    absent(custom_metric)
-    ```
-    
-    - Explanation: This query returns a value when `custom_metric` is not present, useful for alerting on missing metrics.
-    
-    <Figure src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%202.webp" alt="Handling missing data using absent()" caption="Handling missing data using absent()" />
-    
-    Use Case: In a microservices architecture, you'll want to know if a service’s health metric stops being scraped. `absent()` can alert you that the service may be down or unreachable, helping to detect system failures early.
-    
-    Note: It returns an empty vector if the vector passed to it has any elements and a 1-element vector with the value 1 if the vector passed to it has no elements.
-    
+
+   - The `absent()` function helps identify completely missing metrics.
+
+   ```
+   absent(custom_metric)
+   ```
+
+   - Explanation: This query returns a value when `custom_metric` is not present, useful for alerting on missing metrics.
+
+   <Figure
+     src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%202.webp"
+     alt="Handling missing data using absent()"
+     caption="Handling missing data using absent()"
+   />
+
+   Use Case: In a microservices architecture, you'll want to know if a service’s health metric stops being scraped. `absent()` can alert you that the service may be down or unreachable, helping to detect system failures early.
+
+   Note: It returns an empty vector if the vector passed to it has any elements and a 1-element vector with the value 1 if the vector passed to it has no elements.
 
 ### Advanced PromQL Techniques for Null Handling
 
 1. Applying `group_left` and `group_right` for Label Matching
-    - Scenario: You have two metrics: one for system resource usage (e.g., CPU) and another for error rates. The second metric (`error_rate`) doesn’t always have data for every instance, leading to missing information when you attempt to join the two.
-    - Solution: Use `group_left` or `group_right` depending on the label relationship to include all relevant data, even if some metrics are missing values.
-    
-    Syntax:
-    
-    ```python
-    # for left join
-    metric_a * on(label) group_left(label_value) metric_b or vector(0) 
-    # for right join 
-    metric_a * on(label) group_right(label_value) metric_b or vector(0)   
-    ```
-    
-    Query examples:
-    
-    ```python
-    # Left join example
-    system_resource_usage * on(instance,exported_instance) group_left error_rate or vector(0) 
-    
-    # Right join example
-    error_rate * on(instance,system_resource_usage) group_right or vector(0)
-    ```
-    
-    ### Explanation:
-    
-    - `group_left`: Matches `system_resource_usage` with `error_rate` for each instance and exported instance, ensuring that missing error values are filled with `0`.
-    - `group_right`: Ensures all error rates are preserved even if the resource usage data is missing for some instances.
-    - `or vector(0)`: Fills missing values with `0` for better visualization.
-    
-    <Figure src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%203.webp" alt="Handling missing data using group_left()" caption="Handling missing data using group_left()" />
-    
-    Use Case: You’re monitoring CPU usage per instance alongside error rates. By using `group_left`, you ensure that even if there are no errors for certain instances, the CPU usage is still included in your visualizations, and errors are treated as zero instead of missing. Alternatively, use `group_right` if you prioritize error rate data over system resource metrics.
-    
+
+   - Scenario: You have two metrics: one for system resource usage (e.g., CPU) and another for error rates. The second metric (`error_rate`) doesn’t always have data for every instance, leading to missing information when you attempt to join the two.
+   - Solution: Use `group_left` or `group_right` depending on the label relationship to include all relevant data, even if some metrics are missing values.
+
+   Syntax:
+
+   ```python
+   # for left join
+   metric_a * on(label) group_left(label_value) metric_b or vector(0)
+   # for right join
+   metric_a * on(label) group_right(label_value) metric_b or vector(0)
+   ```
+
+   Query examples:
+
+   ```python
+   # Left join example
+   system_resource_usage * on(instance,exported_instance) group_left error_rate or vector(0)
+
+   # Right join example
+   error_rate * on(instance,system_resource_usage) group_right or vector(0)
+   ```
+
+   ### Explanation:
+
+   - `group_left`: Matches `system_resource_usage` with `error_rate` for each instance and exported instance, ensuring that missing error values are filled with `0`.
+   - `group_right`: Ensures all error rates are preserved even if the resource usage data is missing for some instances.
+   - `or vector(0)`: Fills missing values with `0` for better visualization.
+
+   <Figure
+     src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%203.webp"
+     alt="Handling missing data using group_left()"
+     caption="Handling missing data using group_left()"
+   />
+
+   Use Case: You’re monitoring CPU usage per instance alongside error rates. By using `group_left`, you ensure that even if there are no errors for certain instances, the CPU usage is still included in your visualizations, and errors are treated as zero instead of missing. Alternatively, use `group_right` if you prioritize error rate data over system resource metrics.
+
 2. Using `absent_over_time()` for Detecting Long-Term Absences
-    - Scenario: You’re monitoring a critical metric over time and want to detect if it has stopped reporting for an extended period, indicating a problem with the service or the metric’s availability.
-    - Solution: Use `absent_over_time()` to monitor whether a metric has been missing for a defined period.
-    
-    ```
-    absent_over_time(custom_metric[1m])
-    ```
-    
-    Explanation: This function returns a value if `custom_metric` has been absent for the last 1 minute, useful for identifying metrics that are not being scraped over extended periods.
-    
-    <Figure src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%204.webp" alt="Handling missing data using absent_over_time()" caption="Handling missing data using absent_over_time()" />
-    
+
+   - Scenario: You’re monitoring a critical metric over time and want to detect if it has stopped reporting for an extended period, indicating a problem with the service or the metric’s availability.
+   - Solution: Use `absent_over_time()` to monitor whether a metric has been missing for a defined period.
+
+   ```
+   absent_over_time(custom_metric[1m])
+   ```
+
+   Explanation: This function returns a value if `custom_metric` has been absent for the last 1 minute, useful for identifying metrics that are not being scraped over extended periods.
+
+   <Figure
+     src="/img/guides/2024/10/time-series-from-prometheus-source-how-to-set-nulls-as-zero-image%204.webp"
+     alt="Handling missing data using absent_over_time()"
+     caption="Handling missing data using absent_over_time()"
+   />
 
 ## Best Practices for Handling Null/Missing Values in Time Series Data
 
@@ -178,9 +198,9 @@ To effectively manage null values in the Prometheus time series:
 SigNoz is a powerful observability tool that allows you to track missing data points more effectively, helping you avoid blind spots in your monitoring. SigNoz can help you in:
 
 - Detecting Missing Data with SigNoz
-SigNoz can alert you to missing data automatically by configuring rules for your most critical metrics. This means you won’t have to rely on visually spotting gaps in your Grafana dashboards; instead, SigNoz can proactively notify you.
+  SigNoz can alert you to missing data automatically by configuring rules for your most critical metrics. This means you won’t have to rely on visually spotting gaps in your Grafana dashboards; instead, SigNoz can proactively notify you.
 - Visualizing Data Gaps in SigNoz Dashboards
-SigNoz provides advanced visualizations for analyzing patterns in missing data. This can help you see trends where certain metrics go missing frequently, helping you dig into root causes and improve data collection reliability.
+  SigNoz provides advanced visualizations for analyzing patterns in missing data. This can help you see trends where certain metrics go missing frequently, helping you dig into root causes and improve data collection reliability.
 
 <GetStartedSigNoz />
 
@@ -208,4 +228,4 @@ While setting nulls/missing values to zero can improve data continuity, it's imp
 
 ### What are the differences in handling nulls for counters vs. gauges?
 
-For counters, which only increase over time, setting nulls to zero might not be appropriate as it could indicate a reset. For gauges, which can increase or decrease, setting nulls to zero or the last known value might be more suitable. The choice depends on the specific metric and what the null value represents in your system.
\ No newline at end of file
+For counters, which only increase over time, setting nulls to zero might not be appropriate as it could indicate a reset. For gauges, which can increase or decrease, setting nulls to zero or the last known value might be more suitable. The choice depends on the specific metric and what the null value represents in your system.
diff --git a/data/guides/tomcat-logs.mdx b/data/guides/tomcat-logs.mdx
index 964af9f1d..fbcda1a72 100644
--- a/data/guides/tomcat-logs.mdx
+++ b/data/guides/tomcat-logs.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Tomcat Logs - Where to Find and How to Configure Them
-slug: tomcat-logs
 date: 2024-07-31
 tags: [logging]
 authors: [nilesh_sinha]
 description: Discover how to locate, configure, and analyze Tomcat logs for effective application monitoring and troubleshooting in various environments.
-keywords: [Tomcat logs, log configuration, application monitoring, troubleshooting, log analysis, Java logging, containerized environments]
-
+keywords:
+  [
+    Tomcat logs,
+    log configuration,
+    application monitoring,
+    troubleshooting,
+    log analysis,
+    Java logging,
+    containerized environments,
+  ]
 ---
 
 [Tomcat logs](https://signoz.io/guides/tomcat-logs/#accessing-logs-in-containerized-environments) are essential tools for monitoring and troubleshooting Java web applications. They provide valuable insights into your application's behavior, performance, and potential issues. This guide will walk you through the process of finding, configuring, and utilizing Tomcat logs effectively — from basic setups to advanced environments.
@@ -30,15 +36,15 @@ Tomcat generates several types of log files:
 
 Tomcat uses different log levels to categorize the severity of logged events:
 
-| Log Level | Analogy | Description |
-| --- | --- | --- |
-| SEVERE | Fire Alarm | Indicates a critical issue that needs immediate attention, like a system crash or failure. |
-| WARNING | Smell of Smoke | Signals a potential problem that should be monitored and addressed to prevent escalation. |
-| INFO | Daily News Update | Provides general information about the system's operations and events. |
-| CONFIG | Setting Up Equipment | Logs messages related to the configuration and setup of the system. |
-| FINE | GPS Directions | Offers detailed information about the application's operation, like tracing steps. |
-| FINER | Step-by-Step Assembly Guide | Provides even more detailed trace information for debugging purposes. |
-| FINEST | Microscope View | Delivers the most detailed logging, capturing every minute detail of the application's execution. |
+| Log Level | Analogy                     | Description                                                                                       |
+| --------- | --------------------------- | ------------------------------------------------------------------------------------------------- |
+| SEVERE    | Fire Alarm                  | Indicates a critical issue that needs immediate attention, like a system crash or failure.        |
+| WARNING   | Smell of Smoke              | Signals a potential problem that should be monitored and addressed to prevent escalation.         |
+| INFO      | Daily News Update           | Provides general information about the system's operations and events.                            |
+| CONFIG    | Setting Up Equipment        | Logs messages related to the configuration and setup of the system.                               |
+| FINE      | GPS Directions              | Offers detailed information about the application's operation, like tracing steps.                |
+| FINER     | Step-by-Step Assembly Guide | Provides even more detailed trace information for debugging purposes.                             |
+| FINEST    | Microscope View             | Delivers the most detailed logging, capturing every minute detail of the application's execution. |
 
 These levels help you filter and prioritize log messages based on their importance.
 
@@ -85,27 +91,27 @@ metadata:
   name: tomcat-pod
 spec:
   containers:
-  - name: tomcat
-    image: tomcat:latest
-  - name: log-streamer
-    image: log-streamer:latest
-    volumeMounts:
-    - name: logs
-      mountPath: /usr/local/tomcat/logs
+    - name: tomcat
+      image: tomcat:latest
+    - name: log-streamer
+      image: log-streamer:latest
+      volumeMounts:
+        - name: logs
+          mountPath: /usr/local/tomcat/logs
   volumes:
-  - name: logs
-    emptyDir: {}
+    - name: logs
+      emptyDir: {}
 ```
 
 - Tomcat Container:
-    - Uses the `tomcat:latest` image.
-    - Mounts a volume at `/usr/local/tomcat/logs` to store log files.
+  - Uses the `tomcat:latest` image.
+  - Mounts a volume at `/usr/local/tomcat/logs` to store log files.
 - Log Streamer Container:
-    - Uses the `log-streamer:latest` image, which is responsible for streaming logs to an external system (like ELK stack, Fluentd, etc.).
-    - Mounts the same volume at `/usr/local/tomcat/logs` to access the log files generated by the Tomcat container.
+  - Uses the `log-streamer:latest` image, which is responsible for streaming logs to an external system (like ELK stack, Fluentd, etc.).
+  - Mounts the same volume at `/usr/local/tomcat/logs` to access the log files generated by the Tomcat container.
 - Shared Volume:
-    - An `emptyDir` volume named `logs` is created. This volume is ephemeral and exists only as long as the Pod exists.
-    - Both containers mount this volume to the same path, allowing the log-streamer to access and stream the logs produced by the Tomcat container.
+  - An `emptyDir` volume named `logs` is created. This volume is ephemeral and exists only as long as the Pod exists.
+  - Both containers mount this volume to the same path, allowing the log-streamer to access and stream the logs produced by the Tomcat container.
 
 ## Configuring Tomcat Logging
 
@@ -199,9 +205,9 @@ Example `log4j2.xml` configuration:
 ### Appenders
 
 - RollingFile: An appender that writes log messages to a file and rolls the file over based on time and/or size constraints.
-    - name="RollingFile": The name of the appender.
-    - fileName="logs/app.log": The primary log file.
-    - filePattern=`logs/$${date}/app-%d{MM-dd-yyyy}-%i.log.gz`: The pattern for rolled-over log files. It creates a new file for each month, and within each month, it creates a new file daily, appending an index (`%i`) if there are multiple log files for the same day. The logs are also compressed using gzip (`.gz`).
+  - name="RollingFile": The name of the appender.
+  - fileName="logs/app.log": The primary log file.
+  - filePattern=`logs/$${date}/app-%d{MM-dd-yyyy}-%i.log.gz`: The pattern for rolled-over log files. It creates a new file for each month, and within each month, it creates a new file daily, appending an index (`%i`) if there are multiple log files for the same day. The logs are also compressed using gzip (`.gz`).
 
 ### Policies
 
@@ -211,8 +217,8 @@ Example `log4j2.xml` configuration:
 ### Loggers
 
 - Root logger: The main logger for the application.
-    - level="info": Sets the logging level to INFO, meaning it will log messages at INFO level and higher (INFO, WARN, ERROR, FATAL).
-    - AppenderRef ref="RollingFile": Associates the RollingFile appender with the root logger.
+  - level="info": Sets the logging level to INFO, meaning it will log messages at INFO level and higher (INFO, WARN, ERROR, FATAL).
+  - AppenderRef ref="RollingFile": Associates the RollingFile appender with the root logger.
 
 ## Analyzing and Monitoring Tomcat Logs
 
@@ -263,18 +269,18 @@ Security-related log entries:
 ## Best Practices for Tomcat Log Management
 
 1. Implement a [log retention](https://signoz.io/guides/log-retention/) policy:
-    - Define how long to keep logs based on compliance requirements
-    - Use log rotation to manage file sizes and historical data
+   - Define how long to keep logs based on compliance requirements
+   - Use log rotation to manage file sizes and historical data
 2. Centralize logs for multi-instance deployments:
-    - Use a [centralized logging solution](https://signoz.io/blog/centralized-logging/#best-practices-for-centralized-logging) (e.g., ELK stack)
-    - Implement log shipping from each Tomcat instance
+   - Use a [centralized logging solution](https://signoz.io/blog/centralized-logging/#best-practices-for-centralized-logging) (e.g., ELK stack)
+   - Implement log shipping from each Tomcat instance
 3. Use log analysis tools:
-    - Set up alerts for critical errors or performance thresholds
-    - Create dashboards for visualizing application health metrics
+   - Set up alerts for critical errors or performance thresholds
+   - Create dashboards for visualizing application health metrics
 4. Secure log files:
-    - Restrict access to log directories
-    - Encrypt sensitive log data
-    - Implement audit trails for log access
+   - Restrict access to log directories
+   - Encrypt sensitive log data
+   - Implement audit trails for log access
 
 By following these guidelines, you'll be well-equipped to harness the power of Tomcat logs for effective application monitoring and troubleshooting.
 
@@ -282,81 +288,67 @@ By following these guidelines, you'll be well-equipped to harness the power of T
 
 SigNoz is an open-source application performance monitoring (APM) and observability platform. Integrating Tomcat logs with SigNoz can provide a unified view of your application's performance and logs. Here's how to send Tomcat logs to SigNoz:
 
-1. Install SigNoz:
-Follow the [SigNoz installation guide](https://signoz.io/docs/install/) to set up SigNoz in your environment.
-    
-    `<GetStartedSigNoz />`
-    
-2. Configure Log4j2 for Tomcat:
-Create a `log4j2.xml` file in your Tomcat's `conf` directory:
-    
-    ```xml
-    <?xml version="1.0" encoding="UTF-8"?>
-    <Configuration status="INFO">
-      <Appenders>
-        <Console name="Console" target="SYSTEM_OUT">
-          <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
-        </Console>
-        <Http name="SigNoz" url="<http://localhost:8080/v1/logs>">
-          <Property name="Content-Type" value="application/json"/>
-          <JsonLayout complete="false" compact="true" eventEol="true">
-            <KeyValuePair key="service.name" value="tomcat-app"/>
-          </JsonLayout>
-        </Http>
-      </Appenders>
-      <Loggers>
-        <Root level="info">
-          <AppenderRef ref="Console"/>
-          <AppenderRef ref="SigNoz"/>
-        </Root>
-      </Loggers>
-    </Configuration>
-    
-    ```
-    
-    Replace `http://localhost:8080` with your SigNoz server address.
-    
-3. Update Tomcat's logging.properties:
-Modify `conf/logging.properties` to use Log4j2:
-    
-    ```
-    handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
-    .handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
-    
-    org.apache.juli.FileHandler.level = FINE
-    org.apache.juli.FileHandler.directory = ${catalina.base}/logs
-    org.apache.juli.FileHandler.prefix = catalina.
-    
-    java.util.logging.ConsoleHandler.level = FINE
-    java.util.logging.ConsoleHandler.formatter = org.apache.juli.OneLineFormatter
-    
-    org.apache.catalina.core.ContainerBase.[Catalina].[localhost].level = INFO
-    org.apache.catalina.core.ContainerBase.[Catalina].[localhost].handlers = org.apache.juli.FileHandler
-    
-    ```
-    
-4. Add required dependencies:
-Place the following JARs in Tomcat's `lib` directory:
-    - log4j-api-2.x.x.jar
-    - log4j-core-2.x.x.jar
-    - log4j-web-2.x.x.jar
-    - log4j-jul-2.x.x.jar
-5. Configure Tomcat to use Log4j2:
-Add these system properties to `catalina.sh` (Unix) or `catalina.bat` (Windows):
-    
-    ```
-    JAVA_OPTS="$JAVA_OPTS -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager"
-    JAVA_OPTS="$JAVA_OPTS -Dlog4j.configurationFile=conf/log4j2.xml"
-    
-    ```
-    
-6. Restart Tomcat:
-Restart your Tomcat server to apply the changes.
-7. View logs in SigNoz:
-Access your SigNoz dashboard to view and analyze the Tomcat logs alongside other application metrics.
-    
-    <Figure src="/img/guides/2024/07/tomcat-logs-Untitled.webp" alt="Untitled" caption="View Logs in SigNoz" />
-    
+1.  Install SigNoz:
+    Follow the [SigNoz installation guide](https://signoz.io/docs/install/) to set up SigNoz in your environment.
+        `<GetStartedSigNoz />`
+2.  Configure Log4j2 for Tomcat:
+    Create a `log4j2.xml` file in your Tomcat's `conf` directory:
+        ```xml
+        <?xml version="1.0" encoding="UTF-8"?>
+        <Configuration status="INFO">
+          <Appenders>
+            <Console name="Console" target="SYSTEM_OUT">
+              <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+            </Console>
+            <Http name="SigNoz" url="<http://localhost:8080/v1/logs>">
+              <Property name="Content-Type" value="application/json"/>
+              <JsonLayout complete="false" compact="true" eventEol="true">
+                <KeyValuePair key="service.name" value="tomcat-app"/>
+              </JsonLayout>
+            </Http>
+          </Appenders>
+          <Loggers>
+            <Root level="info">
+              <AppenderRef ref="Console"/>
+              <AppenderRef ref="SigNoz"/>
+            </Root>
+          </Loggers>
+        </Configuration>
+
+        ```
+
+        Replace `http://localhost:8080` with your SigNoz server address.
+3.  Update Tomcat's logging.properties:
+    Modify `conf/logging.properties` to use Log4j2:
+        ```
+        handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
+        .handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
+
+        org.apache.juli.FileHandler.level = FINE
+        org.apache.juli.FileHandler.directory = ${catalina.base}/logs
+        org.apache.juli.FileHandler.prefix = catalina.
+
+        java.util.logging.ConsoleHandler.level = FINE
+        java.util.logging.ConsoleHandler.formatter = org.apache.juli.OneLineFormatter
+
+        org.apache.catalina.core.ContainerBase.[Catalina].[localhost].level = INFO
+        org.apache.catalina.core.ContainerBase.[Catalina].[localhost].handlers = org.apache.juli.FileHandler
+
+        ```
+4.  Add required dependencies:
+    Place the following JARs in Tomcat's `lib` directory: - log4j-api-2.x.x.jar - log4j-core-2.x.x.jar - log4j-web-2.x.x.jar - log4j-jul-2.x.x.jar
+5.  Configure Tomcat to use Log4j2:
+    Add these system properties to `catalina.sh` (Unix) or `catalina.bat` (Windows):
+        ```
+        JAVA_OPTS="$JAVA_OPTS -Djava.util.logging.manager=org.apache.logging.log4j.jul.LogManager"
+        JAVA_OPTS="$JAVA_OPTS -Dlog4j.configurationFile=conf/log4j2.xml"
+
+        ```
+6.  Restart Tomcat:
+    Restart your Tomcat server to apply the changes.
+7.  View logs in SigNoz:
+    Access your SigNoz dashboard to view and analyze the Tomcat logs alongside other application metrics.
+        <Figure src="/img/guides/2024/07/tomcat-logs-Untitled.webp" alt="Untitled" caption="View Logs in SigNoz" />
 
 By integrating Tomcat logs with SigNoz, you gain:
 
@@ -429,5 +421,11 @@ Yes, you can delete old Tomcat logs to free up disk space. However, implement a
 
 ## Resources
 
-- <a href="https://tomcat.apache.org/tomcat-8.5-doc/logging.html" rel="noopener noreferrer nofollow" target="_blank">Apache Tomcat Documentation on Logging</a>
+- <a
+    href="https://tomcat.apache.org/tomcat-8.5-doc/logging.html"
+    rel="noopener noreferrer nofollow"
+    target="_blank"
+  >
+    Apache Tomcat Documentation on Logging
+  </a>
 - [Monitoring Java Applications Logs with SigNoz](https://signoz.io/docs/userguide/collecting_application_logs_otel_sdk_java/)
diff --git a/data/guides/understanding-histogram-quantile-based-on-rate-in-prometheus.mdx b/data/guides/understanding-histogram-quantile-based-on-rate-in-prometheus.mdx
index 8b067a117..078a1ed54 100644
--- a/data/guides/understanding-histogram-quantile-based-on-rate-in-prometheus.mdx
+++ b/data/guides/understanding-histogram-quantile-based-on-rate-in-prometheus.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: What is the difference between histogram_quantile and Rate Explained - Prometheus Explained
-slug: understanding-histogram-quantile-based-on-rate-in-prometheus
 date: 2024-11-29
 tags: [Prometheus, faq]
 authors: [nitin_gouda]
 description: Learn the key differences between histogram_quantile and rate functions in Prometheus. Understand how to use them effectively for precise system monitoring.
 keywords: [histogram_quantile, rate, Prometheus, monitoring, metrics, percentiles, time series]
-
 ---
 
 Prometheus, a powerful open-source monitoring system, offers robust tools for analyzing time-series data. Two of its most crucial functions — `histogram_quantile` and `rate` — often confuse even seasoned developers. This article demystifies these functions, explaining their differences, use cases, and how they work together to provide valuable insights into system performance.
@@ -135,47 +132,58 @@ Without `rate`, monitoring systems would struggle to handle counter resets, lead
 The `rate` function in Prometheus is highly useful for tracking changes over time by calculating the per-second average rate of increase of a counter metric. Below are examples of its common uses with the `http_server_requests_seconds_count` metric.
 
 1. Request `Rate` Monitoring:
-    
-    Monitoring the rate of requests helps track how many requests an application or service is processing over a specific period. This is essential for understanding traffic patterns, handling capacity, and detecting unexpected spikes in demand.
-    
-    Example:
-    
-    ```
-    rate(http_server_requests_seconds_count[5m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-6934ff57-80ce-4eb6-836f-a1d003f3af82.webp" alt="Monitoring rate of request, normal traffic and spikes" caption="Monitoring rate of request, normal traffic and spikes" />
-    
-    Here, `rate(http_server_requests_seconds_count[5m])` calculates the average rate of HTTP [server requests](https://signoz.io/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count/) per second over the past 5 minutes. This metric can help you monitor normal traffic levels and identify spikes.
-    
+
+   Monitoring the rate of requests helps track how many requests an application or service is processing over a specific period. This is essential for understanding traffic patterns, handling capacity, and detecting unexpected spikes in demand.
+
+   Example:
+
+   ```
+   rate(http_server_requests_seconds_count[5m])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-6934ff57-80ce-4eb6-836f-a1d003f3af82.webp"
+     alt="Monitoring rate of request, normal traffic and spikes"
+     caption="Monitoring rate of request, normal traffic and spikes"
+   />
+
+   Here, `rate(http_server_requests_seconds_count[5m])` calculates the average rate of HTTP [server requests](https://signoz.io/guides/grafana-graphing-http-requests-per-minute-with-http-server-requests-seconds-count/) per second over the past 5 minutes. This metric can help you monitor normal traffic levels and identify spikes.
+
 2. Throughput Analysis:
-    
-    `rate` can also be used to monitor data throughput by tracking the number of processed requests over time. This is essential in network or storage systems to ensure that resource utilization meets the required levels.
-    
-    Example:
-    
-    ```
-    rate(http_server_requests_seconds_count[5m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-28_at_12.18.27_AM.webp" alt="Monitoring HTTP requests by the server over 5 min" caption="Monitoring HTTP requests by the server over 5 min" /> 
-    
-    This example calculates the rate of HTTP requests processed by the server over the past 5 minutes, providing an overview of throughput. A consistent or increasing rate indicates steady or growing demand on the system, useful for performance tuning and scaling.
-    
+
+   `rate` can also be used to monitor data throughput by tracking the number of processed requests over time. This is essential in network or storage systems to ensure that resource utilization meets the required levels.
+
+   Example:
+
+   ```
+   rate(http_server_requests_seconds_count[5m])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-28_at_12.18.27_AM.webp"
+     alt="Monitoring HTTP requests by the server over 5 min"
+     caption="Monitoring HTTP requests by the server over 5 min"
+   />{' '}
+
+   This example calculates the rate of HTTP requests processed by the server over the past 5 minutes, providing an overview of throughput. A consistent or increasing rate indicates steady or growing demand on the system, useful for performance tuning and scaling.
+
 3. CPU Usage Monitoring:
-    
-    Although `rate` is typically used with specific request metrics, it can also track CPU time usage by a process when combined with metrics that measure CPU usage. Monitoring this helps optimize resource allocation.
-    
-    Example:
-    
-    ```
-    rate(process_cpu_usage[1m])
-    ```
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-28_at_12.32.43_AM.webp" alt="Monitoring CPU Usage over last 1 minute" caption="Monitoring CPU Usage over last 1 minute" />
-    
-    This query calculates the `rate` of CPU time consumed by a process per second over the last 1 minute, helping to pinpoint processes that consume excessive CPU resources.
-    
+
+   Although `rate` is typically used with specific request metrics, it can also track CPU time usage by a process when combined with metrics that measure CPU usage. Monitoring this helps optimize resource allocation.
+
+   Example:
+
+   ```
+   rate(process_cpu_usage[1m])
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-28_at_12.32.43_AM.webp"
+     alt="Monitoring CPU Usage over last 1 minute"
+     caption="Monitoring CPU Usage over last 1 minute"
+   />
+
+   This query calculates the `rate` of CPU time consumed by a process per second over the last 1 minute, helping to pinpoint processes that consume excessive CPU resources.
 
 These examples illustrate how `rate` provides valuable insights across different monitoring scenarios by enabling you to track usage, performance, and errors efficiently in Prometheus.
 
@@ -221,22 +229,26 @@ By using `histogram_quantile` strategically, you can extract detailed performanc
 
 ### Calculating Percentiles with `histogram_quantile`
 
-Using the `histogram_quantile` function in Prometheus can help you analyze and track performance at specific percentiles. This is particularly useful in applications where user experience depends on system responsiveness, as percentiles let you pinpoint response time patterns and identify potential slowdowns. 
+Using the `histogram_quantile` function in Prometheus can help you analyze and track performance at specific percentiles. This is particularly useful in applications where user experience depends on system responsiveness, as percentiles let you pinpoint response time patterns and identify potential slowdowns.
 
 1. Choose the Desired Percentile: First, decide which percentile you need to analyze. For example, to observe the 95th percentile, use `0.95` as the quantile value in your query. The 95th percentile indicates that 95% of observed values fall below this point, giving you insight into high-end performance limits without focusing on extreme outliers.
 2. Apply the `rate` Function: For accurate percentile calculations, apply the `rate` function to the histogram’s bucket data over a selected time range (e.g., 5 minutes). This calculates the rate of change per second for each bucket within the specified interval, smoothing out any short-term variations.
 3. Sum the Rates and Group by Bucket Boundaries: This query calculates the rate of promotion of objects in memory over a 12-hour window, grouped by the `area` label, which represents different segments of memory (such as heap and non-heap). By summing the rates and grouping by `area`, you can gain insights into how the promoted memory usage distributes across different parts of the Java Virtual Machine.
-    
-    Example query:
-    
-    ```
-    sum(rate(jvm_gc_memory_promoted_bytes_total[12h])) by (area)
-    ```
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-30_at_10.45.08_AM.webp" alt="Sum Rates to monitor memory activities" caption="Sum Rates to monitor memory activities" />
-    
-    This query provides a 12-hour perspective on the rate of memory promotion events, helping you monitor trends in memory activity across JVM areas. This visibility is crucial for identifying areas under memory pressure, enabling proactive adjustments to maintain performance and stability.
-    
+
+   Example query:
+
+   ```
+   sum(rate(jvm_gc_memory_promoted_bytes_total[12h])) by (area)
+   ```
+
+   <Figure
+     src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-10-30_at_10.45.08_AM.webp"
+     alt="Sum Rates to monitor memory activities"
+     caption="Sum Rates to monitor memory activities"
+   />
+
+   This query provides a 12-hour perspective on the rate of memory promotion events, helping you monitor trends in memory activity across JVM areas. This visibility is crucial for identifying areas under memory pressure, enabling proactive adjustments to maintain performance and stability.
+
 4. Pass the Result to `histogram_quantile`: Finally, use `histogram_quantile` to calculate the chosen percentile across these grouped bucket rates. This gives you the estimated metric value (such as request duration) below which the chosen percentage of observations fall.
 
 Interpretation: The output of `histogram_quantile` represents the maximum duration that 95% of requests fall under, which is valuable for setting performance benchmarks or identifying slowdowns.
@@ -287,32 +299,32 @@ This approach allows you to see both the distribution (percentiles) and the freq
 Using advanced techniques in Prometheus can help you unlock deeper insights from histogram data by aggregating across multiple instances, filtering by specific labels, and analyzing multi-dimensional data. Here’s how:
 
 1. Aggregate Across Instances: Aggregating histograms across instances allows you to calculate overall percentiles across all instances of a job. This can be especially useful when you have multiple replicas of a service and need a consolidated view.
-    
-    ```
-    histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, job))
-    ```
-    
-    This query calculates the 95th percentile of request durations across all instances of a specified job. By using `sum(...) by (le, job)`, you’re combining data from each instance under the same job label, creating a more comprehensive view of latency for that service.
-    
+
+   ```
+   histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, job))
+   ```
+
+   This query calculates the 95th percentile of request durations across all instances of a specified job. By using `sum(...) by (le, job)`, you’re combining data from each instance under the same job label, creating a more comprehensive view of latency for that service.
+
 2. Filter Based on Labels: Filtering allows you to focus on specific subsets of your data, such as successful requests only or requests with certain attributes.
-    
-    ```
-    histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{status="200"}[5m])) by (le))
-    ```
-    
-    In this example, the query calculates the 99th percentile for requests that have a status code of `200`, focusing on successful requests only. By adding `{status="200"}` to the metric, Prometheus filters for only the matching entries before applying the histogram and rate functions. This technique can help you hone in on specific types of requests, like errors or other critical events.
-    
-3. Handle Multi-Dimensional Data: Prometheus can also handle queries with multiple labels, enabling you to analyze complex, multi-dimensional data across various labels like API method, endpoint path, or HTTP status. 
-    
-    ```
-    histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, method, path))
-    ```
-    
-    This query calculates the 95th percentile of request durations while breaking down results by HTTP method and API path. By grouping the results by `(le, method, path)`, you can analyze performance for each endpoint, gaining insights into how different parts of your application are performing.
-    
+
+   ```
+   histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{status="200"}[5m])) by (le))
+   ```
+
+   In this example, the query calculates the 99th percentile for requests that have a status code of `200`, focusing on successful requests only. By adding `{status="200"}` to the metric, Prometheus filters for only the matching entries before applying the histogram and rate functions. This technique can help you hone in on specific types of requests, like errors or other critical events.
+
+3. Handle Multi-Dimensional Data: Prometheus can also handle queries with multiple labels, enabling you to analyze complex, multi-dimensional data across various labels like API method, endpoint path, or HTTP status.
+
+   ```
+   histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, method, path))
+   ```
+
+   This query calculates the 95th percentile of request durations while breaking down results by HTTP method and API path. By grouping the results by `(le, method, path)`, you can analyze performance for each endpoint, gaining insights into how different parts of your application are performing.
+
 4. Handling Edge Cases and Outliers: When dealing with histogram data, be aware of possible outliers and edge cases, as they can skew percentile calculations. Outliers might be legitimate performance issues or rare spikes. You may choose to:
-    - Add filters to exclude unusually high or low values, reducing the impact of outliers.
-    - Aggregate data over longer time windows to smooth out sudden spikes, which can help you identify true performance trends.
+   - Add filters to exclude unusually high or low values, reducing the impact of outliers.
+   - Aggregate data over longer time windows to smooth out sudden spikes, which can help you identify true performance trends.
 
 Each of these techniques helps you extract more meaningful data and gain specific, actionable insights into application performance and reliability.
 
@@ -320,91 +332,73 @@ Each of these techniques helps you extract more meaningful data and gain specifi
 
 Histograms are powerful tools for capturing critical metrics like latency, response times, and data distributions, enabling detailed analysis of application performance across quantiles. With histogram metrics in SigNoz, you can effectively track application health, spot performance bottlenecks, and gain insights into user experience patterns. By leveraging SigNoz’s histogram capabilities, you can also set precise alerts and make data-driven decisions to enhance application reliability and performance.
 
-[SigNoz](https://signoz.io/) is a versatile, open-source observability platform that provides deep monitoring capabilities, including support for Prometheus-compatible histograms and range vectors. This combination allows you to analyze time-based trends, monitor historical performance, and proactively address issues over specific time windows. 
+[SigNoz](https://signoz.io/) is a versatile, open-source observability platform that provides deep monitoring capabilities, including support for Prometheus-compatible histograms and range vectors. This combination allows you to analyze time-based trends, monitor historical performance, and proactively address issues over specific time windows.
 
 Here's how you can leverage SigNoz to implement range vectors:
 
-1. Create a SigNoz Cloud Account
-[SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
-2. Clone Sample Flask app repository
-From your terminal use the following command to clone sample Flask appfrom the GitHub repository.
-    
-    ```bash
-    git clone https://github.com/SigNoz/sample-golang-app
-    ```
-    
-3. Add .env File to the Root Project Folder
-In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
-    
-    ```yaml
-    OTEL_COLLECTOR_ENDPOINT=ingest.{region}.signoz.cloud:443
-    SIGNOZ_INGESTION_KEY=***
-    ```
-    
-    `OTEL_COLLECTOR_ENDPOINT`: Specifies the address of the SigNoz collector where your application will send its telemetry data.
-    
-    `SIGNOZ_INGESTION_KEY`: Authenticates your application with the SigNoz collector.
-    
-    Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your actual ingestion key.
-    
-    To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Untitled.webp" alt="SigNoz Ingestion Settings Page" caption="SigNoz Ingestion Settings Page" />
-    
-4. Using SigNoz Application Monitoring: 
-In the top left corner, click on getting started. 
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
-    
-    You will be redirected to “Get Started Page”. Choose `Application Monitoring` to check latency and how your application is performing.
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-05_at_11.35.06_AM.webp" alt="SigNoz Getting Started" caption="SigNoz Getting Started" />
-    
-5. Select the language and framework of the application 
-We are using a Go Application which we want to monitor. Select `Go` You can write service name as you want, we are using go.
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-08_at_23.23.11.webp" alt="SigNoz Application Monitoring (Select Data Source)" caption="SigNoz Application Monitoring (Select Data Source)" />
-    
-6. Choose environment your app is running on
-Choose from the environment options that match your setup. Since I'm running this on my Mac, I'm choosing the ARM option.  
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-08_at_23.23.47.webp" alt="SigNoz Env Details" caption="SigNoz Env Details" />
-    
-7. Using OpenTelemtry SDK or Collector to send data to SigNoz
-To send data to SigNoz, we will use the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector. The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations. 
-For more details, visit [OpenTelemetry Collector Guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/).
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-05_at_11.43.33_AM.webp" alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." />
-    
-8. Start Your Application with SigNoz
-To begin sending telemetry data from your application to SigNoz, use the following command to start your app. This command specifies key configuration details like the service name, ingestion key, and the endpoint for the [OpenTelemetry collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/).
-    
-    ```bash
-    SERVICE_NAME=goApp INSECURE_MODE=false 
-    OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=<SIGNOZ-INGESTION_KEY-HERE> OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{region}.signoz.cloud:443 go run main.go
-    ```
-    
-9. Verify Your Application in the SigNoz Dashboard: 
-Once your application is running, navigate to the Services tab in the SigNoz dashboard. If everything is set up correctly, you should see your app listed here. 
-From this tab, you can monitor your app's performance metrics, including latency, error rates, and throughput, gaining valuable insights into how your application is performing in real time
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-09_at_00.29.59.webp" alt="SigNoz Services tab" caption="SigNoz Services tab" />
-    
+1.  Create a SigNoz Cloud Account
+    [SigNoz Cloud](https://signoz.io/teams/) provides a 30-day free trial period. This demo uses SigNoz Cloud, but you can choose to use the open-source version.
+2.  Clone Sample Flask app repository
+    From your terminal use the following command to clone sample Flask appfrom the GitHub repository.
+        ```bash
+        git clone https://github.com/SigNoz/sample-golang-app
+        ```
+3.  Add .env File to the Root Project Folder
+    In the root directory of your project folder, create a new file named `.env` and paste the below details into it:
+        ```yaml
+        OTEL_COLLECTOR_ENDPOINT=ingest.{region}.signoz.cloud:443
+        SIGNOZ_INGESTION_KEY=***
+        ```
+
+        `OTEL_COLLECTOR_ENDPOINT`: Specifies the address of the SigNoz collector where your application will send its telemetry data.
+
+        `SIGNOZ_INGESTION_KEY`: Authenticates your application with the SigNoz collector.
+
+        Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with your actual ingestion key.
+
+        To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
+
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Untitled.webp" alt="SigNoz Ingestion Settings Page" caption="SigNoz Ingestion Settings Page" />
+4.  Using SigNoz Application Monitoring:
+    In the top left corner, click on getting started.
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="SigNoz Dashboard" caption="SigNoz Dashboard" />
+
+        You will be redirected to “Get Started Page”. Choose `Application Monitoring` to check latency and how your application is performing.
+
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-05_at_11.35.06_AM.webp" alt="SigNoz Getting Started" caption="SigNoz Getting Started" />
+5.  Select the language and framework of the application
+    We are using a Go Application which we want to monitor. Select `Go` You can write service name as you want, we are using go.
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-08_at_23.23.11.webp" alt="SigNoz Application Monitoring (Select Data Source)" caption="SigNoz Application Monitoring (Select Data Source)" />
+6.  Choose environment your app is running on
+    Choose from the environment options that match your setup. Since I'm running this on my Mac, I'm choosing the ARM option.
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-08_at_23.23.47.webp" alt="SigNoz Env Details" caption="SigNoz Env Details" />
+7.  Using OpenTelemtry SDK or Collector to send data to SigNoz
+    To send data to SigNoz, we will use the [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) Collector. The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations.
+    For more details, visit [OpenTelemetry Collector Guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/).
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-08-05_at_11.43.33_AM.webp" alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." />
+8.  Start Your Application with SigNoz
+    To begin sending telemetry data from your application to SigNoz, use the following command to start your app. This command specifies key configuration details like the service name, ingestion key, and the endpoint for the [OpenTelemetry collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/).
+        ```bash
+        SERVICE_NAME=goApp INSECURE_MODE=false
+        OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=<SIGNOZ-INGESTION_KEY-HERE> OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{region}.signoz.cloud:443 go run main.go
+        ```
+9.  Verify Your Application in the SigNoz Dashboard:
+    Once your application is running, navigate to the Services tab in the SigNoz dashboard. If everything is set up correctly, you should see your app listed here.
+    From this tab, you can monitor your app's performance metrics, including latency, error rates, and throughput, gaining valuable insights into how your application is performing in real time
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-09_at_00.29.59.webp" alt="SigNoz Services tab" caption="SigNoz Services tab" />
 10. Using `histogram_quantile` to [Analyze Metrics](https://signoz.io/blog/metrics-explorer/):
-Navigate to the Traces section via the sidebar menu in the SigNoz dashboard. In the Search Filter section, input the necessary query expressions. This allows you to filter and analyze specific metrics.
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-735d3ae6-eb7a-472b-aea6-cd5776bc6277.webp" alt="Navigate to Traces to use the Search Filter" caption="Navigate to Traces to use the Search Filter" />
-    
-    To calculate a specific quantile (e.g., 90th percentile) for a metric, use a query like the following:
-    
-    ```
-    histogram_quantile(0.90, sum(rate(http_request_duration_seconds_bucket[15d])) by (le))
-    ```
-    
-    <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-09_at_21.11.55.webp" alt="SigNoz Explorers tab" caption="SigNoz Explorers tab" />
-    
-    This query retrieves the 90th percentile latency over the last 15 days, allowing you to monitor high-latency request patterns and potential performance issues over a longer timeframe. Adjust the quantile or time range (`5m`, `1d`, etc.) to suit the specific behavior you wish to analyze.
-    
+    Navigate to the Traces section via the sidebar menu in the SigNoz dashboard. In the Search Filter section, input the necessary query expressions. This allows you to filter and analyze specific metrics.
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-735d3ae6-eb7a-472b-aea6-cd5776bc6277.webp" alt="Navigate to Traces to use the Search Filter" caption="Navigate to Traces to use the Search Filter" />
+
+        To calculate a specific quantile (e.g., 90th percentile) for a metric, use a query like the following:
+
+        ```
+        histogram_quantile(0.90, sum(rate(http_request_duration_seconds_bucket[15d])) by (le))
+        ```
+
+        <Figure src="/img/guides/2024/11/understanding-histogram-quantile-based-on-rate-in-prometheus-Screenshot_2024-11-09_at_21.11.55.webp" alt="SigNoz Explorers tab" caption="SigNoz Explorers tab" />
+
+        This query retrieves the 90th percentile latency over the last 15 days, allowing you to monitor high-latency request patterns and potential performance issues over a longer timeframe. Adjust the quantile or time range (`5m`, `1d`, etc.) to suit the specific behavior you wish to analyze.
 
 By leveraging `histogram_quantile`, you can gain actionable insights into latency distributions and optimize your application performance efficiently.
 
@@ -415,20 +409,19 @@ By leveraging `histogram_quantile`, you can gain actionable insights into latenc
 When using `histogram_quantile` and `rate` functions in Prometheus, applying best practices will help you get the most accurate and meaningful insights from your data. Here’s a beginner-friendly guide to optimizing their usage:
 
 1. Choose Appropriate Time Windows
-    
-    Time windows define the range over which data is analyzed. Using shorter time windows, such as 1 minute, offers a more granular view of data, capturing rapid changes or spikes in metrics. However, shorter windows can also make data appear noisier, showing more variation that might not reflect long-term trends. For stable insights, consider balancing granularity with smoothness—e.g., 5- or 15-minute windows.
-    
+
+   Time windows define the range over which data is analyzed. Using shorter time windows, such as 1 minute, offers a more granular view of data, capturing rapid changes or spikes in metrics. However, shorter windows can also make data appear noisier, showing more variation that might not reflect long-term trends. For stable insights, consider balancing granularity with smoothness—e.g., 5- or 15-minute windows.
+
 2. Optimize Query Performance with Recording Rules
-    
-    If you frequently query certain metrics, using recording rules can speed up response times. Recording rules precompute specific queries and store their results, allowing you to access them faster in dashboards or alerts. For example, if you consistently track the 95th percentile of response times, set up a recording rule to avoid recalculating it each time you access the metric.
-    
+
+   If you frequently query certain metrics, using recording rules can speed up response times. Recording rules precompute specific queries and store their results, allowing you to access them faster in dashboards or alerts. For example, if you consistently track the 95th percentile of response times, set up a recording rule to avoid recalculating it each time you access the metric.
+
 3. Avoid Common Pitfalls
-    - `histogram_quantile` Requires Histogram Metrics: The `histogram_quantile` function is designed specifically for [Prometheus histogram](https://signoz.io/guides/what-is-a-bucket-in-prometheus/) metrics, which organize data into configurable "buckets" (ranges). Using it on non-histogram data will lead to inaccurate results. Always verify that your metric is a histogram type before using `histogram_quantile`.
-    - Ensure Sufficient Data Points for Accuracy: Calculating accurate percentiles requires enough data points. For example, in high-traffic applications, calculating a 99th percentile with minimal data might not be meaningful. Monitoring data density can help ensure that your percentiles reliably reflect real behavior.
+   - `histogram_quantile` Requires Histogram Metrics: The `histogram_quantile` function is designed specifically for [Prometheus histogram](https://signoz.io/guides/what-is-a-bucket-in-prometheus/) metrics, which organize data into configurable "buckets" (ranges). Using it on non-histogram data will lead to inaccurate results. Always verify that your metric is a histogram type before using `histogram_quantile`.
+   - Ensure Sufficient Data Points for Accuracy: Calculating accurate percentiles requires enough data points. For example, in high-traffic applications, calculating a 99th percentile with minimal data might not be meaningful. Monitoring data density can help ensure that your percentiles reliably reflect real behavior.
 4. Create Meaningful Dashboards
-    
-    To provide a clear view of application performance, it’s best to display multiple percentiles—such as the 50th (median), 95th, and 99th percentiles—in dashboards. This approach gives a comprehensive overview: the median shows typical performance, while higher percentiles reveal the worst-case scenarios users might encounter.
-    
+
+   To provide a clear view of application performance, it’s best to display multiple percentiles—such as the 50th (median), 95th, and 99th percentiles—in dashboards. This approach gives a comprehensive overview: the median shows typical performance, while higher percentiles reveal the worst-case scenarios users might encounter.
 
 ## Key Takeaways
 
@@ -461,4 +454,4 @@ Common pitfalls include:
 - Choosing inappropriate bucket sizes, leading to loss of precision
 - Not accounting for the cumulative nature of histogram buckets in calculations
 
-By understanding these potential issues, you can ensure more accurate and reliable results when working with `histogram_quantile` in your Prometheus queries.
\ No newline at end of file
+By understanding these potential issues, you can ensure more accurate and reliable results when working with `histogram_quantile` in your Prometheus queries.
diff --git a/data/guides/understanding-prometheus-rate-vs-increase-functions-correctly.mdx b/data/guides/understanding-prometheus-rate-vs-increase-functions-correctly.mdx
index 01355fc9a..204470172 100644
--- a/data/guides/understanding-prometheus-rate-vs-increase-functions-correctly.mdx
+++ b/data/guides/understanding-prometheus-rate-vs-increase-functions-correctly.mdx
@@ -1,13 +1,20 @@
 ---
-
 title: What is the difference between Prometheus Rate vs Increase Functions
-slug: understanding-prometheus-rate-vs-increase-functions-correctly
 date: 2024-07-25
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Discover the key differences between Prometheus rate() and increase() functions. Learn when to use each for accurate monitoring and data analysis.
-keywords: [Prometheus, rate function, increase function, monitoring, data analysis, PromQL, time series, metrics]
-
+keywords:
+  [
+    Prometheus,
+    rate function,
+    increase function,
+    monitoring,
+    data analysis,
+    PromQL,
+    time series,
+    metrics,
+  ]
 ---
 
 <head>
@@ -308,4 +315,4 @@ With SigNoz, you can:
 - Access advanced querying and visualization capabilities
 - Benefit from integrated tracing and logging alongside metrics.
 - Get high performance with the clickhouse database
-- Take advantage of [SigNoz](https://signoz.io/docs/introduction/)'s exceptional exception monitoring capabilities
\ No newline at end of file
+- Take advantage of [SigNoz](https://signoz.io/docs/introduction/)'s exceptional exception monitoring capabilities
diff --git a/data/guides/upstream-connect-error.mdx b/data/guides/upstream-connect-error.mdx
index 2d2527a50..330bf2c71 100644
--- a/data/guides/upstream-connect-error.mdx
+++ b/data/guides/upstream-connect-error.mdx
@@ -1,11 +1,19 @@
 ---
-title: "Fixing Upstream Connect Errors (Docker, Kubernetes, Spring Boot & More)"
-slug: "upstream-connect-error"
-date: "2025-09-08"
+title: 'Fixing Upstream Connect Errors (Docker, Kubernetes, Spring Boot & More)'
+date: '2025-09-08'
 tags: [devops]
-authors: ["niyati_thakkar"]
-description: "Fix upstream connect errors in 5 minutes. Complete guide with copy-paste solutions for Docker, Kubernetes, Spring Boot, Nginx. Includes troubleshooting flowchart and real examples."
-keywords: [upstream connect error, 502 bad gateway nginx upstream, 503 service unavailable kubernetes, connection refused while connecting to upstream, upstream connect error spring boot, java 11 networking, docker nginx upstream connection failed]
+authors: ['niyati_thakkar']
+description: 'Fix upstream connect errors in 5 minutes. Complete guide with copy-paste solutions for Docker, Kubernetes, Spring Boot, Nginx. Includes troubleshooting flowchart and real examples.'
+keywords:
+  [
+    upstream connect error,
+    502 bad gateway nginx upstream,
+    503 service unavailable kubernetes,
+    connection refused while connecting to upstream,
+    upstream connect error spring boot,
+    java 11 networking,
+    docker nginx upstream connection failed,
+  ]
 ---
 
 ## What Are Upstream Connect Errors?
@@ -13,8 +21,9 @@ keywords: [upstream connect error, 502 bad gateway nginx upstream, 503 service u
 An upstream connect error occurs when a reverse proxy or load balancer cannot establish a TCP connection to the backend service it's trying to reach. Think of it like a postal service scenario: you hand your letter to the local post office (proxy), but they can't reach the destination post office (upstream server) to deliver it. The connection never even gets established.
 
 These errors typically manifest as:
+
 - **502 Bad Gateway**: The proxy received an invalid response from the upstream server
-- **503 Service Unavailable**: The upstream service is temporarily unavailable  
+- **503 Service Unavailable**: The upstream service is temporarily unavailable
 - **Connection refused**: The upstream service rejected the connection attempt
 
 The error sits in the critical path of your request flow: Client → Reverse Proxy → [ERROR HERE] → Backend Service. Unlike timeout errors where a connection is established but the response is slow, upstream connect errors mean the TCP handshake never completes.
@@ -26,27 +35,32 @@ Different platforms and technologies report upstream connect errors in unique wa
 ### Common Error Messages by Platform
 
 **Docker**
+
 ```
 nginx: [error] connect() failed (111: Connection refused) while connecting to upstream
 ```
 
 **Kubernetes with Istio**
+
 ```
 upstream connect error or disconnect/reset before headers. reset reason: connection failure, transport failure reason: delayed connect error: 111
 ```
 
 **AWS Application Load Balancer**
+
 ```
 502 Bad Gateway - The server was acting as a gateway or proxy and received an invalid response from the upstream server
 ```
 
 **Traditional Nginx**
+
 ```
 upstream timed out (110: Connection timed out) while connecting to upstream
 no live upstreams while connecting to upstream
 ```
 
 **Spring Boot Applications**
+
 ```
 java.net.ConnectException: Connection refused (Connection refused)
 org.springframework.web.client.ResourceAccessException: I/O error on GET request: Connection refused
@@ -84,6 +98,7 @@ This is how Docker networking should work:
 Docker's internal DNS automatically resolves container names to their IP addresses, enabling seamless communication between containers on the same network.
 
 Other Docker-specific causes include:
+
 - Containers running in different Docker networks that can't communicate
 - Port mapping confusion between internal and external ports
 - Container startup order issues where the proxy starts before the backend
@@ -104,12 +119,14 @@ Here's how service discovery works in Kubernetes:
 />
 
 The service discovery flow works like this:
+
 1. Client Pod makes a request to a Service (ClusterIP)
 2. Service uses selectors to find matching Pods
 3. If no Pods match, no Endpoints are created
 4. Request fails with 503 Service Unavailable
 
 Additional Kubernetes-specific causes:
+
 - DNS resolution failures within the cluster
 - Network policies blocking traffic between namespaces
 - Readiness probes failing, removing Pods from service rotation
@@ -117,7 +134,7 @@ Additional Kubernetes-specific causes:
 
 ### Cloud Load Balancers: Security and Health Checks
 
-Cloud providers add their own layer of complexity through security groups, health checks, and target configurations. 
+Cloud providers add their own layer of complexity through security groups, health checks, and target configurations.
 
 #### Load Balancer Architecture
 
@@ -128,25 +145,28 @@ Here's how cloud load balancers manage traffic:
   alt="Load balancer architecture and health checks"
   caption="Cloud load balancers continuously monitor target health and only route traffic to healthy instances"
 />
-The load balancer continuously monitors target health and only routes traffic to healthy instances. 
-When health checks fail, the load balancer removes instances from rotation. If ALL
-instances fail health checks (even if they're actually running), the load balancer has no upstream
-targets to connect to, causing upstream connect errors
+The load balancer continuously monitors target health and only routes traffic to healthy instances.
+When health checks fail, the load balancer removes instances from rotation. If ALL instances fail
+health checks (even if they're actually running), the load balancer has no upstream targets to
+connect to, causing upstream connect errors
 
 Common issues include:
 
 **AWS ALB/NLB**:
+
 - Security groups not allowing traffic from the load balancer to targets
 - Target health checks failing due to incorrect paths or expected status codes
 - Timeout misalignment between ALB (default 60s) and backend services
 - Wrong target type (instance vs IP vs Lambda)
 
 **Azure Application Gateway**:
+
 - Backend pool misconfiguration with incorrect IP addresses
 - Health probe settings too aggressive, marking healthy instances as unhealthy
 - NSG rules blocking traffic from the gateway subnet
 
 **Google Cloud Load Balancing**:
+
 - Firewall rules blocking health check IP ranges
 - Backend service capacity settings too restrictive
 - Connection draining timeout too short during deployments
@@ -156,7 +176,7 @@ Common issues include:
 Even in traditional deployments with nginx, Apache, or HAProxy, upstream errors occur due to:
 
 - SELinux blocking network connections (especially on RHEL/CentOS)
-- Firewall rules preventing proxy-to-backend communication  
+- Firewall rules preventing proxy-to-backend communication
 - Backend services binding to wrong network interfaces (only listening on localhost)
 - File descriptor limits preventing new connections
 - Connection pool exhaustion
@@ -245,12 +265,14 @@ If DNS resolution fails, check your `/etc/resolv.conf` or equivalent DNS configu
 Review your proxy configuration for common mistakes. Each proxy has its own configuration syntax and requirements.
 
 For nginx, test the configuration syntax:
+
 ```bash
 nginx -t
 # nginx: configuration file /etc/nginx/nginx.conf test is successful
 ```
 
 Look for these common configuration issues:
+
 - Using `localhost` instead of service names in containerized environments
 - Incorrect port numbers (using external ports instead of internal container ports)
 - Missing timeout configurations causing premature connection drops
@@ -276,6 +298,7 @@ tail -f /var/log/myapp/application.log | grep -E "ERROR|WARN.*connection"
 ```
 
 Look for patterns like:
+
 - Errors occurring immediately vs after a delay (connection refused vs timeout)
 - Errors affecting all requests vs intermittent failures
 - Correlation with deployment times or traffic spikes
@@ -308,15 +331,15 @@ upstream backend {
 
 server {
     listen 80;
-    
+
     location / {
         proxy_pass http://backend;
-        
+
         # Important: Set appropriate timeouts to prevent premature connection drops
         proxy_connect_timeout 10s;   # Time to establish TCP connection
         proxy_send_timeout 60s;       # Time to send request to backend
         proxy_read_timeout 60s;       # Time to wait for backend response
-        
+
         # Handle connection failures gracefully
         proxy_next_upstream error timeout invalid_header http_500 http_502 http_503;
         proxy_next_upstream_tries 3;
@@ -339,12 +362,12 @@ services:
     image: nginx:alpine
     container_name: nginx-proxy
     ports:
-      - "80:80"  # Map host port 80 to container port 80
+      - '80:80' # Map host port 80 to container port 80
     volumes:
       - ./nginx.conf:/etc/nginx/nginx.conf:ro
     depends_on:
       backend:
-        condition: service_healthy  # Wait for backend to be healthy
+        condition: service_healthy # Wait for backend to be healthy
     networks:
       - app-network
 
@@ -356,16 +379,16 @@ services:
       - ./app:/app
     command: node server.js
     expose:
-      - "3000"  # Only exposed to other containers, not host
+      - '3000' # Only exposed to other containers, not host
     networks:
       - app-network
     # Health check ensures the service is ready before nginx starts using it
     healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      test: ['CMD', 'curl', '-f', 'http://localhost:3000/health']
       interval: 30s
       timeout: 10s
       retries: 5
-      start_period: 40s  # Give the app time to start
+      start_period: 40s # Give the app time to start
 
 networks:
   app-network:
@@ -381,6 +404,7 @@ The `depends_on` with `condition: service_healthy` ensures nginx only starts aft
 Kubernetes uses Services to provide stable network endpoints for Pods. The most common upstream error occurs when Service selectors don't match Pod labels.
 
 **How Service discovery works:**
+
 1. Service defines selectors (e.g., `app: backend`)
 2. Kubernetes finds all Pods with matching labels
 3. These Pods become the Service's Endpoints
@@ -398,35 +422,35 @@ spec:
   replicas: 3
   selector:
     matchLabels:
-      app: backend        # Deployment selector
+      app: backend # Deployment selector
       version: v1
   template:
     metadata:
       labels:
-        app: backend      # Pod labels must match
+        app: backend # Pod labels must match
         version: v1
     spec:
       containers:
-      - name: backend
-        image: myapp:latest
-        ports:
-        - containerPort: 3000  # Container listens on this port
-        # Readiness probe prevents routing traffic to unready pods
-        readinessProbe:
-          httpGet:
-            path: /health
-            port: 3000
-          initialDelaySeconds: 10
-          periodSeconds: 5
-          failureThreshold: 3
-        # Liveness probe restarts unhealthy pods
-        livenessProbe:
-          httpGet:
-            path: /health
-            port: 3000
-          initialDelaySeconds: 30
-          periodSeconds: 10
-          failureThreshold: 3
+        - name: backend
+          image: myapp:latest
+          ports:
+            - containerPort: 3000 # Container listens on this port
+          # Readiness probe prevents routing traffic to unready pods
+          readinessProbe:
+            httpGet:
+              path: /health
+              port: 3000
+            initialDelaySeconds: 10
+            periodSeconds: 5
+            failureThreshold: 3
+          # Liveness probe restarts unhealthy pods
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: 3000
+            initialDelaySeconds: 30
+            periodSeconds: 10
+            failureThreshold: 3
 
 ---
 # Service that discovers pods using selectors
@@ -436,12 +460,12 @@ metadata:
   name: backend-service
 spec:
   selector:
-    app: backend          # Must match pod labels exactly
-    version: v1           # All selectors must match
+    app: backend # Must match pod labels exactly
+    version: v1 # All selectors must match
   ports:
-  - port: 80             # Service port (what other pods use)
-    targetPort: 3000     # Pod port (must match containerPort)
-    protocol: TCP
+    - port: 80 # Service port (what other pods use)
+      targetPort: 3000 # Pod port (must match containerPort)
+      protocol: TCP
   type: ClusterIP
 ```
 
@@ -492,7 +516,7 @@ metadata:
   namespace: production
 spec:
   mtls:
-    mode: PERMISSIVE  # Accepts both encrypted and plain text
+    mode: PERMISSIVE # Accepts both encrypted and plain text
 ```
 
 PERMISSIVE mode allows gradual migration to mTLS. Services with sidecars communicate securely while legacy services without sidecars still work, preventing upstream errors during transition.
@@ -515,11 +539,11 @@ spec:
         http2MaxRequests: 100
     # Circuit breaker configuration
     outlierDetection:
-      consecutive5xxErrors: 5      # Errors before ejection
-      interval: 30s                # Analysis interval
-      baseEjectionTime: 30s        # How long to eject
-      maxEjectionPercent: 50       # Max % of backends to eject
-      minHealthPercent: 30         # Panic threshold
+      consecutive5xxErrors: 5 # Errors before ejection
+      interval: 30s # Analysis interval
+      baseEjectionTime: 30s # How long to eject
+      maxEjectionPercent: 50 # Max % of backends to eject
+      minHealthPercent: 30 # Panic threshold
 ```
 
 The outlier detection acts as a circuit breaker, automatically removing unhealthy instances from the load balancing pool. This prevents cascading failures when backend services become unreliable.
@@ -560,6 +584,7 @@ Note: Early Java 11 versions had HTTP/2 connection issues (JDK-8211806) fixed in
 ### Spring Boot Application Architecture Context
 
 In a typical Spring Boot microservices architecture, upstream errors commonly occur at these points:
+
 - RestTemplate or WebClient calls to other services
 - Feign client interactions
 - Database connection pools (HikariCP)
@@ -570,38 +595,49 @@ In a typical Spring Boot microservices architecture, upstream errors commonly oc
 When diagnosing upstream errors in Spring Boot applications, follow this systematic approach:
 
 1. **Check Application Health**:
+
 ```bash
 curl http://localhost:8080/actuator/health | jq .
 ```
+
 The health endpoint aggregates all component statuses. A DOWN status in any dependency (database, message broker) often causes upstream errors.
 
 2. **Review Connection Pool Metrics**:
+
 ```bash
 curl http://localhost:8080/actuator/metrics/hikaricp.connections.active | jq .
 ```
+
 Connection pool exhaustion is a common cause of upstream errors. If active connections equal max pool size, requests queue and eventually timeout.
 
 3. **Analyze Thread Dump for Blocked Threads**:
+
 ```bash
 curl http://localhost:8080/actuator/threaddump | jq '.threads[] | select(.threadState == "BLOCKED")'
 ```
+
 Blocked threads waiting for connections indicate pool exhaustion or deadlocks. Multiple blocked HTTP client threads suggest upstream services are slow or unresponsive.
 
 4. **Check Circuit Breaker Status**:
+
 ```bash
 curl http://localhost:8080/actuator/metrics/resilience4j.circuitbreaker.state | jq .
 ```
+
 An OPEN circuit breaker stops calling failing services, preventing upstream errors from cascading. Check if breakers are open unexpectedly.
 
 5. **Enable HTTP Client Debug Logging**:
+
 ```bash
 # Add to application.properties
 logging.level.org.apache.http.wire=DEBUG
 logging.level.org.apache.http.headers=DEBUG
 ```
+
 Wire-level logging reveals exactly what's happening during HTTP communication, including connection establishment, TLS handshakes, and request/response details.
 
 6. **Monitor JVM Network Connections**:
+
 ```bash
 # Check established connections
 netstat -an | grep ESTABLISHED | grep <port>
@@ -609,6 +645,7 @@ netstat -an | grep ESTABLISHED | grep <port>
 # Monitor connection states
 watch -n 1 'netstat -an | grep <port> | awk "{print \$6}" | sort | uniq -c'
 ```
+
 Real-time connection monitoring reveals patterns like connection leaks (growing ESTABLISHED count) or exhaustion (many TIME_WAIT states), helping identify the root cause of upstream errors.
 
 ## Monitoring with SigNoz
@@ -618,6 +655,7 @@ While traditional monitoring can identify upstream errors after they occur, mode
 ### Why Observability Matters for Upstream Errors
 
 Upstream errors rarely occur in isolation. They're often symptoms of deeper issues like:
+
 - Cascading failures from dependent services
 - Resource exhaustion under load
 - Network latency spikes
@@ -639,7 +677,7 @@ services:
       - OTEL_SERVICE_NAME=backend-service
       - OTEL_TRACES_EXPORTER=otlp
       - OTEL_METRICS_EXPORTER=otlp
-      
+
   spring-boot-app:
     image: spring-app:latest
     environment:
@@ -665,6 +703,7 @@ For Spring Boot applications, add [OpenTelemetry](https://signoz.io/blog/what-is
 ```
 
 With [SigNoz](https://signoz.io/docs/introduction/), you can:
+
 - Track error rates across all services in real-time
 - View distributed traces showing exactly where connections fail
 - Set up intelligent alerts based on error patterns
@@ -680,7 +719,11 @@ Build dashboards that show the health of your entire request pipeline:
 4. **Connection Pool Metrics**: Monitor connection usage and exhaustion
 5. **JVM Metrics**: For Spring Boot apps, track heap usage, GC activity, and thread pools
 
-<Figure src="/img/docs/dashboards/dashboard-templates/jvm-metrics.webp" alt="JVM metrics dashboard" caption="JVM metrics dashboard" />
+<Figure
+  src="/img/docs/dashboards/dashboard-templates/jvm-metrics.webp"
+  alt="JVM metrics dashboard"
+  caption="JVM metrics dashboard"
+/>
 
 ## Get Started with SigNoz
 
@@ -695,6 +738,7 @@ Those who have the expertise to manage SigNoz themselves or just want to start w
 Upstream connect errors are symptoms of connectivity issues between your proxy and backend services. While the error message itself is generic, the root causes follow predictable patterns based on your platform.
 
 The key to quick resolution is understanding:
+
 1. **Your platform's networking model** - How Docker, Kubernetes, Spring Boot, or cloud providers handle network connections
 2. **Common misconfiguration patterns** - Like using localhost in containers, mismatched selectors in Kubernetes, or exhausted connection pools in Spring Boot
 3. **Systematic debugging approach** - Following a methodical process rather than random troubleshooting
@@ -706,6 +750,7 @@ Most upstream errors stem from simple misconfigurations that can be fixed quickl
 When facing an [upstream error](https://signoz.io/guides/upstream-connect-error-or-disconnect-reset-before-headers-reset-reason-connection-failure-spring-boot-and-java-11/), check these items in order:
 
 **Immediate checks:**
+
 - [ ] Is the backend service actually running?
 - [ ] Can you connect to the backend directly (bypassing the proxy)?
 - [ ] Does DNS resolution work for the backend hostname?
@@ -713,6 +758,7 @@ When facing an [upstream error](https://signoz.io/guides/upstream-connect-error-
 - [ ] Do the ports match between proxy configuration and backend service?
 
 **Platform-specific checks:**
+
 - [ ] Docker: Are containers on the same network?
 - [ ] Kubernetes: Do service selectors match pod labels?
 - [ ] Cloud: Are security groups/firewall rules allowing traffic?
@@ -721,6 +767,7 @@ When facing an [upstream error](https://signoz.io/guides/upstream-connect-error-
 - [ ] Java 11: Are there TLS or HTTP/2 compatibility issues?
 
 **Configuration checks:**
+
 - [ ] Are timeout values properly aligned across the stack?
 - [ ] Do health checks use valid endpoints and expect correct responses?
 - [ ] Is the proxy configuration syntax valid?
@@ -730,4 +777,4 @@ Remember that upstream errors often indicate broader system issues. Implementing
 
 Hope we answered all your questions regarding upstream connect errors. If you have more questions, feel free to use the SigNoz AI chatbot, or join our [slack community](https://signoz.io/slack/).
 
-You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
\ No newline at end of file
+You can also subscribe to our [newsletter](https://newsletter.signoz.io/) for insights from observability nerds at SigNoz, get open source, OpenTelemetry, and devtool building stories straight to your inbox.
diff --git a/data/guides/virtual-machine-monitoring.mdx b/data/guides/virtual-machine-monitoring.mdx
index edda07860..db100c56b 100644
--- a/data/guides/virtual-machine-monitoring.mdx
+++ b/data/guides/virtual-machine-monitoring.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: Essential Guide to Virtual Machine Monitoring Tools
-slug: virtual-machine-monitoring
 date: 2024-11-14
 tags: [monitoring]
 authors: [vivek_goswami]
 description: Discover essential virtual machine monitoring tools, features, and best practices. Learn how to optimize VM performance and choose the right monitoring solution.
-keywords: [virtual machine monitoring, VM performance, monitoring tools, cloud monitoring, IT infrastructure, virtualization, SigNoz]
-
+keywords:
+  [
+    virtual machine monitoring,
+    VM performance,
+    monitoring tools,
+    cloud monitoring,
+    IT infrastructure,
+    virtualization,
+    SigNoz,
+  ]
 ---
 
 In today's digital landscape, virtual machines (VMs) form the backbone of many IT infrastructures. These software-based emulations of physical computers offer flexibility, scalability, and cost-efficiency. However, with great power comes great responsibility — and the need for robust monitoring. Virtual machine monitoring is crucial for maintaining optimal performance, ensuring resource efficiency, and preventing potential issues before they impact your operations.
@@ -54,7 +60,11 @@ Virtual machine (VM) monitoring is essential for maintaining the efficiency and
 
 ## Essential Features of VM Monitoring Tools
 
-<Figure src="/img/guides/2024/11/virtual-machine-monitoring-image.webp" alt="Features of VM Monitoring Tools" caption="Features of VM Monitoring Tools" />
+<Figure
+  src="/img/guides/2024/11/virtual-machine-monitoring-image.webp"
+  alt="Features of VM Monitoring Tools"
+  caption="Features of VM Monitoring Tools"
+/>
 
 Modern virtual machine (VM) monitoring tools should include several key features to effectively manage and optimize virtualized environments. Here are the essential features that organizations should look for in a [VM monitoring tool](https://signoz.io/guides/virtual-machine-monitoring/#how-to-choose-the-right-vm-monitoring-tool):
 
@@ -77,63 +87,60 @@ Advanced monitoring capabilities provide crucial insights into the performance a
 Selecting the appropriate VM monitoring tool can significantly impact performance management and resource allocation. Several factors should be considered to make an informed decision.
 
 1. Assess Specific Needs and Infrastructure
-    
-    Start by analyzing the organization's infrastructure, including the number of virtual machines, applications, and workloads. Evaluate how the monitoring tool will fit into your existing infrastructure and ensure it provides the necessary features to address your organization’s monitoring objectives.
-    
+
+   Start by analyzing the organization's infrastructure, including the number of virtual machines, applications, and workloads. Evaluate how the monitoring tool will fit into your existing infrastructure and ensure it provides the necessary features to address your organization’s monitoring objectives.
+
 2. Evaluate Scalability and Multi-Cloud Support
-    
-    As infrastructure grows, the monitoring tool should scale accordingly without compromising performance. In a dynamic setup with multi-cloud environments, look for a solution that offers robust multi-cloud support, allowing you to monitor resources across various clouds from a single interface.
-    
+
+   As infrastructure grows, the monitoring tool should scale accordingly without compromising performance. In a dynamic setup with multi-cloud environments, look for a solution that offers robust multi-cloud support, allowing you to monitor resources across various clouds from a single interface.
+
 3. Consider Ease of Use and Implementation
-    
-    A tool that is simple to implement and configure can save time and reduce operational complexity. Look for a VM monitoring solution with an intuitive user interface that is easy to navigate. Additionally, consider the implementation process—tools that require extensive setup or training may delay deployment and impact productivity. A solution that offers quick installation and configuration will save valuable time and resources.
-    
+
+   A tool that is simple to implement and configure can save time and reduce operational complexity. Look for a VM monitoring solution with an intuitive user interface that is easy to navigate. Additionally, consider the implementation process—tools that require extensive setup or training may delay deployment and impact productivity. A solution that offers quick installation and configuration will save valuable time and resources.
+
 4. Analyze Cost-Effectiveness and ROI
-    
-    Balancing costs with functionality is vital. Enterprise-level tools come with advanced features but may be overkill for smaller organizations. For businesses with smaller budgets, free or open-source tools could provide basic monitoring at no cost, with paid add-ons for advanced functionalities.
-    
+
+   Balancing costs with functionality is vital. Enterprise-level tools come with advanced features but may be overkill for smaller organizations. For businesses with smaller budgets, free or open-source tools could provide basic monitoring at no cost, with paid add-ons for advanced functionalities.
 
 ## Best Practices for Effective VM Monitoring
 
 To ensure optimal performance and reliability in virtual machine (VM) environments, implementing best practices for VM monitoring is crucial. Here are some key strategies to consider:
 
 1. Establish Baseline Performance Metrics:
-    
-    It is critical to have a clear understanding of what normal performance looks like for a VM. Baseline metrics, such as CPU usage, memory consumption, and disk I/O, serve as reference points to identify anomalies.
-    
+
+   It is critical to have a clear understanding of what normal performance looks like for a VM. Baseline metrics, such as CPU usage, memory consumption, and disk I/O, serve as reference points to identify anomalies.
+
 2. Implement Proactive Monitoring and Alerting:
-    
-    [Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps in identifying potential issues before they escalate into critical problems. Setting up alerts for key performance indicators such as high CPU load, low memory, or unusual network activity ensures quick response to anomalies. 
-    
+
+   [Proactive monitoring](https://signoz.io/guides/proactive-monitoring/) helps in identifying potential issues before they escalate into critical problems. Setting up alerts for key performance indicators such as high CPU load, low memory, or unusual network activity ensures quick response to anomalies.
+
 3. Regular Review and Optimize Monitoring Strategies:
-    
-    Monitoring strategies should evolve with changes in the infrastructure and application workloads. Reviewing data trends regularly helps in adjusting thresholds and monitoring scope.
-    
+
+   Monitoring strategies should evolve with changes in the infrastructure and application workloads. Reviewing data trends regularly helps in adjusting thresholds and monitoring scope.
+
 4. Leverage Automation for Routine Monitoring Tasks:
-    
-    Utilize automation to streamline routine monitoring tasks, such as data collection, report generation, and alert management. Automating repetitive monitoring tasks can save time and reduce the risk of human error. Implementing scripts or utilizing built-in automation features within monitoring tools can significantly improve efficiency.
-    
+
+   Utilize automation to streamline routine monitoring tasks, such as data collection, report generation, and alert management. Automating repetitive monitoring tasks can save time and reduce the risk of human error. Implementing scripts or utilizing built-in automation features within monitoring tools can significantly improve efficiency.
 
 ## Common Challenges in VM Monitoring and How to Overcome Them
 
 Virtual machine (VM) monitoring can present several challenges, especially in complex environments. Addressing these issues requires a clear understanding of how to manage resources, ensure performance, and maintain visibility across different infrastructures.
 
 1. Dealing with VM Sprawl and Resource Overprovisioning:
-    
-    VM sprawl happens when there are too many VMs running unnecessarily, often leading to overprovisioning of resources. This can result in wasted capacity, increased costs, and management complexity. Implementing automation to enforce policies can help limit sprawl and ensure that resources are allocated according to actual demand. Regular audits and consolidation of underutilized VMs also help control sprawl.
-    
+
+   VM sprawl happens when there are too many VMs running unnecessarily, often leading to overprovisioning of resources. This can result in wasted capacity, increased costs, and management complexity. Implementing automation to enforce policies can help limit sprawl and ensure that resources are allocated according to actual demand. Regular audits and consolidation of underutilized VMs also help control sprawl.
+
 2. Managing Performance in Dynamic, Scalable Environments:
-    
-    Maintaining consistent performance becomes a challenge as VMs scale up or down in cloud environments. Monitoring CPU, memory, and disk I/O is essential to identify potential bottlenecks. Real-time performance metrics enable timely adjustments. For instance, auto-scaling can be configured based on workload thresholds, ensuring optimal resource allocation without manual intervention.
-    
+
+   Maintaining consistent performance becomes a challenge as VMs scale up or down in cloud environments. Monitoring CPU, memory, and disk I/O is essential to identify potential bottlenecks. Real-time performance metrics enable timely adjustments. For instance, auto-scaling can be configured based on workload thresholds, ensuring optimal resource allocation without manual intervention.
+
 3. Ensuring Visibility Across Hybrid and Multi-cloud Setups:
-    
-    In hybrid and multi-cloud environments, gaining visibility into the performance and health of VMs across different platforms can be difficult. Centralized monitoring solutions allow teams to track VMs across multiple clouds in one dashboard. These tools collect logs, performance data, and security metrics, providing a comprehensive view. Integrating monitoring across cloud and on-premises environments ensures consistency in performance tracking.
-    
+
+   In hybrid and multi-cloud environments, gaining visibility into the performance and health of VMs across different platforms can be difficult. Centralized monitoring solutions allow teams to track VMs across multiple clouds in one dashboard. These tools collect logs, performance data, and security metrics, providing a comprehensive view. Integrating monitoring across cloud and on-premises environments ensures consistency in performance tracking.
+
 4. Balancing Monitoring Granularity with System Overhead:
-    
-    Monitoring too many metrics can introduce overhead, while too few may result in blind spots. It's essential to strike a balance by identifying critical performance indicators without overloading the system. For example, monitoring memory and CPU usage every few seconds might create excessive data storage and processing needs. Instead, setting up threshold-based alerts, where notifications trigger only when certain limits are breached, can minimize system impact while maintaining effective monitoring.
-    
+
+   Monitoring too many metrics can introduce overhead, while too few may result in blind spots. It's essential to strike a balance by identifying critical performance indicators without overloading the system. For example, monitoring memory and CPU usage every few seconds might create excessive data storage and processing needs. Instead, setting up threshold-based alerts, where notifications trigger only when certain limits are breached, can minimize system impact while maintaining effective monitoring.
 
 ## Leveraging SigNoz for Comprehensive VM Monitoring
 
@@ -142,9 +149,12 @@ Virtual machine (VM) monitoring can present several challenges, especially in co
 ### Key Features of SigNoz for VM Monitoring
 
 - Real-Time Performance Tracking: SigNoz enables continuous tracking of VM performance across multiple virtualization platforms, allowing you to monitor CPU usage, memory, disk I/O, and network bandwidth in real time.
-    
-    <Figure src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp" alt="Infrastructure Monitoring in SigNoz" caption="Infrastructure Monitoring in SigNoz" />
-    
+  {' '}
+  <Figure
+    src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp"
+    alt="Infrastructure Monitoring in SigNoz"
+    caption="Infrastructure Monitoring in SigNoz"
+  />
 - Customizable Dashboards: SigNoz provides flexible dashboards that are fully customizable, offering at-a-glance insights to monitor key performance metrics, identify trends, and respond to issues quickly.
 - Advanced Alerting and Integrations: SigNoz supports alerting capabilities to help you stay informed about critical performance issues. You can configure alerts to integrate with popular communication tools like Slack, email, and PagerDuty, ensuring that you receive notifications as soon as thresholds are crossed.
 - Support for Cloud and On-Premises VM Monitoring: SigNoz is compatible with cloud-native environments as well as on-premises infrastructure, providing comprehensive monitoring solutions regardless of where your VMs are hosted.
@@ -186,4 +196,4 @@ Yes, [VM monitoring tools](https://signoz.io/guides/virtual-machine-monitoring/#
 
 ### How does VM monitoring differ in cloud vs. on-premises environments?
 
-Cloud environments often provide built-in monitoring tools and may require monitoring of additional metrics like cost and usage against quota limits. On-premises environments typically offer more control over the monitoring infrastructure but may require more setup and maintenance.
\ No newline at end of file
+Cloud environments often provide built-in monitoring tools and may require monitoring of additional metrics like cost and usage against quota limits. On-premises environments typically offer more control over the monitoring infrastructure but may require more setup and maintenance.
diff --git a/data/guides/vpc-flow-logs.mdx b/data/guides/vpc-flow-logs.mdx
index 074aab1c7..3861c7924 100644
--- a/data/guides/vpc-flow-logs.mdx
+++ b/data/guides/vpc-flow-logs.mdx
@@ -1,6 +1,5 @@
 ---
 title: Complete Guide to VPC Flow Logs
-slug: vpc-flow-logs
 date: 2024-07-03
 tags: [logging]
 authors: [daniel]
@@ -9,166 +8,172 @@ keywords: [logs, log monitoring, vpc, signoz]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Complete Guide to VPC Flow Logs",
-  "alternativeHeadline": "Understanding, Implementing, and Analyzing VPC Flow Logs for Network Monitoring and Security",
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-03",
-  "dateModified": "2024-07-03",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/vpc-flow-logs/"
-  },
-  "description": "VPC flow logs are a network monitoring feature that captures detailed information about the IP traffic entering and leaving your Virtual Private Cloud (VPC). This includes details such as source/destination IP addresses, ports, protocols, and data volume.",
-  "keywords": "logs, log monitoring, vpc, signoz",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "VPC Flow Logs",
-      "description": "A feature that captures information about IP traffic going to and from network interfaces in a VPC"
-    },
-    {
-      "@type": "Thing",
-      "name": "Network Monitoring",
-      "description": "The practice of overseeing and analyzing network traffic and performance"
-    },
-    {
-      "@type": "Thing",
-      "name": "Cloud Security",
-      "description": "Measures and controls that protect data, applications, and infrastructure associated with cloud computing"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Amazon Web Services",
-      "applicationCategory": "Cloud Computing Platform"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "AWS Lambda",
-      "applicationCategory": "Serverless Computing Service"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What are VPC flow logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "They are detailed network traffic records in your Virtual Private Cloud (VPC)."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Where to view VPC flow logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "In the configured log destination (CloudWatch Logs, S3, or Data Firehose for AWS)."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do you create AWS VPC flow logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "In the Amazon VPC console, select your VPC or subnet, then choose 'Create flow log' from the Actions menu. You can also do this with the AWS CLI."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Is VPC flow log free?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "No, you are charged for the storage and data transfer of logs."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What does VPC stand for?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Virtual Private Cloud."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Create and Forward VPC Flow Logs to SigNoz",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Create/Configure the S3 Bucket",
-        "text": "Create an S3 bucket in AWS to store your VPC flow logs."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create the VPC",
-        "text": "Set up a Virtual Private Cloud (VPC) in AWS if you don't already have one."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create the VPC Flow Logs",
-        "text": "Enable VPC flow logs for your VPC, configuring them to be stored in your S3 bucket."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create a Lambda Function",
-        "text": "Set up an AWS Lambda function to process the VPC flow logs."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Configure Policies for the Function",
-        "text": "Grant the necessary permissions to your Lambda function to access the S3 bucket."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Trigger the Function",
-        "text": "Set up a trigger for the Lambda function to process new log files in the S3 bucket."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Write the Lambda Function",
-        "text": "Implement the Lambda function to process the VPC flow logs and forward them to SigNoz."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Visualize the VPC Flow Logs in SigNoz",
-        "text": "Access and explore the forwarded VPC flow logs in the SigNoz dashboard."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Complete Guide to VPC Flow Logs',
+        alternativeHeadline:
+          'Understanding, Implementing, and Analyzing VPC Flow Logs for Network Monitoring and Security',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-03',
+        dateModified: '2024-07-03',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/vpc-flow-logs/',
+        },
+        description:
+          'VPC flow logs are a network monitoring feature that captures detailed information about the IP traffic entering and leaving your Virtual Private Cloud (VPC). This includes details such as source/destination IP addresses, ports, protocols, and data volume.',
+        keywords: 'logs, log monitoring, vpc, signoz',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'VPC Flow Logs',
+            description:
+              'A feature that captures information about IP traffic going to and from network interfaces in a VPC',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Network Monitoring',
+            description: 'The practice of overseeing and analyzing network traffic and performance',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Cloud Security',
+            description:
+              'Measures and controls that protect data, applications, and infrastructure associated with cloud computing',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Amazon Web Services',
+            applicationCategory: 'Cloud Computing Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'AWS Lambda',
+            applicationCategory: 'Serverless Computing Service',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What are VPC flow logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'They are detailed network traffic records in your Virtual Private Cloud (VPC).',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where to view VPC flow logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'In the configured log destination (CloudWatch Logs, S3, or Data Firehose for AWS).',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do you create AWS VPC flow logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "In the Amazon VPC console, select your VPC or subnet, then choose 'Create flow log' from the Actions menu. You can also do this with the AWS CLI.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is VPC flow log free?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'No, you are charged for the storage and data transfer of logs.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What does VPC stand for?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Virtual Private Cloud.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Create and Forward VPC Flow Logs to SigNoz',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Create/Configure the S3 Bucket',
+              text: 'Create an S3 bucket in AWS to store your VPC flow logs.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create the VPC',
+              text: "Set up a Virtual Private Cloud (VPC) in AWS if you don't already have one.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create the VPC Flow Logs',
+              text: 'Enable VPC flow logs for your VPC, configuring them to be stored in your S3 bucket.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create a Lambda Function',
+              text: 'Set up an AWS Lambda function to process the VPC flow logs.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Policies for the Function',
+              text: 'Grant the necessary permissions to your Lambda function to access the S3 bucket.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Trigger the Function',
+              text: 'Set up a trigger for the Lambda function to process new log files in the S3 bucket.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Write the Lambda Function',
+              text: 'Implement the Lambda function to process the VPC flow logs and forward them to SigNoz.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize the VPC Flow Logs in SigNoz',
+              text: 'Access and explore the forwarded VPC flow logs in the SigNoz dashboard.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
diff --git a/data/guides/what-are-prometheus-labels.mdx b/data/guides/what-are-prometheus-labels.mdx
index 8b764ff75..0e7c67c59 100644
--- a/data/guides/what-are-prometheus-labels.mdx
+++ b/data/guides/what-are-prometheus-labels.mdx
@@ -1,154 +1,169 @@
 ---
-
 title: What are Prometheus labels - Key Concepts and Best Practices
-slug: what-are-prometheus-labels
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Discover Prometheus labels - key-value pairs for metric characterization. Learn their importance, best practices, and advanced concepts for effective monitoring.
-keywords: [Prometheus labels, metric characterization, monitoring, data model, cardinality, relabeling, PromQL, best practices]
-
+keywords:
+  [
+    Prometheus labels,
+    metric characterization,
+    monitoring,
+    data model,
+    cardinality,
+    relabeling,
+    PromQL,
+    best practices,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What are Prometheus labels - Key Concepts and Best Practices",
-    "alternativeHeadline": "Understanding and Using Prometheus Labels for Effective Monitoring",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-are-prometheus-labels/"
-    },
-    "description": "Discover Prometheus labels - key-value pairs for metric characterization. Learn their importance, best practices, and advanced concepts for effective monitoring.",
-    "keywords": "Prometheus labels, metric characterization, monitoring, data model, cardinality, relabeling, PromQL, best practices",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus Labels",
-        "description": "Key-value pairs attached to metrics that provide context and additional information for organizing and querying data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metric Characterization",
-        "description": "The process of adding descriptive information to metrics to enhance their value and usability in monitoring systems."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The practice of observing and checking the progress or quality of a system over a period of time."
-      },
-      {
-        "@type": "Thing",
-        "name": "Data Model",
-        "description": "A conceptual framework for organizing and defining the structure of data, often used in databases and monitoring systems."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is the difference between a metric and a label in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "A metric in Prometheus represents a measurable value, such as the number of requests or CPU usage. Labels, on the other hand, provide additional context or metadata for these metrics. They allow you to create multiple time series for a single metric based on different label combinations."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What are Prometheus labels - Key Concepts and Best Practices',
+        alternativeHeadline: 'Understanding and Using Prometheus Labels for Effective Monitoring',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "How do labels affect Prometheus performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Labels can significantly impact Prometheus performance, particularly when dealing with high cardinality. Each unique combination of labels for a metric creates a new time series, which increases storage requirements and query complexity. Carefully managing label cardinality is crucial for maintaining optimal performance."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I add or modify labels after data collection?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While you cannot directly modify labels on existing data points, Prometheus provides several ways to work with labels post-collection: 1. Relabeling during scraping, 2. Using recording rules to create new metrics with modified labels, 3. Applying label transformations during querying using PromQL functions."
-          }
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-are-prometheus-labels/',
         },
-        {
-          "@type": "Question",
-          "name": "What is label cardinality and why is it important?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Label cardinality refers to the number of unique label value combinations for a given metric. High cardinality can lead to performance issues and increased storage requirements. It's important to balance the need for detailed metrics with the potential impact on system resources."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Using Prometheus Labels Effectively",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Choose Meaningful Label Names",
-          "text": "Use clear, descriptive names for your labels that reflect their purpose. Stick to a consistent naming convention across your metrics."
+        description:
+          'Discover Prometheus labels - key-value pairs for metric characterization. Learn their importance, best practices, and advanced concepts for effective monitoring.',
+        keywords:
+          'Prometheus labels, metric characterization, monitoring, data model, cardinality, relabeling, PromQL, best practices',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Manage Label Cardinality",
-          "text": "Be mindful of the number of unique label value combinations to avoid performance issues. Avoid using labels with an extremely large number of possible values."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus Labels',
+            description:
+              'Key-value pairs attached to metrics that provide context and additional information for organizing and querying data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metric Characterization',
+            description:
+              'The process of adding descriptive information to metrics to enhance their value and usability in monitoring systems.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The practice of observing and checking the progress or quality of a system over a period of time.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Data Model',
+            description:
+              'A conceptual framework for organizing and defining the structure of data, often used in databases and monitoring systems.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is the difference between a metric and a label in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'A metric in Prometheus represents a measurable value, such as the number of requests or CPU usage. Labels, on the other hand, provide additional context or metadata for these metrics. They allow you to create multiple time series for a single metric based on different label combinations.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do labels affect Prometheus performance?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Labels can significantly impact Prometheus performance, particularly when dealing with high cardinality. Each unique combination of labels for a metric creates a new time series, which increases storage requirements and query complexity. Carefully managing label cardinality is crucial for maintaining optimal performance.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I add or modify labels after data collection?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'While you cannot directly modify labels on existing data points, Prometheus provides several ways to work with labels post-collection: 1. Relabeling during scraping, 2. Using recording rules to create new metrics with modified labels, 3. Applying label transformations during querying using PromQL functions.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is label cardinality and why is it important?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Label cardinality refers to the number of unique label value combinations for a given metric. High cardinality can lead to performance issues and increased storage requirements. It's important to balance the need for detailed metrics with the potential impact on system resources.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use Labels to Improve Metric Discoverability",
-          "text": "Implement labels that make it easier to find and understand metrics, such as 'application', 'environment', or 'team'."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Using Prometheus Labels Effectively',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Choose Meaningful Label Names',
+              text: 'Use clear, descriptive names for your labels that reflect their purpose. Stick to a consistent naming convention across your metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Manage Label Cardinality',
+              text: 'Be mindful of the number of unique label value combinations to avoid performance issues. Avoid using labels with an extremely large number of possible values.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use Labels to Improve Metric Discoverability',
+              text: "Implement labels that make it easier to find and understand metrics, such as 'application', 'environment', or 'team'.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Standardize Label Usage',
+              text: 'Establish guidelines for label usage across your organization to ensure consistency and ease of use.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Relabeling in Prometheus',
+              text: "Use relabeling to modify, add, or remove labels before they are stored. Configure relabeling using the 'relabel_config' block in the Prometheus configuration file.",
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Standardize Label Usage",
-          "text": "Establish guidelines for label usage across your organization to ensure consistency and ease of use."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Relabeling in Prometheus",
-          "text": "Use relabeling to modify, add, or remove labels before they are stored. Configure relabeling using the 'relabel_config' block in the Prometheus configuration file."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus labels are essential components of the [Prometheus monitoring system](https://signoz.io/guides/what-is-prometheus-for-monitoring/), playing a crucial role in how metrics are organized and queried. These key-value pairs provide context and additional information to metrics, enabling powerful and flexible data analysis. This article explores the concept of Prometheus labels, their significance in the Prometheus ecosystem, and best practices for their effective use.
@@ -238,7 +253,6 @@ scrape_configs:
         target_label: instance
         regex: '(.*):.*'
         replacement: '$1'
-
 ```
 
 This configuration extracts the hostname from the `__address__` label and sets it as the `instance` label.
@@ -287,4 +301,4 @@ To get started with SigNoz:
 
 <GetStartedSigNoz />
 
-By using [SigNoz](https://signoz.io/docs/introduction/), you can leverage the power of Prometheus-style metrics and labels while benefiting from additional features and ease of use. Whether you're using the cloud or open-source version, SigNoz offers a robust solution for modern monitoring needs.
\ No newline at end of file
+By using [SigNoz](https://signoz.io/docs/introduction/), you can leverage the power of Prometheus-style metrics and labels while benefiting from additional features and ease of use. Whether you're using the cloud or open-source version, SigNoz offers a robust solution for modern monitoring needs.
diff --git a/data/guides/what-are-the-4-types-of-metrics-in-prometheus.mdx b/data/guides/what-are-the-4-types-of-metrics-in-prometheus.mdx
index 580276023..e1dfcccc1 100644
--- a/data/guides/what-are-the-4-types-of-metrics-in-prometheus.mdx
+++ b/data/guides/what-are-the-4-types-of-metrics-in-prometheus.mdx
@@ -1,159 +1,166 @@
 ---
-
 title: What are the 4 Types of Metrics in Prometheus - Understanding the Core Metric Types
-slug: what-are-the-4-types-of-metrics-in-prometheus
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Discover the 4 core metric types in Prometheus - counters, gauges, histograms, and summaries. Learn their characteristics, use cases, and implementation best practices.
 keywords: [Prometheus metrics, monitoring, observability, counters, gauges, histograms, summaries]
-
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What are the 4 types of metrics in Prometheus - Understanding the Core Metric Types",
-    "alternativeHeadline": "Exploring Counters, Gauges, Histograms, and Summaries in Prometheus",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/"
-    },
-    "description": "Discover the 4 core metric types in Prometheus: counters, gauges, histograms, and summaries. Learn their characteristics, use cases, and implementation best practices.",
-    "keywords": "Prometheus metrics, monitoring, observability, counters, gauges, histograms, summaries",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus Metrics",
-        "description": "Numerical measurements collected at regular intervals to monitor the health, performance, and behavior of systems and applications."
-      },
-      {
-        "@type": "Thing",
-        "name": "Counters",
-        "description": "Metrics that represent cumulative values that only increase over time, ideal for tracking events, requests, or occurrences."
-      },
-      {
-        "@type": "Thing",
-        "name": "Gauges",
-        "description": "Metrics representing single numerical values that can arbitrarily go up and down, useful for measuring current states or values that fluctuate."
-      },
-      {
-        "@type": "Thing",
-        "name": "Histograms",
-        "description": "Metrics that measure the distribution of values across predefined buckets, valuable for understanding the spread and concentration of data points."
-      },
-      {
-        "@type": "Thing",
-        "name": "Summaries",
-        "description": "Metrics that calculate streaming φ-quantiles (percentiles) over a sliding time window, useful for precise percentile calculations."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What's the difference between a histogram and a summary in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Histograms and summaries both measure distributions, but they differ in how they calculate and store data. Histograms use predefined buckets and allow for flexible querying and aggregation. Summaries calculate precise percentiles but offer less query flexibility."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "Can I convert one metric type to another in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "No, you cannot directly convert between metric types in Prometheus. Each type stores data differently, so conversion isn't possible. Choose the appropriate metric type based on your monitoring needs from the start."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline:
+          'What are the 4 types of metrics in Prometheus - Understanding the Core Metric Types',
+        alternativeHeadline: 'Exploring Counters, Gauges, Histograms, and Summaries in Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "How do Prometheus metric types affect performance and storage?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Different metric types have varying impacts on performance and storage. Counters and gauges are lightweight, while histograms and summaries consume more resources due to their additional data points. Consider the trade-offs between granularity and resource usage when selecting metric types."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Are there any limitations to the number of metrics I can use in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus can handle millions of time series, but practical limits depend on your hardware resources. High cardinality (many unique label combinations) can impact performance more than the total number of metrics. Monitor Prometheus' resource usage and optimize your metrics accordingly."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Implementing Prometheus Metrics",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Understand the Basics",
-          "text": "Learn the key characteristics and use cases of the four core metric types in Prometheus: counters, gauges, histograms, and summaries."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Choose the Right Metric Type",
-          "text": "Select the appropriate metric type based on the nature of your data and analysis requirements."
+        description:
+          'Discover the 4 core metric types in Prometheus: counters, gauges, histograms, and summaries. Learn their characteristics, use cases, and implementation best practices.',
+        keywords:
+          'Prometheus metrics, monitoring, observability, counters, gauges, histograms, summaries',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Implement Metrics",
-          "text": "Use Prometheus client libraries to define and implement the chosen metric types in your application code."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus Metrics',
+            description:
+              'Numerical measurements collected at regular intervals to monitor the health, performance, and behavior of systems and applications.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Counters',
+            description:
+              'Metrics that represent cumulative values that only increase over time, ideal for tracking events, requests, or occurrences.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Gauges',
+            description:
+              'Metrics representing single numerical values that can arbitrarily go up and down, useful for measuring current states or values that fluctuate.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Histograms',
+            description:
+              'Metrics that measure the distribution of values across predefined buckets, valuable for understanding the spread and concentration of data points.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Summaries',
+            description:
+              'Metrics that calculate streaming φ-quantiles (percentiles) over a sliding time window, useful for precise percentile calculations.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "What's the difference between a histogram and a summary in Prometheus?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Histograms and summaries both measure distributions, but they differ in how they calculate and store data. Histograms use predefined buckets and allow for flexible querying and aggregation. Summaries calculate precise percentiles but offer less query flexibility.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I convert one metric type to another in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "No, you cannot directly convert between metric types in Prometheus. Each type stores data differently, so conversion isn't possible. Choose the appropriate metric type based on your monitoring needs from the start.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do Prometheus metric types affect performance and storage?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Different metric types have varying impacts on performance and storage. Counters and gauges are lightweight, while histograms and summaries consume more resources due to their additional data points. Consider the trade-offs between granularity and resource usage when selecting metric types.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Are there any limitations to the number of metrics I can use in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Prometheus can handle millions of time series, but practical limits depend on your hardware resources. High cardinality (many unique label combinations) can impact performance more than the total number of metrics. Monitor Prometheus' resource usage and optimize your metrics accordingly.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Monitor and Analyze",
-          "text": "Set up Prometheus to collect and store your metrics, and use PromQL queries to analyze the data and gain insights."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Implementing Prometheus Metrics',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Understand the Basics',
+              text: 'Learn the key characteristics and use cases of the four core metric types in Prometheus: counters, gauges, histograms, and summaries.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Choose the Right Metric Type',
+              text: 'Select the appropriate metric type based on the nature of your data and analysis requirements.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Metrics',
+              text: 'Use Prometheus client libraries to define and implement the chosen metric types in your application code.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Monitor and Analyze',
+              text: 'Set up Prometheus to collect and store your metrics, and use PromQL queries to analyze the data and gain insights.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Performance',
+              text: 'Monitor metric cardinality and resource usage, and optimize your metrics for efficient performance and storage.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Performance",
-          "text": "Monitor metric cardinality and resource usage, and optimize your metrics for efficient performance and storage."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus, a powerful open-source monitoring system, uses four core metric types to collect and analyze data. These metric types — counters, gauges, histograms, and summaries — form the foundation of effective system monitoring and observability. Understanding these metric types is crucial for developers and system administrators who want to gain insights into their applications and infrastructure.
@@ -334,4 +341,4 @@ With SigNoz, you can:
 - Set up alerts based on complex queries and thresholds
 - Correlate metrics with traces for deeper insights into application performance
 
-By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
\ No newline at end of file
+By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
diff --git a/data/guides/what-are-the-benefits-of-prometheus.mdx b/data/guides/what-are-the-benefits-of-prometheus.mdx
index 100c7dcfa..fac5baa85 100644
--- a/data/guides/what-are-the-benefits-of-prometheus.mdx
+++ b/data/guides/what-are-the-benefits-of-prometheus.mdx
@@ -1,165 +1,168 @@
 ---
-
 title: What Are The Benefits of Prometheus?
-slug: what-are-the-benefits-of-prometheus
 date: 2024-07-20
 tags: [faq]
 authors: [daniel]
 description: One of the key benefits of using Prometheus is its service discovery which automatically discovers new targets when…
-keywords: [prometheus,monitoring,metrics]
-
+keywords: [prometheus, monitoring, metrics]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What are the Benefits of Prometheus?",
-    "alternativeHeadline": "Discover the key advantages of using Prometheus for monitoring systems and applications",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-20T00:00:00Z",
-    "dateModified": "2024-07-20T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-are-the-benefits-of-prometheus/"
-    },
-    "description": "The key benefits of Prometheus include scalability, flexibility, efficient pull-based monitoring, seamless service discovery, and active community support, amongst others.",
-    "keywords": "prometheus, monitoring, metrics",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The process of observing and checking the behavior and outputs of a system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metrics",
-        "description": "Quantitative data used to measure and track the performance of a system."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, providing powerful queries and alerting capabilities to help you monitor your systems and applications effectively."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What are the benefits of using Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The key benefits of Prometheus include scalability, flexibility, efficient pull-based monitoring, seamless service discovery, and active community support, amongst others."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How does Prometheus's pull-based model work?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus's pull-based model automatically scrapes metrics from targets at predetermined intervals, ensuring consistent capture of metrics regardless of the lifecycle of the services being monitored."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is the importance of service discovery in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Service discovery in Prometheus allows it to automatically discover new targets and remove old ones in dynamic environments, ensuring the monitoring system remains up-to-date without manual intervention."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What are the Benefits of Prometheus?',
+        alternativeHeadline:
+          'Discover the key advantages of using Prometheus for monitoring systems and applications',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "What are some limitations of Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Limitations of Prometheus include limited long-term storage, potential challenges with the pull-based model, single point of failure in its basic setup, basic built-in visualization, steep learning curve for PromQL, cardinality issues, and limited ecosystem for certain domains."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "How can SigNoz address the limitations of Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "SigNoz addresses many limitations of Prometheus by providing long-term storage solutions, advanced visualization capabilities, a user-friendly interface, and a unified platform for metrics, traces, and logs."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Use Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Prometheus",
-          "text": "Download and install Prometheus from the official website."
+        datePublished: '2024-07-20T00:00:00Z',
+        dateModified: '2024-07-20T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-are-the-benefits-of-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Prometheus",
-          "text": "Set up the Prometheus configuration file to define scrape targets and rules."
+        description:
+          'The key benefits of Prometheus include scalability, flexibility, efficient pull-based monitoring, seamless service discovery, and active community support, amongst others.',
+        keywords: 'prometheus, monitoring, metrics',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus",
-          "text": "Run the Prometheus server to start collecting metrics."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The process of observing and checking the behavior and outputs of a system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metrics',
+            description: 'Quantitative data used to measure and track the performance of a system.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, providing powerful queries and alerting capabilities to help you monitor your systems and applications effectively.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the benefits of using Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The key benefits of Prometheus include scalability, flexibility, efficient pull-based monitoring, seamless service discovery, and active community support, amongst others.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How does Prometheus's pull-based model work?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Prometheus's pull-based model automatically scrapes metrics from targets at predetermined intervals, ensuring consistent capture of metrics regardless of the lifecycle of the services being monitored.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the importance of service discovery in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Service discovery in Prometheus allows it to automatically discover new targets and remove old ones in dynamic environments, ensuring the monitoring system remains up-to-date without manual intervention.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some limitations of Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Limitations of Prometheus include limited long-term storage, potential challenges with the pull-based model, single point of failure in its basic setup, basic built-in visualization, steep learning curve for PromQL, cardinality issues, and limited ecosystem for certain domains.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How can SigNoz address the limitations of Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'SigNoz addresses many limitations of Prometheus by providing long-term storage solutions, advanced visualization capabilities, a user-friendly interface, and a unified platform for metrics, traces, and logs.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Up Alerting",
-          "text": "Integrate Prometheus with Alertmanager to manage alerts."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Prometheus',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Prometheus',
+              text: 'Download and install Prometheus from the official website.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Prometheus',
+              text: 'Set up the Prometheus configuration file to define scrape targets and rules.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Start Prometheus',
+              text: 'Run the Prometheus server to start collecting metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Alerting',
+              text: 'Integrate Prometheus with Alertmanager to manage alerts.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Visualize Metrics',
+              text: 'Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Visualize Metrics",
-          "text": "Use Grafana or SigNoz for advanced visualization of metrics collected by Prometheus."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 The key benefits of Prometheus include scalability, flexibility, efficient pull-based monitoring, seamless service discovery, and active community support, amongst others.
@@ -197,7 +200,7 @@ Prometheus's pull-based model significantly simplifies monitoring. It automatica
 
 ### 4. Service Discovery
 
- In dynamic environments where services are frequently created and destroyed, Prometheus's service discovery allows it to automatically discover new targets and remove old ones, ensuring that the monitoring system remains up-to-date without manual intervention.
+In dynamic environments where services are frequently created and destroyed, Prometheus's service discovery allows it to automatically discover new targets and remove old ones, ensuring that the monitoring system remains up-to-date without manual intervention.
 
 ### 5. Community
 
diff --git a/data/guides/what-are-the-limitations-of-prometheus-labels.mdx b/data/guides/what-are-the-limitations-of-prometheus-labels.mdx
index 48bc82ad5..268286c51 100644
--- a/data/guides/what-are-the-limitations-of-prometheus-labels.mdx
+++ b/data/guides/what-are-the-limitations-of-prometheus-labels.mdx
@@ -1,154 +1,167 @@
 ---
-
 title: What are the Limitations of Prometheus Labels?
-slug: what-are-the-limitations-of-prometheus-labels
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [daniel]
 description: Discover the limitations of Prometheus labels, learn best practices for managing high cardinality, and explore advanced techniques for scaling your monitoring setup.
-keywords: [Prometheus labels, label limitations, cardinality, monitoring, time series, performance optimization]
-
+keywords:
+  [
+    Prometheus labels,
+    label limitations,
+    cardinality,
+    monitoring,
+    time series,
+    performance optimization,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What are the Limitations of Prometheus Labels?",
-    "alternativeHeadline": "Understanding and Managing Prometheus Label Limitations",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-are-the-limitations-of-prometheus-labels/"
-    },
-    "description": "Discover the limitations of Prometheus labels, learn best practices for managing high cardinality, and explore advanced techniques for scaling your monitoring setup.",
-    "keywords": "Prometheus labels, label limitations, cardinality, monitoring, time series, performance optimization",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus Labels",
-        "description": "Key-value pairs attached to [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) that provide additional context and enhance the dimensional data model."
-      },
-      {
-        "@type": "Thing",
-        "name": "Cardinality",
-        "description": "The number of unique time series generated by different label value combinations in Prometheus."
-      },
-      {
-        "@type": "Thing",
-        "name": "Metric Relabeling",
-        "description": "A feature in Prometheus to modify, add, or remove labels before they are stored, helping manage high cardinality."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What is the maximum number of label values Prometheus can handle?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus doesn't have a hard limit on label values, but it's recommended to keep the total number of time series below tens of millions for optimal performance."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What are the Limitations of Prometheus Labels?',
+        alternativeHeadline: 'Understanding and Managing Prometheus Label Limitations',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How do I identify high-cardinality metrics in my Prometheus setup?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Use the PromQL query provided in the article to identify metrics with the highest cardinality. Regularly monitor these metrics to prevent performance issues."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Can I use customer names or unique IDs as label values?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "It's generally not recommended to use highly specific identifiers like customer names or unique IDs as label values. This can lead to cardinality explosion. Instead, consider using broader categories or aggregating this data."
-          }
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-are-the-limitations-of-prometheus-labels/',
         },
-        {
-          "@type": "Question",
-          "name": "What are the [alternatives to Prometheus](https://signoz.io/comparisons/prometheus-alternatives/) for high-cardinality environments?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "For environments with extremely high cardinality, consider time series databases designed for such workloads, like InfluxDB or TimescaleDB. Alternatively, you can use SigNoz, which provides advanced observability features while handling high-cardinality data efficiently."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Managing Prometheus Label Limitations",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Understand Cardinality Limits",
-          "text": "Learn about cardinality in Prometheus and how high cardinality can impact performance and resource usage."
+        description:
+          'Discover the limitations of Prometheus labels, learn best practices for managing high cardinality, and explore advanced techniques for scaling your monitoring setup.',
+        keywords:
+          'Prometheus labels, label limitations, cardinality, monitoring, time series, performance optimization',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Identify High-Cardinality Metrics",
-          "text": "Use PromQL queries to identify metrics with high cardinality in your Prometheus setup."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus Labels',
+            description:
+              'Key-value pairs attached to [Prometheus metrics](https://signoz.io/guides/what-are-the-4-types-of-metrics-in-prometheus/) that provide additional context and enhance the dimensional data model.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Cardinality',
+            description:
+              'The number of unique time series generated by different label value combinations in Prometheus.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Metric Relabeling',
+            description:
+              'A feature in Prometheus to modify, add, or remove labels before they are stored, helping manage high cardinality.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is the maximum number of label values Prometheus can handle?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Prometheus doesn't have a hard limit on label values, but it's recommended to keep the total number of time series below tens of millions for optimal performance.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I identify high-cardinality metrics in my Prometheus setup?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Use the PromQL query provided in the article to identify metrics with the highest cardinality. Regularly monitor these metrics to prevent performance issues.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use customer names or unique IDs as label values?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "It's generally not recommended to use highly specific identifiers like customer names or unique IDs as label values. This can lead to cardinality explosion. Instead, consider using broader categories or aggregating this data.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the [alternatives to Prometheus](https://signoz.io/comparisons/prometheus-alternatives/) for high-cardinality environments?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'For environments with extremely high cardinality, consider time series databases designed for such workloads, like InfluxDB or TimescaleDB. Alternatively, you can use SigNoz, which provides advanced observability features while handling high-cardinality data efficiently.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Implement Cardinality Control Measures",
-          "text": "Apply metric relabeling, aggregation, and bucketing techniques to manage and reduce high cardinality."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Managing Prometheus Label Limitations',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Understand Cardinality Limits',
+              text: 'Learn about cardinality in Prometheus and how high cardinality can impact performance and resource usage.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Identify High-Cardinality Metrics',
+              text: 'Use PromQL queries to identify metrics with high cardinality in your Prometheus setup.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Cardinality Control Measures',
+              text: 'Apply metric relabeling, aggregation, and bucketing techniques to manage and reduce high cardinality.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Label Usage',
+              text: 'Remove unnecessary high-cardinality labels and standardize label naming to prevent cardinality explosion.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Scale Prometheus with Advanced Techniques',
+              text: 'Consider horizontal scaling, remote storage, or using projects like Thanos or Cortex for large-scale deployments.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Label Usage",
-          "text": "Remove unnecessary high-cardinality labels and standardize label naming to prevent cardinality explosion."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Scale Prometheus with Advanced Techniques",
-          "text": "Consider horizontal scaling, remote storage, or using projects like Thanos or Cortex for large-scale deployments."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 [Prometheus labels](https://signoz.io/guides/how-to-add-target-specific-label-in-prometheus/) are powerful tools for adding context to metrics, but they come with certain limitations. These constraints primarily revolve around cardinality — the number of unique time series generated by label combinations. Understanding these limitations is crucial for maintaining a performant monitoring system. Let's explore the key aspects of Prometheus label limitations and learn how to work within these constraints effectively.
@@ -249,7 +262,6 @@ scrape_configs:
       - source_labels: [user_id]
         regex: '.+'
         action: drop
-
 ```
 
 This configuration drops the `user_id` label, which might be causing high cardinality.
@@ -289,4 +301,4 @@ For environments with extremely high cardinality, consider time series databases
 
 <GetStartedSigNoz />
 
-[SigNoz](https://signoz.io/docs/introduction/) offers a scalable solution for monitoring high-cardinality environments, providing advanced querying capabilities and efficient data management. It's compatible with Prometheus metrics and can serve as an excellent alternative or complement to your existing Prometheus setup.
\ No newline at end of file
+[SigNoz](https://signoz.io/docs/introduction/) offers a scalable solution for monitoring high-cardinality environments, providing advanced querying capabilities and efficient data management. It's compatible with Prometheus metrics and can serve as an excellent alternative or complement to your existing Prometheus setup.
diff --git a/data/guides/what-database-does-jaeger-use.mdx b/data/guides/what-database-does-jaeger-use.mdx
index 4e39a38b8..c93480775 100644
--- a/data/guides/what-database-does-jaeger-use.mdx
+++ b/data/guides/what-database-does-jaeger-use.mdx
@@ -1,159 +1,172 @@
 ---
-
 title: What Database does Jaeger Use - Elasticsearch vs Cassandra
-slug: what-database-does-jaeger-use
 date: 2024-07-30
 tags: [faq, jaeger]
 authors: [yuvraj]
 description: Discover the primary databases Jaeger uses for distributed tracing. Compare Elasticsearch and Cassandra to choose the best option for your deployment.
-keywords: [Jaeger database, Elasticsearch, Cassandra, distributed tracing, storage backend, Kafka, data persistence]
-
+keywords:
+  [
+    Jaeger database,
+    Elasticsearch,
+    Cassandra,
+    distributed tracing,
+    storage backend,
+    Kafka,
+    data persistence,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What database does Jaeger use: Elasticsearch vs. Cassandra",
-    "alternativeHeadline": "Discover the primary databases Jaeger uses for distributed tracing",
-    "author": {
-      "@type": "Person",
-      "name": "Yuvraj"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-database-does-jaeger-use/"
-    },
-    "description": "Discover the primary databases Jaeger uses for distributed tracing. Compare Elasticsearch and Cassandra to choose the best option for your deployment.",
-    "keywords": "Jaeger database, Elasticsearch, Cassandra, distributed tracing, storage backend, Kafka, data persistence",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Jaeger",
-        "description": "An open-source, end-to-end distributed tracing system."
-      },
-      {
-        "@type": "Thing",
-        "name": "Elasticsearch",
-        "description": "A distributed, RESTful search and analytics engine capable of solving a growing number of use cases."
-      },
-      {
-        "@type": "Thing",
-        "name": "Cassandra",
-        "description": "A highly scalable NoSQL database designed to handle large amounts of data across many commodity servers."
-      },
-      {
-        "@type": "Thing",
-        "name": "Kafka",
-        "description": "A distributed streaming platform capable of handling high-throughput data feeds."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Jaeger",
-        "applicationCategory": "Distributed Tracing"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Elasticsearch",
-        "applicationCategory": "Search Engine"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Cassandra",
-        "applicationCategory": "Database"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "Kafka",
-        "applicationCategory": "Streaming Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Can Jaeger work without a persistent database?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Yes, Jaeger can operate with in-memory storage for testing or development purposes. However, a persistent database is crucial for production deployments to ensure data durability and enable historical analysis."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What database does Jaeger use: Elasticsearch vs. Cassandra',
+        alternativeHeadline: 'Discover the primary databases Jaeger uses for distributed tracing',
+        author: {
+          '@type': 'Person',
+          name: 'Yuvraj',
         },
-        {
-          "@type": "Question",
-          "name": "How does Jaeger's database choice affect its performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The database choice impacts query performance, data ingestion rates, and overall system scalability. Elasticsearch generally offers better query performance, while Cassandra excels in write-heavy scenarios."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Is it possible to use both Elasticsearch and Cassandra with Jaeger?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While it's technically possible to use both databases simultaneously, it's not a common practice. Most organizations choose one primary storage backend for simplicity and consistency."
-          }
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-database-does-jaeger-use/',
         },
-        {
-          "@type": "Question",
-          "name": "What are the minimum hardware requirements for running Jaeger with Elasticsearch?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "The hardware requirements depend on your trace data volume and retention period. For small to medium deployments, start with: 3 Elasticsearch nodes, 8GB RAM per node, 4 CPU cores per node, and SSD storage for improved performance. Scale these resources as your tracing needs grow."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Setting Up Jaeger with Elasticsearch",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Install Elasticsearch",
-          "text": "Install Elasticsearch and ensure it's running."
+        description:
+          'Discover the primary databases Jaeger uses for distributed tracing. Compare Elasticsearch and Cassandra to choose the best option for your deployment.',
+        keywords:
+          'Jaeger database, Elasticsearch, Cassandra, distributed tracing, storage backend, Kafka, data persistence',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Set Environment Variable",
-          "text": "Set the SPAN_STORAGE_TYPE environment variable to elasticsearch."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Jaeger',
+            description: 'An open-source, end-to-end distributed tracing system.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Elasticsearch',
+            description:
+              'A distributed, RESTful search and analytics engine capable of solving a growing number of use cases.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Cassandra',
+            description:
+              'A highly scalable NoSQL database designed to handle large amounts of data across many commodity servers.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Kafka',
+            description:
+              'A distributed streaming platform capable of handling high-throughput data feeds.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Jaeger',
+            applicationCategory: 'Distributed Tracing',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Elasticsearch',
+            applicationCategory: 'Search Engine',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Cassandra',
+            applicationCategory: 'Database',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Kafka',
+            applicationCategory: 'Streaming Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Can Jaeger work without a persistent database?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Jaeger can operate with in-memory storage for testing or development purposes. However, a persistent database is crucial for production deployments to ensure data durability and enable historical analysis.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: "How does Jaeger's database choice affect its performance?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The database choice impacts query performance, data ingestion rates, and overall system scalability. Elasticsearch generally offers better query performance, while Cassandra excels in write-heavy scenarios.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is it possible to use both Elasticsearch and Cassandra with Jaeger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While it's technically possible to use both databases simultaneously, it's not a common practice. Most organizations choose one primary storage backend for simplicity and consistency.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are the minimum hardware requirements for running Jaeger with Elasticsearch?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'The hardware requirements depend on your trace data volume and retention period. For small to medium deployments, start with: 3 Elasticsearch nodes, 8GB RAM per node, 4 CPU cores per node, and SSD storage for improved performance. Scale these resources as your tracing needs grow.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Jaeger",
-          "text": "Configure Jaeger components with Elasticsearch connection details."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Setting Up Jaeger with Elasticsearch',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Elasticsearch',
+              text: "Install Elasticsearch and ensure it's running.",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Environment Variable',
+              text: 'Set the SPAN_STORAGE_TYPE environment variable to elasticsearch.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Jaeger',
+              text: 'Configure Jaeger components with Elasticsearch connection details.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Performance',
+              text: 'Use dedicated Elasticsearch indices for Jaeger data and implement proper index management and data retention policies.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Performance",
-          "text": "Use dedicated Elasticsearch indices for Jaeger data and implement proper index management and data retention policies."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Jaeger, a popular open-source [distributed tracing](https://signoz.io/distributed-tracing/) system, offers flexibility in choosing a database for storing trace data. While Jaeger supports multiple storage backends, two primary options stand out: Elasticsearch and Cassandra. This article delves into Jaeger's database choices, comparing these options to help you make an informed decision for your tracing infrastructure.
@@ -197,7 +210,6 @@ collector:
     server-urls: <http://elasticsearch:9200>
     username: elastic
     password: changeme
-
 ```
 
 For optimal performance:
@@ -295,4 +307,4 @@ While Jaeger is a popular choice for distributed tracing, it's worth considering
 
 If you're looking for a comprehensive observability solution that goes beyond just distributed tracing, SigNoz might be the right fit for your needs. It provides a seamless experience for developers and operations teams, combining the power of metrics, traces, and logs in one tool.
 
-To learn more about how SigNoz compares to Jaeger and how it can enhance your observability stack, visit [https://signoz.io](https://signoz.io/).
\ No newline at end of file
+To learn more about how SigNoz compares to Jaeger and how it can enhance your observability stack, visit [https://signoz.io](https://signoz.io/).
diff --git a/data/guides/what-is-Prometheus-used-for-in-DevOps.mdx b/data/guides/what-is-Prometheus-used-for-in-DevOps.mdx
index 881a0adfe..304e3105e 100644
--- a/data/guides/what-is-Prometheus-used-for-in-DevOps.mdx
+++ b/data/guides/what-is-Prometheus-used-for-in-DevOps.mdx
@@ -1,125 +1,125 @@
 ---
-
 title: What is Prometheus used for in DevOps?
-slug: what-is-Prometheus-used-for-in-DevOps
 date: 2024-07-12
 tags: [faq, prometheus]
 authors: [daniel]
 description: Prometheus is a monitoring and alerting toolkit used in DevOps to track system health and application performance.
-keywords:  [prometheus,monitor,monitoring,metrics, devops]
-
+keywords: [prometheus, monitor, monitoring, metrics, devops]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "What is Prometheus used for in DevOps?",
-  "description": "Prometheus is a monitoring and alerting toolkit used in DevOps to track system health and application performance.",
-  "keywords": ["prometheus", "monitor", "monitoring", "metrics", "devops"],
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "datePublished": "2024-07-12",
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/what-is-Prometheus-used-for-in-DevOps/"
-  },
-  "articleSection": "DevOps",
-  "inLanguage": "en",
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source monitoring and alerting toolkit used in DevOps"
-    },
-    {
-      "@type": "Thing",
-      "name": "DevOps",
-      "description": "A set of practices that combines software development and IT operations"
-    }
-  ],
-  "educationalLevel": "Intermediate",
-  "isAccessibleForFree": true,
-  "image": {
-    "@type": "ImageObject",
-    "url": "https://signoz.io/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.23.50.webp",
-    "caption": "Download Prometheus"
-  },
-  "hasPart": [
-    {
-      "@type": "HowTo",
-      "name": "Quick Start with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Download Prometheus",
-          "text": "Visit the Prometheus download page and download the appropriate package for your operating system."
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What is Prometheus used for in DevOps?',
+        description:
+          'Prometheus is a monitoring and alerting toolkit used in DevOps to track system health and application performance.',
+        keywords: ['prometheus', 'monitor', 'monitoring', 'metrics', 'devops'],
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure prometheus.yml file",
-          "text": "Open the prometheus.yml file in a text editor and configure the targets to monitor."
+        datePublished: '2024-07-12',
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus server",
-          "text": "Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml"
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-is-Prometheus-used-for-in-DevOps/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Access the Prometheus UI",
-          "text": "Open a web browser and visit localhost:9090 to access the Prometheus UI."
-        }
-      ]
-    }
-  ],
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "What is Prometheus?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus is an open-source monitoring and alerting toolkit originally developed at SoundCloud in 2012. It is designed with a focus on reliability and scalability, making it an indispensable tool for monitoring complex infrastructures and applications in DevOps environments."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the key features of Prometheus?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Key features of Prometheus include a time-series data model, pull-based model for collecting metrics, service discovery, powerful query language (PromQL), and integrated alerting capabilities."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "Why is Prometheus popular in DevOps?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus is popular in DevOps due to its open-source nature, which benefits from a large and active community, and its flexibility and scalability, which allow it to integrate seamlessly with a wide range of systems and handle large volumes of metrics."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the main use cases of Prometheus in DevOps?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Main use cases of Prometheus in DevOps include application monitoring (tracking request latency, error rates, and throughput), [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), Kubernetes monitoring, database monitoring, and service discovery and monitoring in dynamic environments."
-      }
-    }
-  ]
-}) }}
+        articleSection: 'DevOps',
+        inLanguage: 'en',
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description: 'An open-source monitoring and alerting toolkit used in DevOps',
+          },
+          {
+            '@type': 'Thing',
+            name: 'DevOps',
+            description: 'A set of practices that combines software development and IT operations',
+          },
+        ],
+        educationalLevel: 'Intermediate',
+        isAccessibleForFree: true,
+        image: {
+          '@type': 'ImageObject',
+          url: 'https://signoz.io/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.23.50.webp',
+          caption: 'Download Prometheus',
+        },
+        hasPart: [
+          {
+            '@type': 'HowTo',
+            name: 'Quick Start with Prometheus',
+            step: [
+              {
+                '@type': 'HowToStep',
+                name: 'Download Prometheus',
+                text: 'Visit the Prometheus download page and download the appropriate package for your operating system.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Configure prometheus.yml file',
+                text: 'Open the prometheus.yml file in a text editor and configure the targets to monitor.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Start Prometheus server',
+                text: 'Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Access the Prometheus UI',
+                text: 'Open a web browser and visit localhost:9090 to access the Prometheus UI.',
+              },
+            ],
+          },
+        ],
+        mainEntity: [
+          {
+            '@type': 'Question',
+            name: 'What is Prometheus?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus is an open-source monitoring and alerting toolkit originally developed at SoundCloud in 2012. It is designed with a focus on reliability and scalability, making it an indispensable tool for monitoring complex infrastructures and applications in DevOps environments.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the key features of Prometheus?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Key features of Prometheus include a time-series data model, pull-based model for collecting metrics, service discovery, powerful query language (PromQL), and integrated alerting capabilities.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'Why is Prometheus popular in DevOps?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus is popular in DevOps due to its open-source nature, which benefits from a large and active community, and its flexibility and scalability, which allow it to integrate seamlessly with a wide range of systems and handle large volumes of metrics.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the main use cases of Prometheus in DevOps?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Main use cases of Prometheus in DevOps include application monitoring (tracking request latency, error rates, and throughput), [infrastructure monitoring](https://signoz.io/guides/infrastructure-monitoring/), Kubernetes monitoring, database monitoring, and service discovery and monitoring in dynamic environments.',
+            },
+          },
+        ],
+      }),
+    }}
   />
 </head>
 
@@ -159,21 +159,29 @@ This quick start guide will help you get Prometheus up and running in a few simp
 
 To download Prometheus on your system, visit the <a href="https://prometheus.io/download/" rel="noopener noreferrer nofollow" target="_blank">Prometheus download</a> page. Set your system architecture and identify the appropriate package for your operating system (Linux, macOS, Windows). Click on the download link for the latest stable release.
 
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.23.50.webp" alt="Download Prometheus" caption="Download Prometheus" />
-
-
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.23.50.webp"
+  alt="Download Prometheus"
+  caption="Download Prometheus"
+/>
 
 1. Configure `prometheus.yml` file
 
 After downloading Prometheus, extract the tarball downloaded file. You'll find a file named `prometheus.yml` in the extracted directory.
 
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.45.09.webp" alt="Extracted Prometheus folder" caption="Extracted Prometheus folder" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.45.09.webp"
+  alt="Extracted Prometheus folder"
+  caption="Extracted Prometheus folder"
+/>
 
 Prometheus uses a configuration file named `prometheus.yml` to specify which targets to monitor and how to scrape them. Open `prometheus.yml` in a text editor.
 
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.25.29.webp" alt="Prometheus.yml file" caption="Prometheus.yml file" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.25.29.webp"
+  alt="Prometheus.yml file"
+  caption="Prometheus.yml file"
+/>
 
 In the `prometheus.yml` file, you will see that Prometheus is configured to scrape metrics from itself. You can add other scrape configurations for Prometheus to scrape metrics from different targets on your system.
 
@@ -187,21 +195,27 @@ Navigate to the directory where you extracted Prometheus and execute the followi
 
 This command will start Prometheus and use the specified configuration file to determine which targets to scrape.
 
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.42.25.webp" alt="Prometheus started" caption="Prometheus started" />
-
-
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.42.25.webp"
+  alt="Prometheus started"
+  caption="Prometheus started"
+/>
 
 1. Access the Prometheus UI
 
 Once Prometheus has started, in your browser, visit [localhost:9090](http://localhost:9090) to access the Prometheus UI:
 
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.43.47.webp" alt="Prometheus UI" caption="Prometheus UI" />
-
-
-
-<Figure src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.45.59.webp" alt="Prometheus targets" caption="Prometheus targets" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.43.47.webp"
+  alt="Prometheus UI"
+  caption="Prometheus UI"
+/>
 
+<Figure
+  src="/img/guides/2024/07/what-is-Prometheus-used-for-in-DevOps-Screenshot_2024-07-12_at_07.45.59.webp"
+  alt="Prometheus targets"
+  caption="Prometheus targets"
+/>
 
 ## Use Cases of Prometheus in DevOps
 
@@ -237,7 +251,7 @@ Prometheus excels in various use cases within the DevOps ecosystem:
 
 ## Conclusion
 
-Prometheus is utilized in DevOps for its robust monitoring and alerting capabilities, empowering teams to maintain system health and performance effectively. 
+Prometheus is utilized in DevOps for its robust monitoring and alerting capabilities, empowering teams to maintain system health and performance effectively.
 
 Key takeaways:
 
diff --git a/data/guides/what-is-a-bucket-in-prometheus.mdx b/data/guides/what-is-a-bucket-in-prometheus.mdx
index 0022d9ee6..cc8c0dbb3 100644
--- a/data/guides/what-is-a-bucket-in-prometheus.mdx
+++ b/data/guides/what-is-a-bucket-in-prometheus.mdx
@@ -1,154 +1,169 @@
 ---
-
 title: What is a Bucket in Prometheus - A Beginner's Guide
-slug: what-is-a-bucket-in-prometheus
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Discover what buckets are in Prometheus, how they work with histogram metrics, and their crucial role in data aggregation and analysis for effective monitoring.
-keywords: [Prometheus, buckets, histogram metrics, monitoring, data aggregation, metric types, custom configurations]
-
+keywords:
+  [
+    Prometheus,
+    buckets,
+    histogram metrics,
+    monitoring,
+    data aggregation,
+    metric types,
+    custom configurations,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What is a bucket in Prometheus - A Beginner's Guide",
-    "alternativeHeadline": "Understanding Buckets in Prometheus and Their Role in Histogram Metrics",
-    "author": {
-      "@type": "Person",
-      "name": "Ankit Anand"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-is-a-bucket-in-prometheus/"
-    },
-    "description": "Discover what buckets are in Prometheus, how they work with histogram metrics, and their crucial role in data aggregation and analysis for effective monitoring.",
-    "keywords": "Prometheus, buckets, histogram metrics, monitoring, data aggregation, metric types, custom configurations",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus Buckets",
-        "description": "Predefined ranges of values used to categorize and count observations in histogram metrics for efficient data aggregation and analysis."
-      },
-      {
-        "@type": "Thing",
-        "name": "Histogram Metrics",
-        "description": "Metrics that sample observations and count them in configurable buckets to understand the distribution of values."
-      },
-      {
-        "@type": "Thing",
-        "name": "Data Aggregation",
-        "description": "The process of collecting and summarizing data to provide insights and facilitate analysis."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The practice of observing and checking the performance and health of systems over time."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "What's the difference between Prometheus histograms and summaries?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Histograms use predefined buckets to track value distributions, while summaries calculate quantiles over a sliding time window. Histograms are more efficient for aggregation across multiple instances, but summaries provide more accurate quantiles for a single instance."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How do I choose the right bucket boundaries for my use case?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Consider your metric's expected range and the level of detail needed. Start with a broad range and refine based on observed data. Focus on critical thresholds relevant to your application's performance or SLAs."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: "What is a bucket in Prometheus - A Beginner's Guide",
+        alternativeHeadline:
+          'Understanding Buckets in Prometheus and Their Role in Histogram Metrics',
+        author: {
+          '@type': 'Person',
+          name: 'Ankit Anand',
         },
-        {
-          "@type": "Question",
-          "name": "Can I change bucket configurations after metrics have been collected?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "You can change bucket configurations, but it will only affect new data. Existing data will remain in the old bucket structure. For significant changes, consider creating a new metric with the updated configuration."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "How do Prometheus buckets impact storage and query performance?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "More buckets increase storage requirements and can slow down queries. However, they also provide finer granularity for analysis. Strike a balance between precision and performance based on your specific monitoring needs."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Using Buckets in Prometheus Histograms",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Understand the Basics",
-          "text": "Learn the key concepts of buckets in Prometheus and how they are used in histogram metrics."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-is-a-bucket-in-prometheus/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure Custom Buckets",
-          "text": "Define custom bucket configurations to better suit your specific use case, focusing on critical value ranges."
+        description:
+          'Discover what buckets are in Prometheus, how they work with histogram metrics, and their crucial role in data aggregation and analysis for effective monitoring.',
+        keywords:
+          'Prometheus, buckets, histogram metrics, monitoring, data aggregation, metric types, custom configurations',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Implement Practical Applications",
-          "text": "Apply buckets to measure request latencies, monitor system resource utilization, calculate Apdex scores, and aid in capacity planning."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus Buckets',
+            description:
+              'Predefined ranges of values used to categorize and count observations in histogram metrics for efficient data aggregation and analysis.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Histogram Metrics',
+            description:
+              'Metrics that sample observations and count them in configurable buckets to understand the distribution of values.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Data Aggregation',
+            description:
+              'The process of collecting and summarizing data to provide insights and facilitate analysis.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The practice of observing and checking the performance and health of systems over time.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: "What's the difference between Prometheus histograms and summaries?",
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Histograms use predefined buckets to track value distributions, while summaries calculate quantiles over a sliding time window. Histograms are more efficient for aggregation across multiple instances, but summaries provide more accurate quantiles for a single instance.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I choose the right bucket boundaries for my use case?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Consider your metric's expected range and the level of detail needed. Start with a broad range and refine based on observed data. Focus on critical thresholds relevant to your application's performance or SLAs.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I change bucket configurations after metrics have been collected?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'You can change bucket configurations, but it will only affect new data. Existing data will remain in the old bucket structure. For significant changes, consider creating a new metric with the updated configuration.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do Prometheus buckets impact storage and query performance?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'More buckets increase storage requirements and can slow down queries. However, they also provide finer granularity for analysis. Strike a balance between precision and performance based on your specific monitoring needs.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Analyze Bucket Data",
-          "text": "Use the cumulative frequency distributions provided by buckets to gain insights into the performance and behavior of your systems."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Using Buckets in Prometheus Histograms',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Understand the Basics',
+              text: 'Learn the key concepts of buckets in Prometheus and how they are used in histogram metrics.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure Custom Buckets',
+              text: 'Define custom bucket configurations to better suit your specific use case, focusing on critical value ranges.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Practical Applications',
+              text: 'Apply buckets to measure request latencies, monitor system resource utilization, calculate Apdex scores, and aid in capacity planning.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Analyze Bucket Data',
+              text: 'Use the cumulative frequency distributions provided by buckets to gain insights into the performance and behavior of your systems.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Optimize Performance',
+              text: 'Balance the number of buckets to achieve the right level of granularity while managing storage and query performance effectively.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Optimize Performance",
-          "text": "Balance the number of buckets to achieve the right level of granularity while managing storage and query performance effectively."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus, an open-source monitoring system, uses buckets as a fundamental concept in its data aggregation and analysis. These buckets play a crucial role in histogram metrics, allowing for efficient storage and querying of observed values. This guide explains what buckets are in Prometheus, how they function, and why they're essential for effective monitoring.
@@ -283,4 +298,4 @@ With SigNoz, you can:
 - Set up alerts based on complex queries and thresholds
 - Correlate metrics with traces for deeper insights into application performance
 
-By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
\ No newline at end of file
+By integrating [SigNoz](https://signoz.io/docs/introduction/) with your existing Prometheus setup, you can take your monitoring to the next level, making it easier to understand and act on your metrics data.
diff --git a/data/guides/what-is-a-prometheus-rule.mdx b/data/guides/what-is-a-prometheus-rule.mdx
index 64ef8ab92..167f8dfd5 100644
--- a/data/guides/what-is-a-prometheus-rule.mdx
+++ b/data/guides/what-is-a-prometheus-rule.mdx
@@ -1,13 +1,19 @@
 ---
-
 title: What is a Prometheus rule? - A Comprehensive Guide
-slug: what-is-a-prometheus-rule
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Discover Prometheus rules - essential for efficient monitoring and alerting. Learn about recording and alerting rules, configuration, and best practices.
-keywords: [Prometheus rules, recording rules, alerting rules, monitoring, PromQL, Prometheus configuration, alert management]
-
+keywords:
+  [
+    Prometheus rules,
+    recording rules,
+    alerting rules,
+    monitoring,
+    PromQL,
+    Prometheus configuration,
+    alert management,
+  ]
 ---
 
 Prometheus rules are powerful configuration elements that enhance the capabilities of the [Prometheus monitoring system](https://signoz.io/guides/what-is-prometheus-for-monitoring/). These rules allow you to precompute complex queries and define alert conditions, making your monitoring more efficient and responsive. In this comprehensive guide, you'll learn about the two main types of Prometheus rules: recording rules and alerting rules. We'll explore their importance, configuration, and best practices to help you optimize your monitoring setup.
@@ -36,7 +42,6 @@ The syntax of a recording rule is straightforward:
 ```yaml
 - record: <new_metric_name>
   expr: <PromQL_expression>
-
 ```
 
 Here's an example of a recording rule that calculates the average CPU usage across all instances:
@@ -44,7 +49,6 @@ Here's an example of a recording rule that calculates the average CPU usage acro
 ```yaml
 - record: job:node_cpu_utilization:avg_rate5m
   expr: avg(rate(node_cpu_seconds_total{mode="user"}[5m])) by (job)
-
 ```
 
 This rule computes the 5-minute average CPU utilization rate and stores it under a new metric name.
@@ -72,17 +76,15 @@ To set up recording rules in Prometheus, follow these steps:
 groups:
   - name: cpu_utilization
     rules:
-    - record: job:node_cpu_utilization:avg_rate5m
-      expr: avg(rate(node_cpu_seconds_total{mode="user"}[5m])) by (job)
-
+      - record: job:node_cpu_utilization:avg_rate5m
+        expr: avg(rate(node_cpu_seconds_total{mode="user"}[5m])) by (job)
 ```
 
 1. Add the rule file to your [Prometheus configuration](https://signoz.io/guides/what-is-prometheus-target/):
 
 ```yaml
 rule_files:
-  - "recording_rules.yml"
-
+  - 'recording_rules.yml'
 ```
 
 1. Restart Prometheus to apply the changes.
@@ -111,7 +113,6 @@ The anatomy of an alerting rule includes:
     <label_key>: <label_value>
   annotations:
     <annotation_key>: <annotation_value>
-
 ```
 
 Here's an example of an alerting rule that triggers when CPU usage is above 90% for 5 minutes:
@@ -123,9 +124,8 @@ Here's an example of an alerting rule that triggers when CPU usage is above 90%
   labels:
     severity: critical
   annotations:
-    summary: "High CPU usage detected on {{ $labels.instance }}"
-    description: "CPU usage is above 90% for 5 minutes on {{ $labels.instance }}"
-
+    summary: 'High CPU usage detected on {{ $labels.instance }}'
+    description: 'CPU usage is above 90% for 5 minutes on {{ $labels.instance }}'
 ```
 
 Prometheus evaluates alerting rules at regular intervals. When an alert condition is met, it generates an alert and sends it to configured notification systems like Alertmanager.
@@ -139,7 +139,6 @@ To create more sophisticated alerting rules:
 ```yaml
 - alert: ServiceDown
   expr: up{job=~"important-service|critical-app"} == 0
-
 ```
 
 1. Implement multi-condition alerts:
@@ -147,7 +146,6 @@ To create more sophisticated alerting rules:
 ```yaml
 - alert: HighErrorRateAndLatency
   expr: (rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])) > 0.05 and http_request_duration_seconds{quantile="0.9"} > 1
-
 ```
 
 1. Reduce alert noise by using the `for` clause and grouping related alerts:
@@ -156,7 +154,6 @@ To create more sophisticated alerting rules:
 - alert: PersistentHighCPU
   expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 90
   for: 15m
-
 ```
 
 1. Integrate with Alertmanager for advanced notification routing and grouping.
@@ -223,4 +220,4 @@ To get started with SigNoz:
 
 <GetStartedSigNoz />
 
-SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
\ No newline at end of file
+SigNoz offers both cloud and open-source versions, giving you flexibility in your monitoring setup. Experience the ease of modern observability with SigNoz and take your monitoring to the next level.
diff --git a/data/guides/what-is-apm.mdx b/data/guides/what-is-apm.mdx
index 0f48f216e..6b0b3a557 100644
--- a/data/guides/what-is-apm.mdx
+++ b/data/guides/what-is-apm.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: What is APM - Implementation and Best Practices
-slug: what-is-apm
 date: 2024-08-08
 tags: [apm]
 authors: [nitin_gouda]
 description: Discover Application Performance Monitoring (APM), its implementation, and best practices. Learn how APM enhances software performance and user experience.
-keywords: [APM, application performance monitoring, software monitoring, performance optimization, DevOps, observability]
-
+keywords:
+  [
+    APM,
+    application performance monitoring,
+    software monitoring,
+    performance optimization,
+    DevOps,
+    observability,
+  ]
 ---
 
 Application Performance Monitoring (APM) is a critical tool in modern software development and operations. It helps ensure your applications run smoothly, and efficiently, and meet user expectations. APM provides real-time insights into your application's performance, allowing you to identify and resolve issues quickly. This article explores APM's core concepts, implementation strategies, and best practices to help you optimize your software performance.
@@ -22,7 +27,11 @@ Key components of APM include:
 - Traces: Traces provide detailed records of transactions as they flow through an application. They track the path of individual requests and show how they interact with various system components. Traces can show how a user request moves through different services, databases, and third-party APIs. They highlight the duration of each step, helping to identify slow or failing components.
 - Logs: Logs are text-based records of events and errors within an application. They provide a chronological record of what has happened within the system. Logs can include error messages, debug information, and audit trails. They record events such as user logins, database queries, and application errors.
 
-<Figure src="/img/guides/2024/08/what-is-apm-CleanShot_2024-08-08_at_15.25.292x.webp" alt="Venn Diagram of logs, metrics and traces" caption="Venn Diagram of logs, metrics and traces" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-CleanShot_2024-08-08_at_15.25.292x.webp"
+  alt="Venn Diagram of logs, metrics and traces"
+  caption="Venn Diagram of logs, metrics and traces"
+/>
 
 APM has evolved significantly with modern software development practices. It now encompasses not just server-side monitoring but also client-side performance, distributed systems, and cloud-native architectures. Combining metrics, traces, and logs provides a comprehensive view of application performance. We at SigNoz don’t think logs, metrics and traces as different pillars but as mesh working together, thinking of them as isolated pillars can create a false dichotomy. To know more about it, you can visit the [Olly Beginner's Guide](https://signoz.io/blog/o11y/) .
 
@@ -49,16 +58,16 @@ In today's digital-first business environment, APM is more than just a nice-to-h
 APM systems work by collecting and analyzing data from various components of your application stack. This data collection is crucial for understanding how your application performs and identifying potential issues. Here's a detailed look at how APM systems operate:
 
 1. Data Collection Methods:
-    1. Agents: Agents are software components installed on application servers. They collect detailed performance data, such as response times, error rates, memory usage, and transaction traces. Agents provide deep insights into the performance of individual components and services within your application.
-    2. APIs: Application Programming Interfaces (APIs) are integration points that allow [APM tools](https://signoz.io/blog/open-source-apm-tools/) to gather data from various parts of your application which enables APM tools to access metrics, logs, and other performance data from third-party services, databases, and custom application components.
-    3. Instrumentation: Instrumentation involves code-level modifications to track specific application behaviors. By inserting monitoring code into the application, developers can capture detailed information about the execution of functions, methods, and transactions. Instrumentation provides granular visibility into the application's performance, helping to identify bottlenecks and optimize critical paths.
+   1. Agents: Agents are software components installed on application servers. They collect detailed performance data, such as response times, error rates, memory usage, and transaction traces. Agents provide deep insights into the performance of individual components and services within your application.
+   2. APIs: Application Programming Interfaces (APIs) are integration points that allow [APM tools](https://signoz.io/blog/open-source-apm-tools/) to gather data from various parts of your application which enables APM tools to access metrics, logs, and other performance data from third-party services, databases, and custom application components.
+   3. Instrumentation: Instrumentation involves code-level modifications to track specific application behaviors. By inserting monitoring code into the application, developers can capture detailed information about the execution of functions, methods, and transactions. Instrumentation provides granular visibility into the application's performance, helping to identify bottlenecks and optimize critical paths.
 2. Data Aggregation and Analysis:
-    1. Centralized Data Aggregation: The collected data from agents, APIs, and instrumentation is aggregated in a central repository. This centralized approach ensures that all performance data is available in one place for comprehensive analysis.
-    2. Real-Time Analysis: APM tools analyze the data in real time, providing immediate insights into application performance. This real-time analysis is crucial for detecting and resolving performance issues as they occur.
-    3. Visualization and Reporting: APM tools use advanced visualization techniques to present performance data in an easily understandable format. Dashboards, graphs, and heatmaps help visualize metrics, trends, and anomalies. Detailed reports summarize the performance data, highlighting key metrics, trends, and potential issues. These reports are valuable for periodic reviews and decision-making.
+   1. Centralized Data Aggregation: The collected data from agents, APIs, and instrumentation is aggregated in a central repository. This centralized approach ensures that all performance data is available in one place for comprehensive analysis.
+   2. Real-Time Analysis: APM tools analyze the data in real time, providing immediate insights into application performance. This real-time analysis is crucial for detecting and resolving performance issues as they occur.
+   3. Visualization and Reporting: APM tools use advanced visualization techniques to present performance data in an easily understandable format. Dashboards, graphs, and heatmaps help visualize metrics, trends, and anomalies. Detailed reports summarize the performance data, highlighting key metrics, trends, and potential issues. These reports are valuable for periodic reviews and decision-making.
 3. Integration with CI/CD and DevOps:
-    1. Continuous Integration/Continuous Deployment (CI/CD): APM tools integrate with CI/CD pipelines to monitor application performance throughout the development lifecycle. Continuous performance monitoring during development, testing, and deployment helps identify and resolve issues early, ensuring that performance standards are maintained.
-    2. DevOps Practices: APM supports DevOps practices by fostering collaboration between development and operations teams. Shared insights from APM tools help teams work together to optimize application performance. : APM tools often integrate with automation frameworks, enabling automated performance testing and monitoring as part of the deployment process.
+   1. Continuous Integration/Continuous Deployment (CI/CD): APM tools integrate with CI/CD pipelines to monitor application performance throughout the development lifecycle. Continuous performance monitoring during development, testing, and deployment helps identify and resolve issues early, ensuring that performance standards are maintained.
+   2. DevOps Practices: APM supports DevOps practices by fostering collaboration between development and operations teams. Shared insights from APM tools help teams work together to optimize application performance. : APM tools often integrate with automation frameworks, enabling automated performance testing and monitoring as part of the deployment process.
 
 ## Implementing APM: A Step-by-Step Guide
 
@@ -134,38 +143,63 @@ Note: Replace `{region}` with your SigNoz region and `SIGNOZ_INGESTION_KEY` with
 
 To obtain the SigNoz ingestion key and region, navigate to the “Settings” page in your SigNoz dashboard. You will find the ingestion key and region under the “Ingestion Settings” tab.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Untitled.webp" alt="SigNoz Ingestion Settings Page" caption="SigNoz Ingestion Settings Page" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Untitled.webp"
+  alt="SigNoz Ingestion Settings Page"
+  caption="SigNoz Ingestion Settings Page"
+/>
 
-1. Using SigNoz Application Monitoring: 
+1. Using SigNoz Application Monitoring:
 
-In the top left corner, click on getting started. 
+In the top left corner, click on getting started.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-07_at_2.39.26_PM.webp" alt="Screenshot 2024-08-07 at 2.39.26 PM.webp" caption="Screenshot 2024-08-07 at 2.39.26 PM.webp" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-07_at_2.39.26_PM.webp"
+  alt="Screenshot 2024-08-07 at 2.39.26 PM.webp"
+  caption="Screenshot 2024-08-07 at 2.39.26 PM.webp"
+/>
 
 You will be redirected to “Get Started Page”. Choose `Application Monitoring` to check latency and how your application is performing.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.35.06_AM.webp" alt="SigNoz Getting Started" caption="SigNoz Getting Started" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.35.06_AM.webp"
+  alt="SigNoz Getting Started"
+  caption="SigNoz Getting Started"
+/>
 
-1. Select the language and framework of the application 
+1. Select the language and framework of the application
 
-We are using a Python Application which we want to monitor. Select `Python`  with framework as `flask.` You can write service name as you want, we are using `flask-app`.
+We are using a Python Application which we want to monitor. Select `Python` with framework as `flask.` You can write service name as you want, we are using `flask-app`.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.37.49_AM.webp" alt="SigNoz Application Monitoring (Select Data Source)" caption="SigNoz Application Monitoring (Select Data Source)" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.37.49_AM.webp"
+  alt="SigNoz Application Monitoring (Select Data Source)"
+  caption="SigNoz Application Monitoring (Select Data Source)"
+/>
 
 1. Choose environment your app is running on
 
 Since we are going to run our app using Docker. Select `Docker` for a Docker-based applications.
 
-<Figure src="/img/guides/2024/08/what-is-apm-9ce80b11-fab2-4e1a-90fd-0a2d77247ad1.webp" alt="SigNoz Env Details" caption="SigNoz Env Details" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-9ce80b11-fab2-4e1a-90fd-0a2d77247ad1.webp"
+  alt="SigNoz Env Details"
+  caption="SigNoz Env Details"
+/>
 
 1. Using OpenTelemtry SDK or Collector to send data to SigNoz :
 
-To send data to SigNoz, we will use the [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/). The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations. 
+To send data to SigNoz, we will use the [OpenTelemetry Collector](https://signoz.io/guides/opentelemetry-collector-vs-exporter/). The OpenTelemetry Collector is a vendor-agnostic service that receives, processes, and exports telemetry data (metrics, logs, and traces) from various sources to various destinations.
 For more details, visit [OpenTelemetry Collector Guide](https://signoz.io/blog/opentelemetry-collector-complete-guide/).
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.43.33_AM.webp" alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data." />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_11.43.33_AM.webp"
+  alt="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data."
+  caption="Select the method using to send data to SigNoz OTEL SDK or OTEL Collector to send data."
+/>
 
 1. Add Services to the Docker & Docker Compose File
+
 - In your `requirements.txt`, add the following [OpenTelemetry](https://signoz.io/blog/what-is-opentelemetry/) dependencies:
 
 ```bash
@@ -193,7 +227,7 @@ ENV OTEL_EXPORTER_OTLP_PROTOCOL=grpc
 
 # Install any needed packages specified in requirements.txt
 # And install OpenTelemetry packages
-RUN pip install --no-cache-dir -r requirements.txt 
+RUN pip install --no-cache-dir -r requirements.txt
 
 RUN opentelemetry-bootstrap --action=install
 # copy the content of the local src directory to the working directory
@@ -220,7 +254,7 @@ In your Docker Compose file, add the below configuration:
       MONGO_HOST: mongodb
       OTEL_RESOURCE_ATTRIBUTES: service.name=sample-flask
       # Replace this with your Exporter Endpoint
-      OTEL_EXPORTER_OTLP_ENDPOINT: ingest.{REGION}.signoz.cloud:443  
+      OTEL_EXPORTER_OTLP_ENDPOINT: ingest.{REGION}.signoz.cloud:443
 ```
 
 1. Start the Docker Compose file
@@ -228,34 +262,54 @@ In your Docker Compose file, add the below configuration:
 Run the following command to start the containers:
 
 ```docker
-docker compose up -d 
+docker compose up -d
 ```
 
 If the containers start without errors, traces should now appear on the SigNoz Dashboard.
 
-1. Click on the Services page to see your Application: 
+1. Click on the Services page to see your Application:
 
 Go to the Services page to see your application. You can monitor `P99 latency` and `error rate`.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_1.01.24_PM.webp" alt="SigNoz Services Page" caption="SigNoz Services Page" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_1.01.24_PM.webp"
+  alt="SigNoz Services Page"
+  caption="SigNoz Services Page"
+/>
 
-Clicking on the Service `flask-app` you will see something like this, where you can check the latency, key Operations etc. 
+Clicking on the Service `flask-app` you will see something like this, where you can check the latency, key Operations etc.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.56.44_PM.webp" alt="SigNoz Dashboard Services Overview" caption="SigNoz Dashboard Services Overview" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.56.44_PM.webp"
+  alt="SigNoz Dashboard Services Overview"
+  caption="SigNoz Dashboard Services Overview"
+/>
 
-1. Checking the traces: 
+1. Checking the traces:
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.55.19_PM.webp" alt="SigNoz Traces Dashboard" caption="SigNoz Traces Dashboard" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.55.19_PM.webp"
+  alt="SigNoz Traces Dashboard"
+  caption="SigNoz Traces Dashboard"
+/>
 
 Click on the traces you want to see we are seeing `GET` request operations
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.55.40_PM.webp" alt="Trace Details of Requests" caption="Trace Details of Requests" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.55.40_PM.webp"
+  alt="Trace Details of Requests"
+  caption="Trace Details of Requests"
+/>
 
 Check only the `Error` tag in the Status menu to filter traces by errors.
 
-<Figure src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.57.43_PM.webp" alt="SigNoz Traces Dashboard" caption="SigNoz Traces Dashboard" />
+<Figure
+  src="/img/guides/2024/08/what-is-apm-Screenshot_2024-08-05_at_12.57.43_PM.webp"
+  alt="SigNoz Traces Dashboard"
+  caption="SigNoz Traces Dashboard"
+/>
 
-There are many functionality that SigNoz offers, you can change it according to your need. 
+There are many functionality that SigNoz offers, you can change it according to your need.
 
 ## The Future of APM: Trends and Innovations
 
@@ -291,4 +345,4 @@ Yes, APM can be implemented in legacy systems, although it may require different
 
 ### What are the key metrics to focus on in APM?
 
-In APM, key metrics to focus on include response time, error rate, throughput, and resource utilization. Response time measures how long it takes for the application to respond to requests, while error rate tracks the frequency of errors occurring in the application. Throughput refers to the number of transactions or requests processed by the application over a given period, and resource utilization monitors the usage of system resources such as CPU, memory, and network bandwidth. The specific metrics to prioritize will depend on your application's nature and your business requirements.
\ No newline at end of file
+In APM, key metrics to focus on include response time, error rate, throughput, and resource utilization. Response time measures how long it takes for the application to respond to requests, while error rate tracks the frequency of errors occurring in the application. Throughput refers to the number of transactions or requests processed by the application over a given period, and resource utilization monitors the usage of system resources such as CPU, memory, and network bandwidth. The specific metrics to prioritize will depend on your application's nature and your business requirements.
diff --git a/data/guides/what-is-prometheus-for-monitoring.mdx b/data/guides/what-is-prometheus-for-monitoring.mdx
index 4bd0f2f0d..0767250a8 100644
--- a/data/guides/what-is-prometheus-for-monitoring.mdx
+++ b/data/guides/what-is-prometheus-for-monitoring.mdx
@@ -1,128 +1,129 @@
 ---
-
 title: What is Prometheus for Monitoring?
-slug: what-is-prometheus-for-monitoring
 date: 2024-07-12
 tags: [faq, prometheus]
 authors: [daniel]
 description: Prometheus is an open-source monitoring tool used for collecting and processing metrics in time series format.
-keywords: [prometheus,monitor,monitoring,metrics]
-
+keywords: [prometheus, monitor, monitoring, metrics]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "What is Prometheus for Monitoring?",
-  "description": "Prometheus is an open-source monitoring tool used for collecting and processing metrics in time series format.",
-  "keywords": ["prometheus", "monitor", "monitoring", "metrics"],
-  "author": {
-    "@type": "Person",
-    "name": "Daniel"
-  },
-  "datePublished": "2024-07-12",
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/what-is-prometheus-for-monitoring/"
-  },
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Prometheus",
-      "description": "An open-source monitoring and alerting toolkit"
-    },
-    {
-      "@type": "Thing",
-      "name": "Monitoring",
-      "description": "The process of collecting, analyzing, and using information to track a program's progress toward reaching its objectives"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Application Performance Monitoring"
-    }
-  ],
-  "educationalLevel": "Beginner",
-  "isAccessibleForFree": true,
-  "image": {
-    "@type": "ImageObject",
-    "url": "https://signoz.io/img/guides/2024/07/what-is-prometheus-for-monitoring-Untitled.webp",
-    "caption": "Prometheus architecture"
-  },
-  "hasPart": [
-    {
-      "@type": "HowTo",
-      "name": "Quick Start with Prometheus",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Download Prometheus",
-          "text": "Visit the Prometheus download page and download the appropriate package for your operating system."
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What is Prometheus for Monitoring?',
+        description:
+          'Prometheus is an open-source monitoring tool used for collecting and processing metrics in time series format.',
+        keywords: ['prometheus', 'monitor', 'monitoring', 'metrics'],
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure prometheus.yml file",
-          "text": "Open the prometheus.yml file in a text editor and configure the targets to monitor."
+        datePublished: '2024-07-12',
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "HowToStep",
-          "name": "Start Prometheus server",
-          "text": "Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml"
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-is-prometheus-for-monitoring/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Access the Prometheus UI",
-          "text": "Open a web browser and visit localhost:9090 to access the Prometheus UI."
-        }
-      ]
-    }
-  ],
-  "mainEntity": [
-    {
-      "@type": "Question",
-      "name": "What is Prometheus?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "Prometheus is an open-source monitoring and alerting toolkit originally built at SoundCloud. It excels in collecting and storing metrics as time series data, recording information with a timestamp and optional key-value pairs called labels."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the components of Prometheus architecture?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "The main components of Prometheus architecture include Prometheus Server, Pushgateway, Alert Manager, Prometheus Targets, Client Libraries, Prometheus Exporters, and Service Discovery."
-      }
-    },
-    {
-      "@type": "Question",
-      "name": "What are the benefits of monitoring systems with Prometheus?",
-      "acceptedAnswer": {
-        "@type": "Answer",
-        "text": "The benefits include scalability, flexibility, multi-dimensional data model, pull-based model, a strong community and ecosystem, cloud-native integration, robust alerting and visualization capabilities, and cost-effectiveness as an open-source solution."
-      }
-    }
-  ]
-}) }}
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description: 'An open-source monitoring and alerting toolkit',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              "The process of collecting, analyzing, and using information to track a program's progress toward reaching its objectives",
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Application Performance Monitoring',
+          },
+        ],
+        educationalLevel: 'Beginner',
+        isAccessibleForFree: true,
+        image: {
+          '@type': 'ImageObject',
+          url: 'https://signoz.io/img/guides/2024/07/what-is-prometheus-for-monitoring-Untitled.webp',
+          caption: 'Prometheus architecture',
+        },
+        hasPart: [
+          {
+            '@type': 'HowTo',
+            name: 'Quick Start with Prometheus',
+            step: [
+              {
+                '@type': 'HowToStep',
+                name: 'Download Prometheus',
+                text: 'Visit the Prometheus download page and download the appropriate package for your operating system.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Configure prometheus.yml file',
+                text: 'Open the prometheus.yml file in a text editor and configure the targets to monitor.',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Start Prometheus server',
+                text: 'Navigate to the Prometheus directory and start the server using the command: ./prometheus --config.file=prometheus.yml',
+              },
+              {
+                '@type': 'HowToStep',
+                name: 'Access the Prometheus UI',
+                text: 'Open a web browser and visit localhost:9090 to access the Prometheus UI.',
+              },
+            ],
+          },
+        ],
+        mainEntity: [
+          {
+            '@type': 'Question',
+            name: 'What is Prometheus?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'Prometheus is an open-source monitoring and alerting toolkit originally built at SoundCloud. It excels in collecting and storing metrics as time series data, recording information with a timestamp and optional key-value pairs called labels.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the components of Prometheus architecture?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'The main components of Prometheus architecture include Prometheus Server, Pushgateway, Alert Manager, Prometheus Targets, Client Libraries, Prometheus Exporters, and Service Discovery.',
+            },
+          },
+          {
+            '@type': 'Question',
+            name: 'What are the benefits of monitoring systems with Prometheus?',
+            acceptedAnswer: {
+              '@type': 'Answer',
+              text: 'The benefits include scalability, flexibility, multi-dimensional data model, pull-based model, a strong community and ecosystem, cloud-native integration, robust alerting and visualization capabilities, and cost-effectiveness as an open-source solution.',
+            },
+          },
+        ],
+      }),
+    }}
   />
 </head>
 
-In monitoring, Prometheus is used for collecting and processing metrics from its targets, which can be applications, servers, databases, or any system that exposes metrics via an HTTP endpoint. It uses a pull-based model, where it periodically scrapes the targets' metrics endpoints to gather data on various aspects such as resource utilization, response times, error rates, and custom application metrics.  This data is then stored in a time-series database and can be queried using PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)), enabling users to analyze trends, visualize data in dashboards, and set up alerts based on predefined conditions.
+In monitoring, Prometheus is used for collecting and processing metrics from its targets, which can be applications, servers, databases, or any system that exposes metrics via an HTTP endpoint. It uses a pull-based model, where it periodically scrapes the targets' metrics endpoints to gather data on various aspects such as resource utilization, response times, error rates, and custom application metrics. This data is then stored in a time-series database and can be queried using PromQL ([Prometheus Query Language](https://signoz.io/guides/promql-cheat-sheet/)), enabling users to analyze trends, visualize data in dashboards, and set up alerts based on predefined conditions.
 
 ## What is Prometheus?
 
@@ -130,9 +131,11 @@ Prometheus is an open-source monitoring and alerting toolkit originally built at
 
 ## Components in Prometheus Architecture
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Untitled.webp" alt="Prometheus architecture" caption="Prometheus architecture" />
-
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Untitled.webp"
+  alt="Prometheus architecture"
+  caption="Prometheus architecture"
+/>
 
 Prometheus is made up of different components which work together, allowing Prometheus to effectively monitor targets. They are:
 
@@ -180,22 +183,29 @@ This quick start guide will help you get Prometheus up and running in a few simp
 
 To download Prometheus on your system, visit the <a href="https://prometheus.io/download/" rel="noopener noreferrer nofollow" target="_blank">Prometheus download</a> page. Set your system architecture and identify the appropriate package for your operating system (Linux, macOS, Windows). Click on the download link for the latest stable release.
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.23.50.webp" alt="Prometheus download links" caption="Prometheus download links" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.23.50.webp"
+  alt="Prometheus download links"
+  caption="Prometheus download links"
+/>
 
 1. Configure `prometheus.yml` file
 
 After downloading Prometheus, extract the tarball downloaded file. You'll find a file named `prometheus.yml` in the extracted directory.
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.45.09.webp" alt="Prometheus extracted folder" caption="Prometheus extracted folder" />
-
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.45.09.webp"
+  alt="Prometheus extracted folder"
+  caption="Prometheus extracted folder"
+/>
 
 Prometheus uses a configuration file named `prometheus.yml` to specify which targets to monitor and how to scrape them. Open `prometheus.yml` in a text editor.
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.25.29.webp" alt="Prometheus.yml file" caption="Prometheus.yml file" />
-
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.25.29.webp"
+  alt="Prometheus.yml file"
+  caption="Prometheus.yml file"
+/>
 
 In the `prometheus.yml` file, you will see that Prometheus is configured to scrape metrics from itself. You can add other scrape configurations for Prometheus to scrape metrics from different targets on your system.
 
@@ -209,20 +219,27 @@ Navigate to the directory where you extracted Prometheus and execute the followi
 
 This command will start Prometheus and use the specified configuration file to determine which targets to scrape.
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.42.25.webp" alt="Prometheus started" caption="Prometheus started" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.42.25.webp"
+  alt="Prometheus started"
+  caption="Prometheus started"
+/>
 
 1. Access the Prometheus UI
 
 Once Prometheus is started, in your browser, visit [localhost:9090](http://localhost:9090) to access the Prometheus UI:
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.43.47.webp" alt="Prometheus UI" caption="Prometheus UI" />
-
-
-
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.45.59.webp" alt="Prometheus targets" caption="Prometheus targets" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.43.47.webp"
+  alt="Prometheus UI"
+  caption="Prometheus UI"
+/>
 
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-Screenshot_2024-07-12_at_07.45.59.webp"
+  alt="Prometheus targets"
+  caption="Prometheus targets"
+/>
 
 ## Benefits of Monitoring Systems with Prometheus
 
@@ -250,8 +267,11 @@ With SigNoz:
 - You can visualize your trace data with [flamegraphs and Gantt charts](https://signoz.io/blog/flamegraphs/) to see the flow of requests. This comes in very handy while debugging performance-related issues.
 - You can create custom dashboards to monitor important components of your application stack like database, host metrics, and infrastructure.
 
-<Figure src="/img/guides/2024/07/what-is-prometheus-for-monitoring-flask_monitoring_dashboard.webp" alt="Monitoring dashboard for a Flask app with Prometheus formatted metrics" caption="Monitoring dashboard for a Flask app with Prometheus formatted metrics" />
-
+<Figure
+  src="/img/guides/2024/07/what-is-prometheus-for-monitoring-flask_monitoring_dashboard.webp"
+  alt="Monitoring dashboard for a Flask app with Prometheus formatted metrics"
+  caption="Monitoring dashboard for a Flask app with Prometheus formatted metrics"
+/>
 
 If you want to collect and visualize metrics from Prometheus in SigNoz, we have created a [guide](https://signoz.io/blog/opentelemetry-collector-prometheus-receiver/#what-is-prometheus) that walks you through the process.
 
diff --git a/data/guides/what-is-prometheus-target.mdx b/data/guides/what-is-prometheus-target.mdx
index 9a12b6153..7819cd23b 100644
--- a/data/guides/what-is-prometheus-target.mdx
+++ b/data/guides/what-is-prometheus-target.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: What is Prometheus target - A Beginner's Guide
-slug: what-is-prometheus-target
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [daniel]
 description: Discover what Prometheus targets are, their importance in monitoring, and how to configure them effectively. A comprehensive guide for beginners.
-keywords: [Prometheus target, monitoring, metrics collection, service discovery, exporters, configuration]
-
+keywords:
+  [Prometheus target, monitoring, metrics collection, service discovery, exporters, configuration]
 ---
 
 Prometheus targets form the foundation of effective monitoring in the Prometheus ecosystem. These endpoints or resources expose metrics that Prometheus collects, analyzes, and stores. Understanding Prometheus targets is crucial for setting up a robust monitoring system. This guide will walk you through the concept of Prometheus targets, their importance, and how to work with them effectively.
@@ -60,7 +58,6 @@ scrape_configs:
   - job_name: 'example-job'
     static_configs:
       - targets: ['localhost:8080', 'localhost:8081']
-
 ```
 
 This configuration tells Prometheus to scrape metrics from two targets: `localhost:8080` and `localhost:8081`.
@@ -137,4 +134,4 @@ To experience how SigNoz can enhance your Prometheus monitoring:
 
 <GetStartedSigNoz />
 
-By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
\ No newline at end of file
+By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
diff --git a/data/guides/what-is-pythons-default-logging-formatter.mdx b/data/guides/what-is-pythons-default-logging-formatter.mdx
index ea33e0aeb..d47d53658 100644
--- a/data/guides/what-is-pythons-default-logging-formatter.mdx
+++ b/data/guides/what-is-pythons-default-logging-formatter.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: What is Python's Default Logging Formatter?
-slug: what-is-pythons-default-logging-formatter
 date: 2024-09-18
 tags: [faq]
 authors: [sushant_gaurav]
 description: Discover Python's default logging formatter, its limitations, and how to customize it for better log management in your applications.
-keywords: [Python logging, default formatter, log customization, logging module, log formatting, Python development]
-
+keywords:
+  [
+    Python logging,
+    default formatter,
+    log customization,
+    logging module,
+    log formatting,
+    Python development,
+  ]
 ---
 
 Python’s logging system is an extremely helpful tool for logging errors, keeping track of events, and debugging your code. The default logging formatter, which controls the appearance of your log messages, is an essential component of this system. Gaining an understanding of the default formatter's operation will improve your ability to handle and evaluate logs.
@@ -23,7 +28,11 @@ The logging module comprises four main components that work together to facilita
 - Formatters: Formatters control the layout and content of log messages. They govern how timestamps, log levels, and messages are shown in the logs.
 - Levels: Logging levels (such as `DEBUG`, `INFO`, `WARNING`, `ERROR`, and `CRITICAL`) help you manage the logs better. Setting a specified log level allows you to filter out less important messages and focus on what matters.
 
-<Figure src="/img/guides/2024/09/what-is-pythons-default-logging-formatter-image.webp" alt="four main components of logging module" caption="four main components of logging module" />
+<Figure
+  src="/img/guides/2024/09/what-is-pythons-default-logging-formatter-image.webp"
+  alt="four main components of logging module"
+  caption="four main components of logging module"
+/>
 
 To learn about logging in Python, different levels of logging, formatters, etc. in more detail, you can refer to this article [Python Logging - From Setup to Monitoring with Best Practices](https://signoz.io/guides/logging-in-python/). You can also check out [Python Logging Best Practices - Expert Tips with Practical Examples](https://signoz.io/guides/python-logging-best-practices/).
 
@@ -482,4 +491,4 @@ try:
     1 / 0
 except ZeroDivisionError:
     logger.exception("An error occurred")
-```
\ No newline at end of file
+```
diff --git a/data/guides/what-is-the-advantage-of-prometheus.mdx b/data/guides/what-is-the-advantage-of-prometheus.mdx
index 480385dd5..bafa3fe11 100644
--- a/data/guides/what-is-the-advantage-of-prometheus.mdx
+++ b/data/guides/what-is-the-advantage-of-prometheus.mdx
@@ -1,13 +1,17 @@
 ---
-
 title: What is the Advantage of Prometheus - Top 5 Advantages in 2025
-slug: what-is-the-advantage-of-prometheus
 date: 2025-01-02
 tags: [faq, prometheus]
 authors: [yuvraj]
 description: Discover the top 5 advantages of Prometheus in 2024, including its powerful TSDB, pull-based architecture, and seamless Kubernetes integration.
-keywords: [Prometheus advantages, monitoring tools, time series database, Kubernetes integration, open-source monitoring]
-
+keywords:
+  [
+    Prometheus advantages,
+    monitoring tools,
+    time series database,
+    Kubernetes integration,
+    open-source monitoring,
+  ]
 ---
 
 Prometheus offers significant advantages for monitoring modern infrastructure in 2024. This open-source monitoring and alerting toolkit excels in container and microservices ecosystems. Its powerful features and growing adoption in DevOps make it a top choice for many organizations. Let's explore the key benefits of Prometheus and why it matters in today's dynamic IT landscape.
@@ -52,7 +56,6 @@ scrape_configs:
   - job_name: 'my_app'
     static_configs:
       - targets: ['localhost:8080']
-
 ```
 
 ### 3. Seamless Kubernetes Integration
@@ -124,7 +127,7 @@ Learn how to [implement Prometheus with OpenTelemetry.](https://signoz.io/blog/o
 
 ## Prometheus vs Alternatives
 
-While Prometheus excels in many areas, it's essential to consider alternatives based on your specific needs. SigNoz stands out as a top alternative, offering similar capabilities with some unique features. 
+While Prometheus excels in many areas, it's essential to consider alternatives based on your specific needs. SigNoz stands out as a top alternative, offering similar capabilities with some unique features.
 
 - **[Unified Observability](https://signoz.io/unified-observability/)**: SigNoz combines metrics, traces, and logs in a single platform, offering a holistic view of your system.
 - **Advanced Visualization**: Create custom dashboards and leverage pre-built templates for quick insights.
@@ -167,4 +170,4 @@ Prometheus has some limitations, including:
 
 ### How does Prometheus ensure data reliability and availability?
 
-Prometheus uses a pull-based model and local storage, which helps maintain data reliability. For high availability, you can run multiple Prometheus instances and use federation to aggregate data.
\ No newline at end of file
+Prometheus uses a pull-based model and local storage, which helps maintain data reliability. For high availability, you can run multiple Prometheus instances and use federation to aggregate data.
diff --git a/data/guides/what-is-the-alert-lifecycle-of-prometheus.mdx b/data/guides/what-is-the-alert-lifecycle-of-prometheus.mdx
index c93a955ed..91fd109af 100644
--- a/data/guides/what-is-the-alert-lifecycle-of-prometheus.mdx
+++ b/data/guides/what-is-the-alert-lifecycle-of-prometheus.mdx
@@ -1,13 +1,11 @@
 ---
-
 title: What is the Prometheus Alert Lifecycle - A Guide
-slug: what-is-the-alert-lifecycle-of-prometheus
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Explore the Prometheus alert lifecycle, from scraping to notification. Learn how to optimize your alerting setup for efficient monitoring and incident response.
-keywords: [Prometheus, alert lifecycle, monitoring, alerting, Alertmanager, DevOps, incident response]
-
+keywords:
+  [Prometheus, alert lifecycle, monitoring, alerting, Alertmanager, DevOps, incident response]
 ---
 
 Prometheus, a powerful open-source monitoring system, plays a crucial role in maintaining the health and performance of modern software infrastructures. At the heart of its functionality lies the alert lifecycle — a process that transforms raw metrics into actionable notifications. This guide delves into the intricacies of the Prometheus alert lifecycle, providing you with the knowledge to enhance your monitoring capabilities and streamline your incident response procedures.
@@ -48,9 +46,8 @@ for: 5m
 labels:
   severity: warning
 annotations:
-  summary: "High CPU usage detected on {{ $labels.instance }}"
-  description: "CPU usage is above 80% for 5 minutes"
-
+  summary: 'High CPU usage detected on {{ $labels.instance }}'
+  description: 'CPU usage is above 80% for 5 minutes'
 ```
 
 This rule fires when CPU usage exceeds 80% for 5 minutes, demonstrating how Prometheus evaluates complex conditions over time.
@@ -101,38 +98,33 @@ Prometheus evaluates alert rules at a set interval, typically matching the scrap
 Creating effective alert rules is a critical skill for any Prometheus user. Here's a step-by-step guide to get you started:
 
 1. Define the metric and condition:
-    
-    ```yaml
-    expr: http_requests_total > 1000
-    
-    ```
-    
+
+   ```yaml
+   expr: http_requests_total > 1000
+   ```
+
 2. Add a duration clause to avoid alerting on short spikes:
-    
-    ```yaml
-    expr: http_requests_total > 1000
-    for: 5m
-    
-    ```
-    
+
+   ```yaml
+   expr: http_requests_total > 1000
+   for: 5m
+   ```
+
 3. Include labels for better organization and routing:
-    
-    ```yaml
-    labels:
-      severity: warning
-      team: frontend
-    
-    ```
-    
+
+   ```yaml
+   labels:
+     severity: warning
+     team: frontend
+   ```
+
 4. Add annotations to provide context:
-    
-    ```yaml
-    annotations:
-      summary: "High request volume detected"
-      description: "More than 1000 requests in the last 5 minutes"
-    
-    ```
-    
+
+   ```yaml
+   annotations:
+     summary: 'High request volume detected'
+     description: 'More than 1000 requests in the last 5 minutes'
+   ```
 
 **Best practices:**
 
@@ -171,10 +163,9 @@ route:
   repeat_interval: 4h
   receiver: 'team-emails'
 receivers:
-- name: 'team-emails'
-  email_configs:
-  - to: 'team@example.com'
-
+  - name: 'team-emails'
+    email_configs:
+      - to: 'team@example.com'
 ```
 
 This configuration groups alerts by name, cluster, and service, waiting 30 seconds before sending the first notification and repeating every 4 hours if the alert persists.
@@ -184,17 +175,17 @@ This configuration groups alerts by name, cluster, and service, waiting 30 secon
 To enhance your Prometheus alerting setup:
 
 1. Reduce alert latency:
-    - Decrease scrape and evaluation intervals for critical metrics
-    - Use push-based exporters for time-sensitive data
+   - Decrease scrape and evaluation intervals for critical metrics
+   - Use push-based exporters for time-sensitive data
 2. Implement alert prioritization:
-    - Use severity labels to distinguish between urgent and non-urgent alerts
-    - Configure Alertmanager routing to handle high-priority alerts differently
+   - Use severity labels to distinguish between urgent and non-urgent alerts
+   - Configure Alertmanager routing to handle high-priority alerts differently
 3. Handle flapping alerts:
-    - Adjust the "for" duration in alert rules
-    - Implement hysteresis in your alerting logic
+   - Adjust the "for" duration in alert rules
+   - Implement hysteresis in your alerting logic
 4. Scale Prometheus and Alertmanager:
-    - Use federation to distribute the monitoring load
-    - Implement high availability setups for Alertmanager
+   - Use federation to distribute the monitoring load
+   - Implement high availability setups for Alertmanager
 
 By applying these optimizations, you can create a more responsive and reliable alerting system that scales with your infrastructure.
 
@@ -252,4 +243,4 @@ To experience how SigNoz can enhance your [Prometheus monitoring](https://signoz
 
 <GetStartedSigNoz />
 
-By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
\ No newline at end of file
+By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
diff --git a/data/guides/what-is-the-default-username-and-password-for-grafana-login-page.mdx b/data/guides/what-is-the-default-username-and-password-for-grafana-login-page.mdx
index 8040c99a2..25cac7ba8 100644
--- a/data/guides/what-is-the-default-username-and-password-for-grafana-login-page.mdx
+++ b/data/guides/what-is-the-default-username-and-password-for-grafana-login-page.mdx
@@ -1,16 +1,14 @@
 ---
-
 title: What is the Default Grafana Login - Username and Password Guide
-slug: what-is-the-default-username-and-password-for-grafana-login-page
 date: 2024-08-30
 tags: [faq, grafana]
 authors: [simran_kumari]
 description: Discover Grafana's default login credentials, learn how to change them, and explore best practices for securing your Grafana instance.
-keywords: [Grafana login, default credentials, password change, security, monitoring, troubleshooting]
-
+keywords:
+  [Grafana login, default credentials, password change, security, monitoring, troubleshooting]
 ---
 
-When setting up Grafana for the first time, one of the initial steps is logging into the web interface. If you’re here, you’re probably looking for the default username and password to get started. This guide not only provides those details but also walks you through the first-time login process, troubleshooting common issues, and implementing security best practices. 
+When setting up Grafana for the first time, one of the initial steps is logging into the web interface. If you’re here, you’re probably looking for the default username and password to get started. This guide not only provides those details but also walks you through the first-time login process, troubleshooting common issues, and implementing security best practices.
 
 ## Grafana's Default Username and Password
 
@@ -26,13 +24,20 @@ These default credentials are set during the initial installation process. While
 To log in to Grafana for the first time:
 
 1. Access the Grafana Login Page: Open your web browser and navigate to the IP address or domain name where Grafana is installed. Typically, it will look something like `http://localhost:3000`. You will be redirected to the login page.
-    
-    <Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image.webp" alt="Grafana Login Page" caption="Grafana Login Page" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image.webp"
+     alt="Grafana Login Page"
+     caption="Grafana Login Page"
+   />
+
 2. Enter Default Credentials: Use `admin` for both the username and password fields.
-    
-    <Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%201.webp" alt="Grafana Default Login Credentials" caption="Grafana Default Login Credentials" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%201.webp"
+     alt="Grafana Default Login Credentials"
+     caption="Grafana Default Login Credentials"
+   />
 
 Upon your first successful login, Grafana will prompt you to change the default password. This security measure ensures that you set a unique, strong password for your admin account.
 
@@ -43,49 +48,57 @@ When the password change prompt appears:
 1. Enter a new, strong password in the "New password" field.
 2. Re-enter the same password in the "Confirm new password" field.
 3. Click "Submit" to save your new credentials
-    
-    <Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%202.webp" alt="Resetting Grafana Password" caption="Resetting Grafana Password" />
-    
+
+   <Figure
+     src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%202.webp"
+     alt="Resetting Grafana Password"
+     caption="Resetting Grafana Password"
+   />
 
 Post a successful login, you will be redirected to the Grafana Home page.
 
-<Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%203.webp" alt="Grafana Home Page" caption="Grafana Home Page" />
+<Figure
+  src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%203.webp"
+  alt="Grafana Home Page"
+  caption="Grafana Home Page"
+/>
 
 ## Common Issues with Grafana Default Login
 
 There are several common issues one might face when logging into Grafana. Here’s a quick rundown of these problems and how to resolve them:
 
 1. Forgotten Password Scenarios:
-    - Problem: You’ve forgotten the admin password.
-    - Solution:
-        - Open the `grafana.ini` configuration file (found in `/etc/grafana/` or `/usr/share/grafana/conf/`).
-        - Locate the `[security]` section and update the `admin_password` line with a new password.
-        - Save the file and restart the Grafana service with:
-            
-            ```bash
-            sudo systemctl restart grafana-server
-            ```
-            
+   - Problem: You’ve forgotten the admin password.
+   - Solution:
+     - Open the `grafana.ini` configuration file (found in `/etc/grafana/` or `/usr/share/grafana/conf/`).
+     - Locate the `[security]` section and update the `admin_password` line with a new password.
+     - Save the file and restart the Grafana service with:
+       ```bash
+       sudo systemctl restart grafana-server
+       ```
 2. Incorrectly Entered Credentials:
-    - Problem: You’re entering the wrong username or password.
-        
-        <Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%204.webp" alt="Grafana Login Error: Invalid Username or Password" caption="Grafana Login Error: Invalid Username or Password" />
-        
-    - Solution:
-        - Double-check that the username is `admin` and the password is entered correctly.
-        - Remember that both fields are case-sensitive.
-        - If you’ve changed the password recently and can’t recall it, reset the password using the method above.
+   - Problem: You’re entering the wrong username or password.
+     {' '}
+     <Figure
+       src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%204.webp"
+       alt="Grafana Login Error: Invalid Username or Password"
+       caption="Grafana Login Error: Invalid Username or Password"
+     />
+   - Solution:
+     - Double-check that the username is `admin` and the password is entered correctly.
+     - Remember that both fields are case-sensitive.
+     - If you’ve changed the password recently and can’t recall it, reset the password using the method above.
 3. Browser Cache and Cookies Affecting Login:
-    - Problem: Cache or cookies are causing login issues, like being stuck in a login loop.
-    - Solution:
-        - Clear your browser’s cache and cookies.
-        - Try logging in from an incognito or private browsing window.
+   - Problem: Cache or cookies are causing login issues, like being stuck in a login loop.
+   - Solution:
+     - Clear your browser’s cache and cookies.
+     - Try logging in from an incognito or private browsing window.
 4. Permissions and Access Control Problems:
-    - Problem: You can log in but lack access to certain features or settings.
-    - Solution:
-        - Verify that your account has the appropriate roles, especially the `Admin` role.
-        - Adjust permissions in the `Server Admin > Users` section.
-        - If using external authentication (LDAP, OAuth), ensure role mappings are correct.
+   - Problem: You can log in but lack access to certain features or settings.
+   - Solution:
+     - Verify that your account has the appropriate roles, especially the `Admin` role.
+     - Adjust permissions in the `Server Admin > Users` section.
+     - If using external authentication (LDAP, OAuth), ensure role mappings are correct.
 
 ## Securing Your Grafana Instance
 
@@ -101,23 +114,21 @@ After setting up your initial login, it's crucial to implement additional securi
 If you encounter persistent login issues with Grafana, consider the following troubleshooting steps:
 
 1. Reset Admin Password via CLI:
-    - Solution: Use the Grafana CLI to reset the admin password if you’ve lost access to your account.
-    - Command:
-        
-        ```bash
-        grafana-cli admin reset-admin-password your_new_password
-        ```
-        
-    - This will reset the admin password and allow you to regain access.
+   - Solution: Use the Grafana CLI to reset the admin password if you’ve lost access to your account.
+   - Command:
+     ```bash
+     grafana-cli admin reset-admin-password your_new_password
+     ```
+   - This will reset the admin password and allow you to regain access.
 2. Check Grafana Logs:
-    - Solution: Review Grafana’s log files for any error messages or authentication issues.
-    - Location: Logs are typically found in `/var/log/grafana/grafana.log` or the directory specified in your configuration file.
+   - Solution: Review Grafana’s log files for any error messages or authentication issues.
+   - Location: Logs are typically found in `/var/log/grafana/grafana.log` or the directory specified in your configuration file.
 3. Verify Configuration Files:
-    - Solution: Ensure that your Grafana configuration files are correctly set up, especially if you’re using external authentication methods (like LDAP or OAuth).
-    - Action: Double-check the `grafana.ini` file and any related configurations to ensure everything is configured correctly.
+   - Solution: Ensure that your Grafana configuration files are correctly set up, especially if you’re using external authentication methods (like LDAP or OAuth).
+   - Action: Double-check the `grafana.ini` file and any related configurations to ensure everything is configured correctly.
 4. Seek Support:
-    - Solution: If problems persist, don’t hesitate to reach out to Grafana’s support channels or community forums for assistance.
-    - Options: You can find help through <a href="https://community.grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana's Community Forums</a>, or check their <a href="https://grafana.com/docs/" rel="noopener noreferrer nofollow" target="_blank">documentation</a> for detailed guidance.
+   - Solution: If problems persist, don’t hesitate to reach out to Grafana’s support channels or community forums for assistance.
+   - Options: You can find help through <a href="https://community.grafana.com/" rel="noopener noreferrer nofollow" target="_blank">Grafana's Community Forums</a>, or check their <a href="https://grafana.com/docs/" rel="noopener noreferrer nofollow" target="_blank">documentation</a> for detailed guidance.
 
 ## Monitoring with SigNoz: A Better Alternative to Grafana
 
@@ -132,7 +143,11 @@ While Grafana excels at displaying metrics from various sources, it has its limi
 - Advanced Tracing Capabilities: While Grafana provides visualizations, SigNoz gives you the ability to trace the journey of individual requests across your services. This level of insight is crucial for diagnosing complex issues and optimizing performance.
 - Integrated Alerts and Troubleshooting: With SigNoz, you can set up real-time alerts for unusual activity or potential issues, much like Grafana. However, SigNoz’s integrated logging and tracing features provide deeper insights for troubleshooting problems, all within the same platform.
 
-<Figure src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%205.webp" alt="" caption="" />
+<Figure
+  src="/img/guides/2024/08/what-is-the-default-username-and-password-for-grafana-login-page-image%205.webp"
+  alt=""
+  caption=""
+/>
 
 ### SigNoz: The Future of Monitoring
 
@@ -170,4 +185,4 @@ Yes, Grafana supports various external authentication methods, including LDAP, O
 ## Resources
 
 - [Observability tools](https://signoz.io/blog/observability-tools/)
-- [Infrastructure Monitoring tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/)
\ No newline at end of file
+- [Infrastructure Monitoring tools](https://signoz.io/comparisons/infrastructure-monitoring-tools/)
diff --git a/data/guides/what-is-the-difference-between-a-gauge-and-a-counter.mdx b/data/guides/what-is-the-difference-between-a-gauge-and-a-counter.mdx
index a70e0e0cd..568ca96b2 100644
--- a/data/guides/what-is-the-difference-between-a-gauge-and-a-counter.mdx
+++ b/data/guides/what-is-the-difference-between-a-gauge-and-a-counter.mdx
@@ -1,154 +1,170 @@
 ---
-
 title: What is the Difference Between a Gauge and a Counter?
-slug: what-is-the-difference-between-a-gauge-and-a-counter
 date: 2024-07-30
 tags: [faq, prometheus]
 authors: [daniel]
 description: Learn the key differences between gauge and counter metrics in monitoring systems. Discover when to use each type and how to implement them effectively.
-keywords: [gauge metrics, counter metrics, monitoring systems, Prometheus, metric types, data visualization, performance tracking, time series data]
-
+keywords:
+  [
+    gauge metrics,
+    counter metrics,
+    monitoring systems,
+    Prometheus,
+    metric types,
+    data visualization,
+    performance tracking,
+    time series data,
+  ]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "What is the difference between a gauge and a counter?",
-    "alternativeHeadline": "Understanding the Key Differences Between Gauge and Counter Metrics in Monitoring Systems",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-30T00:00:00Z",
-    "dateModified": "2024-07-30T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/what-is-the-difference-between-a-gauge-and-a-counter/"
-    },
-    "description": "Learn the key differences between gauge and counter metrics in monitoring systems. Discover when to use each type and how to implement them effectively.",
-    "keywords": "gauge metrics, counter metrics, monitoring systems, Prometheus, metric types, data visualization, performance tracking, time series data",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Gauge Metrics",
-        "description": "A metric that represents a single numerical value that can arbitrarily go up and down, used for fluctuating measurements."
-      },
-      {
-        "@type": "Thing",
-        "name": "Counter Metrics",
-        "description": "A cumulative metric that only increases in value or resets to zero, used for tracking continuously growing values."
-      },
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring Systems",
-        "description": "Tools and processes used to track the performance and health of systems over time."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "SigNoz",
-        "applicationCategory": "Observability Platform"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Can a gauge be used as a counter?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "While it's technically possible to use a gauge as a counter, it's not recommended. Gauges lack the reset detection and rate calculation features that make counters valuable for cumulative metrics."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What happens if a counter goes down?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "In most monitoring systems, if a counter decreases, it's assumed to have reset to zero, and the system adjusts calculations accordingly. This behavior helps maintain accurate metrics even after application restarts."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'What is the difference between a gauge and a counter?',
+        alternativeHeadline:
+          'Understanding the Key Differences Between Gauge and Counter Metrics in Monitoring Systems',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "How do I convert a counter to a gauge in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "You can't directly convert a counter to a gauge in Prometheus. If you need gauge-like behavior from counter data, you can use PromQL functions like `rate()` or `increase()` to calculate changes over time."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "Are there any performance differences between counters and gauges?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Generally, counters and gauges have similar performance characteristics. The choice between them should be based on the type of data you're measuring rather than performance considerations."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "Implementing Gauges and Counters in Monitoring Systems",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Define Counter Metric",
-          "text": "Use the appropriate library for your programming language to define a counter metric. For example, in Python: `from prometheus_client import Counter`."
+        datePublished: '2024-07-30T00:00:00Z',
+        dateModified: '2024-07-30T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/what-is-the-difference-between-a-gauge-and-a-counter/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Increment Counter",
-          "text": "In your application code, increment the counter whenever the tracked event occurs. For example: `total_requests.inc()`."
+        description:
+          'Learn the key differences between gauge and counter metrics in monitoring systems. Discover when to use each type and how to implement them effectively.',
+        keywords:
+          'gauge metrics, counter metrics, monitoring systems, Prometheus, metric types, data visualization, performance tracking, time series data',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Define Gauge Metric",
-          "text": "Use the appropriate library for your programming language to define a gauge metric. For example, in Python: `from prometheus_client import Gauge`."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Gauge Metrics',
+            description:
+              'A metric that represents a single numerical value that can arbitrarily go up and down, used for fluctuating measurements.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Counter Metrics',
+            description:
+              'A cumulative metric that only increases in value or resets to zero, used for tracking continuously growing values.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring Systems',
+            description:
+              'Tools and processes used to track the performance and health of systems over time.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Can a gauge be used as a counter?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "While it's technically possible to use a gauge as a counter, it's not recommended. Gauges lack the reset detection and rate calculation features that make counters valuable for cumulative metrics.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What happens if a counter goes down?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "In most monitoring systems, if a counter decreases, it's assumed to have reset to zero, and the system adjusts calculations accordingly. This behavior helps maintain accurate metrics even after application restarts.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I convert a counter to a gauge in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "You can't directly convert a counter to a gauge in Prometheus. If you need gauge-like behavior from counter data, you can use PromQL functions like `rate()` or `increase()` to calculate changes over time.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Are there any performance differences between counters and gauges?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Generally, counters and gauges have similar performance characteristics. The choice between them should be based on the type of data you're measuring rather than performance considerations.",
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Update Gauge",
-          "text": "In your application code, update the gauge with the current value. For example: `active_connections.set(current_connections)`."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'Implementing Gauges and Counters in Monitoring Systems',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Define Counter Metric',
+              text: 'Use the appropriate library for your programming language to define a counter metric. For example, in Python: `from prometheus_client import Counter`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Increment Counter',
+              text: 'In your application code, increment the counter whenever the tracked event occurs. For example: `total_requests.inc()`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Define Gauge Metric',
+              text: 'Use the appropriate library for your programming language to define a gauge metric. For example, in Python: `from prometheus_client import Gauge`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Update Gauge',
+              text: 'In your application code, update the gauge with the current value. For example: `active_connections.set(current_connections)`.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Use Prometheus Queries',
+              text: 'Leverage PromQL functions to analyze your metrics. For counters, use `rate()` to calculate the rate of increase. For gauges, use aggregation functions like `avg()`, `max()`, or `min()`.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Use Prometheus Queries",
-          "text": "Leverage PromQL functions to analyze your metrics. For counters, use `rate()` to calculate the rate of increase. For gauges, use aggregation functions like `avg()`, `max()`, or `min()`."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Gauges and counters are two fundamental metric types used in monitoring systems. They serve different purposes and behave distinctly, making it crucial to understand their differences. This article explores the characteristics of gauges and counters, their use cases, and how to choose between them for effective system monitoring.
@@ -310,4 +326,4 @@ SigNoz simplifies the process of querying and visualizing label values, making i
 ## Resources
 
 - [Prometheus Metric Types](https://prometheus.io/docs/concepts/metric_types/)
-- [Best Practices for Monitoring with Prometheus](https://prometheus.io/docs/practices/naming/)
\ No newline at end of file
+- [Best Practices for Monitoring with Prometheus](https://prometheus.io/docs/practices/naming/)
diff --git a/data/guides/what-is-the-job-label-in-prometheus.mdx b/data/guides/what-is-the-job-label-in-prometheus.mdx
index 5c43f51e9..964d72d73 100644
--- a/data/guides/what-is-the-job-label-in-prometheus.mdx
+++ b/data/guides/what-is-the-job-label-in-prometheus.mdx
@@ -1,13 +1,10 @@
 ---
-
 title: What is the Job Label in Prometheus
-slug: what-is-the-job-label-in-prometheus
 date: 2024-08-01
 tags: [faq, prometheus]
 authors: [ankit_anand]
 description: Discover the crucial role of job labels in Prometheus, their configuration, and best practices for effective monitoring and metric organization.
 keywords: [Prometheus, job label, monitoring, metrics, service discovery, PromQL, alerting]
-
 ---
 
 The job label in Prometheus is a crucial identifier for scraped targets. It automatically assigns a name to a group of targets that share the same purpose or function. This label plays a vital role in organizing metrics, facilitating service discovery, and enabling effective querying and alerting in [Prometheus monitoring](https://signoz.io/guides/what-is-prometheus-for-monitoring/) systems.
@@ -29,9 +26,9 @@ Job labels follow a specific structure in Prometheus:
 
 - **Format**: `job="<job_name>"`
 - **Examples**:
-    - `job="mysql"`
-    - `job="nginx"`
-    - `job="kubernetes-nodes"`
+  - `job="mysql"`
+  - `job="nginx"`
+  - `job="kubernetes-nodes"`
 
 Unlike other automatically generated labels, job labels provide a higher-level categorization. While an `instance` label might identify a specific server (`10.0.0.1:8080`), the job label groups all servers performing the same function (`web-server`).
 
@@ -63,7 +60,6 @@ scrape_configs:
   - job_name: 'api-servers'
     static_configs:
       - targets: ['localhost:8080', 'localhost:8081']
-
 ```
 
 1. **Overriding**: You can override default job labels for specific targets:
@@ -75,7 +71,6 @@ scrape_configs:
       - targets: ['localhost:9100']
         labels:
           job: 'custom-job-name'
-
 ```
 
 1. **Relabeling**: Use relabeling to modify job labels based on target metadata:
@@ -88,7 +83,6 @@ scrape_configs:
     relabel_configs:
       - source_labels: [__meta_kubernetes_pod_label_app]
         target_label: job
-
 ```
 
 1. **Granularity**: Strike a balance between too broad and too specific job labels. `web-server` might be better than `server`, but `nginx-web-server-us-east` might be too granular.
@@ -107,28 +101,27 @@ Job labels adapt to various monitoring environments:
 Job labels unlock powerful capabilities in Prometheus:
 
 1. **PromQL Queries**: Use job labels in complex queries:
-    
-    ```
-    sum(rate(http_requests_total{job=~".*api.*"}[5m])) by (job)
-    
-    ```
-    
+
+   ```
+   sum(rate(http_requests_total{job=~".*api.*"}[5m])) by (job)
+
+   ```
+
 2. **Grafana Dashboards**: Create dynamic dashboards using job label variables:
-    
-    ```
-    sum(rate(http_requests_total{job="$job"}[5m]))
-    
-    ```
-    
+
+   ```
+   sum(rate(http_requests_total{job="$job"}[5m]))
+
+   ```
+
 3. **Alerting Strategies**: Implement job-based alerts:
-    
-    ```yaml
-    alert: HighErrorRate
-    expr: sum(rate(http_errors_total{job="web-server"}[5m])) / sum(rate(http_requests_total{job="web-server"}[5m])) > 0.1
-    for: 5m
-    
-    ```
-    
+
+   ```yaml
+   alert: HighErrorRate
+   expr: sum(rate(http_errors_total{job="web-server"}[5m])) / sum(rate(http_requests_total{job="web-server"}[5m])) > 0.1
+   for: 5m
+   ```
+
 4. **Metadata Export**: Use the [Prometheus API](https://signoz.io/guides/how-do-i-monitor-api-in-prometheus/) to export job label metadata for external systems.
 
 ## Key Takeaways
@@ -169,4 +162,4 @@ To experience how SigNoz can enhance your Prometheus monitoring:
 
 <GetStartedSigNoz />
 
-By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
\ No newline at end of file
+By integrating SigNoz with your existing Prometheus setup, you can leverage the power of job labels while gaining additional observability features to ensure your systems run smoothly.
diff --git a/data/guides/when-does-dynamodb-throttle-request.mdx b/data/guides/when-does-dynamodb-throttle-request.mdx
index 59e469bb7..9222d013a 100644
--- a/data/guides/when-does-dynamodb-throttle-request.mdx
+++ b/data/guides/when-does-dynamodb-throttle-request.mdx
@@ -1,18 +1,27 @@
 ---
-
 title: When Does DynamoDB Throttle Request - Understanding When and Why It Happens
-slug: when-does-dynamodb-throttle-request
 date: 2024-09-18
 tags: [faq]
 authors: [sushant_gaurav]
 description: Learn when and why DynamoDB throttles requests, how to identify throttling issues, and strategies to prevent them for optimal database performance.
-keywords: [DynamoDB throttling, request throttling, AWS database, performance optimization, capacity planning, monitoring]
-
+keywords:
+  [
+    DynamoDB throttling,
+    request throttling,
+    AWS database,
+    performance optimization,
+    capacity planning,
+    monitoring,
+  ]
 ---
 
-DynamoDB is Amazon's NoSQL database service and it is known for its scalability and reliable performance. However, like every other system, it has some limitations. When these restrictions are surpassed, DynamoDB implements a precaution known as throttling. 
+DynamoDB is Amazon's NoSQL database service and it is known for its scalability and reliable performance. However, like every other system, it has some limitations. When these restrictions are surpassed, DynamoDB implements a precaution known as throttling.
 
-<Figure src="/img/guides/2024/09/when-does-dynamodb-throttle-request-image.webp" alt="DynamoDB landing page" caption="DynamoDB landing page" />
+<Figure
+  src="/img/guides/2024/09/when-does-dynamodb-throttle-request-image.webp"
+  alt="DynamoDB landing page"
+  caption="DynamoDB landing page"
+/>
 
 In this article, you learn about DynamoDB throttling, and how it affects your application and its working. You also learn how to control or prevent DynamoDB throttling.
 
@@ -23,7 +32,11 @@ DynamoDB throttling is a safety mechanism that restricts the number of requests
 - Provisioned throughput mode: In Provisioned throughput mode, you manually set the read and write capacity units (RCUs and WCUs) that your table can handle per second. Throttling occurs when the predefined boundaries are exceeded. For example, if your table is supplied with 50 write capacity units and you attempt to make 70 write requests per second, 20 of them will be throttled.
 - On-demand capacity mode: In On-demand capacity mode, DynamoDB dynamically adapts its capacity according to the workload, but it has some limitations. The on-demand mode is more adaptable than the provisioned throughput mode. It can dynamically assign capacity based on the traffic. However, in case of abrupt traffic surges such as a spike that exceeds double the previous high in a short period can still result in throttling.
 
-<Figure src="/img/guides/2024/09/when-does-dynamodb-throttle-request-image%201.webp" alt="Capacity Modes of DynamoDB" caption="Capacity Modes of DynamoDB" />
+<Figure
+  src="/img/guides/2024/09/when-does-dynamodb-throttle-request-image%201.webp"
+  alt="Capacity Modes of DynamoDB"
+  caption="Capacity Modes of DynamoDB"
+/>
 
 Throttling helps to keep your table and the underlying infrastructure stable by preventing the overconsumption of resources. So, when a request is throttled, DynamoDB returns a `ProvisionedThroughputExceededException` which indicates that the request has exceeded the allocated capacity. This error prevents your table from being overloaded and disturbing other users or workloads.
 
@@ -97,9 +110,7 @@ Monitoring DynamoDB performance is crucial for detecting bottlenecks, such as th
 - SigNoz allows you to design customizable dashboards that are tailored to your individual monitoring needs. You can view important DynamoDB metrics in a single place which makes it simple to discover trends, bottlenecks, and areas for optimization.
 - Create proactive alerts in SigNoz to advise you of throttling events or other performance issues. You can set thresholds for specific metrics, such as high request latencies or excessive throttled requests, to ensure that issues are detected in real time.
 - Actionable Tip
-    
-    Regularly review your SigNoz dashboards and alerts to stay on top of your DynamoDB’s performance. Early detection and intervention can prevent throttling from affecting your application.
-    
+  Regularly review your SigNoz dashboards and alerts to stay on top of your DynamoDB’s performance. Early detection and intervention can prevent throttling from affecting your application.
 
 Get Started with SigNoz: To begin using SigNoz for monitoring your DynamoDB performance, visit [SigNoz](https://signoz.io/) and follow the setup instructions to integrate with your DynamoDB instances.
 
@@ -142,4 +153,4 @@ To determine the appropriate capacity for your DynamoDB table:
 2. You can determine the necessary read and write capacity units depending on the size of the items being read or written and the frequency of access.
 3. You can use DynamoDB's capacity calculator to project your capacity requirements precisely.
 4. You can implement DynamoDB Auto Scaling to dynamically alter capacity in response to traffic changes.
-5. You can review your capacity utilization regularly and update your estimations as your application evolves.
\ No newline at end of file
+5. You can review your capacity utilization regularly and update your estimations as your application evolves.
diff --git a/data/guides/which-database-is-used-in-prometheus.mdx b/data/guides/which-database-is-used-in-prometheus.mdx
index 40c4352d5..f1eb014aa 100644
--- a/data/guides/which-database-is-used-in-prometheus.mdx
+++ b/data/guides/which-database-is-used-in-prometheus.mdx
@@ -1,178 +1,180 @@
 ---
-
 title: Which Database is Used in Prometheus?
-slug: which-database-is-used-in-prometheus
 date: 2024-07-15
 tags: [faq]
 authors: [daniel]
 description: Prometheus uses its own time-series database (TSDB) for storing data. This TSDB is highly optimized for handling large volumes of time-stamped data.
-keywords: [database,prometheus,monitoring]
-
+keywords: [database, prometheus, monitoring]
 ---
 
 <head>
-<script
-  type="application/ld+json"
-  dangerouslySetInnerHTML={{ __html: JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "TechArticle",
-    "headline": "Which Database is Used in Prometheus?",
-    "alternativeHeadline": "Understanding the Time Series Database Used by Prometheus",
-    "author": {
-      "@type": "Person",
-      "name": "Daniel"
-    },
-    "publisher": {
-      "@type": "Organization",
-      "name": "SigNoz",
-      "logo": {
-        "@type": "ImageObject",
-        "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-      }
-    },
-    "datePublished": "2024-07-15T00:00:00Z",
-    "dateModified": "2024-07-15T00:00:00Z",
-    "mainEntityOfPage": {
-      "@type": "WebPage",
-      "@id": "https://signoz.io/guides/which-database-is-used-in-prometheus/"
-    },
-    "description": "Prometheus uses its own time-series database (TSDB) for storing data. This TSDB is highly optimized for handling large volumes of time-stamped data.",
-    "keywords": "database, prometheus, monitoring",
-    "articleSection": "Technology",
-    "inLanguage": "en",
-    "isPartOf": {
-      "@type": "Blog",
-      "name": "SigNoz Blog",
-      "url": "https://signoz.io/blog/"
-    },
-    "about": [
-      {
-        "@type": "Thing",
-        "name": "Prometheus",
-        "description": "An open-source monitoring and alerting toolkit designed for reliability and scalability."
-      },
-      {
-        "@type": "Thing",
-        "name": "Time Series Database",
-        "description": "A database optimized for handling time-stamped data."
-      },
-      {
-        "@type": "Thing",
-        "name": "Monitoring",
-        "description": "The process of observing and checking the behavior and outputs of a system."
-      }
-    ],
-    "mentions": [
-      {
-        "@type": "SoftwareApplication",
-        "name": "Prometheus",
-        "applicationCategory": "Monitoring Tool"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "InfluxDB",
-        "applicationCategory": "Time Series Database"
-      },
-      {
-        "@type": "SoftwareApplication",
-        "name": "TimescaleDB",
-        "applicationCategory": "Time Series Database"
-      }
-    ],
-    "mainEntity": {
-      "@type": "FAQPage",
-      "mainEntity": [
-        {
-          "@type": "Question",
-          "name": "Which database is used in Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus uses its own specialized Time Series Database (TSDB) for storing and managing time-stamped data. This TSDB is optimized for high-performance data ingestion, efficient storage, and fast querying of time series data, making it ideal for monitoring and alerting systems."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is Prometheus?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It is primarily used for collecting and storing metrics as time series data."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "What is a Time Series Database?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "A time series database (TSDB) is a database optimized for handling time-stamped data, where each data point is associated with a specific timestamp indicating when the measurement or event occurred."
-          }
-        },
-        {
-          "@type": "Question",
-          "name": "How does the Prometheus TSDB work?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus TSDB works by ingesting data through sample collection, storing it in memory-mapped chunks, and writing it to a write-ahead log (WAL). The data is then persisted to disk as immutable blocks, ensuring durability and efficient access for queries."
-          }
+  <script
+    type="application/ld+json"
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Which Database is Used in Prometheus?',
+        alternativeHeadline: 'Understanding the Time Series Database Used by Prometheus',
+        author: {
+          '@type': 'Person',
+          name: 'Daniel',
         },
-        {
-          "@type": "Question",
-          "name": "Why does Prometheus use a Time Series Database?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Prometheus uses a TSDB because it is specifically designed to handle the unique requirements of time series data, which is essential for effective monitoring and alerting. The TSDB offers advantages like specialized compression, scalability, performance, durability, and optimized handling of time-ordered data."
-          }
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
         },
-        {
-          "@type": "Question",
-          "name": "What are some alternatives to the Prometheus TSDB?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "Some alternatives to the Prometheus TSDB include InfluxDB, TimescaleDB, and other time series databases like Elasticsearch or ClickHouse. These databases offer distinct features and capabilities for handling time series data, making them suitable for various use cases beyond monitoring and alerting."
-          }
+        datePublished: '2024-07-15T00:00:00Z',
+        dateModified: '2024-07-15T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/which-database-is-used-in-prometheus/',
         },
-        {
-          "@type": "Question",
-          "name": "When should you consider using an alternative time series database?",
-          "acceptedAnswer": {
-            "@type": "Answer",
-            "text": "You should consider using an alternative time series database when you need long-term storage and analysis, high cardinality handling, advanced analytics, non-metric data storage, or specific requirements like high write throughput or SQL support."
-          }
-        }
-      ]
-    },
-    "tutorial": {
-      "@type": "HowTo",
-      "name": "How to Use Prometheus TSDB",
-      "step": [
-        {
-          "@type": "HowToStep",
-          "name": "Set Up Prometheus",
-          "text": "Download and install Prometheus, then configure it to scrape metrics from your targets."
+        description:
+          'Prometheus uses its own time-series database (TSDB) for storing data. This TSDB is highly optimized for handling large volumes of time-stamped data.',
+        keywords: 'database, prometheus, monitoring',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
         },
-        {
-          "@type": "HowToStep",
-          "name": "Configure TSDB Settings",
-          "text": "Adjust TSDB settings in the Prometheus configuration file to optimize data storage and query performance."
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Prometheus',
+            description:
+              'An open-source monitoring and alerting toolkit designed for reliability and scalability.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Time Series Database',
+            description: 'A database optimized for handling time-stamped data.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Monitoring',
+            description:
+              'The process of observing and checking the behavior and outputs of a system.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Prometheus',
+            applicationCategory: 'Monitoring Tool',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'InfluxDB',
+            applicationCategory: 'Time Series Database',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'TimescaleDB',
+            applicationCategory: 'Time Series Database',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'Which database is used in Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus uses its own specialized Time Series Database (TSDB) for storing and managing time-stamped data. This TSDB is optimized for high-performance data ingestion, efficient storage, and fast querying of time series data, making it ideal for monitoring and alerting systems.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Prometheus?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It is primarily used for collecting and storing metrics as time series data.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is a Time Series Database?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'A time series database (TSDB) is a database optimized for handling time-stamped data, where each data point is associated with a specific timestamp indicating when the measurement or event occurred.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How does the Prometheus TSDB work?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus TSDB works by ingesting data through sample collection, storing it in memory-mapped chunks, and writing it to a write-ahead log (WAL). The data is then persisted to disk as immutable blocks, ensuring durability and efficient access for queries.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Why does Prometheus use a Time Series Database?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Prometheus uses a TSDB because it is specifically designed to handle the unique requirements of time series data, which is essential for effective monitoring and alerting. The TSDB offers advantages like specialized compression, scalability, performance, durability, and optimized handling of time-ordered data.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What are some alternatives to the Prometheus TSDB?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Some alternatives to the Prometheus TSDB include InfluxDB, TimescaleDB, and other time series databases like Elasticsearch or ClickHouse. These databases offer distinct features and capabilities for handling time series data, making them suitable for various use cases beyond monitoring and alerting.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'When should you consider using an alternative time series database?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'You should consider using an alternative time series database when you need long-term storage and analysis, high cardinality handling, advanced analytics, non-metric data storage, or specific requirements like high write throughput or SQL support.',
+              },
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Monitor Data Ingestion",
-          "text": "Ensure that Prometheus is correctly ingesting data by checking the write-ahead log (WAL) and memory-mapped chunks."
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Prometheus TSDB',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Set Up Prometheus',
+              text: 'Download and install Prometheus, then configure it to scrape metrics from your targets.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Configure TSDB Settings',
+              text: 'Adjust TSDB settings in the Prometheus configuration file to optimize data storage and query performance.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Monitor Data Ingestion',
+              text: 'Ensure that Prometheus is correctly ingesting data by checking the write-ahead log (WAL) and memory-mapped chunks.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Query Data',
+              text: 'Use PromQL to query the data stored in the TSDB for monitoring and alerting purposes.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with Visualization Tools',
+              text: 'Integrate Prometheus with visualization tools like Grafana or SigNoz for advanced data visualization and analysis.',
+            },
+          ],
         },
-        {
-          "@type": "HowToStep",
-          "name": "Query Data",
-          "text": "Use PromQL to query the data stored in the TSDB for monitoring and alerting purposes."
-        },
-        {
-          "@type": "HowToStep",
-          "name": "Integrate with Visualization Tools",
-          "text": "Integrate Prometheus with visualization tools like Grafana or SigNoz for advanced data visualization and analysis."
-        }
-      ]
-    }
-  }) }}
-/>
+      }),
+    }}
+  />
 </head>
 
 Prometheus uses its own specialized Time Series Database (TSDB) for storing and managing time-stamped data. This TSDB is optimized for high-performance data ingestion, efficient storage, and fast querying of time series data, making it ideal for monitoring and alerting systems.
@@ -189,8 +191,11 @@ Time series data consists of numeric values that change over time and are typica
 
 ## How does the Prometheus TSDB Work?
 
-<Figure src="/img/guides/2024/07/which-database-is-used-in-prometheus-tsdb_(1).webp" alt="Prometheus TSDB" caption="Prometheus TSDB" />
-
+<Figure
+  src="/img/guides/2024/07/which-database-is-used-in-prometheus-tsdb_(1).webp"
+  alt="Prometheus TSDB"
+  caption="Prometheus TSDB"
+/>
 
 The above architecture diagram highlights the key components of the Prometheus TSDB. Here's an overview of how they work together:
 
@@ -223,7 +228,7 @@ Prometheus uses a Time Series Database (TSDB) because it is specifically designe
 1. Storage: TSDBs often employ specialized compression techniques optimized for time series data, significantly reducing storage requirements. Prometheus leverages this through its custom storage format for efficient storage.
 2. Scalability: TSDBs are designed to handle massive amounts of metrics data from numerous sources. Prometheus TSDB can be scaled horizontally by adding more nodes to distribute the load, ensuring performance even as your monitoring needs grow. This scalability is essential for monitoring large-scale distributed systems and dynamic environments where the number of targets and metrics can change rapidly.
 3. Performance: Time series databases are optimized for high write and query throughput, ensuring quick query response times even for complex queries that involve [high cardinality data](https://signoz.io/blog/high-cardinality-data/). This is essential for real-time monitoring and alerting systems, where quick access to accurate data is crucial for maintaining system health and performance. Prometheus uses a TSDB to efficiently store and retrieve metric data from thousands of targets.
-4. Durability: TSDBs are designed with durability in mind. They typically use Write-Ahead Logging (WAL) to ensure durability during writes, preventing data loss in case of crashes or failures. 
+4. Durability: TSDBs are designed with durability in mind. They typically use Write-Ahead Logging (WAL) to ensure durability during writes, preventing data loss in case of crashes or failures.
 5. Optimized for Time-Ordered Data: Time series data is inherently sequential, with each data point tied to a specific timestamp. TSDBs are built to store and query data in this chronological order, making them highly efficient for Prometheus's core function of collecting and analyzing metrics over time.
 
 ## Alternatives to the Times Series Database
@@ -240,17 +245,17 @@ TimescaleDB is a PostgreSQL extension that transforms PostgreSQL into a time ser
 
 Below is a comparison table:
 
-| Feature | Prometheus | InfluxDB | TimescaleDB |
-| --- | --- | --- | --- |
-| Primary Focus | Monitoring and Alerting | Time-series data (metrics, events, logs) | Time-series data, especially complex analytics |
-| Data Model | Multi-dimensional (metrics with labels) | Tag-based, with flexible schemas | Relational (PostgreSQL extension), optimized for time-series data |
-| Query Language | PromQL | InfluxQL | SQL (with time-series extensions) |
-| Scalability | Horizontal scaling through federation | Horizontal scaling, clustering | Horizontal scaling, native PostgreSQL features |
-| Storage Engine | Custom-built TSDB | Custom-built TSM engine (InfluxDB 1.x), or Apache Arrow (2.x) | PostgreSQL with time-series optimizations |
-| Performance | Fast query response times for monitoring | High write and query performance | Optimized for complex queries and analysis |
-| Resource Usage | Low | Moderate to high | Moderate |
-| Ecosystem | Mature | Growing | Large |
-| Use Cases | System and application monitoring, alerting | IoT, real-time analytics | Business intelligence, analytics, time series data analysis |
+| Feature        | Prometheus                                  | InfluxDB                                                      | TimescaleDB                                                       |
+| -------------- | ------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------- |
+| Primary Focus  | Monitoring and Alerting                     | Time-series data (metrics, events, logs)                      | Time-series data, especially complex analytics                    |
+| Data Model     | Multi-dimensional (metrics with labels)     | Tag-based, with flexible schemas                              | Relational (PostgreSQL extension), optimized for time-series data |
+| Query Language | PromQL                                      | InfluxQL                                                      | SQL (with time-series extensions)                                 |
+| Scalability    | Horizontal scaling through federation       | Horizontal scaling, clustering                                | Horizontal scaling, native PostgreSQL features                    |
+| Storage Engine | Custom-built TSDB                           | Custom-built TSM engine (InfluxDB 1.x), or Apache Arrow (2.x) | PostgreSQL with time-series optimizations                         |
+| Performance    | Fast query response times for monitoring    | High write and query performance                              | Optimized for complex queries and analysis                        |
+| Resource Usage | Low                                         | Moderate to high                                              | Moderate                                                          |
+| Ecosystem      | Mature                                      | Growing                                                       | Large                                                             |
+| Use Cases      | System and application monitoring, alerting | IoT, real-time analytics                                      | Business intelligence, analytics, time series data analysis       |
 
 ## When Should you Consider using an Alternative Time Series Database?
 
diff --git a/data/guides/why-does-prometheus-consume-so-much-memory.mdx b/data/guides/why-does-prometheus-consume-so-much-memory.mdx
index bf25d79f0..de1db4876 100644
--- a/data/guides/why-does-prometheus-consume-so-much-memory.mdx
+++ b/data/guides/why-does-prometheus-consume-so-much-memory.mdx
@@ -1,13 +1,18 @@
 ---
-
 title: How to Reduce Prometheus High Memory Usage
-slug: why-does-prometheus-consume-so-much-memory
 date: 2024-11-07
 tags: [faq, prometheus]
 authors: [simran_kumari]
 description: Discover why Prometheus consumes high memory and learn effective strategies to optimize its performance without compromising monitoring capabilities.
-keywords: [Prometheus memory usage, memory optimization, monitoring tools, time series database, cardinality, SigNoz]
-
+keywords:
+  [
+    Prometheus memory usage,
+    memory optimization,
+    monitoring tools,
+    time series database,
+    cardinality,
+    SigNoz,
+  ]
 ---
 
 Prometheus, a powerful open-source monitoring and alerting toolkit, has become a cornerstone of modern observability stacks. However, many users face a common challenge: high memory consumption. This issue can lead to resource constraints and increased operational costs. You might wonder, "Why does Prometheus consume so much memory?" — a question we'll thoroughly explore in this article. We'll delve into the underlying causes of Prometheus' memory usage, provide strategies for optimization, and introduce alternative solutions for efficient monitoring at scale.
@@ -31,13 +36,13 @@ Prometheus's memory consumption is often explained by a rule of thumb that indic
 Breakdown of the 3kB Rule:
 
 1. Memory Components:
-    - Time Series Data: Each time series stores a series of timestamps and corresponding values, which contributes to the overall memory usage.
-    - Metadata Storage: Prometheus maintains metadata for each time series, including labels (key-value pairs). The overhead from these labels can be significant, especially when numerous labels are utilized, as each label adds to the memory footprint.
-    - Indexing and Internal Structures: Prometheus employs various data structures for indexing and querying time series data, which also contributes to the memory consumption.
+   - Time Series Data: Each time series stores a series of timestamps and corresponding values, which contributes to the overall memory usage.
+   - Metadata Storage: Prometheus maintains metadata for each time series, including labels (key-value pairs). The overhead from these labels can be significant, especially when numerous labels are utilized, as each label adds to the memory footprint.
+   - Indexing and Internal Structures: Prometheus employs various data structures for indexing and querying time series data, which also contributes to the memory consumption.
 2. Scaling Impact:
-    - When scaling from hundreds to thousands or millions of time series, the memory requirement can escalate quickly. For example, if you have 1,000 time series, the memory usage might be around 3 MB. However, with 1 million time series, it can balloon to approximately 3 GB, demonstrating how crucial it is to manage the number of series and their associated labels.
+   - When scaling from hundreds to thousands or millions of time series, the memory requirement can escalate quickly. For example, if you have 1,000 time series, the memory usage might be around 3 MB. However, with 1 million time series, it can balloon to approximately 3 GB, demonstrating how crucial it is to manage the number of series and their associated labels.
 3. Strategies for Mitigation:
-    - To optimize memory usage, consider minimizing the number of labels and configuring retention policies to reduce the amount of historical data retained.
+   - To optimize memory usage, consider minimizing the number of labels and configuring retention policies to reduce the amount of historical data retained.
 
 Here's a breakdown of why Prometheus's memory usage can be significant:
 
@@ -60,80 +65,113 @@ Several factors can exacerbate Prometheus' memory consumption:
 To optimize Prometheus' memory usage, consider implementing these strategies:
 
 1. Effective label management:
-    - Limit the number of label values, especially for high-cardinality dimensions.
-    - Use relabeling to drop unnecessary labels or metrics.
+   - Limit the number of label values, especially for high-cardinality dimensions.
+   - Use relabeling to drop unnecessary labels or metrics.
 2. Optimize scrape intervals:
-    - Balance data freshness with resource usage by adjusting scrape frequencies.
-    - Consider longer intervals for stable metrics or less critical targets.
+   - Balance data freshness with resource usage by adjusting scrape frequencies.
+   - Consider longer intervals for stable metrics or less critical targets.
 3. Implement federation:
-    - Use <a href="https://prometheus.io/docs/prometheus/latest/federation/" rel="noopener noreferrer nofollow" target="_blank">Prometheus Federation</a> for large-scale deployments to distribute the load.
-    - Set up hierarchical Prometheus instances, with higher-level instances aggregating data from lower levels.
+   - Use <a href="https://prometheus.io/docs/prometheus/latest/federation/" rel="noopener noreferrer nofollow" target="_blank">Prometheus Federation</a> for large-scale deployments to distribute the load.
+   - Set up hierarchical Prometheus instances, with higher-level instances aggregating data from lower levels.
 4. Utilize retention policies and downsampling:
-    - Set appropriate retention periods to limit the amount of historical data kept in memory.
-    - Implement downsampling for long-term storage to reduce data resolution over time.
+   - Set appropriate retention periods to limit the amount of historical data kept in memory.
+   - Implement downsampling for long-term storage to reduce data resolution over time.
 
 ### Fine-tuning Prometheus Configuration
 
 Adjusting Prometheus configuration can significantly impact memory usage:
 
 1. TSDB settings:
-    - Tune `storage.tsdb.retention.time` and `storage.tsdb.retention.size` to control data retention.
-    - Adjust `storage.tsdb.wal-compression` to enable write-ahead log compression, reducing disk I/O at the cost of some CPU usage. Explore other <a href="https://prometheus.io/docs/prometheus/latest/storage/" rel="noopener noreferrer nofollow" target="_blank">TSDB settings here</a>.
+   - Tune `storage.tsdb.retention.time` and `storage.tsdb.retention.size` to control data retention.
+   - Adjust `storage.tsdb.wal-compression` to enable write-ahead log compression, reducing disk I/O at the cost of some CPU usage. Explore other <a href="https://prometheus.io/docs/prometheus/latest/storage/" rel="noopener noreferrer nofollow" target="_blank">TSDB settings here</a>.
 2. Recording rules:
-    - Implement recording rules to pre-compute expensive queries, reducing query-time memory spikes. Check out the documentation to explore <a href="https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/" rel="noopener noreferrer nofollow" target="_blank">Recording rules in Prometheus</a>.
+   - Implement recording rules to pre-compute expensive queries, reducing query-time memory spikes. Check out the documentation to explore <a href="https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/" rel="noopener noreferrer nofollow" target="_blank">Recording rules in Prometheus</a>.
 3. External storage:
-    - Offloading older or less frequently accessed data to an external storage system can free up memory and disk space. Read more about <a href="https://prometheus.io/docs/prometheus/latest/storage/#remote-storage-integrations" rel="noopener noreferrer nofollow" target="_blank">external storage integrations in Prometheus</a>.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-7db4965a-eeb3-4493-81c1-5b40bd21f2e8.webp" alt="Using external storage for storing grafana metrics" caption="Using external storage for storing grafana metrics" />
-        
+   - Offloading older or less frequently accessed data to an external storage system can free up memory and disk space. Read more about <a href="https://prometheus.io/docs/prometheus/latest/storage/#remote-storage-integrations" rel="noopener noreferrer nofollow" target="_blank">external storage integrations in Prometheus</a>.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-7db4965a-eeb3-4493-81c1-5b40bd21f2e8.webp"
+       alt="Using external storage for storing grafana metrics"
+       caption="Using external storage for storing grafana metrics"
+     />
 
 ## Monitoring and Analyzing Prometheus' Resource Usage
 
 Prometheus can monitor itself, providing valuable insights into its performance:
 
 1. Key metrics to watch:
-    
-    Monitoring specific metrics will help you understand where memory is being consumed and whether adjustments are necessary. Here are some of the most important ones:
-    
-    - `prometheus_tsdb_head_series`: Number of time series in the head block.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image.webp" alt="Metric prometheus_tsdb_head_series" caption="Metric prometheus_tsdb_head_series" />
-        
-    - `prometheus_tsdb_head_samples_appended_total`: Total number of appended samples.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%201.webp" alt="Metric prometheus_tsdb_head_samples_appended_total" caption="Metric prometheus_tsdb_head_samples_appended_total" />
-        
-    - `process_resident_memory_bytes`: Prometheus process memory usage.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%202.webp" alt="Metric process_resident_memory_bytes" caption="Metric process_resident_memory_bytes" />
-        
+
+   Monitoring specific metrics will help you understand where memory is being consumed and whether adjustments are necessary. Here are some of the most important ones:
+
+   - `prometheus_tsdb_head_series`: Number of time series in the head block.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image.webp"
+       alt="Metric prometheus_tsdb_head_series"
+       caption="Metric prometheus_tsdb_head_series"
+     />
+   - `prometheus_tsdb_head_samples_appended_total`: Total number of appended samples.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%201.webp"
+       alt="Metric prometheus_tsdb_head_samples_appended_total"
+       caption="Metric prometheus_tsdb_head_samples_appended_total"
+     />
+   - `process_resident_memory_bytes`: Prometheus process memory usage.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%202.webp"
+       alt="Metric process_resident_memory_bytes"
+       caption="Metric process_resident_memory_bytes"
+     />
+
 2. Dashboards and alerts:
-    - Setting up a dedicated Prometheus self-monitoring dashboard in a visualization tool (like Grafana) allows you to easily track these metrics.
-    - Commonly monitored areas on a Prometheus health dashboard include memory usage, CPU load, query duration, and the number of active time series.
+   - Setting up a dedicated Prometheus self-monitoring dashboard in a visualization tool (like Grafana) allows you to easily track these metrics.
+   - Commonly monitored areas on a Prometheus health dashboard include memory usage, CPU load, query duration, and the number of active time series.
 3. Query analysis:
-    
-    Some queries or targets might contribute more heavily to memory usage than others. Here’s how you can identify and address these issues:
-    
-    - Identify high-cardinality metrics: Run `topk(10, count by (__name__)({__name__=~".+"}))` to find the top 10 metrics with the most series and detect high-cardinality metrics.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%203.webp" alt="Identify High-Cardinality Metrics" caption="Identify High-Cardinality Metrics" />
-        
-    - Monitor query load: Check `prometheus_engine_query_duration_seconds` to spot long-running or resource-intensive queries. Use recording rules for complex queries.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%204.webp" alt="Monitor Query Load" caption="Monitor Query Load" />
-        
-    - Analyze [target metrics](https://signoz.io/guides/what-is-prometheus-target/): Use `prometheus_target_interval_length_seconds` to review scrape intervals and identify any targets with high scrape frequencies that may be overloading memory.
-        
-        <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%205.webp" alt="Identify targets with high scrape frequencies" caption="Identify targets with high scrape frequencies" />
-        
+
+   Some queries or targets might contribute more heavily to memory usage than others. Here’s how you can identify and address these issues:
+
+   - Identify high-cardinality metrics: Run `topk(10, count by (__name__)({__name__=~".+"}))` to find the top 10 metrics with the most series and detect high-cardinality metrics.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%203.webp"
+       alt="Identify High-Cardinality Metrics"
+       caption="Identify High-Cardinality Metrics"
+     />
+   - Monitor query load: Check `prometheus_engine_query_duration_seconds` to spot long-running or resource-intensive queries. Use recording rules for complex queries.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%204.webp"
+       alt="Monitor Query Load"
+       caption="Monitor Query Load"
+     />
+   - Analyze [target metrics](https://signoz.io/guides/what-is-prometheus-target/): Use `prometheus_target_interval_length_seconds` to review scrape intervals and identify any targets with high scrape frequencies that may be overloading memory.
+     {' '}
+     <Figure
+       src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%205.webp"
+       alt="Identify targets with high scrape frequencies"
+       caption="Identify targets with high scrape frequencies"
+     />
 
 ## Alternatives and Complementary Tools for Large-Scale Monitoring
 
 For scenarios where Prometheus alone struggles with resource constraints, consider these alternatives:
 
-1. <a href="https://thanos.io/" rel="noopener noreferrer nofollow" target="_blank">Thanos</a>: Thanos adds horizontal scaling, long-term storage, and downsampling capabilities to Prometheus, making it a good option for large-scale deployments.
-2. <a href="https://victoriametrics.com/" rel="noopener noreferrer nofollow" target="_blank">VictoriaMetrics:</a> VictoriaMetrics is a high-performance time-series database that is compatible with Prometheus but optimized for large-scale environments and efficient resource usage.
-3. <a href="https://grafana.com/oss/mimir/" rel="noopener noreferrer nofollow" target="_blank">Grafana Mimir</a>: Mimir is another scalable solution that works well for multi-tenant environments and offers horizontal scaling similar to Thanos.
+1. <a href="https://thanos.io/" rel="noopener noreferrer nofollow" target="_blank">
+     Thanos
+   </a>
+   : Thanos adds horizontal scaling, long-term storage, and downsampling capabilities to Prometheus,
+   making it a good option for large-scale deployments.
+2. <a href="https://victoriametrics.com/" rel="noopener noreferrer nofollow" target="_blank">
+     VictoriaMetrics:
+   </a> VictoriaMetrics is a high-performance time-series database that is compatible with
+   Prometheus but optimized for large-scale environments and efficient resource usage.
+3. <a href="https://grafana.com/oss/mimir/" rel="noopener noreferrer nofollow" target="_blank">
+     Grafana Mimir
+   </a>
+   : Mimir is another scalable solution that works well for multi-tenant environments and offers
+   horizontal scaling similar to Thanos.
 
 ### Exploring SigNoz for Efficient Monitoring
 
@@ -144,9 +182,12 @@ Key benefits of using SigNoz:
 - Optimized for High-Cardinality Data: SigNoz efficiently handles metrics with high cardinality, reducing memory strain.
 - Efficient resource usage: SigNoz is designed to handle high cardinality data more efficiently than Prometheus.
 - Integrated tracing: Combines metrics and distributed tracing, providing deeper insights into application performance.
-    
-    <Figure src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%206.webp" alt="Integrating traces and logs with metrics for comprehensive observability" caption="Integrating traces and logs with metrics for comprehensive observability" />
-    
+  {' '}
+  <Figure
+    src="/img/guides/2024/11/why-does-prometheus-consume-so-much-memory-image%206.webp"
+    alt="Integrating traces and logs with metrics for comprehensive observability"
+    caption="Integrating traces and logs with metrics for comprehensive observability"
+  />
 - User-friendly interface: Offers an intuitive UI for querying and visualizing data without the need for separate visualization tools.
 
 <GetStartedSigNoz />
@@ -190,4 +231,4 @@ Increasing the scrape interval reduces the frequency of data collection, which c
 
 ### How does SigNoz compare to Prometheus in terms of resource usage?
 
-SigNoz is designed to handle high cardinality data more efficiently than Prometheus, which can lead to lower resource usage in environments with many unique time series. Its integrated approach to metrics, logs, and traces helps reduce complexity and overall resource requirements. Additionally, SigNoz leverages ClickHouse as its storage backend, which is known for its efficient query performance and enhanced resource optimization compared to Prometheus. This makes SigNoz particularly advantageous in high-cardinality scenarios, potentially offering a more lightweight observability solution overall.
\ No newline at end of file
+SigNoz is designed to handle high cardinality data more efficiently than Prometheus, which can lead to lower resource usage in environments with many unique time series. Its integrated approach to metrics, logs, and traces helps reduce complexity and overall resource requirements. Additionally, SigNoz leverages ClickHouse as its storage backend, which is known for its efficient query performance and enhanced resource optimization compared to Prometheus. This makes SigNoz particularly advantageous in high-cardinality scenarios, potentially offering a more lightweight observability solution overall.
diff --git a/data/guides/windows-logs.mdx b/data/guides/windows-logs.mdx
index 5b39df7ea..613b8b4d6 100644
--- a/data/guides/windows-logs.mdx
+++ b/data/guides/windows-logs.mdx
@@ -1,6 +1,5 @@
 ---
 title: Complete Guide to Checking Window Logs
-slug: windows-logs
 date: 2024-07-03
 tags: [logging]
 authors: [nitin_gouda]
@@ -9,141 +8,147 @@ keywords: [windows logs, event viewer, logging]
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Windows Logs",
-  "alternativeHeadline": "Understanding and Utilizing Windows Event Logs for System Monitoring and Troubleshooting",
-  "author": {
-    "@type": "Person",
-    "name": "Nitin Gouda"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-03T00:00:00Z",
-  "dateModified": "2024-07-03T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/windows-logs/"
-  },
-  "description": "Discover the importance of Windows logs for system monitoring, troubleshooting, and security. Learn to access, interpret, and utilize logs effectively for efficient problem-solving.",
-  "keywords": "windows logs, event viewer, logging",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Windows Event Logs",
-      "description": "A feature in Windows that records system, security, and application events"
-    },
-    {
-      "@type": "Thing",
-      "name": "Event Viewer",
-      "description": "A tool in Windows used to view and manage event logs"
-    },
-    {
-      "@type": "Thing",
-      "name": "System Monitoring",
-      "description": "The process of observing and analyzing a computer system's performance and activities"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Windows",
-      "operatingSystem": "Windows"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "How to view Windows logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To view Windows logs, use the built-in Event Viewer: 1. Press Win + R, type eventvwr, and press Enter. 2. Navigate through the console tree to find the log you want to view (e.g., Windows Logs > Application)."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Where are Microsoft logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Microsoft logs, including Windows logs, can be found in the Event Viewer under sections like Application, Security, and System. Log files are also located in the C:\\Windows\\System32\\winevt\\Logs directory."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I audit Windows logs?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "To audit Windows logs: 1. Open Event Viewer. 2. Navigate to Security logs under Windows Logs. 3. Configure auditing policies via the Local Security Policy or Group Policy Management Console."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I check my Windows activity log?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Check your Windows activity log by viewing the Security logs in Event Viewer. These logs record user logins, logoffs, and other security-related activities."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Why are Windows logs important?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Windows logs are important because they provide detailed information about system operations, security events, and application behavior, which is crucial for troubleshooting, auditing, and ensuring system integrity."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Access and Use Windows Event Viewer",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Open Event Viewer",
-        "text": "Open Event Viewer using the Start Menu, Run Dialog, or Control Panel."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Navigate to Log Categories",
-        "text": "Navigate through the console tree to find different log categories like System, Application, and Security."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Understand Event Entries",
-        "text": "Learn to interpret event entries, including date, time, source, event ID, and severity level."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Filter Events",
-        "text": "Use filtering options to narrow down events based on criteria like date, event level, or source."
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Create Custom Views",
-        "text": "Create custom views to focus on specific types of events or combinations of criteria."
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Windows Logs',
+        alternativeHeadline:
+          'Understanding and Utilizing Windows Event Logs for System Monitoring and Troubleshooting',
+        author: {
+          '@type': 'Person',
+          name: 'Nitin Gouda',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-03T00:00:00Z',
+        dateModified: '2024-07-03T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/windows-logs/',
+        },
+        description:
+          'Discover the importance of Windows logs for system monitoring, troubleshooting, and security. Learn to access, interpret, and utilize logs effectively for efficient problem-solving.',
+        keywords: 'windows logs, event viewer, logging',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Windows Event Logs',
+            description:
+              'A feature in Windows that records system, security, and application events',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Event Viewer',
+            description: 'A tool in Windows used to view and manage event logs',
+          },
+          {
+            '@type': 'Thing',
+            name: 'System Monitoring',
+            description:
+              "The process of observing and analyzing a computer system's performance and activities",
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Windows',
+            operatingSystem: 'Windows',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'How to view Windows logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To view Windows logs, use the built-in Event Viewer: 1. Press Win + R, type eventvwr, and press Enter. 2. Navigate through the console tree to find the log you want to view (e.g., Windows Logs > Application).',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where are Microsoft logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Microsoft logs, including Windows logs, can be found in the Event Viewer under sections like Application, Security, and System. Log files are also located in the C:\\Windows\\System32\\winevt\\Logs directory.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I audit Windows logs?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'To audit Windows logs: 1. Open Event Viewer. 2. Navigate to Security logs under Windows Logs. 3. Configure auditing policies via the Local Security Policy or Group Policy Management Console.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I check my Windows activity log?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Check your Windows activity log by viewing the Security logs in Event Viewer. These logs record user logins, logoffs, and other security-related activities.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Why are Windows logs important?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Windows logs are important because they provide detailed information about system operations, security events, and application behavior, which is crucial for troubleshooting, auditing, and ensuring system integrity.',
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Access and Use Windows Event Viewer',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Open Event Viewer',
+              text: 'Open Event Viewer using the Start Menu, Run Dialog, or Control Panel.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Navigate to Log Categories',
+              text: 'Navigate through the console tree to find different log categories like System, Application, and Security.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Understand Event Entries',
+              text: 'Learn to interpret event entries, including date, time, source, event ID, and severity level.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Filter Events',
+              text: 'Use filtering options to narrow down events based on criteria like date, event level, or source.',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Create Custom Views',
+              text: 'Create custom views to focus on specific types of events or combinations of criteria.',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
diff --git a/data/guides/windows-server-monitoring.mdx b/data/guides/windows-server-monitoring.mdx
index f2997dd90..b57bb7946 100644
--- a/data/guides/windows-server-monitoring.mdx
+++ b/data/guides/windows-server-monitoring.mdx
@@ -1,14 +1,19 @@
 ---
-
 title: Top 6 Windows Server Monitoring Tools and How to Implement
-slug: windows-server-monitoring
 date: 2025-03-25
 tags: [monitoring]
 authors: [simran_kumari]
 description: Discover the top 5 Windows Server monitoring tools and learn how to implement them effectively for optimal server performance and security.
-keywords: [windows server monitoring, server performance, IT management, network monitoring, system administration]
-
+keywords:
+  [
+    windows server monitoring,
+    server performance,
+    IT management,
+    network monitoring,
+    system administration,
+  ]
 ---
+
 Windows Server monitoring is the process of tracking and analyzing the performance, health, and security of Windows Server systems. It involves collecting data on various metrics such as CPU usage, memory utilization, disk space, network traffic, and application performance. This continuous observation allows IT professionals to:
 
 1. **Detect issues early**: Identify potential problems before they escalate into critical failures.
@@ -22,21 +27,21 @@ Effective monitoring is not just about collecting data—it's about transforming
 
 For IT professionals, Windows Server monitoring is not just a nice-to-have—it's a necessity. Here's why:
 
-1. **Ensures optimal server performance and uptime**:  
-    
-    Example: Without monitoring, a sudden CPU spike during a sale could crash an e-commerce server. With monitoring, IT can detect and address the issue in real-time, preventing downtime and lost sales.
-    
-2. **Facilitates proactive issue detection**: 
-    
-    Example: Monitoring alerts IT when disk space approaches critical levels, allowing them to take action before it causes system failures.
-    
-3. **Aids in capacity planning**: 
-
-    Example: By monitoring current resource usage, IT can determine if existing infrastructure can support new applications or if upgrades are needed.
-    
-4. **Enhances security**: 
-    
-    Example: Monitoring detects multiple failed login attempts immediately, enabling IT to respond to potential security breaches before damage occurs.
+1. **Ensures optimal server performance and uptime**:
+
+   Example: Without monitoring, a sudden CPU spike during a sale could crash an e-commerce server. With monitoring, IT can detect and address the issue in real-time, preventing downtime and lost sales.
+
+2. **Facilitates proactive issue detection**:
+
+   Example: Monitoring alerts IT when disk space approaches critical levels, allowing them to take action before it causes system failures.
+
+3. **Aids in capacity planning**:
+
+   Example: By monitoring current resource usage, IT can determine if existing infrastructure can support new applications or if upgrades are needed.
+
+4. **Enhances security**:
+
+   Example: Monitoring detects multiple failed login attempts immediately, enabling IT to respond to potential security breaches before damage occurs.
 
 ## Top 6 Windows Server Monitoring Tools
 
@@ -46,7 +51,11 @@ Selecting the right monitoring tool is crucial for effective Windows Server mana
 
 [SigNoz](/docs/infrastructure-monitoring/overview/) is a modern, open-source application performance monitoring (APM) and observability tool that's gaining traction in the Windows Server monitoring space. While it's known for its robust capabilities in monitoring distributed systems, it also offers powerful features for Windows Server environments.
 
-<Figure src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp" alt="SigNoz Infrastructure Monitoring Dashboard" caption="SigNoz Infrastructure Monitoring Dashboard" /> 
+<Figure
+  src="/img/unified-observability/unified-observability-infrastructure-monitoring.webp"
+  alt="SigNoz Infrastructure Monitoring Dashboard"
+  caption="SigNoz Infrastructure Monitoring Dashboard"
+/>{' '}
 
 Key Features:
 
@@ -59,9 +68,20 @@ SigNoz shines in its ability to provide a comprehensive view of your entire stac
 
 ### 2. SolarWinds Server & Application Monitor
 
-<a href="https://www.solarwinds.com/server-application-monitor" rel="noopener noreferrer nofollow" target="_blank">SolarWinds Server & Application Monitor (SAM)</a> is a well-established player in Windows Server monitoring. It offers a comprehensive suite of monitoring capabilities designed to give you deep insights into your server's performance.
-
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%201.webp" alt="SolarWinds Application Summary Dashboard" caption="SolarWinds Application Summary Dashboard" />
+<a
+  href="https://www.solarwinds.com/server-application-monitor"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  SolarWinds Server & Application Monitor (SAM)
+</a> is a well-established player in Windows Server monitoring. It offers a comprehensive suite of
+monitoring capabilities designed to give you deep insights into your server's performance.
+
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%201.webp"
+  alt="SolarWinds Application Summary Dashboard"
+  caption="SolarWinds Application Summary Dashboard"
+/>
 
 Key Features:
 
@@ -74,9 +94,21 @@ SAM's strength lies in its ease of use and extensive customization options. It's
 
 ### 3. ManageEngine OpManager
 
-<a href="https://www.manageengine.com/products/applications_manager/me-opm-monitoring.html" rel="noopener noreferrer nofollow" target="_blank">ManageEngine OpManager</a> is a comprehensive network monitoring solution that includes robust Windows Server monitoring capabilities. It uses Windows Management Instrumentation (WMI) to provide in-depth insights into server performance.
-
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%202.webp" alt="ManageEngine OpManager Monitoring Dashboard" caption="ManageEngine OpManager Monitoring Dashboard" />
+<a
+  href="https://www.manageengine.com/products/applications_manager/me-opm-monitoring.html"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  ManageEngine OpManager
+</a> is a comprehensive network monitoring solution that includes robust Windows Server monitoring
+capabilities. It uses Windows Management Instrumentation (WMI) to provide in-depth insights into
+server performance.
+
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%202.webp"
+  alt="ManageEngine OpManager Monitoring Dashboard"
+  caption="ManageEngine OpManager Monitoring Dashboard"
+/>
 
 Key Features:
 
@@ -89,9 +121,21 @@ OpManager's workflow automation capabilities set it apart, allowing IT teams to
 
 ### 4. Microsoft Windows Admin Center
 
-<a href="https://www.microsoft.com/en-in/windows-server/windows-admin-center" rel="noopener noreferrer nofollow" target="_blank">Windows Admin Center</a> is Microsoft's free, browser-based app for managing Windows servers, clusters, hyper-converged infrastructure, and Windows 10 PCs. It's an excellent option for organizations looking for a native Windows solution.
-
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%203.webp" alt="Microsoft Windows Admin Center Monitoring Dashboard" caption="Microsoft Windows Admin Center Monitoring Dashboard" />
+<a
+  href="https://www.microsoft.com/en-in/windows-server/windows-admin-center"
+  rel="noopener noreferrer nofollow"
+  target="_blank"
+>
+  Windows Admin Center
+</a> is Microsoft's free, browser-based app for managing Windows servers, clusters, hyper-converged
+infrastructure, and Windows 10 PCs. It's an excellent option for organizations looking for a native
+Windows solution.
+
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%203.webp"
+  alt="Microsoft Windows Admin Center Monitoring Dashboard"
+  caption="Microsoft Windows Admin Center Monitoring Dashboard"
+/>
 
 Key Features:
 
@@ -104,9 +148,17 @@ While it may not have all the bells and whistles of paid solutions, Windows Admi
 
 ### 5. PRTG Network Monitor
 
-<a href="https://www.paessler.com/prtg" rel="noopener noreferrer nofollow" target="_blank">PRTG Network Monitor</a>, developed by Paessler, is known for its comprehensive monitoring capabilities that extend beyond just Windows Servers to cover entire IT infrastructures.
+<a href="https://www.paessler.com/prtg" rel="noopener noreferrer nofollow" target="_blank">
+  PRTG Network Monitor
+</a>
+, developed by Paessler, is known for its comprehensive monitoring capabilities that extend beyond
+just Windows Servers to cover entire IT infrastructures.
 
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%204.webp" alt="PRTG Network Monitor Dashboard" caption="PRTG Network Monitor Dashboard" />
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%204.webp"
+  alt="PRTG Network Monitor Dashboard"
+  caption="PRTG Network Monitor Dashboard"
+/>
 
 Key Features:
 
@@ -119,9 +171,17 @@ PRTG's strength lies in its versatility and ease of setup, making it a good fit
 
 ### 6. Zabbix
 
-<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">Zabbix</a> is a robust open-source monitoring solution known for its comprehensive monitoring capabilities across a wide range of platforms, including Windows Servers. It offers extensive flexibility and scalability, making it a versatile choice for organizations of any size.
+<a href="https://www.zabbix.com/" rel="noopener noreferrer nofollow" target="_blank">
+  Zabbix
+</a> is a robust open-source monitoring solution known for its comprehensive monitoring capabilities
+across a wide range of platforms, including Windows Servers. It offers extensive flexibility and
+scalability, making it a versatile choice for organizations of any size.
 
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%205.webp" alt="Zabbix Monitoring Dashboard" caption="Zabbix Monitoring Dashboard" />
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%205.webp"
+  alt="Zabbix Monitoring Dashboard"
+  caption="Zabbix Monitoring Dashboard"
+/>
 
 Key Features:
 
@@ -141,36 +201,43 @@ Follow these steps to set up [Windows Server monitoring](https://signoz.io/guide
 
 Create a SigNoz Cloud account and get your ingestion key from the settings page:
 
-
-<Figure src="/img/docs/ingestion/keys.png" alt="SigNoz Ingestion Key" caption="SigNoz Ingestion Key in Settings" />
+<Figure
+  src="/img/docs/ingestion/keys.png"
+  alt="SigNoz Ingestion Key"
+  caption="SigNoz Ingestion Key in Settings"
+/>
 
 <GetStartedSigNoz />
 
-
-
 ## Step 2: Install and Configure OpenTelemetry Collector
 
 1. Download the OpenTelemetry Collector for Windows:
+
    ```bash
    wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v/otelcol-contrib_0.116.0_windows_amd64.tar.gz
    ```
-   *Alternatively, download from the [releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).*
+
+   _Alternatively, download from the [releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases)._
 
 2. Extract the downloaded file:
+
    ```bash
-   mkdir otelcol-contrib 
+   mkdir otelcol-contrib
    tar xvzf otelcol-contrib_0.116.0_windows_amd64.tar.gz -C otelcol-contrib
    ```
 
 3. Navigate to the extracted directory:
+
    ```bash
    cd otelcol-contrib
    ```
 
 4. Verify the installation:
+
    ```bash
    ./otelcol-contrib.exe --version
    ```
+
    Expected output: `otelcol-contrib version`
 
 5. Create a configuration file named `config.yaml` in the `otelcol-contrib` folder with the following content (replace `<SIGNOZ_INGESTION_KEY>` with your SigNoz key):
@@ -221,11 +288,11 @@ extensions:
   zpages: {}
 exporters:
   otlp:
-    endpoint: "https://ingest.{region}.signoz.cloud:443"
+    endpoint: 'https://ingest.{region}.signoz.cloud:443'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"
+      'signoz-ingestion-key': '<SIGNOZ_INGESTION_KEY>'
   debug:
     verbosity: normal
 service:
@@ -242,46 +309,53 @@ service:
 
 6. Set the correct endpoint based on your SigNoz cloud region:
 
-   | Region | Endpoint |
-   |--------|----------|
-   | US | ingest.us.signoz.cloud:443 |
-   | IN | ingest.in.signoz.cloud:443 |
-   | EU | ingest.eu.signoz.cloud:443 |
+   | Region | Endpoint                   |
+   | ------ | -------------------------- |
+   | US     | ingest.us.signoz.cloud:443 |
+   | IN     | ingest.in.signoz.cloud:443 |
+   | EU     | ingest.eu.signoz.cloud:443 |
 
 7. Start the collector service:
    ```bash
    .\otelcol-contrib.exe --config .\config.yaml
    ```
 
-
 After completing the setup, you should see your Windows Server hostname appear in the Hosts tab of the [Infrastructure Monitoring](https://signoz.io/guides/infrastructure-monitoring/) section in SigNoz.
 
-<Figure src="/img/guides/2025/03/window-server-monitoring-host-view.webp" alt="Windows Server metrics in SigNoz dashboard" caption="Windows Server Metrics in SigNoz dashboard" />
+<Figure
+  src="/img/guides/2025/03/window-server-monitoring-host-view.webp"
+  alt="Windows Server metrics in SigNoz dashboard"
+  caption="Windows Server Metrics in SigNoz dashboard"
+/>
 
 ## Best Practices for Ongoing Windows Server Monitoring
 
 To ensure your Windows Server monitoring remains effective over time, it's important to adopt a set of best practices that keep your systems running smoothly and your data secure. Here's how to maintain a robust monitoring strategy.
 
-<Figure src="/img/guides/2024/08/windows-server-monitoring-image%208.webp" alt="Best Practices for Ongoing Windows Server Monitoring" caption="Best Practices for Ongoing Windows Server Monitoring" />
+<Figure
+  src="/img/guides/2024/08/windows-server-monitoring-image%208.webp"
+  alt="Best Practices for Ongoing Windows Server Monitoring"
+  caption="Best Practices for Ongoing Windows Server Monitoring"
+/>
 
 1. Regularly Review and Update Monitoring Metrics
-    - Why: Your server environment and business needs evolve, and so should your monitoring metrics.
-    - Example: If your organization launches a new application, ensure your monitoring tool tracks its performance metrics. Over time, you might discover new bottlenecks or areas that need closer observation.
+   - Why: Your server environment and business needs evolve, and so should your monitoring metrics.
+   - Example: If your organization launches a new application, ensure your monitoring tool tracks its performance metrics. Over time, you might discover new bottlenecks or areas that need closer observation.
 2. Automate Routine Tasks
-    - Why: Automation reduces the risk of human error and frees up your IT team for more strategic work.
-    - Example: Use your monitoring tool to automate tasks like disk cleanup, service restarts, or scaling resources during peak times. ManageEngine OpManager's automated workflows can handle these routine tasks seamlessly.
+   - Why: Automation reduces the risk of human error and frees up your IT team for more strategic work.
+   - Example: Use your monitoring tool to automate tasks like disk cleanup, service restarts, or scaling resources during peak times. ManageEngine OpManager's automated workflows can handle these routine tasks seamlessly.
 3. Implement Redundancy and Failover Mechanisms
-    - Why: Redundancy ensures that your monitoring continues uninterrupted even if a server or component fails.
-    - Example: If your primary monitoring server goes down, a secondary server should automatically take over. This prevents any gaps in your monitoring data and ensures continuous coverage.
+   - Why: Redundancy ensures that your monitoring continues uninterrupted even if a server or component fails.
+   - Example: If your primary monitoring server goes down, a secondary server should automatically take over. This prevents any gaps in your monitoring data and ensures continuous coverage.
 4. Monitor Security and Compliance Continuously
-    - Why: [Continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) helps detect and respond to security threats and compliance violations promptly.
-    - Example: Set up real-time monitoring for unauthorized access attempts, unusual traffic patterns, or changes to critical system files. This is especially important in industries like finance or healthcare where compliance is critical.
+   - Why: [Continuous monitoring](https://signoz.io/comparisons/continuous-monitoring-tools/) helps detect and respond to security threats and compliance violations promptly.
+   - Example: Set up real-time monitoring for unauthorized access attempts, unusual traffic patterns, or changes to critical system files. This is especially important in industries like finance or healthcare where compliance is critical.
 5. Leverage Historical Data for Trend Analysis
-    - Why: Historical data helps you identify patterns and trends, enabling proactive management.
-    - Example: Analyzing disk usage trends over the past year might reveal that you need to upgrade storage capacity in the near future. This helps in planning for upgrades before performance issues arise.
+   - Why: Historical data helps you identify patterns and trends, enabling proactive management.
+   - Example: Analyzing disk usage trends over the past year might reveal that you need to upgrade storage capacity in the near future. This helps in planning for upgrades before performance issues arise.
 6. Plan for Scalability
-    - Why: As your organization grows, your monitoring solution should scale to meet increased demand.
-    - Example: If you're expanding into new regions, ensure that your monitoring tool can handle the additional servers and infrastructure without performance degradation. Planning for scalability avoids disruptions as your infrastructure grows.
+   - Why: As your organization grows, your monitoring solution should scale to meet increased demand.
+   - Example: If you're expanding into new regions, ensure that your monitoring tool can handle the additional servers and infrastructure without performance degradation. Planning for scalability avoids disruptions as your infrastructure grows.
 
 By following these practices, you'll be well on your way to maintaining a healthy, high-performing Windows Server environment.
 
@@ -309,4 +383,4 @@ Yes, many modern monitoring tools, including SigNoz, offer integration with clou
 
 ### What are the potential security risks of server monitoring?
 
-While monitoring itself enhances security, improperly secured monitoring tools can pose risks. Ensure your monitoring solution uses encryption, strong authentication, and follows the principle of least privilege to mitigate these risks.
\ No newline at end of file
+While monitoring itself enhances security, improperly secured monitoring tools can pose risks. Ensure your monitoring solution uses encryption, strong authentication, and follows the principle of least privilege to mitigate these risks.
diff --git a/data/guides/zap-logger.mdx b/data/guides/zap-logger.mdx
index ee2e4ef67..74ff59058 100644
--- a/data/guides/zap-logger.mdx
+++ b/data/guides/zap-logger.mdx
@@ -1,148 +1,160 @@
 ---
-
 title: Zap Logger - Complete Guide to Golang Zap Logger
-slug: zap-logger
 date: 2024-07-17
 tags: [logging]
 authors: [eromosele]
 description: This article covers logging in software development using Zap, including installation, setup, log levels, customization, encoding formats, and output destinations. It also delves into advanced techniques, best practices, and compares Zap with other solutions. Finally, it guides setting up Zap logs for Signoz with benefits, setup instructions, configuration steps, example code, and deployment.
 keywords: [log, logging, golang, zap, zap logger, benchmark, structured logging]
-
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Zap Logger - Complete Guide to Golang Zap Logger",
-  "alternativeHeadline": "This article covers logging in software development using Zap, including installation, setup, log levels, customization, encoding formats, and output destinations. It also delves into advanced techniques, best practices, and compares Zap with other solutions. Finally, it guides setting up Zap logs for Signoz with benefits, setup instructions, configuration steps, example code, and deployment.",
-  "author": {
-    "@type": "Person",
-    "name": "Eromosele"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-17T00:00:00Z",
-  "dateModified": "2024-07-17T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/zap-logger/"
-  },
-  "description": "This article covers logging in software development using Zap, including installation, setup, log levels, customization, encoding formats, and output destinations. It also delves into advanced techniques, best practices, and compares Zap with other solutions. Finally, it guides setting up Zap logs for Signoz with benefits, setup instructions, configuration steps, example code, and deployment.",
-  "keywords": ["log", "logging", "golang", "zap", "zap logger", "benchmark", "structured logging"],
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Zap Logger",
-      "description": "Complete guide to using Zap Logger in Golang, including installation, setup, and advanced configurations."
-    },
-    {
-      "@type": "Thing",
-      "name": "Logging",
-      "description": "Techniques and best practices for logging in software development using Zap Logger in Golang."
-    },
-    {
-      "@type": "Thing",
-      "name": "Golang",
-      "description": "Using Zap Logger in Golang for efficient and structured logging."
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Zap",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What is Zap Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Zap Logger is a fast, structured logging library for Go. It provides high-performance logging with support for multiple output formats."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Can Zap Logger be used in a concurrent environment?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, Zap Logger is designed to be safe for concurrent use by multiple goroutines."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I handle log rotation with Zap Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Zap Logger supports log rotation through third-party libraries or by implementing custom solutions using its API."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Is Zap Logger suitable for production use?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, Zap Logger is suitable for production use due to its performance, reliability, and feature set."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "How do I benchmark the performance of Zap Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Use built-in benchmarks or custom benchmarks to measure Zap Logger's performance against your application's requirements."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Can I use Zap Logger with other logging libraries?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Yes, Zap Logger can be used alongside other logging libraries in Go applications."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Where can I find the documentation and examples for Zap Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Documentation and examples for Zap Logger are available on its GitHub repository and the official Uber Engineering Blog."
-        }
-      }
-    ]
-  }
-}) }} />
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Zap Logger - Complete Guide to Golang Zap Logger',
+        alternativeHeadline:
+          'This article covers logging in software development using Zap, including installation, setup, log levels, customization, encoding formats, and output destinations. It also delves into advanced techniques, best practices, and compares Zap with other solutions. Finally, it guides setting up Zap logs for Signoz with benefits, setup instructions, configuration steps, example code, and deployment.',
+        author: {
+          '@type': 'Person',
+          name: 'Eromosele',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-17T00:00:00Z',
+        dateModified: '2024-07-17T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/zap-logger/',
+        },
+        description:
+          'This article covers logging in software development using Zap, including installation, setup, log levels, customization, encoding formats, and output destinations. It also delves into advanced techniques, best practices, and compares Zap with other solutions. Finally, it guides setting up Zap logs for Signoz with benefits, setup instructions, configuration steps, example code, and deployment.',
+        keywords: [
+          'log',
+          'logging',
+          'golang',
+          'zap',
+          'zap logger',
+          'benchmark',
+          'structured logging',
+        ],
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Zap Logger',
+            description:
+              'Complete guide to using Zap Logger in Golang, including installation, setup, and advanced configurations.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Logging',
+            description:
+              'Techniques and best practices for logging in software development using Zap Logger in Golang.',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Golang',
+            description: 'Using Zap Logger in Golang for efficient and structured logging.',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Zap',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is Zap Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Zap Logger is a fast, structured logging library for Go. It provides high-performance logging with support for multiple output formats.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can Zap Logger be used in a concurrent environment?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Zap Logger is designed to be safe for concurrent use by multiple goroutines.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I handle log rotation with Zap Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Zap Logger supports log rotation through third-party libraries or by implementing custom solutions using its API.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Is Zap Logger suitable for production use?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Zap Logger is suitable for production use due to its performance, reliability, and feature set.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'How do I benchmark the performance of Zap Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Use built-in benchmarks or custom benchmarks to measure Zap Logger's performance against your application's requirements.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Can I use Zap Logger with other logging libraries?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Yes, Zap Logger can be used alongside other logging libraries in Go applications.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Where can I find the documentation and examples for Zap Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Documentation and examples for Zap Logger are available on its GitHub repository and the official Uber Engineering Blog.',
+              },
+            },
+          ],
+        },
+      }),
+    }}
+  />
 </head>
 
 Logging is the practice of recording or storing information and messages that provide insights into the behavior and execution of a program.
 
-Zap is a high-performance, structured logging library for Go developed by Uber. 
+Zap is a high-performance, structured logging library for Go developed by Uber.
 
-It is designed to offer both speed and flexibility, making it a popular choice for applications that require efficient logging capabilities without compromising on features. 
+It is designed to offer both speed and flexibility, making it a popular choice for applications that require efficient logging capabilities without compromising on features.
 
 This article will provide an overview of how to use Zap loggers, explore its key features and advanced configurations, and demonstrate how to track logs produced by the Zap logger using Signoz.
 
@@ -161,7 +173,7 @@ To use `zap` in your Go application, you need to install it using `go get` on y
 go get -u go.uber.org/zap
 ```
 
-After installation,  import `zap` into your Go code (if there is an error run `go mod tidy`):
+After installation, import `zap` into your Go code (if there is an error run `go mod tidy`):
 
 ```go
 import (
@@ -171,7 +183,7 @@ import (
 
 ### Basic Usage
 
-Let’s explore an example of using the `zap` package to log events in your application: 
+Let’s explore an example of using the `zap` package to log events in your application:
 
 ```go
 package main
@@ -187,14 +199,19 @@ func main() {
 
     // Log some simple messages
     logger.Info("This is an info message")
- 
+
 }
 ```
 
 Output
 
 ```json
-{"level":"info","ts":1721163003.793889,"caller":"Signoz-Article/main.go:13","msg":"This is an info message"}
+{
+  "level": "info",
+  "ts": 1721163003.793889,
+  "caller": "Signoz-Article/main.go:13",
+  "msg": "This is an info message"
+}
 ```
 
 - `zap.NewProduction()` creates a logger configured for production use, which outputs JSON-formatted logs.
@@ -207,47 +224,26 @@ Output
 Zap supports multiple logging levels, which allow you to control the verbosity of the logs. The logging levels, from most to least verbose, are:
 
 - DEBUG
-    
-    The `Debug` level is the most verbose logging level. It includes detailed information that is useful during development and debugging.
-    
-    Use Case: Use `Debug` logs to output diagnostic information that can help developers understand the flow of execution and the state of variables. 
-    
+  The `Debug` level is the most verbose logging level. It includes detailed information that is useful during development and debugging.
+  Use Case: Use `Debug` logs to output diagnostic information that can help developers understand the flow of execution and the state of variables.
 - INFO
-    
-    The `Info` level is used for informational messages that highlight the progress of the application at a high level.
-    
-    Use Case:Use `Info` logs to record key events in the application's lifecycle, such as startup, shutdown, or significant transactions. 
-    
+  The `Info` level is used for informational messages that highlight the progress of the application at a high level.
+  Use Case:Use `Info` logs to record key events in the application's lifecycle, such as startup, shutdown, or significant transactions.
 - WARN
-    
-    The `Warn` level indicates potentially harmful situations that are not immediately detrimental but might lead to errors if not addressed.
-    
-    Use Case: Use `Warn` logs to highlight issues that are concerning but not critical. This might include deprecated API usage, recoverable errors, or unusual behavior that should be investigated.
-    
+  The `Warn` level indicates potentially harmful situations that are not immediately detrimental but might lead to errors if not addressed.
+  Use Case: Use `Warn` logs to highlight issues that are concerning but not critical. This might include deprecated API usage, recoverable errors, or unusual behavior that should be investigated.
 - ERROR
-    
-    The `Error` level logs error events that might still allow the application to continue running but indicate a failure in a particular operation.
-    
-    Use Case: Use `Error` logs to capture errors that require attention but do not necessarily stop the application from running. 
-    
+  The `Error` level logs error events that might still allow the application to continue running but indicate a failure in a particular operation.
+  Use Case: Use `Error` logs to capture errors that require attention but do not necessarily stop the application from running.
 - DPANIC
-    
-    The `DPanic` level stands for "development panic." In development mode, the logger panics after writing the log message. In production, it behaves like an `Error` level.
-    
-    Use Case: Use `DPanic` logs to capture critical errors that you want to be highly visible during development. 
-    
+  The `DPanic` level stands for "development panic." In development mode, the logger panics after writing the log message. In production, it behaves like an `Error` level.
+  Use Case: Use `DPanic` logs to capture critical errors that you want to be highly visible during development.
 - PANIC
-    
-    The `Panic` level logs a message and then panics, which means it stops the ordinary flow of the program and begins to unwind the stack.
-    
-    Use Case: Use `Panic` logs for critical errors from which the application cannot or should not recover.
-    
+  The `Panic` level logs a message and then panics, which means it stops the ordinary flow of the program and begins to unwind the stack.
+  Use Case: Use `Panic` logs for critical errors from which the application cannot or should not recover.
 - FATAL
-    
-    The `Fatal` level logs a message and then calls `os.Exit(1)`, which immediately terminates the program.
-    
-    Use Case: Use `Fatal` logs for errors that are so severe that the program must immediately terminate.
-    
+  The `Fatal` level logs a message and then calls `os.Exit(1)`, which immediately terminates the program.
+  Use Case: Use `Fatal` logs for errors that are so severe that the program must immediately terminate.
 
 By setting the logging level, you can filter out less important log messages and focus on the ones that matter most for your application.
 
@@ -337,7 +333,12 @@ func main() {
 Output:
 
 ```json
-{"L":"INFO","T":"2024-07-16T22:56:42.529+0100","C":"Signoz-Article/main.go:23","M":"Custom logger initialized"}
+{
+  "L": "INFO",
+  "T": "2024-07-16T22:56:42.529+0100",
+  "C": "Signoz-Article/main.go:23",
+  "M": "Custom logger initialized"
+}
 ```
 
 In this example, we create a custom logger configuration that logs `Info` level messages and above, outputs logs in JSON format to both the console and a file, and directs error messages to `stderr`.
@@ -425,7 +426,12 @@ func main() {
 Output(myapp.log):
 
 ```json
-{"level":"info","ts":1721168784.654409,"caller":"Signoz-Article/main.go:20","msg":"This message will be logged to multiple outputs"}
+{
+  "level": "info",
+  "ts": 1721168784.654409,
+  "caller": "Signoz-Article/main.go:20",
+  "msg": "This message will be logged to multiple outputs"
+}
 ```
 
 In this example, we configure the logger to write logs to both the console and a file located at `/Users/macbook/Desktop/API Project in Go/Signoz-Article/myapp.log`.
@@ -657,7 +663,12 @@ func main() {
 Output:
 
 ```json
-{"level":"info","ts":1721173746.537836,"caller":"Signoz-Article/main.go:15","msg":"Logger initialized successfully"}
+{
+  "level": "info",
+  "ts": 1721173746.537836,
+  "caller": "Signoz-Article/main.go:15",
+  "msg": "Logger initialized successfully"
+}
 ```
 
 Ensuring Log Reliability
@@ -709,7 +720,7 @@ func main() {
 Output (myapp.log):
 
 ```json
-{"level":"info","ts":1721173904.548351,"msg":"Logger with log rotation initialized"}
+{ "level": "info", "ts": 1721173904.548351, "msg": "Logger with log rotation initialized" }
 ```
 
 Using External Log Management Systems
@@ -837,7 +848,11 @@ This Go code sets up a basic HTTP server that logs events to a file (`applicatio
 
 After running your application you should see the following output on `localhost:8080/`:
 
-<Figure src="/img/guides/2024/07/zap-logger-Screenshot_2024-07-01_at_14.15.51.webp" alt="Output after running the Go Application" caption="Output after running the Go Application" /> 
+<Figure
+  src="/img/guides/2024/07/zap-logger-Screenshot_2024-07-01_at_14.15.51.webp"
+  alt="Output after running the Go Application"
+  caption="Output after running the Go Application"
+/>{' '}
 
 Step 3: Setting up the Logs Pipeline in Otel Collector
 
@@ -878,7 +893,7 @@ receivers:
             - targets:
               # - localhost:8888
   filelog/app:
-    include: [ <path-to-log-file> ] #include the full path to your log file
+    include: [<path-to-log-file>] #include the full path to your log file
     start_at: end
 processors:
   batch:
@@ -896,11 +911,11 @@ extensions:
   zpages: {}
 exporters:
   otlp:
-    endpoint: "<https://ingest>.{region}.signoz.cloud:443"
+    endpoint: '<https://ingest>.{region}.signoz.cloud:443'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"
+      'signoz-ingestion-key': '<SIGNOZ_INGESTION_KEY>'
   debug:
     verbosity: normal
 service:
@@ -919,7 +934,11 @@ Step 4: Viewing Logs in SigNoz
 
 After running the above application and making the correct configurations, you can navigate to the SigNoz logs dashboard to see all the logs sent to SigNoz.
 
-<Figure src="/img/guides/2024/07/zap-logger-Screenshot_2024-07-06_at_02.29.06.webp" alt="Signoz Log Output" caption="Signoz Log Output" /> 
+<Figure
+  src="/img/guides/2024/07/zap-logger-Screenshot_2024-07-06_at_02.29.06.webp"
+  alt="Signoz Log Output"
+  caption="Signoz Log Output"
+/>{' '}
 
 ## Conclusion
 
diff --git a/data/guides/zerolog-golang.mdx b/data/guides/zerolog-golang.mdx
index aec5c092c..b4aa44bbf 100644
--- a/data/guides/zerolog-golang.mdx
+++ b/data/guides/zerolog-golang.mdx
@@ -1,164 +1,166 @@
 ---
-
-title: Zerolog Golang - Complete Guide to Logging 
-slug: zerolog-golang
+title: Zerolog Golang - Complete Guide to Logging
 date: 2024-07-11
 tags: [logging]
 authors: [eromosele]
 description: The article guides on using Zerolog, a high-performance Go logging library. It covers installation, usage, log levels, context, prettifying logs, sampling, and integration with web apps.
 keywords: [log, logging, golang, zap, zerolog, sampling, pretty logging]
-
 ---
 
 <head>
-<script
+  <script
     type="application/ld+json"
-    dangerouslySetInnerHTML={{ __html: JSON.stringify({
-  "@context": "https://schema.org",
-  "@type": "TechArticle",
-  "headline": "Zerolog Golang - Complete Guide to Logging",
-  "alternativeHeadline": "Master Golang logging with Zerolog - Learn setup, configuration, and advanced features for efficient, structured logging",
-  "author": {
-    "@type": "Person",
-    "name": "Eromosele"
-  },
-  "publisher": {
-    "@type": "Organization",
-    "name": "SigNoz",
-    "logo": {
-      "@type": "ImageObject",
-      "url": "https://signoz.io/img/SigNozLogo-orange.svg"
-    }
-  },
-  "datePublished": "2024-07-11T00:00:00Z",
-  "dateModified": "2024-07-11T00:00:00Z",
-  "mainEntityOfPage": {
-    "@type": "WebPage",
-    "@id": "https://signoz.io/guides/zerolog-golang/"
-  },
-  "description": "The article guides on using Zerolog, a high-performance Go logging library. It covers installation, usage, log levels, context, prettifying logs, sampling, and integration with web apps.",
-  "keywords": "log, logging, golang, zap, zerolog, sampling, pretty logging",
-  "articleSection": "Technology",
-  "inLanguage": "en",
-  "isPartOf": {
-    "@type": "Blog",
-    "name": "SigNoz Blog",
-    "url": "https://signoz.io/blog/"
-  },
-  "about": [
-    {
-      "@type": "Thing",
-      "name": "Zerolog",
-      "description": "A high-performance, zero-allocation logging library for Go"
-    },
-    {
-      "@type": "Thing",
-      "name": "Golang",
-      "description": "A statically typed, compiled programming language developed by Google"
-    },
-    {
-      "@type": "Thing",
-      "name": "Structured Logging",
-      "description": "A logging approach that treats log entries as data structures rather than plain text"
-    }
-  ],
-  "mentions": [
-    {
-      "@type": "SoftwareApplication",
-      "name": "Zerolog",
-      "applicationCategory": "Logging Library"
-    },
-    {
-      "@type": "SoftwareApplication",
-      "name": "SigNoz",
-      "applicationCategory": "Observability Platform"
-    }
-  ],
-  "mainEntity": {
-    "@type": "FAQPage",
-    "mainEntity": [
-      {
-        "@type": "Question",
-        "name": "What is Zerolog?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Zerolog is a high-performance, structured logging library for Go. It is designed to provide efficient and fast logging by using a simple interface and outputting logs in JSON format. Zerolog's focus on performance makes it suitable for applications requiring minimal overhead in their logging operations."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is Structured Logging?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Structured logging refers to the practice of logging data in a consistent, structured format, usually in JSON. This format allows logs to be easily parsed and analyzed by various tools, facilitating better monitoring, debugging, and analysis. Structured logs include key-value pairs that provide more context and are machine-readable, making automated processing and querying more effective."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "What is the Difference Between Zerolog and Zap Logger?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "Both Zerolog and Zap Logger are popular logging libraries in the Go ecosystem, but they have key differences. Zerolog is known for its zero-allocation logging, making it extremely fast and efficient. It has a simpler, more minimalistic API focused on ease of use and minimal overhead. Zap offers more configurability and flexibility with features like structured logging and logging levels, and provides more advanced features out-of-the-box."
-        }
-      },
-      {
-        "@type": "Question",
-        "name": "Which Logger is Best in Golang?",
-        "acceptedAnswer": {
-          "@type": "Answer",
-          "text": "The 'best' logger in Golang depends on the specific requirements of your project. For performance, Zerolog is typically preferred for its zero-allocation and high-performance characteristics, making it ideal for applications where logging overhead needs to be minimized. For flexibility and features, Zap Logger is a strong choice if you need a more feature-rich logging library with advanced capabilities and configurability."
-        }
-      }
-    ]
-  },
-  "tutorial": {
-    "@type": "HowTo",
-    "name": "How to Use Zerolog in Golang",
-    "step": [
-      {
-        "@type": "HowToStep",
-        "name": "Install Zerolog",
-        "text": "Install Zerolog using go get -u github.com/rs/zerolog"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Import Zerolog",
-        "text": "Import Zerolog in your Go code: import 'github.com/rs/zerolog/log'"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Initialize Logger",
-        "text": "Initialize a Zerolog logger with desired configuration"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Set Log Levels",
-        "text": "Configure log levels to control the verbosity of logs"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Add Context to Logs",
-        "text": "Use methods like With() to add context to your logs"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Implement Log Sampling",
-        "text": "Use Zerolog's sampling features to control log volume"
-      },
-      {
-        "@type": "HowToStep",
-        "name": "Integrate with SigNoz",
-        "text": "Set up SigNoz and configure Zerolog to send logs to SigNoz for centralized monitoring"
-      }
-    ]
-  }
-}) }}
+    dangerouslySetInnerHTML={{
+      __html: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'TechArticle',
+        headline: 'Zerolog Golang - Complete Guide to Logging',
+        alternativeHeadline:
+          'Master Golang logging with Zerolog - Learn setup, configuration, and advanced features for efficient, structured logging',
+        author: {
+          '@type': 'Person',
+          name: 'Eromosele',
+        },
+        publisher: {
+          '@type': 'Organization',
+          name: 'SigNoz',
+          logo: {
+            '@type': 'ImageObject',
+            url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+          },
+        },
+        datePublished: '2024-07-11T00:00:00Z',
+        dateModified: '2024-07-11T00:00:00Z',
+        mainEntityOfPage: {
+          '@type': 'WebPage',
+          '@id': 'https://signoz.io/guides/zerolog-golang/',
+        },
+        description:
+          'The article guides on using Zerolog, a high-performance Go logging library. It covers installation, usage, log levels, context, prettifying logs, sampling, and integration with web apps.',
+        keywords: 'log, logging, golang, zap, zerolog, sampling, pretty logging',
+        articleSection: 'Technology',
+        inLanguage: 'en',
+        isPartOf: {
+          '@type': 'Blog',
+          name: 'SigNoz Blog',
+          url: 'https://signoz.io/blog/',
+        },
+        about: [
+          {
+            '@type': 'Thing',
+            name: 'Zerolog',
+            description: 'A high-performance, zero-allocation logging library for Go',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Golang',
+            description: 'A statically typed, compiled programming language developed by Google',
+          },
+          {
+            '@type': 'Thing',
+            name: 'Structured Logging',
+            description:
+              'A logging approach that treats log entries as data structures rather than plain text',
+          },
+        ],
+        mentions: [
+          {
+            '@type': 'SoftwareApplication',
+            name: 'Zerolog',
+            applicationCategory: 'Logging Library',
+          },
+          {
+            '@type': 'SoftwareApplication',
+            name: 'SigNoz',
+            applicationCategory: 'Observability Platform',
+          },
+        ],
+        mainEntity: {
+          '@type': 'FAQPage',
+          mainEntity: [
+            {
+              '@type': 'Question',
+              name: 'What is Zerolog?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "Zerolog is a high-performance, structured logging library for Go. It is designed to provide efficient and fast logging by using a simple interface and outputting logs in JSON format. Zerolog's focus on performance makes it suitable for applications requiring minimal overhead in their logging operations.",
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is Structured Logging?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Structured logging refers to the practice of logging data in a consistent, structured format, usually in JSON. This format allows logs to be easily parsed and analyzed by various tools, facilitating better monitoring, debugging, and analysis. Structured logs include key-value pairs that provide more context and are machine-readable, making automated processing and querying more effective.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'What is the Difference Between Zerolog and Zap Logger?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: 'Both Zerolog and Zap Logger are popular logging libraries in the Go ecosystem, but they have key differences. Zerolog is known for its zero-allocation logging, making it extremely fast and efficient. It has a simpler, more minimalistic API focused on ease of use and minimal overhead. Zap offers more configurability and flexibility with features like structured logging and logging levels, and provides more advanced features out-of-the-box.',
+              },
+            },
+            {
+              '@type': 'Question',
+              name: 'Which Logger is Best in Golang?',
+              acceptedAnswer: {
+                '@type': 'Answer',
+                text: "The 'best' logger in Golang depends on the specific requirements of your project. For performance, Zerolog is typically preferred for its zero-allocation and high-performance characteristics, making it ideal for applications where logging overhead needs to be minimized. For flexibility and features, Zap Logger is a strong choice if you need a more feature-rich logging library with advanced capabilities and configurability.",
+              },
+            },
+          ],
+        },
+        tutorial: {
+          '@type': 'HowTo',
+          name: 'How to Use Zerolog in Golang',
+          step: [
+            {
+              '@type': 'HowToStep',
+              name: 'Install Zerolog',
+              text: 'Install Zerolog using go get -u github.com/rs/zerolog',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Import Zerolog',
+              text: "Import Zerolog in your Go code: import 'github.com/rs/zerolog/log'",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Initialize Logger',
+              text: 'Initialize a Zerolog logger with desired configuration',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Set Log Levels',
+              text: 'Configure log levels to control the verbosity of logs',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Add Context to Logs',
+              text: 'Use methods like With() to add context to your logs',
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Implement Log Sampling',
+              text: "Use Zerolog's sampling features to control log volume",
+            },
+            {
+              '@type': 'HowToStep',
+              name: 'Integrate with SigNoz',
+              text: 'Set up SigNoz and configure Zerolog to send logs to SigNoz for centralized monitoring',
+            },
+          ],
+        },
+      }),
+    }}
   />
 </head>
 
 Logging is the practice of recording or storing information and messages that provide insights into the behavior and execution of a program.
 
-Zerolog is a high-performance, zero-allocation logging library tailored for the Go programming language. Engineered for speed and efficiency, it is particularly suited for latency-sensitive applications where minimizing garbage collection is crucial. 
+Zerolog is a high-performance, zero-allocation logging library tailored for the Go programming language. Engineered for speed and efficiency, it is particularly suited for latency-sensitive applications where minimizing garbage collection is crucial.
 
 Zerolog empowers developers with [structured logging](https://signoz.io/blog/structured-logs/) capabilities, enabling detailed and organized logs with minimal performance overhead. This guide delves into using the Zerolog package for logging, explores its key features, and provides insights into integrating Zerolog seamlessly with web applications.
 
@@ -177,7 +179,7 @@ To use `zerolog` in your Go application, you need to install it using `go get`
 go get -u github.com/rs/zerolog
 ```
 
-After installation,  import `zerolog` into your Go code (if there is an error run `go mod tidy`):
+After installation, import `zerolog` into your Go code (if there is an error run `go mod tidy`):
 
 ```go
 import (
@@ -235,33 +237,19 @@ Understanding Log Levels
 Log levels in Zerolog and other logging frameworks typically consist of standard levels, each representing varying severity levels of events alongside their corresponding integer priority values:
 
 - TRACE(-1): The most detailed level. Used for tracing the flow through the application, providing fine-grained details. Typically not enabled in production due to its verbosity.
-    
-    Use Case: Trace code and explain behavior, frequently with step-by-step execution.
-    
+  Use Case: Trace code and explain behavior, frequently with step-by-step execution.
 - DEBUG(0): Used for debugging information that is useful during development but may not be needed in production. This level often includes detailed information about the application's state.
-    
-    Use Case: Diagnosing a complex issue by logging detailed information about the application's state.
-    
+  Use Case: Diagnosing a complex issue by logging detailed information about the application's state.
 - INFO(1): Provides information messages that highlight the progress of the application at a higher level. This level is often used to record major lifecycle events or significant state changes.
-    
-    Use Case: Log significant events like service starts, user logins, and transactions.
-    
+  Use Case: Log significant events like service starts, user logins, and transactions.
 - WARN(2): Indicates potential issues or anomalies that are not necessarily errors but might require attention. It alerts developers to situations that may lead to problems if not addressed.
-    
-    Use Case: Log anomalies that might need attention but are not errors, like slow responses or deprecated API use.
-    
+  Use Case: Log anomalies that might need attention but are not errors, like slow responses or deprecated API use.
 - ERROR(3): Logs errors that occurred during the execution of the application. These messages indicate problems that need immediate attention but do not necessarily stop the application from functioning.
-    
-    Use Case: Log errors that need immediate attention but don't stop the application, such as failed operations.
-    
+  Use Case: Log errors that need immediate attention but don't stop the application, such as failed operations.
 - FATAL(4): The highest severity level, indicating critical errors that cause the application to terminate abruptly. These errors typically require immediate intervention.
-    
-    Use Case: Log critical errors that cause the application to terminate.
-    
+  Use Case: Log critical errors that cause the application to terminate.
 - PANIC(5): Logs indicate a critical and unexpected situation where the program cannot safely continue, leading to a panic. These logs capture the application's state just before termination, crucial for debugging the issue.
-    
-    Use Case: Log the state just before a panic for post-mortem analysis.
-    
+  Use Case: Log the state just before a panic for post-mortem analysis.
 
 You can set the minimum log level for a custom Logger using the `Level()` method. You can either use the integer values (e.g., -1 for TRACE, 0 for DEBUG) or the predefined constants from the zerolog package (e.g., `zerolog.TraceLevel`, `zerolog.DebugLevel`).
 
@@ -305,7 +293,7 @@ exit status 1
 
 ### Logger
 
-A logger is a tool used to record and manage log messages throughout the execution of an application. 
+A logger is a tool used to record and manage log messages throughout the execution of an application.
 
 The `github.com/rs/zerolog/log` package offers a preconfigured and universally accessible logger that can be imported and utilized. By default, this global logger logs to standard error and is initially set to log at the TRACE level. However, you can adjust the minimum logging level using the `SetGlobalLevel()` function from the main `zerolog` package.
 
@@ -442,7 +430,7 @@ func main() {
         Str("app_version", "1.0.0").
         Str("environment", "production").
         Logger()
-    
+
     // Replace the global logger with the new logger that has global context
     log.Logger = logger
 
@@ -485,7 +473,12 @@ func main() {
 Output:
 
 ```json
-{"level":"warn","Environment":"Production","time":"2024-07-05T16:41:49+01:00","message":"Excessive disk usage"}
+{
+  "level": "warn",
+  "Environment": "Production",
+  "time": "2024-07-05T16:41:49+01:00",
+  "message": "Excessive disk usage"
+}
 ```
 
 `.With` is used during logger initialization to establish static context fields, while`.UpdateContext` is employed to adjust or add context fields dynamically throughout the application's lifecycle.
@@ -529,8 +522,11 @@ func main() {
 
 Output
 
-<Figure src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-05_at_17.10.30.webp" alt="Output of the application" caption="Output of the application" />
-
+<Figure
+  src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-05_at_17.10.30.webp"
+  alt="Output of the application"
+  caption="Output of the application"
+/>
 
 Using `ConsoleWriter`, you can also customize the appearance of the output:
 
@@ -598,7 +594,7 @@ NOTE: It's important to note that `ConsoleWriter` is primarily intended for deve
 
 ### Log Sampling
 
-Logging in applications can generate a significant volume of data, especially in high-traffic environments. Log sampling involves selecting a subset of log messages to record based on predefined criteria such as time intervals, random selection, or specific conditions. 
+Logging in applications can generate a significant volume of data, especially in high-traffic environments. Log sampling involves selecting a subset of log messages to record based on predefined criteria such as time intervals, random selection, or specific conditions.
 
 - Basic Sampler: Basic Sampling allows you to log only a fixed percentage of events. This is useful when you want to reduce the amount of log data but still retain a representative sample. With basic sampling, you specify the frequency with which log messages should be recorded. For example, if you set `N` to 2, only one out of every 2 log messages will be recorded.
 
@@ -684,7 +680,7 @@ The logger is configured with a `BurstSampler` that logs 5 messages in a burst
 
 Running this code will result in 5 messages being logged immediately, then a 10-second pause, and then another 5 messages being logged.
 
-- Level Sampler:  The Level Sampler allows you to specify different sampling rates for different log levels. This is useful when you want to have detailed logging at lower levels (like DEBUG) but less frequent logging at higher levels (like INFO or WARN).
+- Level Sampler: The Level Sampler allows you to specify different sampling rates for different log levels. This is useful when you want to have detailed logging at lower levels (like DEBUG) but less frequent logging at higher levels (like INFO or WARN).
 
 ```go
 package main
@@ -900,7 +896,7 @@ Here's an example using `lumberjack` to implement log rotation:
 package main
 
 import (
- 
+
 
     "github.com/natefinch/lumberjack"
     "github.com/rs/zerolog"
@@ -936,7 +932,7 @@ Output(`app.log` ):
 
 Implementing logging in your Golang application with zerolog is just the first step. To truly leverage the power of logs, sending them to an observability platform like SigNoz can provide numerous benefits, let’s see how to setup SigNoz:
 
-### Using the  Zerolog Package to Send Logs to Signoz:
+### Using the Zerolog Package to Send Logs to Signoz:
 
 Step 1: Setting up Signoz in your Environment:
 
@@ -1017,8 +1013,11 @@ This Go code sets up a basic HTTP server that logs events to a file (`applicatio
 
 After running your application you should see the following output on `localhost:8080/`:
 
-<Figure src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-01_at_14.15.51.webp" alt="Output after running the Go Application" caption="Output after running the Go Application" />
-
+<Figure
+  src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-01_at_14.15.51.webp"
+  alt="Output after running the Go Application"
+  caption="Output after running the Go Application"
+/>
 
 Step 3: Setting up the Logs Pipeline in Otel Collector
 
@@ -1059,7 +1058,7 @@ receivers:
             - targets:
               # - localhost:8888
   filelog/app:
-    include: [ <path-to-log-file> ] #include the full path to your log file
+    include: [<path-to-log-file>] #include the full path to your log file
     start_at: end
 processors:
   batch:
@@ -1077,11 +1076,11 @@ extensions:
   zpages: {}
 exporters:
   otlp:
-    endpoint: "<https://ingest>.{region}.signoz.cloud:443"
+    endpoint: '<https://ingest>.{region}.signoz.cloud:443'
     tls:
       insecure: false
     headers:
-      "signoz-ingestion-key": "<SIGNOZ_INGESTION_KEY>"
+      'signoz-ingestion-key': '<SIGNOZ_INGESTION_KEY>'
   debug:
     verbosity: normal
 service:
@@ -1100,21 +1099,24 @@ Step 4: Viewing Logs in SigNoz
 
 After running the above application and making the correct configurations, you can navigate to the [SigNoz](https://signoz.io/docs/introduction/) logs dashboard to see all the logs sent to SigNoz.
 
-<Figure src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-06_at_02.29.06.webp" alt="Signoz Log Output" caption="Signoz Log Output" />
- 
+<Figure
+  src="/img/guides/2024/07/zerolog-golang-Screenshot_2024-07-06_at_02.29.06.webp"
+  alt="Signoz Log Output"
+  caption="Signoz Log Output"
+/>
 
 ## Conclusion
 
 - Zerolog Overview and Prerequisites: Zerolog provides a highly performant logging solution with minimal overhead, suitable for high-throughput applications. Before getting started, ensure you have the required tools, including Go installed on your system.
 - Getting Started with Zerolog: Installing and setting up Zerolog is straightforward. Basic usage involves simple installation commands and initializing the logger for immediate use.
 - Core Features of Zerolog:
-    - Logger Initialization and Configuration: Properly initializing and configuring the global logger is crucial for maintaining consistent logging behavior across your application.
-    - Log Levels: Understanding and setting log levels allows you to control the verbosity of your logs, ensuring that only relevant information is logged.
-    - Adding Context to Logs: Adding context to your logs, whether through event-specific context or global context, provides more detailed and meaningful log messages.
-    - Prettifying Logs: Using the ConsoleWriter for prettier log output during development can improve readability and debugging efficiency.
-    - Log Sampling: Implementing log sampling techniques, including basic, burst, and advanced sampling, helps manage log volume and performance.
-    - Zerolog Hooks: Hooks offer a way to extend logging functionality, allowing for custom actions to be triggered on log events.
-    - Customizing Log Output: Configuring Zerolog to write logs to files or external systems and implementing rotating log files ensures persistent and organized log storage.
+  - Logger Initialization and Configuration: Properly initializing and configuring the global logger is crucial for maintaining consistent logging behavior across your application.
+  - Log Levels: Understanding and setting log levels allows you to control the verbosity of your logs, ensuring that only relevant information is logged.
+  - Adding Context to Logs: Adding context to your logs, whether through event-specific context or global context, provides more detailed and meaningful log messages.
+  - Prettifying Logs: Using the ConsoleWriter for prettier log output during development can improve readability and debugging efficiency.
+  - Log Sampling: Implementing log sampling techniques, including basic, burst, and advanced sampling, helps manage log volume and performance.
+  - Zerolog Hooks: Hooks offer a way to extend logging functionality, allowing for custom actions to be triggered on log events.
+  - Customizing Log Output: Configuring Zerolog to write logs to files or external systems and implementing rotating log files ensures persistent and organized log storage.
 - Integration with Web Applications: Zerolog seamlessly integrates with web applications, enhancing logging capabilities in a web context.
 - Tracking Logs Using SigNoz: SigNoz provides an efficient solution for tracking and analyzing logs. Integrating Zerolog with SigNoz involves setting up the environment, configuring the logging package, and sending logs for comprehensive monitoring and analysis.
 
diff --git a/layouts/CaseStudyLayout.tsx b/layouts/CaseStudyLayout.tsx
index 97d492027..5e62b4888 100644
--- a/layouts/CaseStudyLayout.tsx
+++ b/layouts/CaseStudyLayout.tsx
@@ -4,7 +4,8 @@ import { ReactNode } from 'react'
 import { CoreContent } from 'pliny/utils/contentlayer'
 import PageTitle from '@/components/PageTitle'
 import React from 'react'
-import { CaseStudy } from '../.contentlayer/generated'
+// import { CaseStudy } from '../.contentlayer/generated'
+import { MDXContent } from '@/utils/strapi'
 
 export interface tocItemProps {
   url: string
@@ -13,7 +14,7 @@ export interface tocItemProps {
 }
 
 interface CaseStudyLayoutProps {
-  content: CoreContent<CaseStudy>
+  content: CoreContent<MDXContent>
   children: ReactNode
   toc: tocItemProps[]
 }
diff --git a/layouts/FAQLayout.tsx b/layouts/FAQLayout.tsx
index 9e357041f..38ae4ebd5 100644
--- a/layouts/FAQLayout.tsx
+++ b/layouts/FAQLayout.tsx
@@ -31,15 +31,25 @@ interface LayoutProps {
   children: ReactNode
   toc: tocItemProps[]
   relatedArticles?: RelatedArticleProps[]
+  tags: string[]
 }
 
-export default function FAQLayout({ content, authors, children, toc }: LayoutProps) {
-  const { slug, date, title, tags, readingTime, relatedArticles } = content
+export default function FAQLayout({
+  content,
+  authors,
+  children,
+  toc,
+  tags,
+  relatedArticles,
+}: LayoutProps) {
+  const { slug, date, title, readingTime } = content
   const mainRef = useRef<HTMLElement | null>(null)
   const [isTocVisible, setIsTocVisible] = useState(true)
   const lastScrollY = useRef(0)
   const scrollDirection = useRef<'up' | 'down'>('up')
 
+  console.log(content, tags, authors)
+
   useEffect(() => {
     const handleScroll = () => {
       const currentScrollY = window.scrollY
@@ -103,7 +113,7 @@ export default function FAQLayout({ content, authors, children, toc }: LayoutPro
               {children}
             </article>
             <div className="my-8">
-              <div className="bg-gradient-to-r from-gray-800 to-gray-900 rounded-xl pt-8 pb-4 px-8 shadow-lg hover:shadow-xl transition-all duration-300 ease-in-out transform hover:-translate-y-1">
+              <div className="transform rounded-xl bg-gradient-to-r from-gray-800 to-gray-900 px-8 pb-4 pt-8 shadow-lg transition-all duration-300 ease-in-out hover:-translate-y-1 hover:shadow-xl">
                 <GetStartedSigNoz />
               </div>
             </div>
@@ -113,8 +123,6 @@ export default function FAQLayout({ content, authors, children, toc }: LayoutPro
           <RelatedArticles relatedArticles={relatedArticles} />
         )}
       </SectionContainer>
-
-      
     </main>
   )
 }
diff --git a/layouts/ListLayoutWithTags.tsx b/layouts/ListLayoutWithTags.tsx
index 031d94de4..b83944d04 100644
--- a/layouts/ListLayoutWithTags.tsx
+++ b/layouts/ListLayoutWithTags.tsx
@@ -5,7 +5,7 @@ import { usePathname } from 'next/navigation'
 import { slug } from 'github-slugger'
 import { formatDate } from 'pliny/utils/formatDate'
 import { CoreContent } from 'pliny/utils/contentlayer'
-import type { Blog, Doc, Guide, Opentelemetry } from 'contentlayer/generated'
+import type { Blog, Doc, Opentelemetry } from 'contentlayer/generated'
 import Link from '@/components/Link'
 import Tag from '@/components/Tag'
 import Button from '@/components/Button/Button'
@@ -17,9 +17,9 @@ interface PaginationProps {
   currentPage: number
 }
 interface ListLayoutProps {
-  posts: CoreContent<Blog | Doc | Opentelemetry | Guide>[]
+  posts: CoreContent<Blog | Doc | Opentelemetry>[]
   title: string
-  initialDisplayPosts?: CoreContent<Blog | Doc | Opentelemetry | Guide>[]
+  initialDisplayPosts?: CoreContent<Blog | Doc | Opentelemetry>[]
   pagination?: PaginationProps
   emptyMessage?: string
 }
diff --git a/lib/rssFeed.js b/lib/rssFeed.js
new file mode 100644
index 000000000..bb2adbc14
--- /dev/null
+++ b/lib/rssFeed.js
@@ -0,0 +1,74 @@
+import { escape } from 'pliny/utils/htmlEscaper.js'
+
+const DEFAULT_COLLECTION_PATH = 'blog'
+export const DEFAULT_RSS_PAGE = 'feed.xml'
+
+const sourcePathToCollection = (sourcePath) => {
+  if (!sourcePath) return DEFAULT_COLLECTION_PATH
+
+  if (sourcePath.startsWith('docs/')) return 'docs'
+  if (sourcePath.startsWith('comparisons/')) return 'comparisons'
+  if (sourcePath.startsWith('guides/')) return 'guides'
+  if (sourcePath.startsWith('opentelemetry/')) return 'opentelemetry'
+  if (sourcePath.startsWith('faqs/')) return ''
+
+  return DEFAULT_COLLECTION_PATH
+}
+
+export const resolvePostUrlPath = (post) => {
+  const sourcePath = post?._raw?.sourceFilePath ?? post?.slug ?? ''
+  return sourcePathToCollection(sourcePath)
+}
+
+export const generateRssItem = (config, post) => {
+  const urlPath = resolvePostUrlPath(post)
+
+  return `
+  <item>
+    <guid>${config.siteUrl}${urlPath?.length > 0 ? `/${urlPath}/` : '/'}${post.slug}</guid>
+    <title>${escape(post.title)}</title>
+    <link>${config.siteUrl}${urlPath?.length > 0 ? `/${urlPath}/` : '/'}${post.slug}</link>
+    ${post.summary || post.description ? `<description>${escape(post.summary || post.description)}</description>` : ''}
+    <pubDate>${new Date(post.date).toUTCString()}</pubDate>
+    <author>${config.email} (${config.author})</author>
+    ${post.tags ? post.tags.map((t) => (typeof t === 'string' ? `<category>${t}</category>` : `<category>${t.value}</category>`)).join('') : ''}
+  </item>
+`
+}
+
+export const generateRss = (config, posts, page = DEFAULT_RSS_PAGE) => {
+  const publishedPosts = Array.isArray(posts) ? posts.filter((post) => post) : []
+
+  if (publishedPosts.length === 0) {
+    return `
+  <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+    <channel>
+      <title>${escape(config.title)}</title>
+      <link>${config.siteUrl}/blog</link>
+      <description>${escape(config.description)}</description>
+      <language>${config.language}</language>
+      <managingEditor>${config.email} (${config.author})</managingEditor>
+      <webMaster>${config.email} (${config.author})</webMaster>
+      <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+      <atom:link href="${config.siteUrl}/${page}" rel="self" type="application/rss+xml"/>
+    </channel>
+  </rss>
+`
+  }
+
+  return `
+  <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+    <channel>
+      <title>${escape(config.title)}</title>
+      <link>${config.siteUrl}/blog</link>
+      <description>${escape(config.description)}</description>
+      <language>${config.language}</language>
+      <managingEditor>${config.email} (${config.author})</managingEditor>
+      <webMaster>${config.email} (${config.author})</webMaster>
+      <lastBuildDate>${new Date(publishedPosts[0].date).toUTCString()}</lastBuildDate>
+      <atom:link href="${config.siteUrl}/${page}" rel="self" type="application/rss+xml"/>
+      ${publishedPosts.map((post) => generateRssItem(config, post)).join('')}
+    </channel>
+  </rss>
+`
+}
diff --git a/package.json b/package.json
index 67a2fd404..f4edb7481 100644
--- a/package.json
+++ b/package.json
@@ -45,6 +45,7 @@
     "next": "14.2.32",
     "next-contentlayer2": "0.5.5",
     "next-image-zoom": "^1.1.7",
+    "next-mdx-remote": "^5.0.0",
     "next-themes": "^0.3.0",
     "pliny": "0.4.1",
     "postcss": "^8.5.0",
diff --git a/scripts/generateIndexes.mjs b/scripts/generateIndexes.mjs
index dbb3c8223..4cd4b2dd1 100644
--- a/scripts/generateIndexes.mjs
+++ b/scripts/generateIndexes.mjs
@@ -3,12 +3,14 @@ import siteMetadata from '../data/siteMetadata.js'
 import {
   allBlogs,
   allDocs,
-  allComparisons,
-  allGuides,
+  // allComparisons,
+  // allGuides,
   allOpentelemetries,
 } from '../.contentlayer/generated/index.mjs'
 import { allCoreContent, sortPosts } from 'pliny/utils/contentlayer.js'
 
+// TODO: Add FAQs, Comparisons, Case Studies, Guides handling to the search indexes
+
 function createSearchIndex(content) {
   if (
     siteMetadata?.search?.provider === 'kbar' &&
@@ -28,8 +30,8 @@ function createSearchIndex(content) {
 const searchIndexes = () => {
   createSearchIndex([
     ...allBlogs,
-    ...allComparisons,
-    ...allGuides,
+    // ...allComparisons,
+    // ...allGuides,
     ...allOpentelemetries,
     ...allDocs,
   ])
diff --git a/scripts/rss.mjs b/scripts/rss.mjs
index f3bed7e34..c47c6d58e 100644
--- a/scripts/rss.mjs
+++ b/scripts/rss.mjs
@@ -7,13 +7,14 @@ import tagData from '../app/tag-data.json' assert { type: 'json' }
 import {
   allBlogs,
   allDocs,
-  allComparisons,
-  allGuides,
+  // allComparisons,
+  // allGuides,
   allOpentelemetries,
-  allFAQs,
 } from '../.contentlayer/generated/index.mjs'
 import { sortPosts } from 'pliny/utils/contentlayer.js'
 
+// TODO: Add FAQs, Comparisons, Case Studies, Guides handling to the RSS feed
+
 const generateRssItem = (config, post) => {
   let urlPath = 'blog'
   if (post._raw.sourceFilePath.startsWith('docs/')) urlPath = 'docs'
@@ -71,7 +72,7 @@ async function generateRSS(config, allBlogs, page = 'feed.xml') {
 }
 
 const rss = () => {
-  generateRSS(siteMetadata, [...allBlogs, ...allComparisons, ...allGuides, ...allOpentelemetries, ...allDocs, ...allFAQs])
+  generateRSS(siteMetadata, [...allBlogs, ...allOpentelemetries, ...allDocs])
   console.log('RSS feed generated...')
 }
 
diff --git a/scripts/sync-content-to-strapi.js b/scripts/sync-content-to-strapi.js
new file mode 100644
index 000000000..f2b596308
--- /dev/null
+++ b/scripts/sync-content-to-strapi.js
@@ -0,0 +1,819 @@
+const fs = require('fs')
+const matter = require('gray-matter')
+const axios = require('axios')
+
+// Configuration
+const CMS_API_URL = process.env.CMS_API_URL
+const CMS_API_TOKEN = process.env.CMS_API_TOKEN
+const SYNC_FOLDERS = JSON.parse(process.env.SYNC_FOLDERS)
+const DEPLOYMENT_STATUS = process.env.DEPLOYMENT_STATUS
+const CHANGED_FILES = JSON.parse(process.env.CHANGED_FILES || '[]')
+const DELETED_FILES = JSON.parse(process.env.DELETED_FILES || '[]')
+
+// Strapi Collection Type Schemas
+const COLLECTION_SCHEMAS = {
+  faqs: {
+    apiPath: 'api::faq.faq',
+    endpoint: 'faqs',
+    fields: ['title', 'description', 'date', 'path', 'content', 'deployment_status'],
+    relations: {
+      authors: {
+        endpoint: 'authors',
+        matchField: 'key', // Match against author.key
+        frontmatterField: 'authors', // Array of author keys in frontmatter
+      },
+      tags: {
+        endpoint: 'tags',
+        matchField: 'key', // Match against tag.key
+        frontmatterField: 'tags', // Array of tag values in frontmatter
+        filterKey: true, // Also check if tag.key contains 'faq' or 'faqs'
+        matchValue: true, // Match against tag.value (case insensitive)
+      },
+      related_faqs: {
+        endpoint: 'faqs',
+        matchField: 'path', // Match against faq.path
+        frontmatterField: 'related_faqs', // Array of FAQ paths in frontmatter
+      },
+    },
+  },
+  'case-study': {
+    apiPath: 'api::case-study.case-study',
+    endpoint: 'case-studies',
+    fields: ['title', 'description', 'image', 'path', 'content', 'deployment_status'],
+    relations: {
+      authors: {
+        endpoint: 'authors',
+        matchField: 'key', // Match against author.key
+        frontmatterField: 'authors', // Array of author keys in frontmatter
+      },
+    },
+  },
+  comparisons: {
+    apiPath: 'api::comparison.comparison',
+    endpoint: 'comparisons',
+    fields: ['title', 'description', 'image', 'path', 'content', 'deployment_status'],
+    relations: {
+      authors: {
+        endpoint: 'authors',
+        matchField: 'key', // Match against author.key
+        frontmatterField: 'authors', // Array of author keys in frontmatter
+      },
+      tags: {
+        endpoint: 'tags',
+        matchField: 'key', // Match against tag.key
+        frontmatterField: 'tags', // Array of tag values in frontmatter
+        filterKey: true, // Also check if tag.key contains 'faq' or 'faqs'
+        matchValue: true, // Match against tag.value (case insensitive)
+      },
+      related_comparisons: {
+        endpoint: 'comparisons',
+        matchField: 'path', // Match against comparison.path
+        frontmatterField: 'related_comparisons', // Array of comparison paths in frontmatter
+      },
+      keywords: {
+        endpoint: 'keywords',
+        matchField: 'key', // Match against keyword.key
+        frontmatterField: 'keywords', // Array of keyword values in frontmatter
+        filterKey: true, // Also check if keyword.key contains 'comparison' or 'comparisons'
+        matchValue: true, // Match against keyword.value (case insensitive)
+      },
+    },
+  },
+  guides: {
+    apiPath: 'api::guide.guide',
+    endpoint: 'guides',
+    fields: ['title', 'description', 'image', 'path', 'content', 'deployment_status', 'date'],
+    relations: {
+      authors: {
+        endpoint: 'authors',
+        matchField: 'key', // Match against author.key
+        frontmatterField: 'authors', // Array of author keys in frontmatter
+      },
+      keywords: {
+        endpoint: 'keywords',
+        matchField: 'key', // Match against keyword.key
+        frontmatterField: 'keywords', // Array of keyword values in frontmatter
+        filterKey: true, // Also check if keyword.key contains 'comparison' or 'comparisons'
+        matchValue: true, // Match against keyword.value (case insensitive)
+      },
+      tags: {
+        endpoint: 'tags',
+        matchField: 'key', // Match against tag.key
+        frontmatterField: 'tags', // Array of tag values in frontmatter
+        filterKey: true, // Also check if tag.key contains 'faq' or 'faqs'
+        matchValue: true, // Match against tag.value (case insensitive)
+      },
+      related_guides: {
+        endpoint: 'guides',
+        matchField: 'path', // Match against guide.path
+        frontmatterField: 'related_guides', // Array of guide paths in frontmatter
+      },
+    },
+  },
+  authors: {
+    apiPath: 'api::author.author',
+    endpoint: 'authors',
+    fields: ['key', 'name', 'title', 'url', 'image_url'],
+  },
+  tags: {
+    apiPath: 'api::tag.tag',
+    endpoint: 'tags',
+    fields: ['value', 'key', 'description'],
+  },
+  keywords: {
+    apiPath: 'api::keyword.keyword',
+    endpoint: 'keywords',
+    fields: ['value', 'key', 'description'],
+  },
+}
+
+// Helper: Extract folder name from file path
+function getFolderName(filePath) {
+  const parts = filePath.split('/')
+  if (parts[0] === 'data' && parts.length > 1) {
+    return parts[1]
+  }
+  return null
+}
+
+// Helper: Generate path field from file path
+function generatePathField(filePath, folderName) {
+  const parts = filePath.split('/')
+  const folderIndex = parts.indexOf(folderName)
+  if (folderIndex === -1) return null
+
+  const pathParts = parts.slice(folderIndex + 1)
+  const fileName = pathParts[pathParts.length - 1]
+  const fileNameWithoutExt = fileName.replace(/\.(mdx?|md)$/, '')
+
+  pathParts[pathParts.length - 1] = fileNameWithoutExt
+  return '/' + pathParts.join('/')
+}
+
+// Helper: Parse MDX file
+function parseMDXFile(filePath) {
+  try {
+    const fileContent = fs.readFileSync(filePath, 'utf8')
+    const { data: frontmatter, content } = matter(fileContent)
+    return { frontmatter, content }
+  } catch (error) {
+    throw new Error(`Failed to parse file ${filePath}: ${error.message}`)
+  }
+}
+
+// Helper: Fetch all entities from Strapi endpoint
+async function fetchAllEntities(endpoint) {
+  try {
+    const response = await axios.get(`${CMS_API_URL}/api/${endpoint}`, {
+      params: {
+        pagination: { pageSize: 100 }, // Adjust if you have more
+      },
+      headers: {
+        Authorization: `Bearer ${CMS_API_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return response.data.data || []
+  } catch (error) {
+    console.error(`Failed to fetch ${endpoint}: ${error.message}`)
+    return []
+  }
+}
+
+// Helper: Create a tag or keyword entry
+async function createTagOrKeyword(endpoint, value, folderName) {
+  try {
+    // Generate key by appending folder name to the value (lowercase, hyphenated)
+    const key = `${folderName}-${value}`
+
+    const data = {
+      key: key,
+      value: value,
+      // description is optional, so we don't include it
+    }
+
+    console.log(`    🆕 Creating new ${endpoint} entry:`)
+    console.log(`       • key: "${key}"`)
+    console.log(`       • value: "${value}"`)
+
+    const response = await axios.post(
+      `${CMS_API_URL}/api/${endpoint}`,
+      { data },
+      {
+        headers: {
+          Authorization: `Bearer ${CMS_API_TOKEN}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    )
+
+    console.log(
+      `    ✅ Successfully created ${endpoint} entry with documentId: ${response.data.data.documentId}`
+    )
+    return response.data.data
+  } catch (error) {
+    const errorMsg = error.response?.data?.error?.message || error.message
+    console.error(`    ❌ Failed to create ${endpoint} entry: ${errorMsg}`)
+    throw error
+  }
+}
+
+// Helper: Resolve relation IDs
+async function resolveRelations(folderName, frontmatter) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  if (!schema.relations) return { relations: {}, warnings: [] }
+
+  const relations = {}
+  const warnings = []
+
+  for (const [relationName, relationConfig] of Object.entries(schema.relations)) {
+    const frontmatterValues = frontmatter[relationConfig.frontmatterField]
+
+    // Skip if no values in frontmatter
+    if (!frontmatterValues || !Array.isArray(frontmatterValues) || frontmatterValues.length === 0) {
+      console.log(`  ⏭️ Skipping ${relationName}: No values in frontmatter`)
+      continue
+    }
+
+    console.log(`  🔗 Resolving ${relationName}: ${frontmatterValues.join(', ')}`)
+
+    // Check if this is tags or keywords relation
+    const isTagsOrKeywords = relationName === 'tags' || relationName === 'keywords'
+
+    // Fetch all entities from the relation endpoint
+    let entities = await fetchAllEntities(relationConfig.endpoint)
+
+    if (entities.length === 0 && !isTagsOrKeywords) {
+      console.warn(`  ⚠️ No entities found in ${relationConfig.endpoint}`)
+      continue
+    }
+
+    // Match entities based on configuration
+    const matchedIds = []
+    const unmatchedValues = []
+
+    for (const value of frontmatterValues) {
+      let matched = null
+
+      if (relationConfig.filterKey && relationConfig.matchValue) {
+        // Special case for tags: check key contains 'faq'/'faqs' AND value matches
+        matched = entities.find((entity) => {
+          const keyMatch =
+            entity?.key && entity?.key.toLowerCase().includes(folderName.toLowerCase())
+
+          const valueMatch = entity?.value && entity?.value.toLowerCase() === value.toLowerCase()
+
+          return keyMatch && valueMatch
+        })
+      } else if (relationConfig.matchValue) {
+        // Match against value field (case insensitive)
+        matched = entities.find(
+          (entity) => entity?.value && entity?.value.toLowerCase() === value.toLowerCase()
+        )
+      } else {
+        // Match against specified field (exact match)
+        matched = entities.find((entity) => entity?.[relationConfig.matchField] === value)
+      }
+
+      // Check if matched and has documentId
+      if (matched && matched?.documentId) {
+        matchedIds.push(matched.documentId)
+        console.log(`    ✅ Matched "${value}" → ID: ${matched.documentId}`)
+      } else if (matched && !matched?.documentId) {
+        // Matched entity but no documentId
+        unmatchedValues.push(value)
+        console.warn(
+          `    ⚠️ Entity found for "${value}" but no documentId in ${relationConfig.endpoint}`
+        )
+      } else {
+        // No match found
+        console.warn(`    ⚠️ No match found for "${value}" in ${relationConfig.endpoint}`)
+
+        // Auto-create tags or keywords if not found
+        if (isTagsOrKeywords) {
+          try {
+            console.log(`    🔧 Auto-creating missing ${relationName} entry for: "${value}"`)
+            const newEntry = await createTagOrKeyword(relationConfig.endpoint, value, folderName)
+
+            if (newEntry && newEntry.documentId) {
+              matchedIds.push(newEntry.documentId)
+              // Add to entities array so it's available for subsequent matches
+              entities.push(newEntry)
+              console.log(`    ✅ Auto-created and matched "${value}" → ID: ${newEntry.documentId}`)
+            } else {
+              unmatchedValues.push(value)
+              console.error(`    ❌ Created entry but no documentId returned for "${value}"`)
+            }
+          } catch (createError) {
+            unmatchedValues.push(value)
+            console.error(
+              `    ❌ Failed to auto-create ${relationName} for "${value}": ${createError.message}`
+            )
+          }
+        } else {
+          unmatchedValues.push(value)
+        }
+      }
+    }
+
+    // Log unmatched values for this field
+    if (unmatchedValues.length > 0) {
+      console.warn(
+        `  ⚠️ ${relationName}: ${unmatchedValues.length} unmatched value(s): ${unmatchedValues.join(', ')}`
+      )
+      warnings.push({
+        relationName,
+        unmatchedValues,
+      })
+    }
+
+    // Only add relation if at least one valid documentId was found
+    if (matchedIds.length > 0) {
+      relations[relationName] = matchedIds
+      console.log(`  ✅ ${relationName}: Resolved ${matchedIds.length} relation(s)`)
+    } else {
+      console.warn(`  ⚠️ ${relationName}: No valid relations found, key will be omitted`)
+    }
+  }
+
+  return { relations, warnings }
+}
+
+// Helper: Map MDX data to Strapi schema
+async function mapToStrapiSchema(folderName, frontmatter, content, pathField) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  if (!schema) {
+    throw new Error(`No schema defined for folder: ${folderName}`)
+  }
+
+  // Base data
+  const data = {
+    path: pathField,
+    content: content,
+    deployment_status: DEPLOYMENT_STATUS,
+    ...frontmatter,
+  }
+
+  // Resolve relations
+  console.log(`  🔍 Resolving relations...`)
+  const { relations, warnings } = await resolveRelations(folderName, frontmatter)
+
+  // Remove raw frontmatter relation fields
+  if (schema.relations) {
+    console.log(`  🧹 [DEBUG] Cleaning up relation fields from frontmatter...`)
+    for (const [relationName, relationConfig] of Object.entries(schema.relations)) {
+      const fieldName = relationConfig.frontmatterField
+      if (data[fieldName]) {
+        console.log(
+          `    🗑️ [DEBUG] Removing raw frontmatter field: ${fieldName} = ${JSON.stringify(data[fieldName])}`
+        )
+        delete data[fieldName]
+      }
+    }
+  }
+
+  if (Object.keys(relations).length > 0) {
+    console.log(
+      `  ➕ [DEBUG] Adding resolved relations to data:`,
+      Object.keys(relations).join(', ')
+    )
+    Object.assign(data, relations)
+  } else {
+    console.log(`  ℹ️ [DEBUG] No relations were successfully resolved, none will be added`)
+  }
+
+  // Check for missing required fields
+  const missingFields = schema.fields.filter(
+    (field) => field !== 'deployment_status' && !(field in data)
+  )
+
+  if (missingFields.length > 0) {
+    console.warn(`  ⚠️ Missing fields: ${missingFields.join(', ')}`)
+  }
+
+  return { data, warnings }
+}
+
+// Helper: Check if file exists in Strapi by path
+async function findEntryByPath(folderName, pathField) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  try {
+    console.log(
+      `  🔍 [DEBUG] Searching for entry: endpoint=${schema.endpoint}, path=${pathField}, deployment_status=${DEPLOYMENT_STATUS}`
+    )
+
+    const response = await axios.get(`${CMS_API_URL}/api/${schema.endpoint}`, {
+      params: {
+        filters: { path: { $eq: pathField }, deployment_status: { $eq: DEPLOYMENT_STATUS } },
+        pagination: { limit: 1 },
+      },
+      headers: {
+        Authorization: `Bearer ${CMS_API_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+
+    console.log(`  🔍 [DEBUG] Response status: ${response.status}`)
+    console.log(`  🔍 [DEBUG] Response data:`, JSON.stringify(response.data, null, 2))
+
+    if (response.data.data && response.data.data.length > 0) {
+      const entry = response.data.data[0]
+      console.log(`  ✅ [DEBUG] Entry found:`, JSON.stringify(entry, null, 2))
+      return entry
+    }
+
+    console.log(`  ℹ️ [DEBUG] No entry found`)
+    return null
+  } catch (error) {
+    console.error(`  ❌ [DEBUG] Error in findEntryByPath:`, error.message)
+    if (error.response) {
+      console.error(`  ❌ [DEBUG] Response status:`, error.response.status)
+      console.error(`  ❌ [DEBUG] Response data:`, JSON.stringify(error.response.data, null, 2))
+    }
+    throw new Error(`Failed to find entry by path: ${error.message}`)
+  }
+}
+
+// Helper: Create entry in Strapi
+async function createEntry(folderName, data) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  try {
+    console.log(`  📝 [DEBUG] Creating entry in ${schema.endpoint}`)
+    console.log(`  📝 [DEBUG] Data keys:`, Object.keys(data).join(', '))
+    console.log(`  📝 [DEBUG] Full data:`, JSON.stringify(data, null, 2))
+
+    const response = await axios.post(
+      `${CMS_API_URL}/api/${schema.endpoint}`,
+      { data },
+      {
+        headers: {
+          Authorization: `Bearer ${CMS_API_TOKEN}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    )
+
+    console.log(`  ✅ [DEBUG] Create response:`, JSON.stringify(response.data, null, 2))
+    return response.data
+  } catch (error) {
+    const errorMsg = error.response?.data?.error?.message || error.message
+    const errorDetails = error.response?.data?.error?.details || {}
+    console.error(`  ❌ [DEBUG] Create failed: ${errorMsg}`)
+    if (Object.keys(errorDetails).length > 0) {
+      console.error(`  ❌ [DEBUG] Error details:`, JSON.stringify(errorDetails, null, 2))
+    }
+    if (error.response) {
+      console.error(`  ❌ [DEBUG] Response status:`, error.response.status)
+      console.error(`  ❌ [DEBUG] Response data:`, JSON.stringify(error.response.data, null, 2))
+    }
+    throw error
+  }
+}
+
+// Helper: Update entry in Strapi
+async function updateEntry(folderName, documentId, data) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  try {
+    console.log(`  🔄 [DEBUG] Updating entry in ${schema.endpoint}`)
+    console.log(`  🔄 [DEBUG] Document ID: ${documentId}`)
+    console.log(`  🔄 [DEBUG] Update URL: ${CMS_API_URL}/api/${schema.endpoint}/${documentId}`)
+    console.log(`  🔄 [DEBUG] Data keys:`, Object.keys(data).join(', '))
+    console.log(`  🔄 [DEBUG] Full data:`, JSON.stringify(data, null, 2))
+
+    const response = await axios.put(
+      `${CMS_API_URL}/api/${schema.endpoint}/${documentId}`,
+      { data },
+      {
+        headers: {
+          Authorization: `Bearer ${CMS_API_TOKEN}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    )
+
+    console.log(`  ✅ [DEBUG] Update response:`, JSON.stringify(response.data, null, 2))
+    return response.data
+  } catch (error) {
+    const errorMsg = error.response?.data?.error?.message || error.message
+    const errorDetails = error.response?.data?.error?.details || {}
+    console.error(`  ❌ [DEBUG] Update failed: ${errorMsg}`)
+    if (Object.keys(errorDetails).length > 0) {
+      console.error(`  ❌ [DEBUG] Error details:`, JSON.stringify(errorDetails, null, 2))
+    }
+    if (error.response) {
+      console.error(`  ❌ [DEBUG] Response status:`, error.response.status)
+      console.error(`  ❌ [DEBUG] Response data:`, JSON.stringify(error.response.data, null, 2))
+    }
+    throw error
+  }
+}
+
+// Helper: Delete entry in Strapi
+async function deleteEntry(folderName, documentId) {
+  const schema = COLLECTION_SCHEMAS[folderName]
+  try {
+    console.log(`  🗑️ [DEBUG] Deleting entry from ${schema.endpoint}`)
+    console.log(`  🗑️ [DEBUG] Document ID: ${documentId}`)
+    console.log(`  🗑️ [DEBUG] Delete URL: ${CMS_API_URL}/api/${schema.endpoint}/${documentId}`)
+
+    const response = await axios.delete(`${CMS_API_URL}/api/${schema.endpoint}/${documentId}`, {
+      headers: {
+        Authorization: `Bearer ${CMS_API_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+    })
+
+    console.log(`  ✅ [DEBUG] Delete response status: ${response.status}`)
+    console.log(`  ✅ [DEBUG] Delete response:`, JSON.stringify(response.data, null, 2))
+    return response.data
+  } catch (error) {
+    const errorMsg = error.response?.data?.error?.message || error.message
+    console.error(`  ❌ [DEBUG] Delete failed: ${errorMsg}`)
+    if (error.response) {
+      console.error(`  ❌ [DEBUG] Response status:`, error.response.status)
+      console.error(`  ❌ [DEBUG] Response data:`, JSON.stringify(error.response.data, null, 2))
+    }
+    throw new Error(`Failed to delete entry: ${errorMsg}`)
+  }
+}
+
+// Helper: Detect operation type
+function detectOperationType(filePath, isDeletedFile = false) {
+  console.log(`  🔍 [DEBUG] detectOperationType called for: ${filePath}`)
+  console.log(`  🔍 [DEBUG] isDeletedFile flag: ${isDeletedFile}`)
+
+  if (isDeletedFile) {
+    console.log(`  🔍 [DEBUG] File is marked as deleted by GitHub`)
+    return 'delete'
+  }
+
+  const exists = fs.existsSync(filePath)
+  console.log(`  🔍 [DEBUG] File exists on disk: ${exists}`)
+
+  if (!exists) {
+    console.log(`  🔍 [DEBUG] File does not exist, operation: delete`)
+    return 'delete'
+  }
+
+  console.log(`  🔍 [DEBUG] File exists, operation: create_or_update`)
+  return 'create_or_update'
+}
+
+// Main sync logic
+async function syncToStrapi() {
+  console.log('🚀 Starting sync to Strapi CMS...\n')
+  console.log(`📦 Deployment Status: ${DEPLOYMENT_STATUS}`)
+  console.log(`🔗 CMS API URL: ${CMS_API_URL}`)
+  console.log(`📁 Sync Folders: ${SYNC_FOLDERS.join(', ')}`)
+  console.log(`\n📄 Changed Files (${CHANGED_FILES.length}):`)
+  CHANGED_FILES.forEach((file, idx) => {
+    console.log(`   ${idx + 1}. ${file}`)
+  })
+  console.log(`\n🗑️ Deleted Files (${DELETED_FILES.length}):`)
+  DELETED_FILES.forEach((file, idx) => {
+    console.log(`   ${idx + 1}. ${file}`)
+  })
+  console.log('')
+
+  const results = {
+    created: [],
+    updated: [],
+    deleted: [],
+    skipped: [],
+    errors: [],
+    relationWarnings: [], // Track unmatched relations
+  }
+
+  // Combine changed and deleted files with a flag to indicate deletion
+  const allFiles = [
+    ...CHANGED_FILES.map((file) => ({ path: file, isDeleted: false })),
+    ...DELETED_FILES.map((file) => ({ path: file, isDeleted: true })),
+  ]
+
+  console.log(`\n📊 [DEBUG] Total files to process: ${allFiles.length}`)
+  console.log(`  - Changed/Modified: ${CHANGED_FILES.length}`)
+  console.log(`  - Deleted: ${DELETED_FILES.length}`)
+  console.log('')
+
+  for (const { path: filePath, isDeleted } of allFiles) {
+    console.log(`\n${'='.repeat(80)}`)
+    console.log(`📄 Processing: ${filePath}`)
+    console.log(`  🏷️ [DEBUG] File marked as deleted: ${isDeleted}`)
+    console.log(`${'='.repeat(80)}`)
+
+    try {
+      console.log(`  🔍 [DEBUG] Extracting folder name...`)
+      const folderName = getFolderName(filePath)
+      console.log(`  🔍 [DEBUG] Folder name: ${folderName}`)
+
+      if (!folderName || !SYNC_FOLDERS.includes(folderName)) {
+        console.log(`⏭️ Skipped: Folder '${folderName}' not in sync list`)
+        console.log(`  ℹ️ [DEBUG] Sync folders: ${SYNC_FOLDERS.join(', ')}`)
+        results.skipped.push(filePath)
+        continue
+      }
+
+      console.log(`  🛣️ [DEBUG] Generating path field...`)
+      const pathField = generatePathField(filePath, folderName)
+      console.log(`  🛣️ [DEBUG] Path field: ${pathField}`)
+
+      if (!pathField) {
+        throw new Error('Could not generate path field')
+      }
+
+      const operationType = detectOperationType(filePath, isDeleted)
+      console.log(`  🔧 [DEBUG] Operation type: ${operationType}`)
+
+      if (operationType === 'delete') {
+        console.log(`🗑️ Deleting from CMS: ${pathField}`)
+        const existingEntry = await findEntryByPath(folderName, pathField)
+
+        if (existingEntry) {
+          await deleteEntry(folderName, existingEntry.documentId)
+          console.log(`✅ Deleted successfully`)
+          results.deleted.push({ file: filePath, path: pathField })
+        } else {
+          console.log(`⚠️ Entry not found in CMS, skipping deletion`)
+          results.skipped.push(filePath)
+        }
+      } else {
+        console.log(`  📖 [DEBUG] Parsing MDX file...`)
+        const { frontmatter, content } = parseMDXFile(filePath)
+        console.log(`  📖 [DEBUG] Frontmatter keys:`, Object.keys(frontmatter).join(', '))
+
+        console.log(`  🗺️ [DEBUG] Mapping to Strapi schema...`)
+        const { data: strapiData, warnings } = await mapToStrapiSchema(
+          folderName,
+          frontmatter,
+          content,
+          pathField
+        )
+        console.log(`  🗺️ [DEBUG] Mapped data keys:`, Object.keys(strapiData).join(', '))
+
+        // Track relation warnings
+        if (warnings && warnings.length > 0) {
+          results.relationWarnings.push({
+            file: filePath,
+            path: pathField,
+            warnings,
+          })
+        }
+
+        console.log(`  🔎 [DEBUG] Checking if entry exists in CMS...`)
+        const existingEntry = await findEntryByPath(folderName, pathField)
+        console.log(`  🔎 [DEBUG] Existing entry result:`, existingEntry ? 'FOUND' : 'NOT FOUND')
+
+        if (existingEntry) {
+          console.log(`🔄 Updating in CMS: ${pathField}`)
+          console.log(
+            `  📋 [DEBUG] Entry details: id=${existingEntry.id}, documentId=${existingEntry.documentId}`
+          )
+
+          if (!existingEntry.documentId) {
+            throw new Error(
+              `Entry found but has no documentId. Entry keys: ${Object.keys(existingEntry).join(', ')}`
+            )
+          }
+
+          await updateEntry(folderName, existingEntry.documentId, strapiData)
+          console.log(`✅ Updated successfully`)
+          results.updated.push({ file: filePath, path: pathField })
+        } else {
+          console.log(`➕ Creating in CMS: ${pathField}`)
+          await createEntry(folderName, strapiData)
+          console.log(`✅ Created successfully`)
+          results.created.push({ file: filePath, path: pathField })
+        }
+      }
+    } catch (error) {
+      console.error(`\n❌ [DEBUG] ============ ERROR DETAILS ============`)
+      console.error(`❌ [DEBUG] File: ${filePath}`)
+      console.error(`❌ [DEBUG] Error message: ${error.message}`)
+      console.error(`❌ [DEBUG] Error name: ${error.name}`)
+      console.error(`❌ [DEBUG] Error stack:`, error.stack)
+
+      if (error.response) {
+        console.error(`❌ [DEBUG] HTTP Response status: ${error.response.status}`)
+        console.error(
+          `❌ [DEBUG] HTTP Response headers:`,
+          JSON.stringify(error.response.headers, null, 2)
+        )
+        console.error(
+          `❌ [DEBUG] HTTP Response data:`,
+          JSON.stringify(error.response.data, null, 2)
+        )
+      }
+
+      if (error.config) {
+        console.error(`❌ [DEBUG] Request config:`)
+        console.error(`  - URL: ${error.config.url}`)
+        console.error(`  - Method: ${error.config.method}`)
+        console.error(`  - Data: ${error.config.data}`)
+      }
+
+      console.error(`❌ [DEBUG] =========================================\n`)
+
+      console.error(`❌ Error processing ${filePath}: ${error.message}`)
+      results.errors.push({ file: filePath, error: error.message })
+    }
+  }
+
+  // Print summary
+  console.log('\n' + '='.repeat(60))
+  console.log('📊 SYNC SUMMARY')
+  console.log('='.repeat(60))
+  console.log(`✅ Created: ${results.created.length}`)
+  console.log(`🔄 Updated: ${results.updated.length}`)
+  console.log(`🗑️ Deleted: ${results.deleted.length}`)
+  console.log(`⏭️ Skipped: ${results.skipped.length}`)
+  console.log(`❌ Errors: ${results.errors.length}`)
+  console.log(`⚠️ Relation Warnings: ${results.relationWarnings.length}`)
+  console.log('='.repeat(60) + '\n')
+
+  if (results.errors.length > 0) {
+    console.error('\n❌ SYNC FAILED - The following errors occurred:\n')
+    results.errors.forEach(({ file, error }) => {
+      console.error(`  • ${file}: ${error}`)
+    })
+
+    // Extract relation types even on error for PR comment
+    const usedSchemas = new Set()
+    const allRelationNames = new Set()
+
+    ;[...results.created, ...results.updated].forEach((item) => {
+      const folderName = getFolderName(item.file)
+      if (folderName && COLLECTION_SCHEMAS[folderName]) {
+        usedSchemas.add(folderName)
+        const schema = COLLECTION_SCHEMAS[folderName]
+        if (schema.relations) {
+          Object.keys(schema.relations).forEach((relationName) => {
+            allRelationNames.add(relationName)
+          })
+        }
+      }
+    })
+
+    results.relationTypes = Array.from(allRelationNames)
+    results.deploymentStatus = DEPLOYMENT_STATUS
+
+    // Save results to file even on error for PR comment
+    try {
+      fs.writeFileSync('sync-results.json', JSON.stringify(results, null, 2))
+      console.log('📝 Results saved to sync-results.json')
+    } catch (writeError) {
+      console.error('Failed to save results:', writeError.message)
+    }
+
+    process.exit(1)
+  }
+
+  // Extract all unique relation names from schemas used
+  const usedSchemas = new Set()
+  const allRelationNames = new Set()
+
+  // Get schemas from processed files
+  ;[...results.created, ...results.updated].forEach((item) => {
+    const folderName = getFolderName(item.file)
+    if (folderName && COLLECTION_SCHEMAS[folderName]) {
+      usedSchemas.add(folderName)
+      const schema = COLLECTION_SCHEMAS[folderName]
+      if (schema.relations) {
+        Object.keys(schema.relations).forEach((relationName) => {
+          allRelationNames.add(relationName)
+        })
+      }
+    }
+  })
+
+  // Add relation info to results
+  results.relationTypes = Array.from(allRelationNames)
+  results.deploymentStatus = DEPLOYMENT_STATUS
+
+  // Save results to file for PR comment script
+  try {
+    fs.writeFileSync('sync-results.json', JSON.stringify(results, null, 2))
+    console.log('📝 Results saved to sync-results.json')
+  } catch (writeError) {
+    console.error('Failed to save results:', writeError.message)
+  }
+
+  return results
+}
+
+// Validate environment variables
+if (!CMS_API_URL || !CMS_API_TOKEN) {
+  console.error('❌ ERROR: Missing required environment variables')
+  console.error('   Required: CMS_API_URL, CMS_API_TOKEN')
+  process.exit(1)
+}
+
+// Run sync
+syncToStrapi()
+  .then(() => {
+    console.log('✅ Sync completed successfully!')
+  })
+  .catch((error) => {
+    console.error('❌ SYNC FAILED:', error.message)
+    process.exit(1)
+  })
diff --git a/scripts/update-pr-comment.js b/scripts/update-pr-comment.js
new file mode 100644
index 000000000..523b002e5
--- /dev/null
+++ b/scripts/update-pr-comment.js
@@ -0,0 +1,99 @@
+const fs = require('fs')
+const path = require('path')
+
+module.exports = async ({ github, context, core }) => {
+  const status = process.env.JOB_STATUS
+  const deploymentStatus = process.env.DEPLOYMENT_STATUS
+
+  let body = ''
+
+  if (status === 'success') {
+    // Read sync results from file
+    let syncResults = null
+    try {
+      const resultsPath = path.join(process.cwd(), 'sync-results.json')
+      const resultsContent = fs.readFileSync(resultsPath, 'utf8')
+      syncResults = JSON.parse(resultsContent)
+    } catch (error) {
+      console.error('Failed to read sync results:', error.message)
+    }
+
+    if (syncResults) {
+      // Build comprehensive summary
+      body = `✅ **CMS Sync Successful**\n\n`
+      body += `Content has been synced to Strapi CMS with deployment status: \`${deploymentStatus}\`\n\n`
+
+      // Summary counts
+      body += `### 📊 Summary\n\n`
+      body += `| Operation | Count |\n`
+      body += `|-----------|-------|\n`
+      body += `| ✅ Created | ${syncResults.created.length} |\n`
+      body += `| 🔄 Updated | ${syncResults.updated.length} |\n`
+      body += `| 🗑️ Deleted | ${syncResults.deleted.length} |\n`
+      body += `| ⏭️ Skipped | ${syncResults.skipped.length} |\n\n`
+
+      // Get relation types from sync results (dynamically extracted from schemas)
+      const relationTypes = syncResults.relationTypes || []
+
+      if (relationTypes.length > 0) {
+        body += `### 🔗 Relations\n\n`
+        body += `The following relations were automatically resolved:\n`
+        body += relationTypes.map((rel) => `- \`${rel}\``).join('\n')
+        body += '\n\n'
+      }
+
+      // Documents details
+      const allProcessed = [
+        ...syncResults.created.map((item) => ({ ...item, operation: 'Created' })),
+        ...syncResults.updated.map((item) => ({ ...item, operation: 'Updated' })),
+        ...syncResults.deleted.map((item) => ({ ...item, operation: 'Deleted' })),
+      ]
+
+      if (allProcessed.length > 0) {
+        body += `### 📄 Processed Documents\n\n`
+        body += `<details>\n`
+        body += `<summary>View ${allProcessed.length} document(s)</summary>\n\n`
+        body += `| Operation | Route |\n`
+        body += `|-----------|-------|\n`
+        allProcessed.forEach((item) => {
+          body += `| ${item.operation} | \`${item.path}\` |\n`
+        })
+        body += `\n</details>\n\n`
+      }
+
+      // Relation warnings
+      if (syncResults.relationWarnings && syncResults.relationWarnings.length > 0) {
+        body += `### ⚠️ Relation Warnings\n\n`
+        body += `Some relations could not be resolved due to missing or unmatched fields:\n\n`
+        body += `<details>\n`
+        body += `<summary>View ${syncResults.relationWarnings.length} warning(s)</summary>\n\n`
+
+        syncResults.relationWarnings.forEach((item) => {
+          body += `**File:** \`${item.path}\`\n\n`
+          item.warnings.forEach((warning) => {
+            body += `- **${warning.relationName}**: ${warning.unmatchedValues.length} unmatched value(s)\n`
+            body += `  - ${warning.unmatchedValues.map((v) => `\`${v}\``).join(', ')}\n`
+          })
+          body += `\n`
+        })
+
+        body += `</details>\n\n`
+        body += `> **Note:** Documents were still synced successfully, but some relations were omitted. Please check the values in your frontmatter.\n`
+      }
+    } else {
+      // Fallback if results file not found
+      body = `✅ **CMS Sync Successful**\n\n`
+      body += `Content has been synced to Strapi CMS with deployment status: \`${deploymentStatus}\`\n\n`
+      body += `Relations have been automatically resolved.`
+    }
+  } else {
+    body = `❌ **CMS Sync Failed**\n\nPlease check the workflow logs for details.`
+  }
+
+  github.rest.issues.createComment({
+    issue_number: context.issue.number,
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    body: body,
+  })
+}
diff --git a/tsconfig.json b/tsconfig.json
index 6eded663b..a499c498b 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,11 +2,7 @@
   "compilerOptions": {
     "incremental": true,
     "target": "ESNext",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
+    "lib": ["dom", "dom.iterable", "esnext"],
     "allowJs": true,
     "skipLibCheck": true,
     "strict": false,
@@ -20,36 +16,17 @@
     "jsx": "preserve",
     "baseUrl": "./",
     "paths": {
-      "@/shared/*": [
-        "shared/*"
-      ],
-      "@/components/*": [
-        "components/*"
-      ],
-      "@/utils/*": [
-        "utils/*"
-      ],
-      "@/constants/*": [
-        "constants/*"
-      ],
-      "@/data/*": [
-        "data/*"
-      ],
-      "@/layouts/*": [
-        "layouts/*"
-      ],
-      "@/css/*": [
-        "css/*"
-      ],
-      "@/api/*": [
-        "api/*"
-      ],
-      "@/hooks/*": [
-        "hooks/*"
-      ],
-      "contentlayer/generated": [
-        "./.contentlayer/generated"
-      ]
+      "@/shared/*": ["shared/*"],
+      "@/components/*": ["components/*"],
+      "@/utils/*": ["utils/*"],
+      "@/lib/*": ["lib/*"],
+      "@/constants/*": ["constants/*"],
+      "@/data/*": ["data/*"],
+      "@/layouts/*": ["layouts/*"],
+      "@/css/*": ["css/*"],
+      "@/api/*": ["api/*"],
+      "@/hooks/*": ["hooks/*"],
+      "contentlayer/generated": ["./.contentlayer/generated"]
     },
     "plugins": [
       {
@@ -70,7 +47,5 @@
     ".next/types/**/*.ts",
     "docs/shared/get-started-signoz.mdx"
   ],
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }
diff --git a/utils/strapi.ts b/utils/strapi.ts
index 7cdc583a2..0043cea8e 100644
--- a/utils/strapi.ts
+++ b/utils/strapi.ts
@@ -233,3 +233,346 @@ export const fetchChangelogById = async (
     throw error
   }
 }
+
+// MDX Content schema
+export type MDXContent = {
+  id: number
+  documentId: string
+  title: string
+  slug: string
+  path: string
+  content: string
+  excerpt?: string
+  publishedAt: string
+  createdAt: string
+  updatedAt: string
+  [key: string]: any
+}
+
+export type MDXContentApiResponse = {
+  data: MDXContent[]
+  meta: {
+    pagination: {
+      page: number
+      pageSize: number
+      pageCount: number
+      total: number
+    }
+  }
+}
+
+export type MDXContentByIdApiResponse = {
+  data: MDXContent
+  meta: {}
+}
+
+// Cache for storing paths to avoid repeated API calls - avoid later maybe
+let pathsCache: string[] | null = null
+let pathsCacheTimestamp: number = 0
+const PATHS_CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+// Fetch MDX content by path or all content for a collection
+export const fetchMDXContentByPath = async (
+  collectionName: string,
+  path?: string,
+  deployment_status?: string,
+  fetchAll: boolean = false
+): Promise<MDXContentByIdApiResponse | MDXContentApiResponse> => {
+  try {
+    const queryObject: any = {
+      populate: '*',
+      pagination: {
+        page: 1,
+        pageSize: 100,
+      },
+      sort: ['publishedAt:desc'],
+    }
+
+    // Add filters only if not fetching all
+    if (!fetchAll) {
+      if (!path) {
+        throw new Error('Path is required when fetchAll is false')
+      }
+      // Ensure path starts with a slash and has no trailing slashes
+      const normalizedPath = `/${path.replace(/^\/+|\/+$/g, '')}`
+      console.log('Normalized path for Strapi query:', normalizedPath)
+
+      queryObject.filters = {
+        path: {
+          $eq: normalizedPath,
+        },
+      }
+
+      if (deployment_status) {
+        queryObject.filters.deployment_status = {
+          $eq: deployment_status,
+        }
+      }
+    } else {
+      // Optionally filter by deployment status for list views
+      if (deployment_status) {
+        queryObject.filters = {
+          deployment_status: {
+            $eq: deployment_status,
+          },
+        }
+      }
+    }
+
+    if (!API_URL) {
+      throw new Error('NEXT_PUBLIC_SIGNOZ_CMS_API_URL is not configured')
+    }
+
+    // If fetchAll is true, fetch all pages and combine results
+    if (fetchAll) {
+      let allData: MDXContent[] = []
+      let currentPage = 1
+      let totalPages = 1
+      let finalMeta: any = {}
+
+      do {
+        queryObject.pagination.page = currentPage
+
+        const queryParams = qs.stringify(queryObject, {
+          encode: false,
+          addQueryPrefix: true,
+          arrayFormat: 'repeat',
+        })
+
+        const response = await fetch(`${API_URL}/api/${collectionName}${queryParams}`, {
+          next: {
+            tags: [`${collectionName}-list`],
+          },
+          headers: {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+            Pragma: 'no-cache',
+            Expires: '0',
+          },
+          cache: 'no-store',
+        })
+
+        if (!response.ok) {
+          if (response.status === 404) {
+            throw new Error('Content not found')
+          }
+          const errorMessage = await response.text()
+          throw new Error(`Network response was not ok: ${response.status} ${errorMessage}`)
+        }
+
+        const data: MDXContentApiResponse = await response.json()
+
+        if (data.data && data.data.length > 0) {
+          allData = allData.concat(data.data)
+        }
+
+        totalPages = data.meta.pagination.pageCount
+        finalMeta = data.meta
+        currentPage++
+      } while (currentPage <= totalPages)
+
+      // Update the pagination meta to reflect all data
+      finalMeta.pagination = {
+        page: 1,
+        pageSize: allData.length,
+        pageCount: 1,
+        total: allData.length,
+      }
+
+      return {
+        data: allData,
+        meta: finalMeta,
+      }
+    }
+
+    // Single content fetch
+    const queryParams = qs.stringify(queryObject, {
+      encode: false,
+      addQueryPrefix: true,
+      arrayFormat: 'repeat',
+    })
+
+    const response = await fetch(`${API_URL}/api/${collectionName}${queryParams}`, {
+      next: {
+        tags: [`${collectionName}-${path}`],
+      },
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+        Pragma: 'no-cache',
+        Expires: '0',
+      },
+      cache: 'no-store',
+    })
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error('Content not found')
+      }
+      const errorMessage = await response.text()
+      throw new Error(`Network response was not ok: ${response.status} ${errorMessage}`)
+    }
+
+    const data: MDXContentApiResponse = await response.json()
+
+    console.log('Data:', data)
+    console.log('Data.data:', data.data)
+    console.log('Data.data.length:', data.data.length)
+    console.log('Query URL:', `${API_URL}/api/${collectionName}${queryParams}`)
+    console.log('Authors in response:', data.data[0]?.attributes?.authors)
+    console.log('Related FAQs in response:', data.data[0]?.attributes?.related_faqs)
+
+    if (!data.data || data.data.length === 0) {
+      throw new Error('Content not found')
+    }
+
+    return {
+      data: data.data[0],
+      meta: {},
+    }
+  } catch (error) {
+    console.error(`Error fetching MDX content for ${collectionName}:`, error)
+    throw error
+  }
+}
+
+// Fetch Authors by key - has path nesting
+export const fetchAuthorByKey = async (key: string): Promise<MDXContentByIdApiResponse> => {
+  try {
+    const queryObject = {
+      filters: {
+        key: {
+          $eq: key,
+        },
+      },
+    }
+
+    const queryParams = qs.stringify(queryObject, {
+      encode: false,
+      addQueryPrefix: true,
+      arrayFormat: 'repeat',
+    })
+
+    if (!API_URL) {
+      throw new Error('NEXT_PUBLIC_SIGNOZ_CMS_API_URL is not configured')
+    }
+
+    const response = await fetch(`${API_URL}/api/authors${queryParams}`, {
+      next: {
+        // revalidate: 3600, // Same as export const revalidate = 3600; in the page - we need no-store, only one should be specified
+        tags: [`authors-${key}`],
+      },
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store', // Avoid caching
+        Pragma: 'no-cache',
+        Expires: '0',
+      },
+      cache: 'no-store', // For fetch requests
+    })
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error('Content not found')
+      }
+      const errorMessage = await response.text()
+      throw new Error(`Network response was not ok: ${response.status} ${errorMessage}`)
+    }
+
+    const data: any = await response.json()
+
+    if (!data.data || data.data.length === 0) {
+      throw new Error('Content not found')
+    }
+
+    return {
+      data: data.data[0],
+      meta: {},
+    }
+  } catch (error) {
+    console.error(`Error fetching Authors by key ${key}:`, error)
+    throw error
+  }
+}
+
+// Fetch all MDX content paths for static generation if needed
+// This is unused for now, we can remove it later if needed
+export const fetchAllMDXPaths = async (
+  collectionName: string,
+  useCache: boolean = true
+): Promise<string[]> => {
+  // Check cache first
+  if (useCache && pathsCache && Date.now() - pathsCacheTimestamp < PATHS_CACHE_TTL) {
+    return pathsCache
+  }
+
+  try {
+    const queryObject = {
+      fields: ['path'],
+      pagination: {
+        pageSize: 1000, // TODO: Adjust based on content volume
+      },
+      sort: ['publishedAt:desc'],
+    }
+
+    const queryParams = qs.stringify(queryObject, {
+      encode: false,
+      addQueryPrefix: true,
+      arrayFormat: 'repeat',
+    })
+
+    const response = await fetch(`${API_URL}/api/${collectionName}${queryParams}`, {
+      next: {
+        // revalidate: 3600, // Same as export const revalidate = 3600; in the page - we need no-store, only one should be specified
+        tags: [`${collectionName}-paths`],
+      },
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store', // Avoid caching
+        Pragma: 'no-cache',
+        Expires: '0',
+      },
+      cache: 'no-store', // For fetch requests
+    })
+
+    if (!response.ok) {
+      const errorMessage = await response.text()
+      throw new Error(`Network response was not ok: ${response.status} ${errorMessage}`)
+    }
+
+    const data: MDXContentApiResponse = await response.json()
+    const paths = data.data.map((item) => item.path)
+
+    // Update cache
+    pathsCache = paths
+    pathsCacheTimestamp = Date.now()
+
+    return paths
+  } catch (error) {
+    console.error('Error fetching all MDX paths:', error)
+    // Return cached data if available, otherwise empty array
+    return pathsCache || []
+  }
+}
+
+// Utility function to validate MDX content structure
+export const validateMDXContent = (content: any): content is MDXContent => {
+  return (
+    content &&
+    typeof content.id === 'number' &&
+    typeof content.documentId === 'string' &&
+    typeof content.title === 'string' &&
+    typeof content.slug === 'string' &&
+    typeof content.path === 'string' &&
+    typeof content.content === 'string' &&
+    typeof content.publishedAt === 'string' &&
+    typeof content.createdAt === 'string' &&
+    typeof content.updatedAt === 'string'
+  )
+}
+
+// Clear the paths cache (useful for revalidation)
+export const clearPathsCache = (): void => {
+  pathsCache = null
+  pathsCacheTimestamp = 0
+}
diff --git a/utils/structuredData.ts b/utils/structuredData.ts
new file mode 100644
index 000000000..c8e6203f8
--- /dev/null
+++ b/utils/structuredData.ts
@@ -0,0 +1,129 @@
+import siteMetadata from '@/data/siteMetadata'
+import { MDXContent } from './strapi'
+
+type Author = {
+  '@type': 'Person' | 'Organization'
+  name: string
+}
+
+type StructuredData = {
+  '@context': 'https://schema.org'
+  '@type': 'BlogPosting' | 'TechArticle' | 'Article'
+  mainEntityOfPage: {
+    '@type': 'WebPage'
+    '@id': string
+  }
+  author: Author | Author[]
+  publisher: {
+    '@type': 'Organization'
+    name: string
+    logo: {
+      '@type': 'ImageObject'
+      url: string
+    }
+  }
+  headline: string
+  datePublished: string
+  dateModified: string
+  description: string
+  image: string
+  url: string
+}
+
+type FAQStructuredData = {
+  '@context': 'https://schema.org'
+  '@type': 'FAQPage'
+  mainEntity: {
+    '@type': 'Question'
+    name: string
+    acceptedAnswer: {
+      '@type': 'Answer'
+      text: string
+    }
+  }
+  url: string
+}
+
+const getDefaultAuthor = (): Author => ({
+  '@type': 'Organization',
+  name: 'SigNoz',
+})
+
+const getDefaultPublisher = (): StructuredData['publisher'] => ({
+  '@type': 'Organization',
+  name: 'SigNoz',
+  logo: {
+    '@type': 'ImageObject',
+    url: 'https://signoz.io/img/SigNozLogo-orange.svg',
+  },
+})
+
+const getDefaultImage = (content: MDXContent): string => {
+  return `${siteMetadata.siteUrl}${content.image || (content.images ? content.images[0] : siteMetadata.socialBanner)}`
+}
+
+const getAuthors = (content: MDXContent): Author[] => {
+  if (!content.authors || !Array.isArray(content.authors)) {
+    return [getDefaultAuthor()]
+  }
+
+  return content.authors.map((author) => ({
+    '@type': 'Person',
+    name: author.name || 'SigNoz Team',
+  }))
+}
+
+export const generateStructuredData = (
+  collectionType: string,
+  content: MDXContent
+): StructuredData | FAQStructuredData => {
+  const baseUrl = siteMetadata.siteUrl
+  const contentPath = content.path || content.slug
+  const fullUrl = `${baseUrl}/${contentPath}`
+
+  // FAQ type has a different structure
+  if (collectionType === 'faqs') {
+    return {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: {
+        '@type': 'Question',
+        name: content.title,
+        acceptedAnswer: {
+          '@type': 'Answer',
+          text: content.description || '',
+        },
+      },
+      url: fullUrl,
+    }
+  }
+
+  // Map collection types to schema types
+  const schemaTypeMap: Record<string, string> = {
+    blog: 'BlogPosting',
+    docs: 'TechArticle',
+    guides: 'BlogPosting',
+    comparisons: 'BlogPosting',
+    opentelemetry: 'BlogPosting',
+    newsroom: 'BlogPosting',
+  }
+
+  const schemaType = (schemaTypeMap[collectionType] || 'Article') as StructuredData['@type']
+
+  return {
+    '@context': 'https://schema.org',
+    '@type': schemaType,
+    mainEntityOfPage: {
+      '@type': 'WebPage',
+      '@id': fullUrl,
+    },
+    author: collectionType === 'docs' ? getDefaultAuthor() : getAuthors(content),
+    publisher: getDefaultPublisher(),
+    headline: content.title,
+    datePublished: content.publishedAt || content.createdAt,
+    dateModified: content.updatedAt || content.publishedAt || content.createdAt,
+    description: content.description || `Read about ${content.title}`,
+    image: getDefaultImage(content),
+    url: fullUrl,
+  }
+}
diff --git a/yarn.lock b/yarn.lock
index 9c789ab21..b99e01cd4 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3,23 +3,23 @@
 
 
 "@aaronhayes/react-use-hubspot-form@^2.1.1":
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/@aaronhayes/react-use-hubspot-form/-/react-use-hubspot-form-2.1.1.tgz"
-  integrity sha512-K1ybIAa6b49hTnr08OcYZWI9yqpI/bGzjh2Vnk+H3Lt1udpToa0wJnP9ONmfs+wUdefzX2v0BwQPxtZ7yE6E8A==
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@aaronhayes/react-use-hubspot-form/-/react-use-hubspot-form-2.1.2.tgz#d3a1324399eda4abb9e99321a655c93519311611"
+  integrity sha512-SfQQap4T+D4S/epRE5fw0m2QOrD0vgUfZguWk9nlL6IRre1UQklCuns+9Ck/K//TA95xiTbW3WFY1RfgGkzRQQ==
 
-"@algolia/abtesting@1.3.0":
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/@algolia/abtesting/-/abtesting-1.3.0.tgz#3fade769bf5b03244baaee8034b83e2b49f8e86c"
-  integrity sha512-KqPVLdVNfoJzX5BKNGM9bsW8saHeyax8kmPFXul5gejrSPN3qss7PgsFH5mMem7oR8tvjvNkia97ljEYPYCN8Q==
+"@algolia/abtesting@1.5.0":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@algolia/abtesting/-/abtesting-1.5.0.tgz#3faf3770c7fcb4afcf86d9ac29d29c3cfca33441"
+  integrity sha512-W/ohRkbKQsqDWALJg28X15KF7Tcyg53L1MfdOkLgvkcCcofdzGHSimHHeNG05ojjFw9HK8+VPhe/Vwq4MozIJg==
   dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
 "@algolia/autocomplete-core@1.17.9":
   version "1.17.9"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.9.tgz"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-core/-/autocomplete-core-1.17.9.tgz#83374c47dc72482aa45d6b953e89377047f0dcdc"
   integrity sha512-O7BxrpLDPJWWHv/DLA9DRFWs+iY1uOJZkqUwjS5HSZAGcl0hIVCQ97LTLewiZmZ402JYUrun+8NqFP+hCknlbQ==
   dependencies:
     "@algolia/autocomplete-plugin-algolia-insights" "1.17.9"
@@ -27,282 +27,150 @@
 
 "@algolia/autocomplete-plugin-algolia-insights@1.17.9":
   version "1.17.9"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.9.tgz"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.9.tgz#74c86024d09d09e8bfa3dd90b844b77d9f9947b6"
   integrity sha512-u1fEHkCbWF92DBeB/KHeMacsjsoI0wFhjZtlCq2ddZbAehshbZST6Hs0Avkc0s+4UyBGbMDnSuXHLuvRWK5iDQ==
   dependencies:
     "@algolia/autocomplete-shared" "1.17.9"
 
 "@algolia/autocomplete-preset-algolia@1.17.9":
   version "1.17.9"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.9.tgz"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.9.tgz#911f3250544eb8ea4096fcfb268f156b085321b5"
   integrity sha512-Na1OuceSJeg8j7ZWn5ssMu/Ax3amtOwk76u4h5J4eK2Nx2KB5qt0Z4cOapCsxot9VcEN11ADV5aUSlQF4RhGjQ==
   dependencies:
     "@algolia/autocomplete-shared" "1.17.9"
 
 "@algolia/autocomplete-shared@1.17.9":
   version "1.17.9"
-  resolved "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.9.tgz"
+  resolved "https://registry.yarnpkg.com/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.9.tgz#5f38868f7cb1d54b014b17a10fc4f7e79d427fa8"
   integrity sha512-iDf05JDQ7I0b7JEA/9IektxN/80a2MZ1ToohfmNS3rfeuQnIKI3IJlIafD0xu4StbtQTghx9T3Maa97ytkXenQ==
 
-"@algolia/client-abtesting@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.23.3.tgz"
-  integrity sha512-yHI0hBwYcNPc+nJoHPTmmlP8pG6nstCEhpHaZQCDwLZhdMtNhd1hliZMCtLgNnvd1yKEgTt/ZDnTSdZLehfKdA==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-abtesting@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-abtesting/-/client-abtesting-5.37.0.tgz#37df3674ccc37dfb0aa4cbfea42002bb136fb909"
-  integrity sha512-Dp2Zq+x9qQFnuiQhVe91EeaaPxWBhzwQ6QnznZQnH9C1/ei3dvtmAFfFeaTxM6FzfJXDLvVnaQagTYFTQz3R5g==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/client-analytics@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.23.3.tgz"
-  integrity sha512-/70Ey+nZm4bRr2DcNrGU251YIn9lDu0g8xeP4jTCyunGRNFZ/d8hQAw9El34pcTpO1QDojJWAi6ywKIrUaks9w==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-analytics@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-analytics/-/client-analytics-5.37.0.tgz#6fb4d748e1af43d8bc9f955d73d98205ce1c1ee5"
-  integrity sha512-wyXODDOluKogTuZxRII6mtqhAq4+qUR3zIUJEKTiHLe8HMZFxfUEI4NO2qSu04noXZHbv/sRVdQQqzKh12SZuQ==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/client-common@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.23.3.tgz"
-  integrity sha512-fkpbPclIvaiyw3ADKRBCxMZhrNx/8//6DClfWGxeEiTJ0HEEYtHlqE6GjAkEJubz4v1ioCQkhZwMoFfFct2/vQ==
-
-"@algolia/client-common@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-common/-/client-common-5.37.0.tgz#f7ca097c4bae44e4ea365ee8f420693d0005c98e"
-  integrity sha512-GylIFlPvLy9OMgFG8JkonIagv3zF+Dx3H401Uo2KpmfMVBBJiGfAb9oYfXtplpRMZnZPxF5FnkWaI/NpVJMC+g==
-
-"@algolia/client-insights@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.23.3.tgz"
-  integrity sha512-TXc5Ve6QOCihWCTWY9N56CZxF1iovzpBWBUhQhy6JSiUfX3MXceV3saV+sXHQ1NVt2NKkyUfEspYHBsTrYzIDg==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-insights@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-insights/-/client-insights-5.37.0.tgz#f4f4011fc89bc0b2dfc384acc3c6fb38f633f4ec"
-  integrity sha512-T63afO2O69XHKw2+F7mfRoIbmXWGzgpZxgOFAdP3fR4laid7pWBt20P4eJ+Zn23wXS5kC9P2K7Bo3+rVjqnYiw==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/client-personalization@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.23.3.tgz"
-  integrity sha512-JlReruxxiw9LB53jF/BmvVV+c0thiWQUHRdgtbVIEusvRaiX1IdpWJSPQExEtBQ7VFg89nP8niCzWtA34ktKSA==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-personalization@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-personalization/-/client-personalization-5.37.0.tgz#c1688db681623b189f353599815a118033ceebb5"
-  integrity sha512-1zOIXM98O9zD8bYDCJiUJRC/qNUydGHK/zRK+WbLXrW1SqLFRXECsKZa5KoG166+o5q5upk96qguOtE8FTXDWQ==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/client-query-suggestions@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.23.3.tgz"
-  integrity sha512-GDEExFMXwx0ScE0AZUA4F6ssztdJvGcXUkdWmWyt2hbYz43ukqmlVJqPaYgGmWdjJjvTx+dNF/hcinwWuXbCug==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-query-suggestions@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-query-suggestions/-/client-query-suggestions-5.37.0.tgz#fa514df8d36fb548258c712f3ba6f97eb84ebb87"
-  integrity sha512-31Nr2xOLBCYVal+OMZn1rp1H4lPs1914Tfr3a34wU/nsWJ+TB3vWjfkUUuuYhWoWBEArwuRzt3YNLn0F/KRVkg==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/client-search@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.23.3.tgz"
-  integrity sha512-mwofV6tGo0oHt4BPi+S5eLC3wnhOa4A1OVgPxetTxZuetod+2W4cxKavUW2v/Ma5CABXPLooXX+g9E67umELZw==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-"@algolia/client-search@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/client-search/-/client-search-5.37.0.tgz#38c7110d96fbbbda7b7fb0578a18b8cad3c25af2"
-  integrity sha512-DAFVUvEg+u7jUs6BZiVz9zdaUebYULPiQ4LM2R4n8Nujzyj7BZzGr2DCd85ip4p/cx7nAZWKM8pLcGtkTRTdsg==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
+"@algolia/client-abtesting@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-abtesting/-/client-abtesting-5.39.0.tgz#7de7ad39e0b98b60bd25e61c113aab0d6918c80a"
+  integrity sha512-Vf0ZVe+qo3sHDrCinouJqlg8VoxM4Qo/KxNIqMYybkuctutfnp3kIY9OmESplOQ/9NGBthU9EG+4d5fBibWK/A==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
+
+"@algolia/client-analytics@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-analytics/-/client-analytics-5.39.0.tgz#be55775f09734d9031579657e182d5456e4f1924"
+  integrity sha512-V16ITZxYIwcv1arNce65JZmn94Ft6vKlBZ//gXw8AvIH32glJz1KcbaVAUr9p7PYlGZ/XVHP6LxDgrpNdtwgcA==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
+
+"@algolia/client-common@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-common/-/client-common-5.39.0.tgz#3c16868b645d6e984920ae43509726e19995042f"
+  integrity sha512-UCJTuwySEQeiKPWV3wruhuI/wHbDYenHzgL9pYsvh6r/u5Z+g61ip1iwdAlFp02CnywzI9O7+AQPh2ManYyHmQ==
+
+"@algolia/client-insights@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-insights/-/client-insights-5.39.0.tgz#0d03882ec93b63346459c67bc94f782ea17f7030"
+  integrity sha512-s0ia8M/ZZR+iO2uLNTBrlQdEb6ZMAMcKMHckp5mcoglxrf8gHifL4LmdhGKdAxAn3UIagtqIP0RCnIymHUbm7A==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
+
+"@algolia/client-personalization@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-personalization/-/client-personalization-5.39.0.tgz#ebf29cd9aeb9cde8a33fbd954d0452ab76969f8f"
+  integrity sha512-vZPIt7Lw+toNsHZUiPhNIc1Z3vUjDp7nzn6AMOaPC73gEuTq2iLPNvM06CSB6aHePo5eMeJIP5YEKBUQUA/PJA==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
+
+"@algolia/client-query-suggestions@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-query-suggestions/-/client-query-suggestions-5.39.0.tgz#4f5d11e404f6e16712b53c79115d05ee3de65a85"
+  integrity sha512-jcPQr3iKTWNVli2NYHPv02aNLwixDjPCpOgMp9CZTvEiPI6Ec4jHX+oFr3LDZagOFY9e1xJhc/JrgMGGW1sHnw==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
+
+"@algolia/client-search@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/client-search/-/client-search-5.39.0.tgz#fdce8cdb4cc972a5e1faf313316b5d9f126001bf"
+  integrity sha512-/IYpF10BpthGZEJQZMhMqV4AqWr5avcWfZm/SIKK1RvUDmzGqLoW/+xeJVX9C8ZnNkIC8hivbIQFaNaRw0BFZQ==
+  dependencies:
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
 "@algolia/events@^4.0.1":
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/@algolia/events/-/events-4.0.1.tgz#fd39e7477e7bc703d7f893b556f676c032af3950"
   integrity sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==
 
-"@algolia/ingestion@1.23.3":
-  version "1.23.3"
-  resolved "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.23.3.tgz"
-  integrity sha512-Zxgmi7Hk4lI52YFphzzJekUqWxYxVjY2GrCpOxV+QiojvUi8Ru+knq6REcwLHFSwpwaDh2Th5pOefMpn4EkQCw==
+"@algolia/ingestion@1.39.0":
+  version "1.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/ingestion/-/ingestion-1.39.0.tgz#4e2959a830523373aa92b20e80139ca828ac03dc"
+  integrity sha512-IgSHKUiuecqLfBlXiuCSdRTdsO3/yvpmXrMFz8fAJ8M4QmDtHkOuD769dmybRYqsbYMHivw+lir4BgbRGMtOIQ==
   dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
-"@algolia/ingestion@1.37.0":
-  version "1.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/ingestion/-/ingestion-1.37.0.tgz#bb6016e656c68014050814abf130e103f977794e"
-  integrity sha512-pkCepBRRdcdd7dTLbFddnu886NyyxmhgqiRcHHaDunvX03Ij4WzvouWrQq7B7iYBjkMQrLS8wQqSP0REfA4W8g==
+"@algolia/monitoring@1.39.0":
+  version "1.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/monitoring/-/monitoring-1.39.0.tgz#c7292bc099351e9a63cb9c63f1531b2eba84c7b8"
+  integrity sha512-8Xnd4+609SKC/hqVsuFc4evFBmvA2765/4NcH+Dpr756SKPbL1BY0X8kVxlmM3YBLNqnduSQxHxpDJUK58imCA==
   dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
-"@algolia/monitoring@1.23.3":
-  version "1.23.3"
-  resolved "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.23.3.tgz"
-  integrity sha512-zi/IqvsmFW4E5gMaovAE4KRbXQ+LDYpPGG1nHtfuD5u3SSuQ31fT1vX2zqb6PbPTlgJMEmMk91Mbb7fIKmbQUw==
+"@algolia/recommend@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/recommend/-/recommend-5.39.0.tgz#6b8ebfc05e86df0e6f499c81ad3b9025191a973f"
+  integrity sha512-D7Ye2Ss/5xqUkQUxKm/VqEJLt5kARd9IMmjdzlxaKhGgNlOemTay0lwBmOVFuJRp7UODjp5c9+K+B8g0ORObIw==
   dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
+    "@algolia/client-common" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
-"@algolia/monitoring@1.37.0":
-  version "1.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/monitoring/-/monitoring-1.37.0.tgz#6d20c220d648db8faea45679350f1516917cc13d"
-  integrity sha512-fNw7pVdyZAAQQCJf1cc/ih4fwrRdQSgKwgor4gchsI/Q/ss9inmC6bl/69jvoRSzgZS9BX4elwHKdo0EfTli3w==
+"@algolia/requester-browser-xhr@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.39.0.tgz#2fc3a126cda69c1ea1f0130a5bd3d1a5abdfe8f0"
+  integrity sha512-mgPte1ZJqpk9dkVs44J3wKAbHATvHZNlSpzhMdjMLIg/3qTycSZyDiomLiSlxE8CLsxyBAOJWnyKRHfom+Z1rg==
   dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
+    "@algolia/client-common" "5.39.0"
 
-"@algolia/recommend@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.23.3.tgz"
-  integrity sha512-C9TwbT1zGwULLXGSUSB+G7o/30djacPmQcsTHepvT47PVfPr2ISK/5QVtUnjMU84LEP8uNjuPUeM4ZeWVJ2iuQ==
+"@algolia/requester-fetch@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-fetch/-/requester-fetch-5.39.0.tgz#f470926aa005ce5b1f4728ecd645032ed2f43f91"
+  integrity sha512-LIrCkrxu1WnO3ev1+w6NnZ12JZL/o+2H9w6oWnZAjQZIlA/Ym6M9QHkt+OQ/SwkuoiNkW3DAo+Pi4A2V9FPtqg==
   dependencies:
-    "@algolia/client-common" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
+    "@algolia/client-common" "5.39.0"
 
-"@algolia/recommend@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/recommend/-/recommend-5.37.0.tgz#dd5e814f30bbb92395902e120fdb28a120b91341"
-  integrity sha512-U+FL5gzN2ldx3TYfQO5OAta2TBuIdabEdFwD5UVfWPsZE5nvOKkc/6BBqP54Z/adW/34c5ZrvvZhlhNTZujJXQ==
+"@algolia/requester-node-http@5.39.0":
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/@algolia/requester-node-http/-/requester-node-http-5.39.0.tgz#537cec65ebee684fe0cec7921128c425f95ff0bd"
+  integrity sha512-6beG+egPwXmvhAg+m0STCj+ZssDcjrLzf4L05aKm2nGglMXSSPz0cH/rM+kVD9krNfldiMctURd4wjojW1fV0w==
   dependencies:
-    "@algolia/client-common" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
-
-"@algolia/requester-browser-xhr@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.23.3.tgz"
-  integrity sha512-/7oYeUhYzY0lls7WtkAURM6wy21/Wwmq9GdujW1MpoYVC0ATXXxwCiAfOpYL9xdWxLV0R3wjyD+yZEni+nboKg==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-
-"@algolia/requester-browser-xhr@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.37.0.tgz#8851ab846d8005055c36a59422161ebe1594ae48"
-  integrity sha512-Ao8GZo8WgWFABrU7iq+JAftXV0t+UcOtCDL4mzHHZ+rQeTTf1TZssr4d0vIuoqkVNnKt9iyZ7T4lQff4ydcTrw==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-
-"@algolia/requester-fetch@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.23.3.tgz"
-  integrity sha512-r/4fKz4t+bSU1KdjRq+swdNvuGfJ0spV8aFTHPtcsF+1ZaN/VqmdXrTe5NkaZLSztFeMqKwZlJIVvE7VuGlFtw==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-
-"@algolia/requester-fetch@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/requester-fetch/-/requester-fetch-5.37.0.tgz#93602fdc9a59b41ecd53768c53c11cddb0db846a"
-  integrity sha512-H7OJOXrFg5dLcGJ22uxx8eiFId0aB9b0UBhoOi4SMSuDBe6vjJJ/LeZyY25zPaSvkXNBN3vAM+ad6M0h6ha3AA==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
-
-"@algolia/requester-node-http@5.23.3":
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.23.3.tgz"
-  integrity sha512-UZiTNmUBQFPl3tUKuXaDd8BxEC0t0ny86wwW6XgwfM9IQf4PrzuMpvuOGIJMcCGlrNolZDEI0mcbz/tqRdKW7A==
-  dependencies:
-    "@algolia/client-common" "5.23.3"
-
-"@algolia/requester-node-http@5.37.0":
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/@algolia/requester-node-http/-/requester-node-http-5.37.0.tgz#83da1b52f3ee86f262a5d4b2a88a74db665211c2"
-  integrity sha512-npZ9aeag4SGTx677eqPL3rkSPlQrnzx/8wNrl1P7GpWq9w/eTmRbOq+wKrJ2r78idlY0MMgmY/mld2tq6dc44g==
-  dependencies:
-    "@algolia/client-common" "5.37.0"
+    "@algolia/client-common" "5.39.0"
 
 "@alloc/quick-lru@^5.2.0":
   version "5.2.0"
-  resolved "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@alloc/quick-lru/-/quick-lru-5.2.0.tgz#7bf68b20c0a350f936915fcae06f58e32007ce30"
   integrity sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==
 
-"@ampproject/remapping@^2.2.0":
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz"
-  integrity sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==
-  dependencies:
-    "@jridgewell/gen-mapping" "^0.3.5"
-    "@jridgewell/trace-mapping" "^0.3.24"
-
-"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.24.7.tgz"
-  integrity sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==
-  dependencies:
-    "@babel/highlight" "^7.24.7"
-    picocolors "^1.0.0"
-
-"@babel/code-frame@^7.27.1":
+"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.23.5", "@babel/code-frame@^7.27.1":
   version "7.27.1"
   resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be"
   integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==
@@ -311,68 +179,32 @@
     js-tokens "^4.0.0"
     picocolors "^1.1.1"
 
-"@babel/compat-data@^7.22.6", "@babel/compat-data@^7.25.2", "@babel/compat-data@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.25.4.tgz"
-  integrity sha512-+LGRog6RAsCJrrrg/IO6LGmpphNe5DiK30dGjCoxxeGv49B10/3XYGxPsAwrDlMFcFEvdAUavDT8r9k/hSyQqQ==
-
-"@babel/compat-data@^7.27.2":
-  version "7.28.0"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.28.0.tgz#9fc6fd58c2a6a15243cd13983224968392070790"
-  integrity sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw==
+"@babel/compat-data@^7.27.2", "@babel/compat-data@^7.27.7", "@babel/compat-data@^7.28.0":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.28.4.tgz#96fdf1af1b8859c8474ab39c295312bfb7c24b04"
+  integrity sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==
 
-"@babel/core@^7.18.5":
-  version "7.28.3"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.28.3.tgz#aceddde69c5d1def69b839d09efa3e3ff59c97cb"
-  integrity sha512-yDBHV9kQNcr2/sUr9jghVyz9C3Y5G2zUM2H2lo+9mKv4sFgbA8s8Z9t8D1jiTkGoO/NoIfKMyKWr4s6CN23ZwQ==
+"@babel/core@^7.18.5", "@babel/core@^7.21.3":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.28.4.tgz#12a550b8794452df4c8b084f95003bce1742d496"
+  integrity sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==
   dependencies:
-    "@ampproject/remapping" "^2.2.0"
     "@babel/code-frame" "^7.27.1"
     "@babel/generator" "^7.28.3"
     "@babel/helper-compilation-targets" "^7.27.2"
     "@babel/helper-module-transforms" "^7.28.3"
-    "@babel/helpers" "^7.28.3"
-    "@babel/parser" "^7.28.3"
+    "@babel/helpers" "^7.28.4"
+    "@babel/parser" "^7.28.4"
     "@babel/template" "^7.27.2"
-    "@babel/traverse" "^7.28.3"
-    "@babel/types" "^7.28.2"
+    "@babel/traverse" "^7.28.4"
+    "@babel/types" "^7.28.4"
+    "@jridgewell/remapping" "^2.3.5"
     convert-source-map "^2.0.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
     json5 "^2.2.3"
     semver "^6.3.1"
 
-"@babel/core@^7.21.3":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/core/-/core-7.25.2.tgz"
-  integrity sha512-BBt3opiCOxUr9euZ5/ro/Xv8/V7yJ5bjYMqG/C1YAo8MIKAnumZalCN+msbci3Pigy4lIQfPUpfMM27HMGaYEA==
-  dependencies:
-    "@ampproject/remapping" "^2.2.0"
-    "@babel/code-frame" "^7.24.7"
-    "@babel/generator" "^7.25.0"
-    "@babel/helper-compilation-targets" "^7.25.2"
-    "@babel/helper-module-transforms" "^7.25.2"
-    "@babel/helpers" "^7.25.0"
-    "@babel/parser" "^7.25.0"
-    "@babel/template" "^7.25.0"
-    "@babel/traverse" "^7.25.2"
-    "@babel/types" "^7.25.2"
-    convert-source-map "^2.0.0"
-    debug "^4.1.0"
-    gensync "^1.0.0-beta.2"
-    json5 "^2.2.3"
-    semver "^6.3.1"
-
-"@babel/generator@^7.25.0", "@babel/generator@^7.25.6":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/generator/-/generator-7.25.6.tgz"
-  integrity sha512-VPC82gr1seXOpkjAAKoLhP50vx4vGNlF4msF64dSFq1P8RfB+QAuJWGHPXXPc8QyfVWwwB/TNNU4+ayZmHNbZw==
-  dependencies:
-    "@babel/types" "^7.25.6"
-    "@jridgewell/gen-mapping" "^0.3.5"
-    "@jridgewell/trace-mapping" "^0.3.25"
-    jsesc "^2.5.1"
-
 "@babel/generator@^7.28.3":
   version "7.28.3"
   resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.28.3.tgz#9626c1741c650cbac39121694a0f2d7451b8ef3e"
@@ -384,33 +216,14 @@
     "@jridgewell/trace-mapping" "^0.3.28"
     jsesc "^3.0.2"
 
-"@babel/helper-annotate-as-pure@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.24.7.tgz"
-  integrity sha512-BaDeOonYvhdKw+JoMVkAixAAJzG2jVPIwWoKBPdYuY9b452e2rPuI9QPYh3KpofZ3pW2akOmwZLOiOsHMiqRAg==
-  dependencies:
-    "@babel/types" "^7.24.7"
-
-"@babel/helper-builder-binary-assignment-operator-visitor@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.24.7.tgz"
-  integrity sha512-xZeCVVdwb4MsDBkkyZ64tReWYrLRHlMN72vP7Bdm3OUOuyFZExhsHUUnuWnm2/XOlAJzR0LfPpB56WXZn0X/lA==
-  dependencies:
-    "@babel/traverse" "^7.24.7"
-    "@babel/types" "^7.24.7"
-
-"@babel/helper-compilation-targets@^7.22.6", "@babel/helper-compilation-targets@^7.24.7", "@babel/helper-compilation-targets@^7.24.8", "@babel/helper-compilation-targets@^7.25.2":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.2.tgz"
-  integrity sha512-U2U5LsSaZ7TAt3cfaymQ8WHh0pxvdHoEk6HVpaexxixjyEquMh0L0YNJNM6CTGKMXV1iksi0iZkGw4AcFkPaaw==
+"@babel/helper-annotate-as-pure@^7.27.1", "@babel/helper-annotate-as-pure@^7.27.3":
+  version "7.27.3"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz#f31fd86b915fc4daf1f3ac6976c59be7084ed9c5"
+  integrity sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==
   dependencies:
-    "@babel/compat-data" "^7.25.2"
-    "@babel/helper-validator-option" "^7.24.8"
-    browserslist "^4.23.1"
-    lru-cache "^5.1.1"
-    semver "^6.3.1"
+    "@babel/types" "^7.27.3"
 
-"@babel/helper-compilation-targets@^7.27.2":
+"@babel/helper-compilation-targets@^7.27.1", "@babel/helper-compilation-targets@^7.27.2":
   version "7.27.2"
   resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz#46a0f6efab808d51d29ce96858dd10ce8732733d"
   integrity sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==
@@ -421,59 +234,51 @@
     lru-cache "^5.1.1"
     semver "^6.3.1"
 
-"@babel/helper-create-class-features-plugin@^7.24.7", "@babel/helper-create-class-features-plugin@^7.25.0", "@babel/helper-create-class-features-plugin@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.4.tgz"
-  integrity sha512-ro/bFs3/84MDgDmMwbcHgDa8/E6J3QKNTk4xJJnVeFtGE+tL0K26E3pNxhYz2b67fJpt7Aphw5XcploKXuCvCQ==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-member-expression-to-functions" "^7.24.8"
-    "@babel/helper-optimise-call-expression" "^7.24.7"
-    "@babel/helper-replace-supers" "^7.25.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
-    "@babel/traverse" "^7.25.4"
+"@babel/helper-create-class-features-plugin@^7.27.1", "@babel/helper-create-class-features-plugin@^7.28.3":
+  version "7.28.3"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.3.tgz#3e747434ea007910c320c4d39a6b46f20f371d46"
+  integrity sha512-V9f6ZFIYSLNEbuGA/92uOvYsGCJNsuA8ESZ4ldc09bWk/j8H8TKiPw8Mk1eG6olpnO0ALHJmYfZvF4MEE4gajg==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-member-expression-to-functions" "^7.27.1"
+    "@babel/helper-optimise-call-expression" "^7.27.1"
+    "@babel/helper-replace-supers" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/traverse" "^7.28.3"
     semver "^6.3.1"
 
-"@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.24.7", "@babel/helper-create-regexp-features-plugin@^7.25.0", "@babel/helper-create-regexp-features-plugin@^7.25.2":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.25.2.tgz"
-  integrity sha512-+wqVGP+DFmqwFD3EH6TMTfUNeqDehV3E/dl+Sd54eaXqm17tEUNbEIn4sVivVowbvUpOtIGxdo3GoXyDH9N/9g==
+"@babel/helper-create-regexp-features-plugin@^7.18.6", "@babel/helper-create-regexp-features-plugin@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.27.1.tgz#05b0882d97ba1d4d03519e4bce615d70afa18c53"
+  integrity sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    regexpu-core "^5.3.1"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    regexpu-core "^6.2.0"
     semver "^6.3.1"
 
-"@babel/helper-define-polyfill-provider@^0.6.2":
-  version "0.6.2"
-  resolved "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.2.tgz"
-  integrity sha512-LV76g+C502biUK6AyZ3LK10vDpDyCzZnhZFXkH1L75zHPj68+qc8Zfpx2th+gzwA2MzyK+1g/3EPl62yFnVttQ==
+"@babel/helper-define-polyfill-provider@^0.6.5":
+  version "0.6.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.5.tgz#742ccf1cb003c07b48859fc9fa2c1bbe40e5f753"
+  integrity sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.22.6"
-    "@babel/helper-plugin-utils" "^7.22.5"
-    debug "^4.1.1"
+    "@babel/helper-compilation-targets" "^7.27.2"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    debug "^4.4.1"
     lodash.debounce "^4.0.8"
-    resolve "^1.14.2"
+    resolve "^1.22.10"
 
 "@babel/helper-globals@^7.28.0":
   version "7.28.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz#b9430df2aa4e17bc28665eadeae8aa1d985e6674"
   integrity sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==
 
-"@babel/helper-member-expression-to-functions@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.24.8.tgz"
-  integrity sha512-LABppdt+Lp/RlBxqrh4qgf1oEH/WxdzQNDJIu5gC/W1GyvPVrOBiItmmM8wan2fm4oYqFuFfkXmlGpLQhPY8CA==
-  dependencies:
-    "@babel/traverse" "^7.24.8"
-    "@babel/types" "^7.24.8"
-
-"@babel/helper-module-imports@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.24.7.tgz"
-  integrity sha512-8AyH3C+74cgCVVXow/myrynrAGv+nTVg5vKu2nZph9x7RcRwzmh0VFallJuFTZ9mx6u4eSdXZfcOzSqTUm0HCA==
+"@babel/helper-member-expression-to-functions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.27.1.tgz#ea1211276be93e798ce19037da6f06fbb994fa44"
+  integrity sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==
   dependencies:
-    "@babel/traverse" "^7.24.7"
-    "@babel/types" "^7.24.7"
+    "@babel/traverse" "^7.27.1"
+    "@babel/types" "^7.27.1"
 
 "@babel/helper-module-imports@^7.27.1":
   version "7.27.1"
@@ -483,17 +288,7 @@
     "@babel/traverse" "^7.27.1"
     "@babel/types" "^7.27.1"
 
-"@babel/helper-module-transforms@^7.24.7", "@babel/helper-module-transforms@^7.24.8", "@babel/helper-module-transforms@^7.25.0", "@babel/helper-module-transforms@^7.25.2":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.25.2.tgz"
-  integrity sha512-BjyRAbix6j/wv83ftcVJmBt72QtHI56C7JXZoG2xATiLpmoC7dpd8WnkikExHDVPpi/3qCmO6WY1EaXOluiecQ==
-  dependencies:
-    "@babel/helper-module-imports" "^7.24.7"
-    "@babel/helper-simple-access" "^7.24.7"
-    "@babel/helper-validator-identifier" "^7.24.7"
-    "@babel/traverse" "^7.25.2"
-
-"@babel/helper-module-transforms@^7.28.3":
+"@babel/helper-module-transforms@^7.27.1", "@babel/helper-module-transforms@^7.28.3":
   version "7.28.3"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz#a2b37d3da3b2344fe085dab234426f2b9a2fa5f6"
   integrity sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==
@@ -502,852 +297,690 @@
     "@babel/helper-validator-identifier" "^7.27.1"
     "@babel/traverse" "^7.28.3"
 
-"@babel/helper-optimise-call-expression@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.24.7.tgz"
-  integrity sha512-jKiTsW2xmWwxT1ixIdfXUZp+P5yURx2suzLZr5Hi64rURpDYdMW0pv+Uf17EYk2Rd428Lx4tLsnjGJzYKDM/6A==
+"@babel/helper-optimise-call-expression@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz#c65221b61a643f3e62705e5dd2b5f115e35f9200"
+  integrity sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==
   dependencies:
-    "@babel/types" "^7.24.7"
-
-"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.22.5", "@babel/helper-plugin-utils@^7.24.7", "@babel/helper-plugin-utils@^7.24.8", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.8.tgz"
-  integrity sha512-FFWx5142D8h2Mgr/iPVGH5G7w6jDn4jUSpZTyDnQO0Yn7Ks2Kuz6Pci8H6MPCoUJegd/UZQ3tAvfLCxQSnWWwg==
+    "@babel/types" "^7.27.1"
 
-"@babel/helper-remap-async-to-generator@^7.24.7", "@babel/helper-remap-async-to-generator@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.25.0.tgz"
-  integrity sha512-NhavI2eWEIz/H9dbrG0TuOicDhNexze43i5z7lEqwYm0WEZVTwnPpA0EafUTP7+6/W79HWIP2cTe3Z5NiSTVpw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-wrap-function" "^7.25.0"
-    "@babel/traverse" "^7.25.0"
+"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.18.6", "@babel/helper-plugin-utils@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz#ddb2f876534ff8013e6c2b299bf4d39b3c51d44c"
+  integrity sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==
 
-"@babel/helper-replace-supers@^7.24.7", "@babel/helper-replace-supers@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.25.0.tgz"
-  integrity sha512-q688zIvQVYtZu+i2PsdIu/uWGRpfxzr5WESsfpShfZECkO+d2o+WROWezCi/Q6kJ0tfPa5+pUGUlfx2HhrA3Bg==
+"@babel/helper-remap-async-to-generator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz#4601d5c7ce2eb2aea58328d43725523fcd362ce6"
+  integrity sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==
   dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.24.8"
-    "@babel/helper-optimise-call-expression" "^7.24.7"
-    "@babel/traverse" "^7.25.0"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-wrap-function" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/helper-simple-access@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.24.7.tgz"
-  integrity sha512-zBAIvbCMh5Ts+b86r/CjU+4XGYIs+R1j951gxI3KmmxBMhCg4oQMsv6ZXQ64XOm/cvzfU1FmoCyt6+owc5QMYg==
+"@babel/helper-replace-supers@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz#b1ed2d634ce3bdb730e4b52de30f8cccfd692bc0"
+  integrity sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==
   dependencies:
-    "@babel/traverse" "^7.24.7"
-    "@babel/types" "^7.24.7"
+    "@babel/helper-member-expression-to-functions" "^7.27.1"
+    "@babel/helper-optimise-call-expression" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/helper-skip-transparent-expression-wrappers@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.24.7.tgz"
-  integrity sha512-IO+DLT3LQUElMbpzlatRASEyQtfhSE0+m465v++3jyyXeBTBUjtVZg28/gHeV5mrTJqvEKhKroBGAvhW+qPHiQ==
+"@babel/helper-skip-transparent-expression-wrappers@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz#62bb91b3abba8c7f1fec0252d9dbea11b3ee7a56"
+  integrity sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==
   dependencies:
-    "@babel/traverse" "^7.24.7"
-    "@babel/types" "^7.24.7"
-
-"@babel/helper-string-parser@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.24.8.tgz"
-  integrity sha512-pO9KhhRcuUyGnJWwyEgnRJTSIZHiT+vMD0kPeD+so0l7mxkMT19g3pjY9GTnHySck/hDzq+dtW/4VgnMkippsQ==
+    "@babel/traverse" "^7.27.1"
+    "@babel/types" "^7.27.1"
 
 "@babel/helper-string-parser@^7.27.1":
   version "7.27.1"
   resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz#54da796097ab19ce67ed9f88b47bb2ec49367687"
   integrity sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==
 
-"@babel/helper-validator-identifier@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz"
-  integrity sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==
-
 "@babel/helper-validator-identifier@^7.27.1":
   version "7.27.1"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz#a7054dcc145a967dd4dc8fee845a57c1316c9df8"
   integrity sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==
 
-"@babel/helper-validator-option@^7.24.7", "@babel/helper-validator-option@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.24.8.tgz"
-  integrity sha512-xb8t9tD1MHLungh/AIoWYN+gVHaB9kwlu8gffXGSt3FFEIT7RjS+xWbc2vUD1UTZdIpKj/ab3rdqJ7ufngyi2Q==
-
 "@babel/helper-validator-option@^7.27.1":
   version "7.27.1"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz#fa52f5b1e7db1ab049445b421c4471303897702f"
   integrity sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==
 
-"@babel/helper-wrap-function@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.25.0.tgz"
-  integrity sha512-s6Q1ebqutSiZnEjaofc/UKDyC4SbzV5n5SrA2Gq8UawLycr3i04f1dX4OzoQVnexm6aOCh37SQNYlJ/8Ku+PMQ==
-  dependencies:
-    "@babel/template" "^7.25.0"
-    "@babel/traverse" "^7.25.0"
-    "@babel/types" "^7.25.0"
-
-"@babel/helpers@^7.25.0":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/helpers/-/helpers-7.25.6.tgz"
-  integrity sha512-Xg0tn4HcfTijTwfDwYlvVCl43V6h4KyVVX2aEm4qdO/PC6L2YvzLHFdmxhoeSA3eslcE6+ZVXHgWwopXYLNq4Q==
-  dependencies:
-    "@babel/template" "^7.25.0"
-    "@babel/types" "^7.25.6"
-
-"@babel/helpers@^7.28.3":
+"@babel/helper-wrap-function@^7.27.1":
   version "7.28.3"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.28.3.tgz#b83156c0a2232c133d1b535dd5d3452119c7e441"
-  integrity sha512-PTNtvUQihsAsDHMOP5pfobP8C6CM4JWXmP8DrEIt46c3r2bf87Ua1zoqevsMo9g+tWDwgWrFP5EIxuBx5RudAw==
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.28.3.tgz#fe4872092bc1438ffd0ce579e6f699609f9d0a7a"
+  integrity sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==
   dependencies:
     "@babel/template" "^7.27.2"
+    "@babel/traverse" "^7.28.3"
     "@babel/types" "^7.28.2"
 
-"@babel/highlight@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.24.7.tgz"
-  integrity sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.24.7"
-    chalk "^2.4.2"
-    js-tokens "^4.0.0"
-    picocolors "^1.0.0"
-
-"@babel/parser@^7.25.0", "@babel/parser@^7.25.6":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.25.6.tgz"
-  integrity sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q==
+"@babel/helpers@^7.28.4":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.28.4.tgz#fe07274742e95bdf7cf1443593eeb8926ab63827"
+  integrity sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==
   dependencies:
-    "@babel/types" "^7.25.6"
+    "@babel/template" "^7.27.2"
+    "@babel/types" "^7.28.4"
 
-"@babel/parser@^7.27.2", "@babel/parser@^7.28.3":
-  version "7.28.3"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.28.3.tgz#d2d25b814621bca5fe9d172bc93792547e7a2a71"
-  integrity sha512-7+Ey1mAgYqFAx2h0RuoxcQT5+MlG3GTV0TQrgr7/ZliKsm/MNDxVVutlWaziMq7wJNAz8MTqz55XLpWvva6StA==
+"@babel/parser@^7.27.2", "@babel/parser@^7.28.3", "@babel/parser@^7.28.4":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.28.4.tgz#da25d4643532890932cc03f7705fe19637e03fa8"
+  integrity sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==
   dependencies:
-    "@babel/types" "^7.28.2"
+    "@babel/types" "^7.28.4"
 
-"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.25.3":
-  version "7.25.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.25.3.tgz"
-  integrity sha512-wUrcsxZg6rqBXG05HG1FPYgsP6EvwF4WpBbxIpWIIYnH8wG0gzx3yZY3dtEHas4sTAOGkbTsc9EGPxwff8lRoA==
+"@babel/plugin-bugfix-firefox-class-in-computed-class-key@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.27.1.tgz#61dd8a8e61f7eb568268d1b5f129da3eee364bf9"
+  integrity sha512-QPG3C9cCVRQLxAVwmefEmwdTanECuUBMQZ/ym5kiw3XKCGA7qkuQLcjWWHcrD/GKbn/WmJwaezfuuAOcyKlRPA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/traverse" "^7.25.3"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/plugin-bugfix-safari-class-field-initializer-scope@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.25.0.tgz"
-  integrity sha512-Bm4bH2qsX880b/3ziJ8KD711LT7z4u8CFudmjqle65AZj/HNUFhEf90dqYv6O86buWvSBmeQDjv0Tn2aF/bIBA==
+"@babel/plugin-bugfix-safari-class-field-initializer-scope@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz#43f70a6d7efd52370eefbdf55ae03d91b293856d"
+  integrity sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.25.0.tgz"
-  integrity sha512-lXwdNZtTmeVOOFtwM/WDe7yg1PL8sYhRk/XH0FzbR2HDQ0xC+EnQ/JHeoMYSavtU115tnUk0q9CDyq8si+LMAA==
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz#beb623bd573b8b6f3047bd04c32506adc3e58a72"
+  integrity sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.24.7.tgz"
-  integrity sha512-+izXIbke1T33mY4MSNnrqhPXDz01WYhEf3yF5NbnUtkiNnm+XBZJl3kNfoK6NKmYlz/D07+l2GWVK/QfDkNCuQ==
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz#e134a5479eb2ba9c02714e8c1ebf1ec9076124fd"
+  integrity sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
-    "@babel/plugin-transform-optional-chaining" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/plugin-transform-optional-chaining" "^7.27.1"
 
-"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.25.0.tgz"
-  integrity sha512-tggFrk1AIShG/RUQbEwt2Tr/E+ObkfwrPjR6BjbRvsx24+PSjK8zrq0GWPNCjo8qpRx4DuJzlcvWJqlm+0h3kw==
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@^7.28.3":
+  version "7.28.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.3.tgz#373f6e2de0016f73caf8f27004f61d167743742a"
+  integrity sha512-b6YTX108evsvE4YgWyQ921ZAFFQm3Bn+CA3+ZXlNVnPhx+UfsVURoPjfGAPCjBgrqo30yX/C2nZGX96DxvR9Iw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/traverse" "^7.25.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.28.3"
 
 "@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2":
   version "7.21.0-placeholder-for-preset-env.2"
-  resolved "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz#7844f9289546efa9febac2de4cfe358a050bd703"
   integrity sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==
 
-"@babel/plugin-syntax-async-generators@^7.8.4":
-  version "7.8.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz"
-  integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-class-properties@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz"
-  integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
+"@babel/plugin-syntax-import-assertions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.27.1.tgz#88894aefd2b03b5ee6ad1562a7c8e1587496aecd"
+  integrity sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-class-static-block@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz"
-  integrity sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==
+"@babel/plugin-syntax-import-attributes@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz#34c017d54496f9b11b61474e7ea3dfd5563ffe07"
+  integrity sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-dynamic-import@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz"
-  integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
+"@babel/plugin-syntax-jsx@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz#2f9beb5eff30fa507c5532d107daac7b888fa34c"
+  integrity sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-export-namespace-from@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz"
-  integrity sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==
+"@babel/plugin-syntax-typescript@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz#5147d29066a793450f220c63fa3a9431b7e6dd18"
+  integrity sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.3"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-import-assertions@^7.24.7":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.25.6.tgz"
-  integrity sha512-aABl0jHw9bZ2karQ/uUD6XP4u0SG22SJrOHFoL6XB1R7dTovOP4TzTlsxOYC5yQ1pdscVK2JTUnF6QL3ARoAiQ==
+"@babel/plugin-syntax-unicode-sets-regex@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz#d49a3b3e6b52e5be6740022317580234a6a47357"
+  integrity sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-create-regexp-features-plugin" "^7.18.6"
+    "@babel/helper-plugin-utils" "^7.18.6"
 
-"@babel/plugin-syntax-import-attributes@^7.24.7":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.25.6.tgz"
-  integrity sha512-sXaDXaJN9SNLymBdlWFA+bjzBhFD617ZaFiY13dGt7TVslVvVgA6fkZOP7Ki3IGElC45lwHdOTrCtKZGVAWeLQ==
+"@babel/plugin-transform-arrow-functions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz#6e2061067ba3ab0266d834a9f94811196f2aba9a"
+  integrity sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-import-meta@^7.10.4":
-  version "7.10.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz"
-  integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==
+"@babel/plugin-transform-async-generator-functions@^7.28.0":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.28.0.tgz#1276e6c7285ab2cd1eccb0bc7356b7a69ff842c2"
+  integrity sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.10.4"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-remap-async-to-generator" "^7.27.1"
+    "@babel/traverse" "^7.28.0"
 
-"@babel/plugin-syntax-json-strings@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz"
-  integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
+"@babel/plugin-transform-async-to-generator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.27.1.tgz#9a93893b9379b39466c74474f55af03de78c66e7"
+  integrity sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-module-imports" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-remap-async-to-generator" "^7.27.1"
 
-"@babel/plugin-syntax-jsx@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.24.7.tgz"
-  integrity sha512-6ddciUPe/mpMnOKv/U+RSd2vvVy+Yw/JfBB0ZHYjEZt9NLHmCUylNYlsbqCCS1Bffjlb0fCwC9Vqz+sBz6PsiQ==
+"@babel/plugin-transform-block-scoped-functions@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz#558a9d6e24cf72802dd3b62a4b51e0d62c0f57f9"
+  integrity sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
-  version "7.10.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz"
-  integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
+"@babel/plugin-transform-block-scoping@^7.28.0":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.4.tgz#e19ac4ddb8b7858bac1fd5c1be98a994d9726410"
+  integrity sha512-1yxmvN0MJHOhPVmAsmoW5liWwoILobu/d/ShymZmj867bAdxGbehIrew1DuLpw2Ukv+qDSSPQdYW1dLNE7t11A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.10.4"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz"
-  integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
+"@babel/plugin-transform-class-properties@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.27.1.tgz#dd40a6a370dfd49d32362ae206ddaf2bb082a925"
+  integrity sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-create-class-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-numeric-separator@^7.10.4":
-  version "7.10.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz"
-  integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
+"@babel/plugin-transform-class-static-block@^7.28.3":
+  version "7.28.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.3.tgz#d1b8e69b54c9993bc558203e1f49bfc979bfd852"
+  integrity sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.10.4"
+    "@babel/helper-create-class-features-plugin" "^7.28.3"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-object-rest-spread@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz"
-  integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
+"@babel/plugin-transform-classes@^7.28.3":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.4.tgz#75d66175486788c56728a73424d67cbc7473495c"
+  integrity sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-compilation-targets" "^7.27.2"
+    "@babel/helper-globals" "^7.28.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-replace-supers" "^7.27.1"
+    "@babel/traverse" "^7.28.4"
 
-"@babel/plugin-syntax-optional-catch-binding@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz"
-  integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
+"@babel/plugin-transform-computed-properties@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.27.1.tgz#81662e78bf5e734a97982c2b7f0a793288ef3caa"
+  integrity sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/template" "^7.27.1"
 
-"@babel/plugin-syntax-optional-chaining@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz"
-  integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
+"@babel/plugin-transform-destructuring@^7.28.0":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.0.tgz#0f156588f69c596089b7d5b06f5af83d9aa7f97a"
+  integrity sha512-v1nrSMBiKcodhsyJ4Gf+Z0U/yawmJDBOTpEB3mcQY52r9RIyPneGyAS/yM6seP/8I+mWI3elOMtT5dB8GJVs+A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.28.0"
 
-"@babel/plugin-syntax-private-property-in-object@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz"
-  integrity sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==
+"@babel/plugin-transform-dotall-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.27.1.tgz#aa6821de864c528b1fecf286f0a174e38e826f4d"
+  integrity sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-top-level-await@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz"
-  integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==
+"@babel/plugin-transform-duplicate-keys@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz#f1fbf628ece18e12e7b32b175940e68358f546d1"
+  integrity sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-typescript@^7.24.7":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.4.tgz"
-  integrity sha512-uMOCoHVU52BsSWxPOMVv5qKRdeSlPuImUCB2dlPuBSU+W2/ROE7/Zg8F2Kepbk+8yBa68LlRKxO+xgEVWorsDg==
+"@babel/plugin-transform-duplicate-named-capturing-groups-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.27.1.tgz#5043854ca620a94149372e69030ff8cb6a9eb0ec"
+  integrity sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-syntax-unicode-sets-regex@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz"
-  integrity sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==
+"@babel/plugin-transform-dynamic-import@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz#4c78f35552ac0e06aa1f6e3c573d67695e8af5a4"
+  integrity sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.18.6"
-    "@babel/helper-plugin-utils" "^7.18.6"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-arrow-functions@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.24.7.tgz"
-  integrity sha512-Dt9LQs6iEY++gXUwY03DNFat5C2NbO48jj+j/bSAz6b3HgPs39qcPiYt77fDObIcFwj3/C2ICX9YMwGflUoSHQ==
+"@babel/plugin-transform-explicit-resource-management@^7.28.0":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.0.tgz#45be6211b778dbf4b9d54c4e8a2b42fa72e09a1a"
+  integrity sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/plugin-transform-destructuring" "^7.28.0"
 
-"@babel/plugin-transform-async-generator-functions@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.25.4.tgz"
-  integrity sha512-jz8cV2XDDTqjKPwVPJBIjORVEmSGYhdRa8e5k5+vN+uwcjSrSxUaebBRa4ko1jqNF2uxyg8G6XYk30Jv285xzg==
+"@babel/plugin-transform-exponentiation-operator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.27.1.tgz#fc497b12d8277e559747f5a3ed868dd8064f83e1"
+  integrity sha512-uspvXnhHvGKf2r4VVtBpeFnuDWsJLQ6MF6lGJLC89jBR1uoVeqM416AZtTuhTezOfgHicpJQmoD5YUakO/YmXQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-remap-async-to-generator" "^7.25.0"
-    "@babel/plugin-syntax-async-generators" "^7.8.4"
-    "@babel/traverse" "^7.25.4"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-async-to-generator@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.24.7.tgz"
-  integrity sha512-SQY01PcJfmQ+4Ash7NE+rpbLFbmqA2GPIgqzxfFTL4t1FKRq4zTms/7htKpoCUI9OcFYgzqfmCdH53s6/jn5fA==
+"@babel/plugin-transform-export-namespace-from@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz#71ca69d3471edd6daa711cf4dfc3400415df9c23"
+  integrity sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==
   dependencies:
-    "@babel/helper-module-imports" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-remap-async-to-generator" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-block-scoped-functions@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.24.7.tgz"
-  integrity sha512-yO7RAz6EsVQDaBH18IDJcMB1HnrUn2FJ/Jslc/WtPPWcjhpUJXU/rjbwmluzp7v/ZzWcEhTMXELnnsz8djWDwQ==
+"@babel/plugin-transform-for-of@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz#bc24f7080e9ff721b63a70ac7b2564ca15b6c40a"
+  integrity sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-block-scoping@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.25.0.tgz"
-  integrity sha512-yBQjYoOjXlFv9nlXb3f1casSHOZkWr29NX+zChVanLg5Nc157CrbEX9D7hxxtTpuFy7Q0YzmmWfJxzvps4kXrQ==
+"@babel/plugin-transform-function-name@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz#4d0bf307720e4dce6d7c30fcb1fd6ca77bdeb3a7"
+  integrity sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-compilation-targets" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/plugin-transform-class-properties@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.25.4.tgz"
-  integrity sha512-nZeZHyCWPfjkdU5pA/uHiTaDAFUEqkpzf1YoQT2NeSynCGYq9rxfyI3XpQbfx/a0hSnFH6TGlEXvae5Vi7GD8g==
+"@babel/plugin-transform-json-strings@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.27.1.tgz#a2e0ce6ef256376bd527f290da023983527a4f4c"
+  integrity sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.25.4"
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-class-static-block@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.24.7.tgz"
-  integrity sha512-HMXK3WbBPpZQufbMG4B46A90PkuuhN9vBCb5T8+VAHqvAqvcLi+2cKoukcpmUYkszLhScU3l1iudhrks3DggRQ==
+"@babel/plugin-transform-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz#baaefa4d10a1d4206f9dcdda50d7d5827bb70b24"
+  integrity sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-class-static-block" "^7.14.5"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-classes@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.4.tgz"
-  integrity sha512-oexUfaQle2pF/b6E0dwsxQtAol9TLSO88kQvym6HHBWFliV2lGdrPieX+WgMRLSJDVzdYywk7jXbLPuO2KLTLg==
+"@babel/plugin-transform-logical-assignment-operators@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.27.1.tgz#890cb20e0270e0e5bebe3f025b434841c32d5baa"
+  integrity sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-compilation-targets" "^7.25.2"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-replace-supers" "^7.25.0"
-    "@babel/traverse" "^7.25.4"
-    globals "^11.1.0"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-computed-properties@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.24.7.tgz"
-  integrity sha512-25cS7v+707Gu6Ds2oY6tCkUwsJ9YIDbggd9+cu9jzzDgiNq7hR/8dkzxWfKWnTic26vsI3EsCXNd4iEB6e8esQ==
+"@babel/plugin-transform-member-expression-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz#37b88ba594d852418e99536f5612f795f23aeaf9"
+  integrity sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/template" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-destructuring@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.24.8.tgz"
-  integrity sha512-36e87mfY8TnRxc7yc6M9g9gOB7rKgSahqkIKwLpz4Ppk2+zC2Cy1is0uwtuSG6AE4zlTOUa+7JGz9jCJGLqQFQ==
+"@babel/plugin-transform-modules-amd@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz#a4145f9d87c2291fe2d05f994b65dba4e3e7196f"
+  integrity sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-dotall-regex@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.24.7.tgz"
-  integrity sha512-ZOA3W+1RRTSWvyqcMJDLqbchh7U4NRGqwRfFSVbOLS/ePIP4vHB5e8T8eXcuqyN1QkgKyj5wuW0lcS85v4CrSw==
+"@babel/plugin-transform-modules-commonjs@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz#8e44ed37c2787ecc23bdc367f49977476614e832"
+  integrity sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-duplicate-keys@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.24.7.tgz"
-  integrity sha512-JdYfXyCRihAe46jUIliuL2/s0x0wObgwwiGxw/UbgJBr20gQBThrokO4nYKgWkD7uBaqM7+9x5TU7NkExZJyzw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-
-"@babel/plugin-transform-duplicate-named-capturing-groups-regex@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.25.0.tgz"
-  integrity sha512-YLpb4LlYSc3sCUa35un84poXoraOiQucUTTu8X1j18JV+gNa8E0nyUf/CjZ171IRGr4jEguF+vzJU66QZhn29g==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.0"
-    "@babel/helper-plugin-utils" "^7.24.8"
-
-"@babel/plugin-transform-dynamic-import@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.24.7.tgz"
-  integrity sha512-sc3X26PhZQDb3JhORmakcbvkeInvxz+A8oda99lj7J60QRuPZvNAk9wQlTBS1ZynelDrDmTU4pw1tyc5d5ZMUg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
-
-"@babel/plugin-transform-exponentiation-operator@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.24.7.tgz"
-  integrity sha512-Rqe/vSc9OYgDajNIK35u7ot+KeCoetqQYFXM4Epf7M7ez3lWlOjrDjrwMei6caCVhfdw+mIKD4cgdGNy5JQotQ==
-  dependencies:
-    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-
-"@babel/plugin-transform-export-namespace-from@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.24.7.tgz"
-  integrity sha512-v0K9uNYsPL3oXZ/7F9NNIbAj2jv1whUEtyA6aujhekLs56R++JDQuzRcP2/z4WX5Vg/c5lE9uWZA0/iUoFhLTA==
+"@babel/plugin-transform-modules-systemjs@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.27.1.tgz#00e05b61863070d0f3292a00126c16c0e024c4ed"
+  integrity sha512-w5N1XzsRbc0PQStASMksmUeqECuzKuTJer7kFagK8AXgpCMkeDMO5S+aaFb7A51ZYDF7XI34qsTX+fkHiIm5yA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-identifier" "^7.27.1"
+    "@babel/traverse" "^7.27.1"
 
-"@babel/plugin-transform-for-of@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.24.7.tgz"
-  integrity sha512-wo9ogrDG1ITTTBsy46oGiN1dS9A7MROBTcYsfS8DtsImMkHk9JXJ3EWQM6X2SUw4x80uGPlwj0o00Uoc6nEE3g==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
-
-"@babel/plugin-transform-function-name@^7.25.1":
-  version "7.25.1"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.25.1.tgz"
-  integrity sha512-TVVJVdW9RKMNgJJlLtHsKDTydjZAbwIsn6ySBPQaEAUU5+gVvlJt/9nRmqVbsV/IBanRjzWoaAQKLoamWVOUuA==
-  dependencies:
-    "@babel/helper-compilation-targets" "^7.24.8"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/traverse" "^7.25.1"
-
-"@babel/plugin-transform-json-strings@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.24.7.tgz"
-  integrity sha512-2yFnBGDvRuxAaE/f0vfBKvtnvvqU8tGpMHqMNpTN2oWMKIR3NqFkjaAgGwawhqK/pIN2T3XdjGPdaG0vDhOBGw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-json-strings" "^7.8.3"
-
-"@babel/plugin-transform-literals@^7.25.2":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.25.2.tgz"
-  integrity sha512-HQI+HcTbm9ur3Z2DkO+jgESMAMcYLuN/A7NRw9juzxAezN9AvqvUTnpKP/9kkYANz6u7dFlAyOu44ejuGySlfw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
-
-"@babel/plugin-transform-logical-assignment-operators@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.24.7.tgz"
-  integrity sha512-4D2tpwlQ1odXmTEIFWy9ELJcZHqrStlzK/dAOWYyxX3zT0iXQB6banjgeOJQXzEc4S0E0a5A+hahxPaEFYftsw==
+"@babel/plugin-transform-modules-umd@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz#63f2cf4f6dc15debc12f694e44714863d34cd334"
+  integrity sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
+    "@babel/helper-module-transforms" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-member-expression-literals@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.24.7.tgz"
-  integrity sha512-T/hRC1uqrzXMKLQ6UCwMT85S3EvqaBXDGf0FaMf4446Qx9vKwlghvee0+uuZcDUCZU5RuNi4781UQ7R308zzBw==
+"@babel/plugin-transform-named-capturing-groups-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.27.1.tgz#f32b8f7818d8fc0cc46ee20a8ef75f071af976e1"
+  integrity sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-
-"@babel/plugin-transform-modules-amd@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.24.7.tgz"
-  integrity sha512-9+pB1qxV3vs/8Hdmz/CulFB8w2tuu6EB94JZFsjdqxQokwGa9Unap7Bo2gGBGIvPmDIVvQrom7r5m/TCDMURhg==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-modules-commonjs@^7.24.7", "@babel/plugin-transform-modules-commonjs@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.24.8.tgz"
-  integrity sha512-WHsk9H8XxRs3JXKWFiqtQebdh9b/pTk4EgueygFzYlTKAg0Ud985mSevdNjdXdFBATSKVJGQXP1tv6aGbssLKA==
+"@babel/plugin-transform-new-target@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz#259c43939728cad1706ac17351b7e6a7bea1abeb"
+  integrity sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==
   dependencies:
-    "@babel/helper-module-transforms" "^7.24.8"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-simple-access" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-modules-systemjs@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.25.0.tgz"
-  integrity sha512-YPJfjQPDXxyQWg/0+jHKj1llnY5f/R6a0p/vP4lPymxLu7Lvl4k2WMitqi08yxwQcCVUUdG9LCUj4TNEgAp3Jw==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.25.0"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-validator-identifier" "^7.24.7"
-    "@babel/traverse" "^7.25.0"
-
-"@babel/plugin-transform-modules-umd@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.24.7.tgz"
-  integrity sha512-3aytQvqJ/h9z4g8AsKPLvD4Zqi2qT+L3j7XoFFu1XBlZWEl2/1kWnhmAbxpLgPrHSY0M6UA02jyTiwUVtiKR6A==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-
-"@babel/plugin-transform-named-capturing-groups-regex@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.24.7.tgz"
-  integrity sha512-/jr7h/EWeJtk1U/uz2jlsCioHkZk1JJZVcc8oQsJ1dUlaJD83f4/6Zeh2aHt9BIFokHIsSeDfhUmju0+1GPd6g==
+"@babel/plugin-transform-nullish-coalescing-operator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.27.1.tgz#4f9d3153bf6782d73dd42785a9d22d03197bc91d"
+  integrity sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-new-target@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.24.7.tgz"
-  integrity sha512-RNKwfRIXg4Ls/8mMTza5oPF5RkOW8Wy/WgMAp1/F1yZ8mMbtwXW+HDoJiOsagWrAhI5f57Vncrmr9XeT4CVapA==
+"@babel/plugin-transform-numeric-separator@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.27.1.tgz#614e0b15cc800e5997dadd9bd6ea524ed6c819c6"
+  integrity sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-nullish-coalescing-operator@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.24.7.tgz"
-  integrity sha512-Ts7xQVk1OEocqzm8rHMXHlxvsfZ0cEF2yomUqpKENHWMF4zKk175Y4q8H5knJes6PgYad50uuRmt3UJuhBw8pQ==
+"@babel/plugin-transform-object-rest-spread@^7.28.0":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.4.tgz#9ee1ceca80b3e6c4bac9247b2149e36958f7f98d"
+  integrity sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
+    "@babel/helper-compilation-targets" "^7.27.2"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/plugin-transform-destructuring" "^7.28.0"
+    "@babel/plugin-transform-parameters" "^7.27.7"
+    "@babel/traverse" "^7.28.4"
 
-"@babel/plugin-transform-numeric-separator@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.24.7.tgz"
-  integrity sha512-e6q1TiVUzvH9KRvicuxdBTUj4AdKSRwzIyFFnfnezpCfP2/7Qmbb8qbU2j7GODbl4JMkblitCQjKYUaX/qkkwA==
+"@babel/plugin-transform-object-super@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz#1c932cd27bf3874c43a5cac4f43ebf970c9871b5"
+  integrity sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-replace-supers" "^7.27.1"
 
-"@babel/plugin-transform-object-rest-spread@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.24.7.tgz"
-  integrity sha512-4QrHAr0aXQCEFni2q4DqKLD31n2DL+RxcwnNjDFkSG0eNQ/xCavnRkfCUjsyqGC2OviNJvZOF/mQqZBw7i2C5Q==
+"@babel/plugin-transform-optional-catch-binding@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.27.1.tgz#84c7341ebde35ccd36b137e9e45866825072a30c"
+  integrity sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==
   dependencies:
-    "@babel/helper-compilation-targets" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-transform-parameters" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-object-super@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.24.7.tgz"
-  integrity sha512-A/vVLwN6lBrMFmMDmPPz0jnE6ZGx7Jq7d6sT/Ev4H65RER6pZ+kczlf1DthF5N0qaPHBsI7UXiE8Zy66nmAovg==
+"@babel/plugin-transform-optional-chaining@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.27.1.tgz#874ce3c4f06b7780592e946026eb76a32830454f"
+  integrity sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-replace-supers" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-optional-catch-binding@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.24.7.tgz"
-  integrity sha512-uLEndKqP5BfBbC/5jTwPxLh9kqPWWgzN/f8w6UwAIirAEqiIVJWWY312X72Eub09g5KF9+Zn7+hT7sDxmhRuKA==
+"@babel/plugin-transform-parameters@^7.27.7":
+  version "7.27.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz#1fd2febb7c74e7d21cf3b05f7aebc907940af53a"
+  integrity sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-optional-chaining@^7.24.7", "@babel/plugin-transform-optional-chaining@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.24.8.tgz"
-  integrity sha512-5cTOLSMs9eypEy8JUVvIKOu6NgvbJMnpG62VpIHrTmROdQ+L5mDAaI40g25k5vXti55JWNX5jCkq3HZxXBQANw==
+"@babel/plugin-transform-private-methods@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.27.1.tgz#fdacbab1c5ed81ec70dfdbb8b213d65da148b6af"
+  integrity sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
-    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
-
-"@babel/plugin-transform-parameters@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.24.7.tgz"
-  integrity sha512-yGWW5Rr+sQOhK0Ot8hjDJuxU3XLRQGflvT4lhlSY0DFvdb3TwKaY26CJzHtYllU0vT9j58hc37ndFPsqT1SrzA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-create-class-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-private-methods@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.25.4.tgz"
-  integrity sha512-ao8BG7E2b/URaUQGqN3Tlsg+M3KlHY6rJ1O1gXAEUnZoyNQnvKyH87Kfg+FoxSeyWUB8ISZZsC91C44ZuBFytw==
+"@babel/plugin-transform-private-property-in-object@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.27.1.tgz#4dbbef283b5b2f01a21e81e299f76e35f900fb11"
+  integrity sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.25.4"
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-create-class-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-private-property-in-object@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.24.7.tgz"
-  integrity sha512-9z76mxwnwFxMyxZWEgdgECQglF2Q7cFLm0kMf8pGwt+GSJsY0cONKj/UuO4bOH0w/uAel3ekS4ra5CEAyJRmDA==
+"@babel/plugin-transform-property-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz#07eafd618800591e88073a0af1b940d9a42c6424"
+  integrity sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-create-class-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-property-literals@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.24.7.tgz"
-  integrity sha512-EMi4MLQSHfd2nrCqQEWxFdha2gBCqU4ZcCng4WBGZ5CJL4bBRW0ptdqqDdeirGZcpALazVVNJqRmsO8/+oNCBA==
+"@babel/plugin-transform-react-constant-elements@^7.21.3":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.27.1.tgz#6c6b50424e749a6e48afd14cf7b92f98cb9383f9"
+  integrity sha512-edoidOjl/ZxvYo4lSBOQGDSyToYVkTAwyVoa2tkuYTSmjrB1+uAedoL5iROVLXkxH+vRgA7uP4tMg2pUJpZ3Ug==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-react-constant-elements@^7.21.3":
-  version "7.25.1"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.25.1.tgz"
-  integrity sha512-SLV/giH/V4SmloZ6Dt40HjTGTAIkxn33TVIHxNGNvo8ezMhrxBkzisj4op1KZYPIOHFLqhv60OHvX+YRu4xbmQ==
+"@babel/plugin-transform-react-display-name@^7.27.1":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz#6f20a7295fea7df42eb42fed8f896813f5b934de"
+  integrity sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-react-display-name@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.24.7.tgz"
-  integrity sha512-H/Snz9PFxKsS1JLI4dJLtnJgCJRoo0AUm3chP6NYr+9En1JMKloheEiLIhlp5MDVznWo+H3AAC1Mc8lmUEpsgg==
+"@babel/plugin-transform-react-jsx-development@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz#47ff95940e20a3a70e68ad3d4fcb657b647f6c98"
+  integrity sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/plugin-transform-react-jsx" "^7.27.1"
 
-"@babel/plugin-transform-react-jsx-development@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.24.7.tgz"
-  integrity sha512-QG9EnzoGn+Qar7rxuW+ZOsbWOt56FvvI93xInqsZDC5fsekx1AlIO4KIJ5M+D0p0SqSH156EpmZyXq630B8OlQ==
+"@babel/plugin-transform-react-jsx@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz#1023bc94b78b0a2d68c82b5e96aed573bcfb9db0"
+  integrity sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==
   dependencies:
-    "@babel/plugin-transform-react-jsx" "^7.24.7"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-module-imports" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/plugin-syntax-jsx" "^7.27.1"
+    "@babel/types" "^7.27.1"
 
-"@babel/plugin-transform-react-jsx@^7.24.7":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.2.tgz"
-  integrity sha512-KQsqEAVBpU82NM/B/N9j9WOdphom1SZH3R+2V7INrQUH+V9EBFwZsEJl8eBIVeQE62FxJCc70jzEZwqU7RcVqA==
+"@babel/plugin-transform-react-pure-annotations@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz#339f1ce355eae242e0649f232b1c68907c02e879"
+  integrity sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-module-imports" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/plugin-syntax-jsx" "^7.24.7"
-    "@babel/types" "^7.25.2"
+    "@babel/helper-annotate-as-pure" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-react-pure-annotations@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.24.7.tgz"
-  integrity sha512-PLgBVk3fzbmEjBJ/u8kFzOqS9tUeDjiaWud/rRym/yjCo/M9cASPlnrd2ZmmZpQT40fOOrvR8jh+n8jikrOhNA==
+"@babel/plugin-transform-regenerator@^7.28.3":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.28.4.tgz#9d3fa3bebb48ddd0091ce5729139cd99c67cea51"
+  integrity sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-regenerator@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.24.7.tgz"
-  integrity sha512-lq3fvXPdimDrlg6LWBoqj+r/DEWgONuwjuOuQCSYgRroXDH/IdM1C0IZf59fL5cHLpjEH/O6opIRBbqv7ELnuA==
+"@babel/plugin-transform-regexp-modifiers@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.27.1.tgz#df9ba5577c974e3f1449888b70b76169998a6d09"
+  integrity sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    regenerator-transform "^0.15.2"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-reserved-words@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.24.7.tgz"
-  integrity sha512-0DUq0pHcPKbjFZCfTss/pGkYMfy3vFWydkUBd9r0GHpIyfs2eCDENvqadMycRS9wZCXR41wucAfJHJmwA0UmoQ==
+"@babel/plugin-transform-reserved-words@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz#40fba4878ccbd1c56605a4479a3a891ac0274bb4"
+  integrity sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-shorthand-properties@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.24.7.tgz"
-  integrity sha512-KsDsevZMDsigzbA09+vacnLpmPH4aWjcZjXdyFKGzpplxhbeB4wYtury3vglQkg6KM/xEPKt73eCjPPf1PgXBA==
+"@babel/plugin-transform-shorthand-properties@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz#532abdacdec87bfee1e0ef8e2fcdee543fe32b90"
+  integrity sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-spread@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.24.7.tgz"
-  integrity sha512-x96oO0I09dgMDxJaANcRyD4ellXFLLiWhuwDxKZX5g2rWP1bTPkBSwCYv96VDXVT1bD9aPj8tppr5ITIh8hBng==
+"@babel/plugin-transform-spread@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.27.1.tgz#1a264d5fc12750918f50e3fe3e24e437178abb08"
+  integrity sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
 
-"@babel/plugin-transform-sticky-regex@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.24.7.tgz"
-  integrity sha512-kHPSIJc9v24zEml5geKg9Mjx5ULpfncj0wRpYtxbvKyTtHCYDkVE3aHQ03FrpEo4gEe2vrJJS1Y9CJTaThA52g==
+"@babel/plugin-transform-sticky-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz#18984935d9d2296843a491d78a014939f7dcd280"
+  integrity sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-template-literals@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.24.7.tgz"
-  integrity sha512-AfDTQmClklHCOLxtGoP7HkeMw56k1/bTQjwsfhL6pppo/M4TOBSq+jjBUBLmV/4oeFg4GWMavIl44ZeCtmmZTw==
+"@babel/plugin-transform-template-literals@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz#1a0eb35d8bb3e6efc06c9fd40eb0bcef548328b8"
+  integrity sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-typeof-symbol@^7.24.8":
-  version "7.24.8"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.24.8.tgz"
-  integrity sha512-adNTUpDCVnmAE58VEqKlAA6ZBlNkMnWD0ZcW76lyNFN3MJniyGFZfNwERVk8Ap56MCnXztmDr19T4mPTztcuaw==
+"@babel/plugin-transform-typeof-symbol@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz#70e966bb492e03509cf37eafa6dcc3051f844369"
+  integrity sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-typescript@^7.24.7":
-  version "7.25.2"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.25.2.tgz"
-  integrity sha512-lBwRvjSmqiMYe/pS0+1gggjJleUJi7NzjvQ1Fkqtt69hBa/0t1YuW/MLQMAPixfwaQOHUXsd6jeU3Z+vdGv3+A==
+"@babel/plugin-transform-typescript@^7.27.1":
+  version "7.28.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.0.tgz#796cbd249ab56c18168b49e3e1d341b72af04a6b"
+  integrity sha512-4AEiDEBPIZvLQaWlc9liCavE0xRM0dNca41WtBeM3jgFptfUOSG9z0uteLhq6+3rq+WB6jIvUwKDTpXEHPJ2Vg==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.24.7"
-    "@babel/helper-create-class-features-plugin" "^7.25.0"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.24.7"
-    "@babel/plugin-syntax-typescript" "^7.24.7"
+    "@babel/helper-annotate-as-pure" "^7.27.3"
+    "@babel/helper-create-class-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.27.1"
+    "@babel/plugin-syntax-typescript" "^7.27.1"
 
-"@babel/plugin-transform-unicode-escapes@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.24.7.tgz"
-  integrity sha512-U3ap1gm5+4edc2Q/P+9VrBNhGkfnf+8ZqppY71Bo/pzZmXhhLdqgaUl6cuB07O1+AQJtCLfaOmswiNbSQ9ivhw==
+"@babel/plugin-transform-unicode-escapes@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz#3e3143f8438aef842de28816ece58780190cf806"
+  integrity sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-unicode-property-regex@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.24.7.tgz"
-  integrity sha512-uH2O4OV5M9FZYQrwc7NdVmMxQJOCCzFeYudlZSzUAHRFeOujQefa92E74TQDVskNHCzOXoigEuoyzHDhaEaK5w==
+"@babel/plugin-transform-unicode-property-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.27.1.tgz#bdfe2d3170c78c5691a3c3be934c8c0087525956"
+  integrity sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-unicode-regex@^7.24.7":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.24.7.tgz"
-  integrity sha512-hlQ96MBZSAXUq7ltkjtu3FJCCSMx/j629ns3hA3pXnBXjanNP0LHi+JpPeA81zaWgVK1VGH95Xuy7u0RyQ8kMg==
+"@babel/plugin-transform-unicode-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz#25948f5c395db15f609028e370667ed8bae9af97"
+  integrity sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.24.7"
-    "@babel/helper-plugin-utils" "^7.24.7"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
-"@babel/plugin-transform-unicode-sets-regex@^7.25.4":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.25.4.tgz"
-  integrity sha512-qesBxiWkgN1Q+31xUE9RcMk79eOXXDCv6tfyGMRSs4RGlioSg2WVyQAm07k726cSE56pa+Kb0y9epX2qaXzTvA==
+"@babel/plugin-transform-unicode-sets-regex@^7.27.1":
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.27.1.tgz#6ab706d10f801b5c72da8bb2548561fa04193cd1"
+  integrity sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.25.2"
-    "@babel/helper-plugin-utils" "^7.24.8"
+    "@babel/helper-create-regexp-features-plugin" "^7.27.1"
+    "@babel/helper-plugin-utils" "^7.27.1"
 
 "@babel/preset-env@^7.20.2":
-  version "7.25.4"
-  resolved "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.25.4.tgz"
-  integrity sha512-W9Gyo+KmcxjGahtt3t9fb14vFRWvPpu5pT6GBlovAK6BTBcxgjfVMSQCfJl4oi35ODrxP6xx2Wr8LNST57Mraw==
-  dependencies:
-    "@babel/compat-data" "^7.25.4"
-    "@babel/helper-compilation-targets" "^7.25.2"
-    "@babel/helper-plugin-utils" "^7.24.8"
-    "@babel/helper-validator-option" "^7.24.8"
-    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.25.3"
-    "@babel/plugin-bugfix-safari-class-field-initializer-scope" "^7.25.0"
-    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.25.0"
-    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.24.7"
-    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.25.0"
+  version "7.28.3"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.28.3.tgz#2b18d9aff9e69643789057ae4b942b1654f88187"
+  integrity sha512-ROiDcM+GbYVPYBOeCR6uBXKkQpBExLl8k9HO1ygXEyds39j+vCCsjmj7S8GOniZQlEs81QlkdJZe76IpLSiqpg==
+  dependencies:
+    "@babel/compat-data" "^7.28.0"
+    "@babel/helper-compilation-targets" "^7.27.2"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key" "^7.27.1"
+    "@babel/plugin-bugfix-safari-class-field-initializer-scope" "^7.27.1"
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.27.1"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.27.1"
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly" "^7.28.3"
     "@babel/plugin-proposal-private-property-in-object" "7.21.0-placeholder-for-preset-env.2"
-    "@babel/plugin-syntax-async-generators" "^7.8.4"
-    "@babel/plugin-syntax-class-properties" "^7.12.13"
-    "@babel/plugin-syntax-class-static-block" "^7.14.5"
-    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
-    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
-    "@babel/plugin-syntax-import-assertions" "^7.24.7"
-    "@babel/plugin-syntax-import-attributes" "^7.24.7"
-    "@babel/plugin-syntax-import-meta" "^7.10.4"
-    "@babel/plugin-syntax-json-strings" "^7.8.3"
-    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
-    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
-    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
-    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
-    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
-    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
-    "@babel/plugin-syntax-top-level-await" "^7.14.5"
+    "@babel/plugin-syntax-import-assertions" "^7.27.1"
+    "@babel/plugin-syntax-import-attributes" "^7.27.1"
     "@babel/plugin-syntax-unicode-sets-regex" "^7.18.6"
-    "@babel/plugin-transform-arrow-functions" "^7.24.7"
-    "@babel/plugin-transform-async-generator-functions" "^7.25.4"
-    "@babel/plugin-transform-async-to-generator" "^7.24.7"
-    "@babel/plugin-transform-block-scoped-functions" "^7.24.7"
-    "@babel/plugin-transform-block-scoping" "^7.25.0"
-    "@babel/plugin-transform-class-properties" "^7.25.4"
-    "@babel/plugin-transform-class-static-block" "^7.24.7"
-    "@babel/plugin-transform-classes" "^7.25.4"
-    "@babel/plugin-transform-computed-properties" "^7.24.7"
-    "@babel/plugin-transform-destructuring" "^7.24.8"
-    "@babel/plugin-transform-dotall-regex" "^7.24.7"
-    "@babel/plugin-transform-duplicate-keys" "^7.24.7"
-    "@babel/plugin-transform-duplicate-named-capturing-groups-regex" "^7.25.0"
-    "@babel/plugin-transform-dynamic-import" "^7.24.7"
-    "@babel/plugin-transform-exponentiation-operator" "^7.24.7"
-    "@babel/plugin-transform-export-namespace-from" "^7.24.7"
-    "@babel/plugin-transform-for-of" "^7.24.7"
-    "@babel/plugin-transform-function-name" "^7.25.1"
-    "@babel/plugin-transform-json-strings" "^7.24.7"
-    "@babel/plugin-transform-literals" "^7.25.2"
-    "@babel/plugin-transform-logical-assignment-operators" "^7.24.7"
-    "@babel/plugin-transform-member-expression-literals" "^7.24.7"
-    "@babel/plugin-transform-modules-amd" "^7.24.7"
-    "@babel/plugin-transform-modules-commonjs" "^7.24.8"
-    "@babel/plugin-transform-modules-systemjs" "^7.25.0"
-    "@babel/plugin-transform-modules-umd" "^7.24.7"
-    "@babel/plugin-transform-named-capturing-groups-regex" "^7.24.7"
-    "@babel/plugin-transform-new-target" "^7.24.7"
-    "@babel/plugin-transform-nullish-coalescing-operator" "^7.24.7"
-    "@babel/plugin-transform-numeric-separator" "^7.24.7"
-    "@babel/plugin-transform-object-rest-spread" "^7.24.7"
-    "@babel/plugin-transform-object-super" "^7.24.7"
-    "@babel/plugin-transform-optional-catch-binding" "^7.24.7"
-    "@babel/plugin-transform-optional-chaining" "^7.24.8"
-    "@babel/plugin-transform-parameters" "^7.24.7"
-    "@babel/plugin-transform-private-methods" "^7.25.4"
-    "@babel/plugin-transform-private-property-in-object" "^7.24.7"
-    "@babel/plugin-transform-property-literals" "^7.24.7"
-    "@babel/plugin-transform-regenerator" "^7.24.7"
-    "@babel/plugin-transform-reserved-words" "^7.24.7"
-    "@babel/plugin-transform-shorthand-properties" "^7.24.7"
-    "@babel/plugin-transform-spread" "^7.24.7"
-    "@babel/plugin-transform-sticky-regex" "^7.24.7"
-    "@babel/plugin-transform-template-literals" "^7.24.7"
-    "@babel/plugin-transform-typeof-symbol" "^7.24.8"
-    "@babel/plugin-transform-unicode-escapes" "^7.24.7"
-    "@babel/plugin-transform-unicode-property-regex" "^7.24.7"
-    "@babel/plugin-transform-unicode-regex" "^7.24.7"
-    "@babel/plugin-transform-unicode-sets-regex" "^7.25.4"
+    "@babel/plugin-transform-arrow-functions" "^7.27.1"
+    "@babel/plugin-transform-async-generator-functions" "^7.28.0"
+    "@babel/plugin-transform-async-to-generator" "^7.27.1"
+    "@babel/plugin-transform-block-scoped-functions" "^7.27.1"
+    "@babel/plugin-transform-block-scoping" "^7.28.0"
+    "@babel/plugin-transform-class-properties" "^7.27.1"
+    "@babel/plugin-transform-class-static-block" "^7.28.3"
+    "@babel/plugin-transform-classes" "^7.28.3"
+    "@babel/plugin-transform-computed-properties" "^7.27.1"
+    "@babel/plugin-transform-destructuring" "^7.28.0"
+    "@babel/plugin-transform-dotall-regex" "^7.27.1"
+    "@babel/plugin-transform-duplicate-keys" "^7.27.1"
+    "@babel/plugin-transform-duplicate-named-capturing-groups-regex" "^7.27.1"
+    "@babel/plugin-transform-dynamic-import" "^7.27.1"
+    "@babel/plugin-transform-explicit-resource-management" "^7.28.0"
+    "@babel/plugin-transform-exponentiation-operator" "^7.27.1"
+    "@babel/plugin-transform-export-namespace-from" "^7.27.1"
+    "@babel/plugin-transform-for-of" "^7.27.1"
+    "@babel/plugin-transform-function-name" "^7.27.1"
+    "@babel/plugin-transform-json-strings" "^7.27.1"
+    "@babel/plugin-transform-literals" "^7.27.1"
+    "@babel/plugin-transform-logical-assignment-operators" "^7.27.1"
+    "@babel/plugin-transform-member-expression-literals" "^7.27.1"
+    "@babel/plugin-transform-modules-amd" "^7.27.1"
+    "@babel/plugin-transform-modules-commonjs" "^7.27.1"
+    "@babel/plugin-transform-modules-systemjs" "^7.27.1"
+    "@babel/plugin-transform-modules-umd" "^7.27.1"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.27.1"
+    "@babel/plugin-transform-new-target" "^7.27.1"
+    "@babel/plugin-transform-nullish-coalescing-operator" "^7.27.1"
+    "@babel/plugin-transform-numeric-separator" "^7.27.1"
+    "@babel/plugin-transform-object-rest-spread" "^7.28.0"
+    "@babel/plugin-transform-object-super" "^7.27.1"
+    "@babel/plugin-transform-optional-catch-binding" "^7.27.1"
+    "@babel/plugin-transform-optional-chaining" "^7.27.1"
+    "@babel/plugin-transform-parameters" "^7.27.7"
+    "@babel/plugin-transform-private-methods" "^7.27.1"
+    "@babel/plugin-transform-private-property-in-object" "^7.27.1"
+    "@babel/plugin-transform-property-literals" "^7.27.1"
+    "@babel/plugin-transform-regenerator" "^7.28.3"
+    "@babel/plugin-transform-regexp-modifiers" "^7.27.1"
+    "@babel/plugin-transform-reserved-words" "^7.27.1"
+    "@babel/plugin-transform-shorthand-properties" "^7.27.1"
+    "@babel/plugin-transform-spread" "^7.27.1"
+    "@babel/plugin-transform-sticky-regex" "^7.27.1"
+    "@babel/plugin-transform-template-literals" "^7.27.1"
+    "@babel/plugin-transform-typeof-symbol" "^7.27.1"
+    "@babel/plugin-transform-unicode-escapes" "^7.27.1"
+    "@babel/plugin-transform-unicode-property-regex" "^7.27.1"
+    "@babel/plugin-transform-unicode-regex" "^7.27.1"
+    "@babel/plugin-transform-unicode-sets-regex" "^7.27.1"
     "@babel/preset-modules" "0.1.6-no-external-plugins"
-    babel-plugin-polyfill-corejs2 "^0.4.10"
-    babel-plugin-polyfill-corejs3 "^0.10.6"
-    babel-plugin-polyfill-regenerator "^0.6.1"
-    core-js-compat "^3.37.1"
+    babel-plugin-polyfill-corejs2 "^0.4.14"
+    babel-plugin-polyfill-corejs3 "^0.13.0"
+    babel-plugin-polyfill-regenerator "^0.6.5"
+    core-js-compat "^3.43.0"
     semver "^6.3.1"
 
 "@babel/preset-modules@0.1.6-no-external-plugins":
   version "0.1.6-no-external-plugins"
-  resolved "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz"
+  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz#ccb88a2c49c817236861fee7826080573b8a923a"
   integrity sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
@@ -1355,60 +988,34 @@
     esutils "^2.0.2"
 
 "@babel/preset-react@^7.18.6":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.24.7.tgz"
-  integrity sha512-AAH4lEkpmzFWrGVlHaxJB7RLH21uPQ9+He+eFLWHmF9IuFQVugz8eAsamaW0DXRrTfco5zj1wWtpdcXJUOfsag==
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/preset-react/-/preset-react-7.27.1.tgz#86ea0a5ca3984663f744be2fd26cb6747c3fd0ec"
+  integrity sha512-oJHWh2gLhU9dW9HHr42q0cI0/iHHXTLGe39qvpAZZzagHy0MzYLCnCVV0symeRvzmjHyVU7mw2K06E6u/JwbhA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-validator-option" "^7.24.7"
-    "@babel/plugin-transform-react-display-name" "^7.24.7"
-    "@babel/plugin-transform-react-jsx" "^7.24.7"
-    "@babel/plugin-transform-react-jsx-development" "^7.24.7"
-    "@babel/plugin-transform-react-pure-annotations" "^7.24.7"
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-transform-react-display-name" "^7.27.1"
+    "@babel/plugin-transform-react-jsx" "^7.27.1"
+    "@babel/plugin-transform-react-jsx-development" "^7.27.1"
+    "@babel/plugin-transform-react-pure-annotations" "^7.27.1"
 
 "@babel/preset-typescript@^7.21.0":
-  version "7.24.7"
-  resolved "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.24.7.tgz"
-  integrity sha512-SyXRe3OdWwIwalxDg5UtJnJQO+YPcTfwiIY2B0Xlddh9o7jpWLvv8X1RthIeDOxQ+O1ML5BLPCONToObyVQVuQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.24.7"
-    "@babel/helper-validator-option" "^7.24.7"
-    "@babel/plugin-syntax-jsx" "^7.24.7"
-    "@babel/plugin-transform-modules-commonjs" "^7.24.7"
-    "@babel/plugin-transform-typescript" "^7.24.7"
-
-"@babel/regjsgen@^0.8.0":
-  version "0.8.0"
-  resolved "https://registry.npmjs.org/@babel/regjsgen/-/regjsgen-0.8.0.tgz"
-  integrity sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==
-
-"@babel/runtime@^7.1.2", "@babel/runtime@^7.12.13", "@babel/runtime@^7.17.8", "@babel/runtime@^7.20.13", "@babel/runtime@^7.23.2", "@babel/runtime@^7.23.8", "@babel/runtime@^7.5.5", "@babel/runtime@^7.6.2", "@babel/runtime@^7.7.2", "@babel/runtime@^7.8.4", "@babel/runtime@^7.8.7":
-  version "7.26.10"
-  resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz"
-  integrity sha512-2WJMeRQPHKSPemqk/awGrAiuFfzBmOIPXKizAsVhWH9YJqLZ0H+HS4c8loHGgW6utJ3E/ejXQUsiGaQy2NZ9Fw==
+  version "7.27.1"
+  resolved "https://registry.yarnpkg.com/@babel/preset-typescript/-/preset-typescript-7.27.1.tgz#190742a6428d282306648a55b0529b561484f912"
+  integrity sha512-l7WfQfX0WK4M0v2RudjuQK4u99BS6yLHYEmdtVPP7lKV013zr9DygFuWNlnbvQ9LR+LS0Egz/XAvGx5U9MX0fQ==
   dependencies:
-    regenerator-runtime "^0.14.0"
-
-"@babel/runtime@^7.22.5":
-  version "7.27.6"
-  resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.6.tgz"
-  integrity sha512-vbavdySgbTTrmFE+EsiqUTzlOr5bzlnJtUv9PynGCAKvfQqjIXbvFdumPM/GxMDfyuGMJaJAU6TO4zc1Jf1i8Q==
+    "@babel/helper-plugin-utils" "^7.27.1"
+    "@babel/helper-validator-option" "^7.27.1"
+    "@babel/plugin-syntax-jsx" "^7.27.1"
+    "@babel/plugin-transform-modules-commonjs" "^7.27.1"
+    "@babel/plugin-transform-typescript" "^7.27.1"
 
-"@babel/runtime@^7.27.6":
+"@babel/runtime@^7.1.2", "@babel/runtime@^7.12.13", "@babel/runtime@^7.17.8", "@babel/runtime@^7.20.13", "@babel/runtime@^7.22.5", "@babel/runtime@^7.23.2", "@babel/runtime@^7.23.8", "@babel/runtime@^7.27.6", "@babel/runtime@^7.5.5", "@babel/runtime@^7.6.2", "@babel/runtime@^7.7.2", "@babel/runtime@^7.8.7":
   version "7.28.4"
   resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.28.4.tgz#a70226016fabe25c5783b2f22d3e1c9bc5ca3326"
   integrity sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==
 
-"@babel/template@^7.24.7", "@babel/template@^7.25.0":
-  version "7.25.0"
-  resolved "https://registry.npmjs.org/@babel/template/-/template-7.25.0.tgz"
-  integrity sha512-aOOgh1/5XzKvg1jvVz7AVrx2piJ2XBi227DHmbY6y+bM9H2FlN+IfecYu4Xl0cNiiVejlsCri89LUsbj8vJD9Q==
-  dependencies:
-    "@babel/code-frame" "^7.24.7"
-    "@babel/parser" "^7.25.0"
-    "@babel/types" "^7.25.0"
-
-"@babel/template@^7.27.2":
+"@babel/template@^7.27.1", "@babel/template@^7.27.2":
   version "7.27.2"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.27.2.tgz#fa78ceed3c4e7b63ebf6cb39e5852fca45f6809d"
   integrity sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==
@@ -1417,52 +1024,30 @@
     "@babel/parser" "^7.27.2"
     "@babel/types" "^7.27.1"
 
-"@babel/traverse@^7.24.7", "@babel/traverse@^7.24.8", "@babel/traverse@^7.25.0", "@babel/traverse@^7.25.1", "@babel/traverse@^7.25.2", "@babel/traverse@^7.25.3", "@babel/traverse@^7.25.4":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.6.tgz"
-  integrity sha512-9Vrcx5ZW6UwK5tvqsj0nGpp/XzqthkT0dqIc9g1AdtygFToNtTF67XzYS//dm+SAK9cp3B9R4ZO/46p63SCjlQ==
-  dependencies:
-    "@babel/code-frame" "^7.24.7"
-    "@babel/generator" "^7.25.6"
-    "@babel/parser" "^7.25.6"
-    "@babel/template" "^7.25.0"
-    "@babel/types" "^7.25.6"
-    debug "^4.3.1"
-    globals "^11.1.0"
-
-"@babel/traverse@^7.27.1", "@babel/traverse@^7.28.3":
-  version "7.28.3"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.28.3.tgz#6911a10795d2cce43ec6a28cffc440cca2593434"
-  integrity sha512-7w4kZYHneL3A6NP2nxzHvT3HCZ7puDZZjFMqDpBPECub79sTtSO5CGXDkKrTQq8ksAwfD/XI2MRFX23njdDaIQ==
+"@babel/traverse@^7.27.1", "@babel/traverse@^7.28.0", "@babel/traverse@^7.28.3", "@babel/traverse@^7.28.4":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.28.4.tgz#8d456101b96ab175d487249f60680221692b958b"
+  integrity sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==
   dependencies:
     "@babel/code-frame" "^7.27.1"
     "@babel/generator" "^7.28.3"
     "@babel/helper-globals" "^7.28.0"
-    "@babel/parser" "^7.28.3"
+    "@babel/parser" "^7.28.4"
     "@babel/template" "^7.27.2"
-    "@babel/types" "^7.28.2"
+    "@babel/types" "^7.28.4"
     debug "^4.3.1"
 
-"@babel/types@^7.21.3", "@babel/types@^7.24.7", "@babel/types@^7.24.8", "@babel/types@^7.25.0", "@babel/types@^7.25.2", "@babel/types@^7.25.6", "@babel/types@^7.4.4":
-  version "7.25.6"
-  resolved "https://registry.npmjs.org/@babel/types/-/types-7.25.6.tgz"
-  integrity sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw==
-  dependencies:
-    "@babel/helper-string-parser" "^7.24.8"
-    "@babel/helper-validator-identifier" "^7.24.7"
-    to-fast-properties "^2.0.0"
-
-"@babel/types@^7.27.1", "@babel/types@^7.28.2":
-  version "7.28.2"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.28.2.tgz#da9db0856a9a88e0a13b019881d7513588cf712b"
-  integrity sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==
+"@babel/types@^7.21.3", "@babel/types@^7.27.1", "@babel/types@^7.27.3", "@babel/types@^7.28.2", "@babel/types@^7.28.4", "@babel/types@^7.4.4":
+  version "7.28.4"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.28.4.tgz#0a4e618f4c60a7cd6c11cb2d48060e4dbe38ac3a"
+  integrity sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==
   dependencies:
     "@babel/helper-string-parser" "^7.27.1"
     "@babel/helper-validator-identifier" "^7.27.1"
 
 "@commitlint/cli@^17.6.7":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/cli/-/cli-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/cli/-/cli-17.8.1.tgz#10492114a022c91dcfb1d84dac773abb3db76d33"
   integrity sha512-ay+WbzQesE0Rv4EQKfNbSMiJJ12KdKTDzIt0tcK4k11FdsWmtwP0Kp1NWMOUswfIWo6Eb7p7Ln721Nx9FLNBjg==
   dependencies:
     "@commitlint/format" "^17.8.1"
@@ -1478,14 +1063,14 @@
 
 "@commitlint/config-conventional@^17.6.7":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/config-conventional/-/config-conventional-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/config-conventional/-/config-conventional-17.8.1.tgz#e5bcf0cfec8da7ac50bc04dc92e0a4ea74964ce0"
   integrity sha512-NxCOHx1kgneig3VLauWJcDWS40DVjg7nKOpBEEK9E5fjJpQqLCilcnKkIIjdBH98kEO1q3NpE5NSrZ2kl/QGJg==
   dependencies:
     conventional-changelog-conventionalcommits "^6.1.0"
 
 "@commitlint/config-validator@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/config-validator/-/config-validator-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/config-validator/-/config-validator-17.8.1.tgz#5cc93b6b49d5524c9cc345a60e5bf74bcca2b7f9"
   integrity sha512-UUgUC+sNiiMwkyiuIFR7JG2cfd9t/7MV8VB4TZ+q02ZFkHoduUS4tJGsCBWvBOGD9Btev6IecPMvlWUfJorkEA==
   dependencies:
     "@commitlint/types" "^17.8.1"
@@ -1493,7 +1078,7 @@
 
 "@commitlint/ensure@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/ensure/-/ensure-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/ensure/-/ensure-17.8.1.tgz#59183557844999dbb6aab6d03629a3d104d01a8d"
   integrity sha512-xjafwKxid8s1K23NFpL8JNo6JnY/ysetKo8kegVM7c8vs+kWLP8VrQq+NbhgVlmCojhEDbzQKp4eRXSjVOGsow==
   dependencies:
     "@commitlint/types" "^17.8.1"
@@ -1505,12 +1090,12 @@
 
 "@commitlint/execute-rule@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/execute-rule/-/execute-rule-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/execute-rule/-/execute-rule-17.8.1.tgz#504ed69eb61044eeb84fdfd10cc18f0dab14f34c"
   integrity sha512-JHVupQeSdNI6xzA9SqMF+p/JjrHTcrJdI02PwesQIDCIGUrv04hicJgCcws5nzaoZbROapPs0s6zeVHoxpMwFQ==
 
 "@commitlint/format@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/format/-/format-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/format/-/format-17.8.1.tgz#6108bb6b4408e711006680649927e1b559bdc5f8"
   integrity sha512-f3oMTyZ84M9ht7fb93wbCKmWxO5/kKSbwuYvS867duVomoOsgrgljkGGIztmT/srZnaiGbaK8+Wf8Ik2tSr5eg==
   dependencies:
     "@commitlint/types" "^17.8.1"
@@ -1518,7 +1103,7 @@
 
 "@commitlint/is-ignored@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/is-ignored/-/is-ignored-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/is-ignored/-/is-ignored-17.8.1.tgz#cf25bcd8409c79684b63f8bdeb35df48edda244e"
   integrity sha512-UshMi4Ltb4ZlNn4F7WtSEugFDZmctzFpmbqvpyxD3la510J+PLcnyhf9chs7EryaRFJMdAKwsEKfNK0jL/QM4g==
   dependencies:
     "@commitlint/types" "^17.8.1"
@@ -1526,7 +1111,7 @@
 
 "@commitlint/lint@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/lint/-/lint-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/lint/-/lint-17.8.1.tgz#bfc21215f6b18d41d4d43e2aa3cb79a5d7726cd8"
   integrity sha512-aQUlwIR1/VMv2D4GXSk7PfL5hIaFSfy6hSHV94O8Y27T5q+DlDEgd/cZ4KmVI+MWKzFfCTiTuWqjfRSfdRllCA==
   dependencies:
     "@commitlint/is-ignored" "^17.8.1"
@@ -1536,7 +1121,7 @@
 
 "@commitlint/load@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/load/-/load-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/load/-/load-17.8.1.tgz#fa061e7bfa53281eb03ca8517ca26d66a189030c"
   integrity sha512-iF4CL7KDFstP1kpVUkT8K2Wl17h2yx9VaR1ztTc8vzByWWcbO/WaKwxsnCOqow9tVAlzPfo1ywk9m2oJ9ucMqA==
   dependencies:
     "@commitlint/config-validator" "^17.8.1"
@@ -1556,12 +1141,12 @@
 
 "@commitlint/message@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/message/-/message-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/message/-/message-17.8.1.tgz#a5cd226c419be20ee03c3d237db6ac37b95958b3"
   integrity sha512-6bYL1GUQsD6bLhTH3QQty8pVFoETfFQlMn2Nzmz3AOLqRVfNNtXBaSY0dhZ0dM6A2MEq4+2d7L/2LP8TjqGRkA==
 
 "@commitlint/parse@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/parse/-/parse-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/parse/-/parse-17.8.1.tgz#6e00b8f50ebd63562d25dcf4230da2c9f984e626"
   integrity sha512-/wLUickTo0rNpQgWwLPavTm7WbwkZoBy3X8PpkUmlSmQJyWQTj0m6bDjiykMaDt41qcUbfeFfaCvXfiR4EGnfw==
   dependencies:
     "@commitlint/types" "^17.8.1"
@@ -1570,7 +1155,7 @@
 
 "@commitlint/read@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/read/-/read-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/read/-/read-17.8.1.tgz#b3f28777607c756078356cc133368b0e8c08092f"
   integrity sha512-Fd55Oaz9irzBESPCdMd8vWWgxsW3OWR99wOntBDHgf9h7Y6OOHjWEdS9Xzen1GFndqgyoaFplQS5y7KZe0kO2w==
   dependencies:
     "@commitlint/top-level" "^17.8.1"
@@ -1581,7 +1166,7 @@
 
 "@commitlint/resolve-extends@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/resolve-extends/-/resolve-extends-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/resolve-extends/-/resolve-extends-17.8.1.tgz#9af01432bf2fd9ce3dd5a00d266cce14e4c977e7"
   integrity sha512-W/ryRoQ0TSVXqJrx5SGkaYuAaE/BUontL1j1HsKckvM6e5ZaG0M9126zcwL6peKSuIetJi7E87PRQF8O86EW0Q==
   dependencies:
     "@commitlint/config-validator" "^17.8.1"
@@ -1593,7 +1178,7 @@
 
 "@commitlint/rules@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/rules/-/rules-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/rules/-/rules-17.8.1.tgz#da49cab1b7ebaf90d108de9f58f684dc4ccb65a0"
   integrity sha512-2b7OdVbN7MTAt9U0vKOYKCDsOvESVXxQmrvuVUZ0rGFMCrCPJWWP1GJ7f0lAypbDAhaGb8zqtdOr47192LBrIA==
   dependencies:
     "@commitlint/ensure" "^17.8.1"
@@ -1604,26 +1189,26 @@
 
 "@commitlint/to-lines@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/to-lines/-/to-lines-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/to-lines/-/to-lines-17.8.1.tgz#a5c4a7cf7dff3dbdd69289fc0eb19b66f3cfe017"
   integrity sha512-LE0jb8CuR/mj6xJyrIk8VLz03OEzXFgLdivBytoooKO5xLt5yalc8Ma5guTWobw998sbR3ogDd+2jed03CFmJA==
 
 "@commitlint/top-level@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/top-level/-/top-level-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/top-level/-/top-level-17.8.1.tgz#206d37d6782f33c9572e44fbe3758392fdeea7bc"
   integrity sha512-l6+Z6rrNf5p333SHfEte6r+WkOxGlWK4bLuZKbtf/2TXRN+qhrvn1XE63VhD8Oe9oIHQ7F7W1nG2k/TJFhx2yA==
   dependencies:
     find-up "^5.0.0"
 
 "@commitlint/types@^17.8.1":
   version "17.8.1"
-  resolved "https://registry.npmjs.org/@commitlint/types/-/types-17.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@commitlint/types/-/types-17.8.1.tgz#883a0ad35c5206d5fef7bc6ce1bbe648118af44e"
   integrity sha512-PXDQXkAmiMEG162Bqdh9ChML/GJZo6vU+7F03ALKDK8zYc6SuAr47LjG7hGYRqUOz+WK0dU7bQ0xzuqFMdxzeQ==
   dependencies:
     chalk "^4.1.0"
 
 "@contentlayer2/cli@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/cli/-/cli-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/cli/-/cli-0.5.5.tgz#63ec7154fd785695f3faf75d04d2bb81199a8b2c"
   integrity sha512-N0Jn0kj4XG6MzeYREYPxpT7/q+IZz+/C626cTjP21Gs0Ei0XYrdKoTVLBg32bwVhwvwgTm8miV5+F3vJc9ZFXg==
   dependencies:
     "@contentlayer2/core" "0.5.5"
@@ -1631,16 +1216,33 @@
     clipanion "^3.2.1"
     typanion "^3.12.1"
 
+"@contentlayer2/cli@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/cli/-/cli-0.5.8.tgz#dfe9c3dc4e8e253c6e34f8b97a4b526c1455e64c"
+  integrity sha512-sPXTe24tXPpru6hE45riBj7xjVIDuTfjQXbwitwcNkm0yd0kNJaDPBA2C4U5mRFgg1a/aftlIKeVavlkBnuZQA==
+  dependencies:
+    "@contentlayer2/core" "0.5.8"
+    "@contentlayer2/utils" "0.5.8"
+    clipanion "^3.2.1"
+    typanion "^3.12.1"
+
 "@contentlayer2/client@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/client/-/client-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/client/-/client-0.5.5.tgz#bac17980ecbf60d6a5317b468dd371f1702856a1"
   integrity sha512-YOTQIIDh+Krit5LOEI87eWooz+1HNOYI2tkGZivs7+VRc2nPVvvHTX6Ry9+FxQ0gSDmFQw5luxiWwhlIpcP2bQ==
   dependencies:
     "@contentlayer2/core" "0.5.5"
 
+"@contentlayer2/client@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/client/-/client-0.5.8.tgz#85064456c51e20e5de5f266685c7280e2a977a37"
+  integrity sha512-mc6uGuHI5ygO6s5KHhoFfiUN7BUUHrPUsxjU+EnGHjMo3+rcYnHd+G6cDDcf0fB21cX7NbJ57V9UlAMu5JKM0w==
+  dependencies:
+    "@contentlayer2/core" "0.5.8"
+
 "@contentlayer2/core@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/core/-/core-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/core/-/core-0.5.5.tgz#e8f6ec56d92f98589d1290d12a3f7290f3339fee"
   integrity sha512-VAGcRSNPLd6SGS+NaVHbLqdAAXjezU45nSExzkSCGXSCIVRA9Uj63XYKUHQDD6hbdvPFBpLKzcoEFa6kGKZRxg==
   dependencies:
     "@contentlayer2/utils" "0.5.5"
@@ -1657,9 +1259,28 @@
     type-fest "^4.10.0"
     unified "^11.0.4"
 
+"@contentlayer2/core@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/core/-/core-0.5.8.tgz#94cd2b1463085bfe851d8f3e06ae778fa7af9f0a"
+  integrity sha512-0DDlANRIceEiMhLRQ1S4nWPu2p/c6U7V469QqhtGbWcC2/kp2RAnbjhykf6cBUaXq7eeCxcQkBdg+Ns6Hn3KyQ==
+  dependencies:
+    "@contentlayer2/utils" "0.5.8"
+    camel-case "^4.1.2"
+    comment-json "^4.2.3"
+    esbuild ">=0.17"
+    gray-matter "^4.0.3"
+    mdx-bundler "^10.1.1"
+    rehype-stringify "^10.0.0"
+    remark-frontmatter "^5.0.0"
+    remark-parse "^11.0.0"
+    remark-rehype "^11.1.0"
+    source-map-support "^0.5.21"
+    type-fest "^4.10.0"
+    unified "^11.0.4"
+
 "@contentlayer2/source-files@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/source-files/-/source-files-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/source-files/-/source-files-0.5.5.tgz#0782de47354d9656a3a1aa9c964ba71f27427922"
   integrity sha512-TEVSn4T5RlASHQ0kCtV/DHpMfDc5Yg/U2v24RWyiTKp/yDq3iD04EFCw/O4x1LHpiUcFtKCW4waF0J6KNOxd4w==
   dependencies:
     "@contentlayer2/core" "0.5.5"
@@ -1674,18 +1295,44 @@
     yaml "^2.3.1"
     zod "^3.22.4"
 
+"@contentlayer2/source-files@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/source-files/-/source-files-0.5.8.tgz#16a25954849a7379288bcaa36f620a3940f0cdcd"
+  integrity sha512-yoKjA7D8OeMV7KcRwq2ygnyAMw8x4BLx9du8EkA1nBg0uSAjOpNIBVvNjrSuRLnm1/WdH97BwKCQF0Qf1yz5kQ==
+  dependencies:
+    "@contentlayer2/core" "0.5.8"
+    "@contentlayer2/utils" "0.5.8"
+    chokidar "^3.5.3"
+    fast-glob "^3.2.12"
+    gray-matter "^4.0.3"
+    imagescript "^1.2.16"
+    micromatch "^4.0.5"
+    ts-pattern "^5.0.6"
+    unified "^11.0.4"
+    yaml "^2.3.1"
+    zod "^3.22.4"
+
 "@contentlayer2/source-remote-files@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/source-remote-files/-/source-remote-files-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/source-remote-files/-/source-remote-files-0.5.5.tgz#19a98d949c0a694c7e812651122ad386d407ca79"
   integrity sha512-d/8LDXtAUmncaCSSjKt0BsRq7N5hisbtoF19ASGStJ179K5btUMBt4KEwBzg0UTE2iY4kXBUpn8MZmYVHy7VBg==
   dependencies:
     "@contentlayer2/core" "0.5.5"
     "@contentlayer2/source-files" "0.5.5"
     "@contentlayer2/utils" "0.5.5"
 
+"@contentlayer2/source-remote-files@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/source-remote-files/-/source-remote-files-0.5.8.tgz#56fe4c88966871d9777461d0b1f656aa645f96b3"
+  integrity sha512-sjk7QIB5NHeIM6J4/U7z7/ZUN+JENkN142tUHyQUagltlwYQ4Y9KMaa4RHmwYAfEwfTgQ6w0snPpQfINZY+MPw==
+  dependencies:
+    "@contentlayer2/core" "0.5.8"
+    "@contentlayer2/source-files" "0.5.8"
+    "@contentlayer2/utils" "0.5.8"
+
 "@contentlayer2/utils@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@contentlayer2/utils/-/utils-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/utils/-/utils-0.5.5.tgz#eea17686af37278e8c4f8414aaa5d241a07ec595"
   integrity sha512-VnfwvIszsIfyIhkMsDutuVgKyeSwN36Mv+ClPl9fuTejR0uiKCyOKdGQTHJ2b5LDE+fFuySd2pTE7GDVXLBjTg==
   dependencies:
     "@effect-ts/core" "^0.60.5"
@@ -1707,26 +1354,50 @@
     ts-pattern "^5.0.6"
     type-fest "^4.10.0"
 
+"@contentlayer2/utils@0.5.8":
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/@contentlayer2/utils/-/utils-0.5.8.tgz#19c5e08e0a8e6b4df2555ccde183a7240776f05d"
+  integrity sha512-KCC4qp5oCASW2jtUn8o4PLaaF/w0r9675gKnBCpbcpalZzFpZrqeH25VrHOTTMZZp7EeKqoKpiz2/WWq8i66MA==
+  dependencies:
+    "@effect-ts/core" "^0.60.5"
+    "@effect-ts/otel" "^0.15.1"
+    "@effect-ts/otel-sdk-trace-node" "^0.15.1"
+    "@js-temporal/polyfill" "^0.4.4"
+    "@opentelemetry/api" "^1.9.0"
+    "@opentelemetry/core" "^1.30.1"
+    "@opentelemetry/exporter-trace-otlp-grpc" "^0.57.1"
+    "@opentelemetry/resources" "^1.30.1"
+    "@opentelemetry/sdk-trace-base" "^1.30.1"
+    "@opentelemetry/sdk-trace-node" "^1.30.1"
+    "@opentelemetry/semantic-conventions" "^1.28.0"
+    chokidar "^3.5.3"
+    hash-wasm "^4.11.0"
+    inflection "^3.0.0"
+    memfs "^4.8.2"
+    oo-ascii-tree "^1.94.0"
+    ts-pattern "^5.0.6"
+    type-fest "^4.10.0"
+
 "@cspotcode/source-map-support@^0.8.0":
   version "0.8.1"
-  resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1"
   integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
   dependencies:
     "@jridgewell/trace-mapping" "0.3.9"
 
 "@discoveryjs/json-ext@0.5.7":
   version "0.5.7"
-  resolved "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz"
+  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70"
   integrity sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==
 
 "@docsearch/css@3.9.0":
   version "3.9.0"
-  resolved "https://registry.npmjs.org/@docsearch/css/-/css-3.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/@docsearch/css/-/css-3.9.0.tgz#3bc29c96bf024350d73b0cfb7c2a7b71bf251cd5"
   integrity sha512-cQbnVbq0rrBwNAKegIac/t6a8nWoUAn8frnkLFW6YARaRmAQr5/Eoe6Ln2fqkUCZ40KpdrKbpSAmgrkviOxuWA==
 
 "@docsearch/react@^3.6.2":
   version "3.9.0"
-  resolved "https://registry.npmjs.org/@docsearch/react/-/react-3.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/@docsearch/react/-/react-3.9.0.tgz#d0842b700c3ee26696786f3c8ae9f10c1a3f0db3"
   integrity sha512-mb5FOZYZIkRQ6s/NWnM98k879vu5pscWqTLubLFBO87igYYT4VzVazh4h5o/zCvTIZgEt3PvsCOMOswOUo9yHQ==
   dependencies:
     "@algolia/autocomplete-core" "1.17.9"
@@ -1736,31 +1407,53 @@
 
 "@effect-ts/core@^0.60.5":
   version "0.60.5"
-  resolved "https://registry.npmjs.org/@effect-ts/core/-/core-0.60.5.tgz"
+  resolved "https://registry.yarnpkg.com/@effect-ts/core/-/core-0.60.5.tgz#df79049e1be4a576ab6b45abbe92c831bda62361"
   integrity sha512-qi1WrtJA90XLMnj2hnUszW9Sx4dXP03ZJtCc5DiUBIOhF4Vw7plfb65/bdBySPoC9s7zy995TdUX1XBSxUkl5w==
   dependencies:
     "@effect-ts/system" "^0.57.5"
 
 "@effect-ts/otel-sdk-trace-node@^0.15.1":
   version "0.15.1"
-  resolved "https://registry.npmjs.org/@effect-ts/otel-sdk-trace-node/-/otel-sdk-trace-node-0.15.1.tgz"
+  resolved "https://registry.yarnpkg.com/@effect-ts/otel-sdk-trace-node/-/otel-sdk-trace-node-0.15.1.tgz#d425cc51f82da208de702b4dec4434c7bb78b512"
   integrity sha512-a2sF0ylmn8xOJs8fNeT/spJ1gUcsksAJCALxo9WOfuTCMtTwMVtVhCKEPEeQoL7wFqU+JgPkVdP91+FJ/Rkeow==
   dependencies:
     "@effect-ts/otel" "^0.15.1"
 
 "@effect-ts/otel@^0.15.1":
   version "0.15.1"
-  resolved "https://registry.npmjs.org/@effect-ts/otel/-/otel-0.15.1.tgz"
+  resolved "https://registry.yarnpkg.com/@effect-ts/otel/-/otel-0.15.1.tgz#c5466ed96229c9cda40978f7726086a1b390359e"
   integrity sha512-AmZJHl7t0+Peh7Yb2+hqn6r9+rd9/UfeA4AMV9h0YGTdOyouyFfD3wzWlxnAUzAQ4Lrod4kC7Noruret4EpqpA==
 
 "@effect-ts/system@^0.57.5":
   version "0.57.5"
-  resolved "https://registry.npmjs.org/@effect-ts/system/-/system-0.57.5.tgz"
+  resolved "https://registry.yarnpkg.com/@effect-ts/system/-/system-0.57.5.tgz#921e9b39dcea2d1728e0f49a0af233472efdc6cb"
   integrity sha512-/crHGujo0xnuHIYNc1VgP0HGJGFSoSqq88JFXe6FmFyXPpWt8Xu39LyLg7rchsxfXFeEdA9CrIZvLV5eswXV5g==
 
+"@emnapi/core@^1.4.3":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@emnapi/core/-/core-1.5.0.tgz#85cd84537ec989cebb2343606a1ee663ce4edaf0"
+  integrity sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==
+  dependencies:
+    "@emnapi/wasi-threads" "1.1.0"
+    tslib "^2.4.0"
+
+"@emnapi/runtime@^1.4.3":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@emnapi/runtime/-/runtime-1.5.0.tgz#9aebfcb9b17195dce3ab53c86787a6b7d058db73"
+  integrity sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==
+  dependencies:
+    tslib "^2.4.0"
+
+"@emnapi/wasi-threads@1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz#60b2102fddc9ccb78607e4a3cf8403ea69be41bf"
+  integrity sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==
+  dependencies:
+    tslib "^2.4.0"
+
 "@esbuild-plugins/node-resolve@^0.2.2":
   version "0.2.2"
-  resolved "https://registry.npmjs.org/@esbuild-plugins/node-resolve/-/node-resolve-0.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/@esbuild-plugins/node-resolve/-/node-resolve-0.2.2.tgz#4f1b8d265a1b6e8b2438a03770239277687f0c17"
   integrity sha512-+t5FdX3ATQlb53UFDBRb4nqjYBz492bIrnVWvpQHpzZlu9BQL5HasMZhqc409ygUwOWCXZhrWr6NyZ6T6Y+cxw==
   dependencies:
     "@types/resolve" "^1.17.1"
@@ -1768,146 +1461,151 @@
     escape-string-regexp "^4.0.0"
     resolve "^1.19.0"
 
-"@esbuild/aix-ppc64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.0.tgz#499600c5e1757a524990d5d92601f0ac3ce87f64"
-  integrity sha512-O7vun9Sf8DFjH2UtqK8Ku3LkquL9SZL8OLY1T5NZkA34+wG3OQF7cl4Ql8vdNzM6fzBbYfLaiRLIOZ+2FOCgBQ==
-
-"@esbuild/android-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.0.tgz#b9b8231561a1dfb94eb31f4ee056b92a985c324f"
-  integrity sha512-grvv8WncGjDSyUBjN9yHXNt+cq0snxXbDxy5pJtzMKGmmpPxeAmAhWxXI+01lU5rwZomDgD3kJwulEnhTRUd6g==
-
-"@esbuild/android-arm@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.0.tgz#ca6e7888942505f13e88ac9f5f7d2a72f9facd2b"
-  integrity sha512-PTyWCYYiU0+1eJKmw21lWtC+d08JDZPQ5g+kFyxP0V+es6VPPSUhM6zk8iImp2jbV6GwjX4pap0JFbUQN65X1g==
-
-"@esbuild/android-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.0.tgz#e765ea753bac442dfc9cb53652ce8bd39d33e163"
-  integrity sha512-m/ix7SfKG5buCnxasr52+LI78SQ+wgdENi9CqyCXwjVR2X4Jkz+BpC3le3AoBPYTC9NHklwngVXvbJ9/Akhrfg==
-
-"@esbuild/darwin-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.0.tgz"
-  integrity sha512-mVwdUb5SRkPayVadIOI78K7aAnPamoeFR2bT5nszFUZ9P8UpK4ratOdYbZZXYSqPKMHfS1wdHCJk1P1EZpRdvw==
-
-"@esbuild/darwin-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.0.tgz#91979d98d30ba6e7d69b22c617cc82bdad60e47a"
-  integrity sha512-DgDaYsPWFTS4S3nWpFcMn/33ZZwAAeAFKNHNa1QN0rI4pUjgqf0f7ONmXf6d22tqTY+H9FNdgeaAa+YIFUn2Rg==
-
-"@esbuild/freebsd-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.0.tgz#b97e97073310736b430a07b099d837084b85e9ce"
-  integrity sha512-VN4ocxy6dxefN1MepBx/iD1dH5K8qNtNe227I0mnTRjry8tj5MRk4zprLEdG8WPyAPb93/e4pSgi1SoHdgOa4w==
-
-"@esbuild/freebsd-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.0.tgz#f3b694d0da61d9910ec7deff794d444cfbf3b6e7"
-  integrity sha512-mrSgt7lCh07FY+hDD1TxiTyIHyttn6vnjesnPoVDNmDfOmggTLXRv8Id5fNZey1gl/V2dyVK1VXXqVsQIiAk+A==
-
-"@esbuild/linux-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.0.tgz#f921f699f162f332036d5657cad9036f7a993f73"
-  integrity sha512-9QAQjTWNDM/Vk2bgBl17yWuZxZNQIF0OUUuPZRKoDtqF2k4EtYbpyiG5/Dk7nqeK6kIJWPYldkOcBqjXjrUlmg==
-
-"@esbuild/linux-arm@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.0.tgz#cc49305b3c6da317c900688995a4050e6cc91ca3"
-  integrity sha512-vkB3IYj2IDo3g9xX7HqhPYxVkNQe8qTK55fraQyTzTX/fxaDtXiEnavv9geOsonh2Fd2RMB+i5cbhu2zMNWJwg==
-
-"@esbuild/linux-ia32@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.0.tgz#3e0736fcfab16cff042dec806247e2c76e109e19"
-  integrity sha512-43ET5bHbphBegyeqLb7I1eYn2P/JYGNmzzdidq/w0T8E2SsYL1U6un2NFROFRg1JZLTzdCoRomg8Rvf9M6W6Gg==
-
-"@esbuild/linux-loong64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.0.tgz#ea2bf730883cddb9dfb85124232b5a875b8020c7"
-  integrity sha512-fC95c/xyNFueMhClxJmeRIj2yrSMdDfmqJnyOY4ZqsALkDrrKJfIg5NTMSzVBr5YW1jf+l7/cndBfP3MSDpoHw==
-
-"@esbuild/linux-mips64el@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.0.tgz#4cababb14eede09248980a2d2d8b966464294ff1"
-  integrity sha512-nkAMFju7KDW73T1DdH7glcyIptm95a7Le8irTQNO/qtkoyypZAnjchQgooFUDQhNAy4iu08N79W4T4pMBwhPwQ==
-
-"@esbuild/linux-ppc64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.0.tgz#8860a4609914c065373a77242e985179658e1951"
-  integrity sha512-NhyOejdhRGS8Iwv+KKR2zTq2PpysF9XqY+Zk77vQHqNbo/PwZCzB5/h7VGuREZm1fixhs4Q/qWRSi5zmAiO4Fw==
-
-"@esbuild/linux-riscv64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.0.tgz#baf26e20bb2d38cfb86ee282dff840c04f4ed987"
-  integrity sha512-5S/rbP5OY+GHLC5qXp1y/Mx//e92L1YDqkiBbO9TQOvuFXM+iDqUNG5XopAnXoRH3FjIUDkeGcY1cgNvnXp/kA==
-
-"@esbuild/linux-s390x@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.0.tgz#8323afc0d6cb1b6dc6e9fd21efd9e1542c3640a4"
-  integrity sha512-XM2BFsEBz0Fw37V0zU4CXfcfuACMrppsMFKdYY2WuTS3yi8O1nFOhil/xhKTmE1nPmVyvQJjJivgDT+xh8pXJA==
-
-"@esbuild/linux-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.0.tgz#08fcf60cb400ed2382e9f8e0f5590bac8810469a"
-  integrity sha512-9yl91rHw/cpwMCNytUDxwj2XjFpxML0y9HAOH9pNVQDpQrBxHy01Dx+vaMu0N1CKa/RzBD2hB4u//nfc+Sd3Cw==
-
-"@esbuild/netbsd-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.0.tgz#935c6c74e20f7224918fbe2e6c6fe865b6c6ea5b"
-  integrity sha512-RuG4PSMPFfrkH6UwCAqBzauBWTygTvb1nxWasEJooGSJ/NwRw7b2HOwyRTQIU97Hq37l3npXoZGYMy3b3xYvPw==
-
-"@esbuild/netbsd-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.0.tgz#414677cef66d16c5a4d210751eb2881bb9c1b62b"
-  integrity sha512-jl+qisSB5jk01N5f7sPCsBENCOlPiS/xptD5yxOx2oqQfyourJwIKLRA2yqWdifj3owQZCL2sn6o08dBzZGQzA==
-
-"@esbuild/openbsd-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.0.tgz#8fd55a4d08d25cdc572844f13c88d678c84d13f7"
-  integrity sha512-21sUNbq2r84YE+SJDfaQRvdgznTD8Xc0oc3p3iW/a1EVWeNj/SdUCbm5U0itZPQYRuRTW20fPMWMpcrciH2EJw==
-
-"@esbuild/openbsd-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.0.tgz#0c48ddb1494bbc2d6bcbaa1429a7f465fa1dedde"
-  integrity sha512-2gwwriSMPcCFRlPlKx3zLQhfN/2WjJ2NSlg5TKLQOJdV0mSxIcYNTMhk3H3ulL/cak+Xj0lY1Ym9ysDV1igceg==
-
-"@esbuild/sunos-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.0.tgz#86ff9075d77962b60dd26203d7352f92684c8c92"
-  integrity sha512-bxI7ThgLzPrPz484/S9jLlvUAHYMzy6I0XiU1ZMeAEOBcS0VePBFxh1JjTQt3Xiat5b6Oh4x7UC7IwKQKIJRIg==
-
-"@esbuild/win32-arm64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.0.tgz#849c62327c3229467f5b5cd681bf50588442e96c"
-  integrity sha512-ZUAc2YK6JW89xTbXvftxdnYy3m4iHIkDtK3CLce8wg8M2L+YZhIvO1DKpxrd0Yr59AeNNkTiic9YLf6FTtXWMw==
-
-"@esbuild/win32-ia32@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.0.tgz#f62eb480cd7cca088cb65bb46a6db25b725dc079"
-  integrity sha512-eSNxISBu8XweVEWG31/JzjkIGbGIJN/TrRoiSVZwZ6pkC6VX4Im/WV2cz559/TXLcYbcrDN8JtKgd9DJVIo8GA==
-
-"@esbuild/win32-x64@0.25.0":
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.0.tgz#c8e119a30a7c8d60b9d2e22d2073722dde3b710b"
-  integrity sha512-ZENoHJBxA20C2zFzh6AI4fT6RraMzjYw4xKWemRTRmRVtN9c5DcH9r/f2ihEkMjOW5eGgrwCslG/+Y/3bL+DHQ==
+"@esbuild/aix-ppc64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz#ee6b7163a13528e099ecf562b972f2bcebe0aa97"
+  integrity sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==
+
+"@esbuild/android-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz#115fc76631e82dd06811bfaf2db0d4979c16e2cb"
+  integrity sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==
+
+"@esbuild/android-arm@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.25.10.tgz#8d5811912da77f615398611e5bbc1333fe321aa9"
+  integrity sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==
+
+"@esbuild/android-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.25.10.tgz#e3e96516b2d50d74105bb92594c473e30ddc16b1"
+  integrity sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==
+
+"@esbuild/darwin-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz#6af6bb1d05887dac515de1b162b59dc71212ed76"
+  integrity sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==
+
+"@esbuild/darwin-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz#99ae82347fbd336fc2d28ffd4f05694e6e5b723d"
+  integrity sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==
+
+"@esbuild/freebsd-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz#0c6d5558a6322b0bdb17f7025c19bd7d2359437d"
+  integrity sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==
+
+"@esbuild/freebsd-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz#8c35873fab8c0857a75300a3dcce4324ca0b9844"
+  integrity sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==
+
+"@esbuild/linux-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz#3edc2f87b889a15b4cedaf65f498c2bed7b16b90"
+  integrity sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==
+
+"@esbuild/linux-arm@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz#86501cfdfb3d110176d80c41b27ed4611471cde7"
+  integrity sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==
+
+"@esbuild/linux-ia32@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz#e6589877876142537c6864680cd5d26a622b9d97"
+  integrity sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==
+
+"@esbuild/linux-loong64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz#11119e18781f136d8083ea10eb6be73db7532de8"
+  integrity sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==
+
+"@esbuild/linux-mips64el@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz#3052f5436b0c0c67a25658d5fc87f045e7def9e6"
+  integrity sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==
+
+"@esbuild/linux-ppc64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz#2f098920ee5be2ce799f35e367b28709925a8744"
+  integrity sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==
+
+"@esbuild/linux-riscv64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz#fa51d7fd0a22a62b51b4b94b405a3198cf7405dd"
+  integrity sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==
+
+"@esbuild/linux-s390x@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz#a27642e36fc282748fdb38954bd3ef4f85791e8a"
+  integrity sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==
+
+"@esbuild/linux-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz#9d9b09c0033d17529570ced6d813f98315dfe4e9"
+  integrity sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==
+
+"@esbuild/netbsd-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz#25c09a659c97e8af19e3f2afd1c9190435802151"
+  integrity sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==
+
+"@esbuild/netbsd-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz#7fa5f6ffc19be3a0f6f5fd32c90df3dc2506937a"
+  integrity sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==
+
+"@esbuild/openbsd-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz#8faa6aa1afca0c6d024398321d6cb1c18e72a1c3"
+  integrity sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==
+
+"@esbuild/openbsd-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz#a42979b016f29559a8453d32440d3c8cd420af5e"
+  integrity sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==
+
+"@esbuild/openharmony-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz#fd87bfeadd7eeb3aa384bbba907459ffa3197cb1"
+  integrity sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==
+
+"@esbuild/sunos-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.25.10.tgz#3a18f590e36cb78ae7397976b760b2b8c74407f4"
+  integrity sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ==
+
+"@esbuild/win32-arm64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz#e71741a251e3fd971408827a529d2325551f530c"
+  integrity sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==
+
+"@esbuild/win32-ia32@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz#c6f010b5d3b943d8901a0c87ea55f93b8b54bf94"
+  integrity sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==
+
+"@esbuild/win32-x64@0.25.10":
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz#e4b3e255a1b4aea84f6e1d2ae0b73f826c3785bd"
+  integrity sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.4.0":
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz"
-  integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==
+  version "4.9.0"
+  resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz#7308df158e064f0dd8b8fdb58aa14fa2a7f913b3"
+  integrity sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==
   dependencies:
-    eslint-visitor-keys "^3.3.0"
+    eslint-visitor-keys "^3.4.3"
 
 "@eslint-community/regexpp@^4.5.1", "@eslint-community/regexpp@^4.6.1":
-  version "4.11.1"
-  resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.1.tgz"
-  integrity sha512-m4DVN9ZqskZoLU5GlWZadwDnYo3vAEydiUayB9widCl9ffWx2IvPnp6n3on5rJmziJSw9Bv+Z3ChDVdMwXCY8Q==
+  version "4.12.1"
+  resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.12.1.tgz#cfc6cffe39df390a3841cde2abccf92eaa7ae0e0"
+  integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==
 
 "@eslint/eslintrc@^2.1.4":
   version "2.1.4"
-  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.1.4.tgz#388a269f0f25c1b6adc317b5a2c55714894c70ad"
   integrity sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==
   dependencies:
     ajv "^6.12.4"
@@ -1922,190 +1620,166 @@
 
 "@eslint/js@8.57.1":
   version "8.57.1"
-  resolved "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz"
+  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.57.1.tgz#de633db3ec2ef6a3c89e2f19038063e8a122e2c2"
   integrity sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==
 
 "@faker-js/faker@5.5.3":
   version "5.5.3"
-  resolved "https://registry.npmjs.org/@faker-js/faker/-/faker-5.5.3.tgz"
+  resolved "https://registry.yarnpkg.com/@faker-js/faker/-/faker-5.5.3.tgz#18e3af6b8eae7984072bbeb0c0858474d7c4cefe"
   integrity sha512-R11tGE6yIFwqpaIqcfkcg7AICXzFg14+5h5v0TfF/9+RMDL6jhzCy/pxHVOfbALGdtVYdt6JdR21tuxEgl34dw==
 
 "@fal-works/esbuild-plugin-global-externals@^2.1.2":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/@fal-works/esbuild-plugin-global-externals/-/esbuild-plugin-global-externals-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@fal-works/esbuild-plugin-global-externals/-/esbuild-plugin-global-externals-2.1.2.tgz#c05ed35ad82df8e6ac616c68b92c2282bd083ba4"
   integrity sha512-cEee/Z+I12mZcFJshKcCqC8tuX5hG3s+d+9nZ3LabqKF1vKdF41B92pJVCBggjAGORAeOzyyDDKrZwIkLffeOQ==
 
-"@floating-ui/core@^1.6.0":
-  version "1.6.8"
-  resolved "https://registry.npmjs.org/@floating-ui/core/-/core-1.6.8.tgz"
-  integrity sha512-7XJ9cPU+yI2QeLS+FCSlqNFZJq8arvswefkZrYI1yQBbftw6FyrZOxYSh+9S7z7TpeWlRt9zJ5IhM1WIL334jA==
-  dependencies:
-    "@floating-ui/utils" "^0.2.8"
-
 "@floating-ui/core@^1.7.3":
   version "1.7.3"
-  resolved "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.3.tgz"
+  resolved "https://registry.yarnpkg.com/@floating-ui/core/-/core-1.7.3.tgz#462d722f001e23e46d86fd2bd0d21b7693ccb8b7"
   integrity sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w==
   dependencies:
     "@floating-ui/utils" "^0.2.10"
 
-"@floating-ui/dom@^1.0.0":
-  version "1.6.11"
-  resolved "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.6.11.tgz"
-  integrity sha512-qkMCxSR24v2vGkhYDo/UzxfJN3D4syqSjyuTFz6C7XcpU1pASPRieNI0Kj5VP3/503mOfYiGY891ugBX1GlABQ==
-  dependencies:
-    "@floating-ui/core" "^1.6.0"
-    "@floating-ui/utils" "^0.2.8"
-
-"@floating-ui/dom@^1.7.3":
-  version "1.7.3"
-  resolved "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.3.tgz"
-  integrity sha512-uZA413QEpNuhtb3/iIKoYMSK07keHPYeXF02Zhd6e213j+d1NamLix/mCLxBUDW/Gx52sPH2m+chlUsyaBs/Ag==
+"@floating-ui/dom@^1.7.4":
+  version "1.7.4"
+  resolved "https://registry.yarnpkg.com/@floating-ui/dom/-/dom-1.7.4.tgz#ee667549998745c9c3e3e84683b909c31d6c9a77"
+  integrity sha512-OOchDgh4F2CchOX94cRVqhvy7b3AFb+/rQXyswmzmGakRfkMgoWVjfnLWkRirfLEfuD4ysVW16eXzwt3jHIzKA==
   dependencies:
     "@floating-ui/core" "^1.7.3"
     "@floating-ui/utils" "^0.2.10"
 
-"@floating-ui/react-dom@^2.0.0":
-  version "2.1.5"
-  resolved "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.5.tgz"
-  integrity sha512-HDO/1/1oH9fjj4eLgegrlH3dklZpHtUYYFiVwMUwfGvk9jWDRWqkklA2/NFScknrcNSspbV868WjXORvreDX+Q==
-  dependencies:
-    "@floating-ui/dom" "^1.7.3"
-
-"@floating-ui/react-dom@^2.1.2":
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.2.tgz"
-  integrity sha512-06okr5cgPzMNBy+Ycse2A6udMi4bqwW/zgBF/rwjcNqWkyr82Mcg8b0vjX8OJpZFy/FKjJmw6wV7t44kK6kW7A==
+"@floating-ui/react-dom@^2.0.0", "@floating-ui/react-dom@^2.1.2":
+  version "2.1.6"
+  resolved "https://registry.yarnpkg.com/@floating-ui/react-dom/-/react-dom-2.1.6.tgz#189f681043c1400561f62972f461b93f01bf2231"
+  integrity sha512-4JX6rEatQEvlmgU80wZyq9RT96HZJa88q8hp0pBd+LrczeDI4o6uA2M+uvxngVHo4Ihr8uibXxH6+70zhAFrVw==
   dependencies:
-    "@floating-ui/dom" "^1.0.0"
+    "@floating-ui/dom" "^1.7.4"
 
 "@floating-ui/react@^0.26.16":
-  version "0.26.24"
-  resolved "https://registry.npmjs.org/@floating-ui/react/-/react-0.26.24.tgz"
-  integrity sha512-2ly0pCkZIGEQUq5H8bBK0XJmc1xIK/RM3tvVzY3GBER7IOD1UgmC2Y2tjj4AuS+TC+vTE1KJv2053290jua0Sw==
+  version "0.26.28"
+  resolved "https://registry.yarnpkg.com/@floating-ui/react/-/react-0.26.28.tgz#93f44ebaeb02409312e9df9507e83aab4a8c0dc7"
+  integrity sha512-yORQuuAtVpiRjpMhdc0wJj06b9JFjrYF4qp96j++v2NBpbi6SEGF7donUJ3TMieerQ6qVkAv1tgr7L4r5roTqw==
   dependencies:
     "@floating-ui/react-dom" "^2.1.2"
     "@floating-ui/utils" "^0.2.8"
     tabbable "^6.0.0"
 
-"@floating-ui/utils@^0.2.10":
+"@floating-ui/utils@^0.2.10", "@floating-ui/utils@^0.2.8":
   version "0.2.10"
-  resolved "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz"
+  resolved "https://registry.yarnpkg.com/@floating-ui/utils/-/utils-0.2.10.tgz#a2a1e3812d14525f725d011a73eceb41fef5bc1c"
   integrity sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ==
 
-"@floating-ui/utils@^0.2.8":
-  version "0.2.8"
-  resolved "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.8.tgz"
-  integrity sha512-kym7SodPp8/wloecOpcmSnWJsK7M0E5Wg8UcFA+uO4B9s5d0ywXOEro/8HM9x0rW+TljRzul/14UYz3TleT3ig==
-
-"@formatjs/ecma402-abstract@2.0.0":
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/@formatjs/ecma402-abstract/-/ecma402-abstract-2.0.0.tgz"
-  integrity sha512-rRqXOqdFmk7RYvj4khklyqzcfQl9vEL/usogncBHRZfZBDOwMGuSRNFl02fu5KGHXdbinju+YXyuR+Nk8xlr/g==
+"@formatjs/ecma402-abstract@2.3.4":
+  version "2.3.4"
+  resolved "https://registry.yarnpkg.com/@formatjs/ecma402-abstract/-/ecma402-abstract-2.3.4.tgz#e90c5a846ba2b33d92bc400fdd709da588280fbc"
+  integrity sha512-qrycXDeaORzIqNhBOx0btnhpD1c+/qFIHAN9znofuMJX6QBwtbrmlpWfD4oiUUD2vJUOIYFA/gYtg2KAMGG7sA==
   dependencies:
-    "@formatjs/intl-localematcher" "0.5.4"
-    tslib "^2.4.0"
+    "@formatjs/fast-memoize" "2.2.7"
+    "@formatjs/intl-localematcher" "0.6.1"
+    decimal.js "^10.4.3"
+    tslib "^2.8.0"
 
-"@formatjs/fast-memoize@2.2.0":
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/@formatjs/fast-memoize/-/fast-memoize-2.2.0.tgz"
-  integrity sha512-hnk/nY8FyrL5YxwP9e4r9dqeM6cAbo8PeU9UjyXojZMNvVad2Z06FAVHyR3Ecw6fza+0GH7vdJgiKIVXTMbSBA==
+"@formatjs/fast-memoize@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@formatjs/fast-memoize/-/fast-memoize-2.2.7.tgz#707f9ddaeb522a32f6715bb7950b0831f4cc7b15"
+  integrity sha512-Yabmi9nSvyOMrlSeGGWDiH7rf3a7sIwplbvo/dlz9WCIjzIQAfy1RMf4S0X3yG724n5Ghu2GmEl5NJIV6O9sZQ==
   dependencies:
-    tslib "^2.4.0"
+    tslib "^2.8.0"
 
-"@formatjs/icu-messageformat-parser@2.7.8":
-  version "2.7.8"
-  resolved "https://registry.npmjs.org/@formatjs/icu-messageformat-parser/-/icu-messageformat-parser-2.7.8.tgz"
-  integrity sha512-nBZJYmhpcSX0WeJ5SDYUkZ42AgR3xiyhNCsQweFx3cz/ULJjym8bHAzWKvG5e2+1XO98dBYC0fWeeAECAVSwLA==
+"@formatjs/icu-messageformat-parser@2.11.2":
+  version "2.11.2"
+  resolved "https://registry.yarnpkg.com/@formatjs/icu-messageformat-parser/-/icu-messageformat-parser-2.11.2.tgz#85aea211bea40aa81ee1d44ac7accc3cf5500a73"
+  integrity sha512-AfiMi5NOSo2TQImsYAg8UYddsNJ/vUEv/HaNqiFjnI3ZFfWihUtD5QtuX6kHl8+H+d3qvnE/3HZrfzgdWpsLNA==
   dependencies:
-    "@formatjs/ecma402-abstract" "2.0.0"
-    "@formatjs/icu-skeleton-parser" "1.8.2"
-    tslib "^2.4.0"
+    "@formatjs/ecma402-abstract" "2.3.4"
+    "@formatjs/icu-skeleton-parser" "1.8.14"
+    tslib "^2.8.0"
 
-"@formatjs/icu-skeleton-parser@1.8.2":
-  version "1.8.2"
-  resolved "https://registry.npmjs.org/@formatjs/icu-skeleton-parser/-/icu-skeleton-parser-1.8.2.tgz"
-  integrity sha512-k4ERKgw7aKGWJZgTarIcNEmvyTVD9FYh0mTrrBMHZ1b8hUu6iOJ4SzsZlo3UNAvHYa+PnvntIwRPt1/vy4nA9Q==
+"@formatjs/icu-skeleton-parser@1.8.14":
+  version "1.8.14"
+  resolved "https://registry.yarnpkg.com/@formatjs/icu-skeleton-parser/-/icu-skeleton-parser-1.8.14.tgz#b9581d00363908efb29817fdffc32b79f41dabe5"
+  integrity sha512-i4q4V4qslThK4Ig8SxyD76cp3+QJ3sAqr7f6q9VVfeGtxG9OhiAk3y9XF6Q41OymsKzsGQ6OQQoJNY4/lI8TcQ==
   dependencies:
-    "@formatjs/ecma402-abstract" "2.0.0"
-    tslib "^2.4.0"
+    "@formatjs/ecma402-abstract" "2.3.4"
+    tslib "^2.8.0"
 
-"@formatjs/intl-localematcher@0.5.4":
-  version "0.5.4"
-  resolved "https://registry.npmjs.org/@formatjs/intl-localematcher/-/intl-localematcher-0.5.4.tgz"
-  integrity sha512-zTwEpWOzZ2CiKcB93BLngUX59hQkuZjT2+SAQEscSm52peDW/getsawMcWF1rGRpMCX6D7nSJA3CzJ8gn13N/g==
+"@formatjs/intl-localematcher@0.6.1":
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/@formatjs/intl-localematcher/-/intl-localematcher-0.6.1.tgz#25dc30675320bf65a9d7f73876fc1e4064c0e299"
+  integrity sha512-ePEgLgVCqi2BBFnTMWPfIghu6FkbZnnBVhO2sSxvLfrdFw7wCHAHiDoM2h4NRgjbaY7+B7HgOLZGkK187pZTZg==
   dependencies:
-    tslib "^2.4.0"
+    tslib "^2.8.0"
 
-"@fortawesome/fontawesome-common-types@6.6.0":
-  version "6.6.0"
-  resolved "https://registry.npmjs.org/@fortawesome/fontawesome-common-types/-/fontawesome-common-types-6.6.0.tgz"
-  integrity sha512-xyX0X9mc0kyz9plIyryrRbl7ngsA9jz77mCZJsUkLl+ZKs0KWObgaEBoSgQiYWAsSmjz/yjl0F++Got0Mdp4Rw==
+"@fortawesome/fontawesome-common-types@6.7.2":
+  version "6.7.2"
+  resolved "https://registry.yarnpkg.com/@fortawesome/fontawesome-common-types/-/fontawesome-common-types-6.7.2.tgz#7123d74b0c1e726794aed1184795dbce12186470"
+  integrity sha512-Zs+YeHUC5fkt7Mg1l6XTniei3k4bwG/yo3iFUtZWd/pMx9g3fdvkSK9E0FOC+++phXOka78uJcYb8JaFkW52Xg==
 
 "@fortawesome/fontawesome-svg-core@^6.1.1":
-  version "6.6.0"
-  resolved "https://registry.npmjs.org/@fortawesome/fontawesome-svg-core/-/fontawesome-svg-core-6.6.0.tgz"
-  integrity sha512-KHwPkCk6oRT4HADE7smhfsKudt9N/9lm6EJ5BVg0tD1yPA5hht837fB87F8pn15D8JfTqQOjhKTktwmLMiD7Kg==
+  version "6.7.2"
+  resolved "https://registry.yarnpkg.com/@fortawesome/fontawesome-svg-core/-/fontawesome-svg-core-6.7.2.tgz#0ac6013724d5cc327c1eb81335b91300a4fce2f2"
+  integrity sha512-yxtOBWDrdi5DD5o1pmVdq3WMCvnobT0LU6R8RyyVXPvFRd2o79/0NCuQoCjNTeZz9EzA9xS3JxNWfv54RIHFEA==
   dependencies:
-    "@fortawesome/fontawesome-common-types" "6.6.0"
+    "@fortawesome/fontawesome-common-types" "6.7.2"
 
 "@fortawesome/react-fontawesome@^0.2.0":
-  version "0.2.2"
-  resolved "https://registry.npmjs.org/@fortawesome/react-fontawesome/-/react-fontawesome-0.2.2.tgz"
-  integrity sha512-EnkrprPNqI6SXJl//m29hpaNzOp1bruISWaOiRtkMi/xSvHJlzc2j2JAYS7egxt/EbjSNV/k6Xy0AQI6vB2+1g==
+  version "0.2.6"
+  resolved "https://registry.yarnpkg.com/@fortawesome/react-fontawesome/-/react-fontawesome-0.2.6.tgz#b75d0c7710c646c9bb6b9bb61cb5b8548a9ef2f5"
+  integrity sha512-mtBFIi1UsYQo7rYonYFkjgYKGoL8T+fEH6NGUpvuqtY3ytMsAoDaPo5rk25KuMtKDipY4bGYM/CkmCHA1N3FUg==
   dependencies:
     prop-types "^15.8.1"
 
 "@giscus/react@^3.0.0":
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/@giscus/react/-/react-3.0.0.tgz"
-  integrity sha512-hgCjLpg3Wgh8VbTF5p8ZLcIHI74wvDk1VIFv12+eKhenNVUDjgwNg2B1aq/3puyHOad47u/ZSyqiMtohjy/OOA==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@giscus/react/-/react-3.1.0.tgz#0ab77cc80d765989e87403ea7f50ba7a790a36c7"
+  integrity sha512-0TCO2TvL43+oOdyVVGHDItwxD1UMKP2ZYpT6gXmhFOqfAJtZxTzJ9hkn34iAF/b6YzyJ4Um89QIt9z/ajmAEeg==
   dependencies:
-    giscus "^1.5.0"
+    giscus "^1.6.0"
 
 "@growthbook/growthbook@^1.4.1":
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/@growthbook/growthbook/-/growthbook-1.4.1.tgz"
-  integrity sha512-Cl+q1SPwTYHvV2mcsjDcAuT4ezzpA6pOJr7nGCKiPaIZ4BN+pNt2kQM/dtCiwwse7vFz26S1/UJ+mb6qSSW8sQ==
+  version "1.6.1"
+  resolved "https://registry.yarnpkg.com/@growthbook/growthbook/-/growthbook-1.6.1.tgz#4135c680397af3e5de8d2ab92defe2c6ed697fc5"
+  integrity sha512-GSvb7bNaBTfH54AZ0oQdnoyV/ZxN9NhDEIHOsRUiM+CSOPiodz0i8/+1O6Wg0wFEVgBxS5CGWffyd74fym43Xw==
   dependencies:
     dom-mutator "^0.6.0"
 
 "@grpc/grpc-js@^1.7.1":
-  version "1.11.3"
-  resolved "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.11.3.tgz"
-  integrity sha512-i9UraDzFHMR+Iz/MhFLljT+fCpgxZ3O6CxwGJ8YuNYHJItIHUzKJpW2LvoFZNnGPwqc9iWy9RAucxV0JoR9aUQ==
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/@grpc/grpc-js/-/grpc-js-1.14.0.tgz#a3c47e7816ca2b4d5490cba9e06a3cf324e675ad"
+  integrity sha512-N8Jx6PaYzcTRNzirReJCtADVoq4z7+1KQ4E70jTg/koQiMoUSN1kbNjPOqpPbhMFhfU1/l7ixspPl8dNY+FoUg==
   dependencies:
-    "@grpc/proto-loader" "^0.7.13"
+    "@grpc/proto-loader" "^0.8.0"
     "@js-sdsl/ordered-map" "^4.4.2"
 
-"@grpc/proto-loader@^0.7.13":
-  version "0.7.13"
-  resolved "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.13.tgz"
-  integrity sha512-AiXO/bfe9bmxBjxxtYxFAXGZvMaN5s8kO+jBHAJCON8rJoB5YS/D6X7ZNc6XQkuHNmyl4CYaMI1fJ/Gn27RGGw==
+"@grpc/proto-loader@^0.8.0":
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/@grpc/proto-loader/-/proto-loader-0.8.0.tgz#b6c324dd909c458a0e4aa9bfd3d69cf78a4b9bd8"
+  integrity sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ==
   dependencies:
     lodash.camelcase "^4.3.0"
     long "^5.0.0"
-    protobufjs "^7.2.5"
+    protobufjs "^7.5.3"
     yargs "^17.7.2"
 
 "@headlessui/react@^2.0.3":
-  version "2.1.8"
-  resolved "https://registry.npmjs.org/@headlessui/react/-/react-2.1.8.tgz"
-  integrity sha512-uajqVkAcVG/wHwG9Fh5PFMcFpf2VxM4vNRNKxRjuK009kePVur8LkuuygHfIE+2uZ7z7GnlTtYsyUe6glPpTLg==
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@headlessui/react/-/react-2.2.9.tgz#213f78534c86e03a7c986d2c2abe1270622b3e13"
+  integrity sha512-Mb+Un58gwBn0/yWZfyrCh0TJyurtT+dETj7YHleylHk5od3dv2XqETPGWMyQ5/7sYN7oWdyM1u9MvC0OC8UmzQ==
   dependencies:
     "@floating-ui/react" "^0.26.16"
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@tanstack/react-virtual" "^3.8.1"
+    "@react-aria/focus" "^3.20.2"
+    "@react-aria/interactions" "^3.25.0"
+    "@tanstack/react-virtual" "^3.13.9"
+    use-sync-external-store "^1.5.0"
 
 "@heroicons/react@^2.1.3":
-  version "2.1.5"
-  resolved "https://registry.npmjs.org/@heroicons/react/-/react-2.1.5.tgz"
-  integrity sha512-FuzFN+BsHa+7OxbvAERtgBTNeZpUjgM/MIizfVkSCL2/edriN0Hx/DWRCR//aPYwO5QX/YlgLGXk+E3PcfZwjA==
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/@heroicons/react/-/react-2.2.0.tgz#0c05124af50434a800773abec8d3af6a297d904b"
+  integrity sha512-LMcepvRaS9LYHJGsF0zzmgKCUim/X3N/DQKc4jepAXJ7l8QxJ1PmxJzqplF2Z3FE4PqBAIGyJAQ/w4B5dsqbtQ==
 
 "@humanwhocodes/config-array@^0.13.0":
   version "0.13.0"
-  resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.13.0.tgz#fb907624df3256d04b9aa2df50d7aa97ec648748"
   integrity sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==
   dependencies:
     "@humanwhocodes/object-schema" "^2.0.3"
@@ -2114,46 +1788,53 @@
 
 "@humanwhocodes/module-importer@^1.0.1":
   version "1.0.1"
-  resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
   integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
 
 "@humanwhocodes/object-schema@^2.0.3":
   version "2.0.3"
-  resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz#4a2868d75d6d6963e423bcf90b7fd1be343409d3"
   integrity sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==
 
-"@internationalized/date@^3.5.4", "@internationalized/date@^3.5.5":
-  version "3.5.5"
-  resolved "https://registry.npmjs.org/@internationalized/date/-/date-3.5.5.tgz"
-  integrity sha512-H+CfYvOZ0LTJeeLOqm19E3uj/4YjrmOFtBufDHPfvtI80hFAMqtrp7oCACpe4Cil5l8S0Qu/9dYfZc/5lY8WQQ==
+"@internationalized/date@3.6.0":
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/@internationalized/date/-/date-3.6.0.tgz#b30d43030bfed1855f20c9503606926d75bfdf64"
+  integrity sha512-+z6ti+CcJnRlLHok/emGEsWQhe7kfSmEW+/6qCzvKY67YPh7YOBfvc7+/+NXq+zJlbArg30tYpqLjNgcAYv2YQ==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@internationalized/message@^3.1.4":
-  version "3.1.4"
-  resolved "https://registry.npmjs.org/@internationalized/message/-/message-3.1.4.tgz"
-  integrity sha512-Dygi9hH1s7V9nha07pggCkvmRfDd3q2lWnMGvrJyrOwYMe1yj4D2T9BoH9I6MGR7xz0biQrtLPsqUkqXzIrBOw==
+"@internationalized/date@^3.6.0", "@internationalized/date@^3.9.0":
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/@internationalized/date/-/date-3.9.0.tgz#cf241989b5dd07a2a9f1c91aabd2ad93968a0cc3"
+  integrity sha512-yaN3brAnHRD+4KyyOsJyk49XUvj2wtbNACSqg0bz3u8t2VuzhC8Q5dfRnrSxjnnbDb+ienBnkn1TzQfE154vyg==
+  dependencies:
+    "@swc/helpers" "^0.5.0"
+
+"@internationalized/message@^3.1.6", "@internationalized/message@^3.1.8":
+  version "3.1.8"
+  resolved "https://registry.yarnpkg.com/@internationalized/message/-/message-3.1.8.tgz#7181e8178f0868535f4507a573bf285e925832cb"
+  integrity sha512-Rwk3j/TlYZhn3HQ6PyXUV0XP9Uv42jqZGNegt0BXlxjE6G3+LwHjbQZAGHhCnCPdaA6Tvd3ma/7QzLlLkJxAWA==
   dependencies:
     "@swc/helpers" "^0.5.0"
     intl-messageformat "^10.1.0"
 
-"@internationalized/number@^3.5.3":
-  version "3.5.3"
-  resolved "https://registry.npmjs.org/@internationalized/number/-/number-3.5.3.tgz"
-  integrity sha512-rd1wA3ebzlp0Mehj5YTuTI50AQEx80gWFyHcQu+u91/5NgdwBecO8BH6ipPfE+lmQ9d63vpB3H9SHoIUiupllw==
+"@internationalized/number@^3.6.0", "@internationalized/number@^3.6.5":
+  version "3.6.5"
+  resolved "https://registry.yarnpkg.com/@internationalized/number/-/number-3.6.5.tgz#1103f2832ca8d9dd3e4eecf95733d497791dbbbe"
+  integrity sha512-6hY4Kl4HPBvtfS62asS/R22JzNNy8vi/Ssev7x6EobfCp+9QIB2hKvI2EtbdJ0VSQacxVNtqhE/NmF/NZ0gm6g==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@internationalized/string@^3.2.3":
-  version "3.2.3"
-  resolved "https://registry.npmjs.org/@internationalized/string/-/string-3.2.3.tgz"
-  integrity sha512-9kpfLoA8HegiWTeCbR2livhdVeKobCnVv8tlJ6M2jF+4tcMqDo94ezwlnrUANBWPgd8U7OXIHCk2Ov2qhk4KXw==
+"@internationalized/string@^3.2.5", "@internationalized/string@^3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@internationalized/string/-/string-3.2.7.tgz#76ae10f1e6e1fdaec7d0028a3f807d37a71bd2dd"
+  integrity sha512-D4OHBjrinH+PFZPvfCXvG28n2LSykWcJ7GIioQL+ok0LON15SdfoUssoHzzOUmVZLbRoREsQXVzA6r8JKsbP6A==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
 "@isaacs/cliui@^8.0.2":
   version "8.0.2"
-  resolved "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550"
   integrity sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==
   dependencies:
     string-width "^5.1.2"
@@ -2163,7 +1844,12 @@
     wrap-ansi "^8.1.0"
     wrap-ansi-cjs "npm:wrap-ansi@^7.0.0"
 
-"@jridgewell/gen-mapping@^0.3.12":
+"@isaacs/string-locale-compare@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@isaacs/string-locale-compare/-/string-locale-compare-1.1.0.tgz#291c227e93fd407a96ecd59879a35809120e432b"
+  integrity sha512-SQ7Kzhh9+D+ZW9MA0zkYv3VXhIDNx+LzM6EJ+/65I3QY+enU6Itte7E5XX7EWrqLW2FN4n06GWzBnPoC3th2aQ==
+
+"@jridgewell/gen-mapping@^0.3.12", "@jridgewell/gen-mapping@^0.3.2", "@jridgewell/gen-mapping@^0.3.5":
   version "0.3.13"
   resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz#6342a19f44347518c93e43b1ac69deb3c4656a1f"
   integrity sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==
@@ -2171,67 +1857,48 @@
     "@jridgewell/sourcemap-codec" "^1.5.0"
     "@jridgewell/trace-mapping" "^0.3.24"
 
-"@jridgewell/gen-mapping@^0.3.2", "@jridgewell/gen-mapping@^0.3.5":
-  version "0.3.5"
-  resolved "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz"
-  integrity sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==
+"@jridgewell/remapping@^2.3.5":
+  version "2.3.5"
+  resolved "https://registry.yarnpkg.com/@jridgewell/remapping/-/remapping-2.3.5.tgz#375c476d1972947851ba1e15ae8f123047445aa1"
+  integrity sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==
   dependencies:
-    "@jridgewell/set-array" "^1.2.1"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
+    "@jridgewell/gen-mapping" "^0.3.5"
     "@jridgewell/trace-mapping" "^0.3.24"
 
 "@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0":
   version "3.1.2"
-  resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6"
   integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==
 
-"@jridgewell/set-array@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz"
-  integrity sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==
-
-"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.4.15":
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz"
-  integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==
-
-"@jridgewell/sourcemap-codec@^1.5.0", "@jridgewell/sourcemap-codec@^1.5.5":
+"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14", "@jridgewell/sourcemap-codec@^1.4.15", "@jridgewell/sourcemap-codec@^1.5.0", "@jridgewell/sourcemap-codec@^1.5.5":
   version "1.5.5"
   resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz#6912b00d2c631c0d15ce1a7ab57cd657f2a8f8ba"
   integrity sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==
 
 "@jridgewell/trace-mapping@0.3.9":
   version "0.3.9"
-  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
   integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
   dependencies:
     "@jridgewell/resolve-uri" "^3.0.3"
     "@jridgewell/sourcemap-codec" "^1.4.10"
 
-"@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.25":
-  version "0.3.25"
-  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz"
-  integrity sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==
-  dependencies:
-    "@jridgewell/resolve-uri" "^3.1.0"
-    "@jridgewell/sourcemap-codec" "^1.4.14"
-
-"@jridgewell/trace-mapping@^0.3.28":
-  version "0.3.30"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.30.tgz#4a76c4daeee5df09f5d3940e087442fb36ce2b99"
-  integrity sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==
+"@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.28":
+  version "0.3.31"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz#db15d6781c931f3a251a3dac39501c98a6082fd0"
+  integrity sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==
   dependencies:
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
 "@js-sdsl/ordered-map@^4.4.2":
   version "4.4.2"
-  resolved "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz#9299f82874bab9e4c7f9c48d865becbfe8d6907c"
   integrity sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==
 
 "@js-temporal/polyfill@^0.4.4":
   version "0.4.4"
-  resolved "https://registry.npmjs.org/@js-temporal/polyfill/-/polyfill-0.4.4.tgz"
+  resolved "https://registry.yarnpkg.com/@js-temporal/polyfill/-/polyfill-0.4.4.tgz#4c26b4a1a68c19155808363f520204712cfc2558"
   integrity sha512-2X6bvghJ/JAoZO52lbgyAPFj8uCflhTo2g7nkFzEQdXd/D8rEeD4HtmTEpmtGCva260fcd66YNXBOYdnmHqSOg==
   dependencies:
     jsbi "^4.3.0"
@@ -2239,83 +1906,110 @@
 
 "@jsdevtools/ono@^7.1.3":
   version "7.1.3"
-  resolved "https://registry.npmjs.org/@jsdevtools/ono/-/ono-7.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/@jsdevtools/ono/-/ono-7.1.3.tgz#9df03bbd7c696a5c58885c34aa06da41c8543796"
   integrity sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg==
 
-"@jsonjoy.com/base64@^1.1.1":
+"@jsonjoy.com/base64@^1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@jsonjoy.com/base64/-/base64-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/base64/-/base64-1.1.2.tgz#cf8ea9dcb849b81c95f14fc0aaa151c6b54d2578"
   integrity sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==
 
-"@jsonjoy.com/json-pack@^1.0.3":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-1.1.0.tgz"
-  integrity sha512-zlQONA+msXPPwHWZMKFVS78ewFczIll5lXiVPwFPCZUsrOKdxc2AvxU1HoNBmMRhqDZUR9HkC3UOm+6pME6Xsg==
-  dependencies:
-    "@jsonjoy.com/base64" "^1.1.1"
-    "@jsonjoy.com/util" "^1.1.2"
+"@jsonjoy.com/buffers@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/buffers/-/buffers-1.0.0.tgz#ade6895b7d3883d70f87b5743efaa12c71dfef7a"
+  integrity sha512-NDigYR3PHqCnQLXYyoLbnEdzMMvzeiCWo1KOut7Q0CoIqg9tUAPKJ1iq/2nFhc5kZtexzutNY0LFjdwWL3Dw3Q==
+
+"@jsonjoy.com/codegen@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/codegen/-/codegen-1.0.0.tgz#5c23f796c47675f166d23b948cdb889184b93207"
+  integrity sha512-E8Oy+08cmCf0EK/NMxpaJZmOxPqM+6iSe2S4nlSBrPZOORoDJILxtbSUEDKQyTamm/BVAhIGllOBNU79/dwf0g==
+
+"@jsonjoy.com/json-pack@^1.11.0":
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pack/-/json-pack-1.14.0.tgz#eda5255ccdaeafb3aa811ff1ae4814790b958b4f"
+  integrity sha512-LpWbYgVnKzphN5S6uss4M25jJ/9+m6q6UJoeN6zTkK4xAGhKsiBRPVeF7OYMWonn5repMQbE5vieRXcMUrKDKw==
+  dependencies:
+    "@jsonjoy.com/base64" "^1.1.2"
+    "@jsonjoy.com/buffers" "^1.0.0"
+    "@jsonjoy.com/codegen" "^1.0.0"
+    "@jsonjoy.com/json-pointer" "^1.0.1"
+    "@jsonjoy.com/util" "^1.9.0"
     hyperdyperid "^1.2.0"
-    thingies "^1.20.0"
+    thingies "^2.5.0"
 
-"@jsonjoy.com/util@^1.1.2", "@jsonjoy.com/util@^1.3.0":
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/@jsonjoy.com/util/-/util-1.3.0.tgz"
-  integrity sha512-Cebt4Vk7k1xHy87kHY7KSPLT77A7Ev7IfOblyLZhtYEhrdQ6fX4EoLq3xOQ3O/DRMEh2ok5nyC180E+ABS8Wmw==
+"@jsonjoy.com/json-pointer@^1.0.1":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz#049cb530ac24e84cba08590c5e36b431c4843408"
+  integrity sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==
+  dependencies:
+    "@jsonjoy.com/codegen" "^1.0.0"
+    "@jsonjoy.com/util" "^1.9.0"
+
+"@jsonjoy.com/util@^1.9.0":
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/@jsonjoy.com/util/-/util-1.9.0.tgz#7ee95586aed0a766b746cd8d8363e336c3c47c46"
+  integrity sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==
+  dependencies:
+    "@jsonjoy.com/buffers" "^1.0.0"
+    "@jsonjoy.com/codegen" "^1.0.0"
 
 "@juggle/resize-observer@^3.3.1":
   version "3.4.0"
-  resolved "https://registry.npmjs.org/@juggle/resize-observer/-/resize-observer-3.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/@juggle/resize-observer/-/resize-observer-3.4.0.tgz#08d6c5e20cf7e4cc02fd181c4b0c225cd31dbb60"
   integrity sha512-dfLbk+PwWvFzSxwk3n5ySL0hfBog779o8h68wK/7/APo/7cgyWp5jcXockbxdk5kFRkbeXWm4Fbi9FrdN381sA==
 
-"@lit-labs/ssr-dom-shim@^1.2.0":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@lit-labs/ssr-dom-shim/-/ssr-dom-shim-1.2.1.tgz"
-  integrity sha512-wx4aBmgeGvFmOKucFKY+8VFJSYZxs9poN3SDNQFF6lT6NrQUnHiPB2PWz2sc4ieEcAaYYzN+1uWahEeTq2aRIQ==
+"@lit-labs/ssr-dom-shim@^1.4.0":
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/@lit-labs/ssr-dom-shim/-/ssr-dom-shim-1.4.0.tgz#55eb80ab5ef6e188f7e541c1e2bea1ef582413b8"
+  integrity sha512-ficsEARKnmmW5njugNYKipTm4SFnbik7CXtoencDZzmzo/dQ+2Q0bgkzJuoJP20Aj0F+izzJjOqsnkd6F/o1bw==
 
-"@lit/reactive-element@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@lit/reactive-element/-/reactive-element-2.0.4.tgz"
-  integrity sha512-GFn91inaUa2oHLak8awSIigYz0cU0Payr1rcFsrkf5OJ5eSPxElyZfKh0f2p9FsTiZWXQdWGJeXZICEfXXYSXQ==
+"@lit/reactive-element@^2.1.0":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@lit/reactive-element/-/reactive-element-2.1.1.tgz#0662ac4a43d4898974aef9a6c5cd47b9e331919a"
+  integrity sha512-N+dm5PAYdQ8e6UlywyyrgI2t++wFGXfHx+dSJ1oBrg6FAxUj40jId++EaRm80MKX5JnlH1sBsyZ5h0bcZKemCg==
   dependencies:
-    "@lit-labs/ssr-dom-shim" "^1.2.0"
+    "@lit-labs/ssr-dom-shim" "^1.4.0"
 
 "@mailchimp/mailchimp_marketing@^3.0.80":
   version "3.0.80"
-  resolved "https://registry.npmjs.org/@mailchimp/mailchimp_marketing/-/mailchimp_marketing-3.0.80.tgz"
+  resolved "https://registry.yarnpkg.com/@mailchimp/mailchimp_marketing/-/mailchimp_marketing-3.0.80.tgz#120a4aeb9751ac80ff4c86fabb43af7a6add4e49"
   integrity sha512-Cgz0xPb+1DUjmrl5whAsmqfAChBko+Wf4/PLQE4RvwfPlcq2agfHr1QFiXEhZ8e+GQwQ3hZQn9iLGXwIXwxUCg==
   dependencies:
     dotenv "^8.2.0"
     superagent "3.8.1"
 
 "@mdx-js/esbuild@^3.0.0":
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/@mdx-js/esbuild/-/esbuild-3.0.1.tgz"
-  integrity sha512-+KZbCKcRjFtRD6qzD+c70Vq/VPVt5LHFsOshNcsdcONkaLTCSjmM7/uj71i3BcP+170f+P4DwVEMtqR/k0t5aw==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@mdx-js/esbuild/-/esbuild-3.1.1.tgz#4b04856044a013b2c91eff70c3cb3afd82699b19"
+  integrity sha512-NS35VhTdvKNj5/B1JSD5W3kN1R0WDHgk+zCWq+tSChQw5L2Bgeiz7yyZPFrc5LWuPVOxE1xMbJr82bO9VVzmfQ==
   dependencies:
     "@mdx-js/mdx" "^3.0.0"
     "@types/unist" "^3.0.0"
+    source-map "^0.7.0"
     vfile "^6.0.0"
     vfile-message "^4.0.0"
 
-"@mdx-js/mdx@^3.0.0":
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.0.1.tgz"
-  integrity sha512-eIQ4QTrOWyL3LWEe/bu6Taqzq2HQvHcyTMaOrI95P2/LmJE7AsfPfgJGuFLPVqBUE1BC1rik3VIhU+s9u72arA==
+"@mdx-js/mdx@^3.0.0", "@mdx-js/mdx@^3.0.1":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@mdx-js/mdx/-/mdx-3.1.1.tgz#c5ffd991a7536b149e17175eee57a1a2a511c6d1"
+  integrity sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/estree-jsx" "^1.0.0"
     "@types/hast" "^3.0.0"
     "@types/mdx" "^2.0.0"
+    acorn "^8.0.0"
     collapse-white-space "^2.0.0"
     devlop "^1.0.0"
-    estree-util-build-jsx "^3.0.0"
     estree-util-is-identifier-name "^3.0.0"
-    estree-util-to-js "^2.0.0"
+    estree-util-scope "^1.0.0"
     estree-walker "^3.0.0"
-    hast-util-to-estree "^3.0.0"
     hast-util-to-jsx-runtime "^2.0.0"
     markdown-extensions "^2.0.0"
-    periscopic "^3.0.0"
+    recma-build-jsx "^1.0.0"
+    recma-jsx "^1.0.0"
+    recma-stringify "^1.0.0"
+    rehype-recma "^1.0.0"
     remark-mdx "^3.0.0"
     remark-parse "^11.0.0"
     remark-rehype "^11.0.0"
@@ -2326,6 +2020,22 @@
     unist-util-visit "^5.0.0"
     vfile "^6.0.0"
 
+"@mdx-js/react@^3.0.1":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@mdx-js/react/-/react-3.1.1.tgz#24bda7fffceb2fe256f954482123cda1be5f5fef"
+  integrity sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==
+  dependencies:
+    "@types/mdx" "^2.0.0"
+
+"@napi-rs/wasm-runtime@^0.2.11":
+  version "0.2.12"
+  resolved "https://registry.yarnpkg.com/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz#3e78a8b96e6c33a6c517e1894efbd5385a7cb6f2"
+  integrity sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==
+  dependencies:
+    "@emnapi/core" "^1.4.3"
+    "@emnapi/runtime" "^1.4.3"
+    "@tybys/wasm-util" "^0.10.0"
+
 "@next/bundle-analyzer@14.2.20":
   version "14.2.20"
   resolved "https://registry.yarnpkg.com/@next/bundle-analyzer/-/bundle-analyzer-14.2.20.tgz#2d7f71a6de6b28c0e9add3a1b4b04d2f678b1bb1"
@@ -2340,7 +2050,7 @@
 
 "@next/eslint-plugin-next@14.2.3":
   version "14.2.3"
-  resolved "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-14.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/@next/eslint-plugin-next/-/eslint-plugin-next-14.2.3.tgz#287ad8620e7061ba01e8d3313d464db6d217b6df"
   integrity sha512-L3oDricIIjgj1AVnRdRor21gI7mShlSwU/1ZGHmqM3LzHhXXhdkrfeNY5zif25Bi5Dd7fiJHsbhoZCHfXYvlAw==
   dependencies:
     glob "10.3.10"
@@ -2391,935 +2101,1001 @@
   integrity sha512-2N0lSoU4GjfLSO50wvKpMQgKd4HdI2UHEhQPPPnlgfBJlOgJxkjpkYBqzk08f1gItBB6xF/n+ykso2hgxuydsA==
 
 "@next/third-parties@^14.2.3":
-  version "14.2.13"
-  resolved "https://registry.npmjs.org/@next/third-parties/-/third-parties-14.2.13.tgz"
-  integrity sha512-OSqD2E9JO0/GE8HT5QAUsYVXwjWtPLScAX70kO2xopwDAdRzakrsQS55Cihd862X/4bUB37ApVZ9DlHcExzeOg==
+  version "14.2.33"
+  resolved "https://registry.yarnpkg.com/@next/third-parties/-/third-parties-14.2.33.tgz#44e87529f26271b8c7fc86c48e090cd28673a51e"
+  integrity sha512-hrHZXJYbgY2VCmRUEUcQt2PsxZ2yCB8IJyPy0qI3pz237i+eI2BlwMpAI7L4ZkUl5IRyO4/SBJIgulVDF2pRow==
   dependencies:
     third-party-capital "1.0.20"
 
-"@nextui-org/accordion@2.0.40":
-  version "2.0.40"
-  resolved "https://registry.npmjs.org/@nextui-org/accordion/-/accordion-2.0.40.tgz"
-  integrity sha512-aJmhflLOXOFTjbBWlWto30hYzimw+sw1EZwSRG9CdxbjRact2dRfCLsZQmHkJW2ifVx51g/qLNE2NSFAi2L8dA==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/divider" "2.0.32"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-accordion" "2.0.7"
-    "@react-aria/button" "3.9.5"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/tree" "3.8.1"
-    "@react-types/accordion" "3.0.0-alpha.21"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/aria-utils@2.0.26":
-  version "2.0.26"
-  resolved "https://registry.npmjs.org/@nextui-org/aria-utils/-/aria-utils-2.0.26.tgz"
-  integrity sha512-e81HxkNI3/HCPPJT9OVK0g0ivTkuqeeQ043WlAxvgf+upFTEvNN5vmsSKBfWGgfZpsVHgNyHIzwbHjy9zKePLQ==
-  dependencies:
-    "@nextui-org/react-rsc-utils" "2.0.14"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system" "2.2.6"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/collections" "3.10.7"
-    "@react-stately/overlays" "3.6.7"
-    "@react-types/overlays" "3.8.7"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/autocomplete@2.1.7":
-  version "2.1.7"
-  resolved "https://registry.npmjs.org/@nextui-org/autocomplete/-/autocomplete-2.1.7.tgz"
-  integrity sha512-T3dF5akCXvJ21OxwPxAQmTjHoiB/GMUa2ppcJ9PStfCCPiI2vjwb4CO4q/duj/nXJIpQf/UfPhpSonnJ444o6g==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/input" "2.2.5"
-    "@nextui-org/listbox" "2.1.27"
-    "@nextui-org/popover" "2.1.29"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/scroll-shadow" "2.1.20"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/spinner" "2.0.34"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/combobox" "3.9.1"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/combobox" "3.8.4"
-    "@react-types/combobox" "3.11.1"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/avatar@2.0.33":
-  version "2.0.33"
-  resolved "https://registry.npmjs.org/@nextui-org/avatar/-/avatar-2.0.33.tgz"
-  integrity sha512-SPnIKM+34T/a+KCRCBiG8VwMBzu2/bap7IPHhmICtQ6KmG8Dzmazj3tGZsVt7HjhMRVY7e1vzev4IMaHqkIdRg==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-image" "2.0.6"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-
-"@nextui-org/badge@2.0.32":
-  version "2.0.32"
-  resolved "https://registry.npmjs.org/@nextui-org/badge/-/badge-2.0.32.tgz"
-  integrity sha512-vlV/SY0e7/AmpVP7hB57XoSOo95Fr3kRWcLfMx8yL8VDR2UWMFaMlrT7JTghdgTGFSO7L1Ov1BFwDRRKVe3eyg==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-
-"@nextui-org/breadcrumbs@2.0.13":
-  version "2.0.13"
-  resolved "https://registry.npmjs.org/@nextui-org/breadcrumbs/-/breadcrumbs-2.0.13.tgz"
-  integrity sha512-tdet47IBOwUaJL0PmxTuGH+ZI2nucyNwG3mX1OokfIXmq5HuMCGKaVFXaNP8mWb4Pii2bvtRqaqTfxmUb3kjGw==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/breadcrumbs" "3.5.13"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/breadcrumbs" "3.7.5"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/button@2.0.38":
-  version "2.0.38"
-  resolved "https://registry.npmjs.org/@nextui-org/button/-/button-2.0.38.tgz"
-  integrity sha512-XbgyqBv+X7QirXeriGwkqkMOENpAxXRo+jzfMyBMvfsM3kwrFj92OSF1F7/dWDvcW7imVZB9o2Ci7LIppq9ZZQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/ripple" "2.0.33"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/spinner" "2.0.34"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@react-aria/button" "3.9.5"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/button" "3.9.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/calendar@2.0.12":
-  version "2.0.12"
-  resolved "https://registry.npmjs.org/@nextui-org/calendar/-/calendar-2.0.12.tgz"
-  integrity sha512-FnEnOQnsuyN+F+hy4LEJBvZZcfXMpDGgLkTdnDdoZObXQWwd0PWPjU8GzY+ukhhR5eiU7QIj2AADVRCvuAkiLA==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@react-aria/calendar" "3.5.8"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/calendar" "3.5.1"
-    "@react-stately/utils" "3.10.1"
-    "@react-types/button" "3.9.4"
-    "@react-types/calendar" "3.4.6"
-    "@react-types/shared" "3.23.1"
+"@nextui-org/accordion@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/accordion/-/accordion-2.2.7.tgz#aab6d766f2b4cab1d54f3b74a1530a1fddc0dbd5"
+  integrity sha512-jdobOwUxSi617m+LpxHFzg64UhDuOfDJI2CMk3MP+b2WBJ7SNW4hmN2NW5Scx5JiY+kyBGmlxJ4Y++jZpZgQjQ==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/divider" "2.2.5"
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-accordion" "2.2.2"
+    "@react-aria/button" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/tree" "3.8.6"
+    "@react-types/accordion" "3.0.0-alpha.25"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/alert@2.2.9":
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/alert/-/alert-2.2.9.tgz#b7f6071bcef7c29f9cad1f159e2cbaf3f8bc66a3"
+  integrity sha512-SjMZewEqknx/jqmMcyQdbeo6RFg40+A3b1lGjnj/fdkiJozQoTesiOslzDsacqiSgvso2F+8u1emC2tFBAU3hw==
+  dependencies:
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/utils" "3.10.5"
+
+"@nextui-org/aria-utils@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/aria-utils/-/aria-utils-2.2.7.tgz#38b2ce13e652d78f874311c74f6c72c6d282ddf7"
+  integrity sha512-QgMZ8fii6BCI/+ZIkgXgkm/gMNQ92pQJn83q90fBT6DF+6j4hsCpJwLNCF5mIJkX/cQ/4bHDsDaj7w1OzkhQNg==
+  dependencies:
+    "@nextui-org/react-rsc-utils" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system" "2.4.6"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/collections" "3.12.0"
+    "@react-stately/overlays" "3.6.12"
+    "@react-types/overlays" "3.8.11"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/autocomplete@2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/autocomplete/-/autocomplete-2.3.9.tgz#d4f3eceae312e9431a60afb164a20db6ea3ba402"
+  integrity sha512-1AizOvL8lERoWjm8WiA0NPJWB3h0gqYlbV/qGZeacac5356hb8cNzWUlxGzr9bNkhn9slIoEUyGMgtYeKq7ptg==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/input" "2.4.8"
+    "@nextui-org/listbox" "2.3.9"
+    "@nextui-org/popover" "2.3.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/scroll-shadow" "2.3.5"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/spinner" "2.2.6"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/combobox" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/combobox" "3.10.1"
+    "@react-types/combobox" "3.13.1"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/avatar@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/avatar/-/avatar-2.2.6.tgz#24e55f5f3a32e633b1c216b18646d716fe06032e"
+  integrity sha512-QRNCAMXnSZrFJYKo78lzRPiAPRq5pn1LIHUVvX/mCRiTvbu1FXrMakAvOWz/n1X1mLndnrfQMRNgmtC8YlHIdg==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-image" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+
+"@nextui-org/badge@2.2.5":
+  version "2.2.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/badge/-/badge-2.2.5.tgz#999ee8e2e42ff6dd40315d128cddfa7f2e0ce6fe"
+  integrity sha512-8pLbuY+RVCzI/00CzNudc86BiuXByPFz2yHh00djKvZAXbT0lfjvswClJxSC2FjUXlod+NtE+eHmlhSMo3gmpw==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+
+"@nextui-org/breadcrumbs@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/breadcrumbs/-/breadcrumbs-2.2.6.tgz#64b18d3e7bd3a422b0bf71106aba0435fe9b7483"
+  integrity sha512-TlAUSiIClmm02tJqOvtwySpKDOENduXCXkKzCbmSaqEFhziHnhyE0eM8IVEprBoK6z1VP+sUrX6C2gZ871KUSw==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/breadcrumbs" "3.5.19"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/breadcrumbs" "3.7.9"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/button@2.2.9":
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/button/-/button-2.2.9.tgz#c0205fa89ea2daceebba7fc6311e8de47c31d4c9"
+  integrity sha512-RrfjAZHoc6nmaqoLj40M0Qj3tuDdv2BMGCgggyWklOi6lKwtOaADPvxEorDwY3GnN54Xej+9SWtUwE8Oc3SnOg==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/ripple" "2.2.7"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/spinner" "2.2.6"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@react-aria/button" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/button" "3.10.1"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/calendar@2.2.9":
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/calendar/-/calendar-2.2.9.tgz#aaea270b3fbf6d00ab99eff5d9b5bb28923e3b8b"
+  integrity sha512-tx1401HLnwadoDHNkmEIZNeAw9uYW6KsgIRRQnXTNVstBXdMmPWjoMBj8fkQqF55+U58k6a+w3N4tTpgRGOpaQ==
+  dependencies:
+    "@internationalized/date" "3.6.0"
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@react-aria/calendar" "3.6.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/calendar" "3.6.0"
+    "@react-stately/utils" "3.10.5"
+    "@react-types/button" "3.10.1"
+    "@react-types/calendar" "3.5.0"
+    "@react-types/shared" "3.26.0"
     "@types/lodash.debounce" "^4.0.7"
-    lodash.debounce "^4.0.8"
     scroll-into-view-if-needed "3.0.10"
 
-"@nextui-org/card@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/card/-/card-2.0.34.tgz"
-  integrity sha512-2RYNPsQkM0FOifGCKmRBR3AuYgYCNmPV7dyA5M3D9Lf0APsHHtsXRA/GeIJ/AuPnglZrYBX8wpM5kLt3dnlQjQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/ripple" "2.0.33"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@react-aria/button" "3.9.5"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/checkbox@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.npmjs.org/@nextui-org/checkbox/-/checkbox-2.1.5.tgz"
-  integrity sha512-PSCWmxEzFPfeIJfoGAtbQS5T7JvBRblUMz5NdCMArA8MLvWW8EKL41cMPsqWjaUanjD0fAI8Q9HuDfBZnkcPbw==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-callback-ref" "2.0.6"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/checkbox" "3.14.3"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/checkbox" "3.6.5"
-    "@react-stately/toggle" "3.7.4"
-    "@react-types/checkbox" "3.8.1"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/chip@2.0.33":
-  version "2.0.33"
-  resolved "https://registry.npmjs.org/@nextui-org/chip/-/chip-2.0.33.tgz"
-  integrity sha512-6cQkMTV/34iPprjnfK6xlwkv5lnZjMsbYBN3ZqHHrQfV2zQg19ewFcuIw9XlRYA3pGYPpoycdOmSdQ6qXc66lQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/checkbox" "3.8.1"
-
-"@nextui-org/code@2.0.33":
-  version "2.0.33"
-  resolved "https://registry.npmjs.org/@nextui-org/code/-/code-2.0.33.tgz"
-  integrity sha512-G2254ov2rsPxFEoJ0UHVHe+rSmNYwoHZc7STAtiTsJ2HfebZPQbNnfuCifMIpa+kgvHrMBGb85eGk0gy1R+ArA==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system-rsc" "2.1.6"
-
-"@nextui-org/date-input@2.1.4":
-  version "2.1.4"
-  resolved "https://registry.npmjs.org/@nextui-org/date-input/-/date-input-2.1.4.tgz"
-  integrity sha512-U8Pbe7EhMp9VTfFxB/32+A9N9cJJWswebIz1qpaPy0Hmr92AHS3c1qVTcspkop6wbIM8AnHWEST0QkR95IXPDA==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/datepicker" "3.10.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/datepicker" "3.9.4"
-    "@react-types/datepicker" "3.7.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/date-picker@2.1.8":
-  version "2.1.8"
-  resolved "https://registry.npmjs.org/@nextui-org/date-picker/-/date-picker-2.1.8.tgz"
-  integrity sha512-pokAFcrf6AdM53QHf1EzvqVhj8imQRZHWitK9eZPtIdGzJzx28dW0ir7ID0lQFMiNNIQTesSpBLzedTawbcJrg==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/calendar" "2.0.12"
-    "@nextui-org/date-input" "2.1.4"
-    "@nextui-org/popover" "2.1.29"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/datepicker" "3.10.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/datepicker" "3.9.4"
-    "@react-stately/overlays" "3.6.7"
-    "@react-stately/utils" "3.10.1"
-    "@react-types/datepicker" "3.7.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/divider@2.0.32":
-  version "2.0.32"
-  resolved "https://registry.npmjs.org/@nextui-org/divider/-/divider-2.0.32.tgz"
-  integrity sha512-2B2j3VmvVDFnMc9Uw7UWMkByA+osgnRmVwMZNZjl9g3oCycz3UDXotNJXjgsLocT8tGO8UwMcrdgo7QBZl52uw==
-  dependencies:
-    "@nextui-org/react-rsc-utils" "2.0.14"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system-rsc" "2.1.6"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/dropdown@2.1.31":
-  version "2.1.31"
-  resolved "https://registry.npmjs.org/@nextui-org/dropdown/-/dropdown-2.1.31.tgz"
-  integrity sha512-tP6c5MAhWK4hJ6U02oX6APUpjjrn97Zn7t+56Xx4YyQOSj0CJx18VF0JsU+MrjFZxPX3UBKU3B2zGBHOEGE4Kw==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/menu" "2.0.30"
-    "@nextui-org/popover" "2.1.29"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/menu" "3.14.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/menu" "3.7.1"
-    "@react-types/menu" "3.9.9"
-
-"@nextui-org/framer-utils@2.0.25":
-  version "2.0.25"
-  resolved "https://registry.npmjs.org/@nextui-org/framer-utils/-/framer-utils-2.0.25.tgz"
-  integrity sha512-bhQKDg4c5Da4II4UYLKyvYagusTd62eVwPqpfUP+GHZKKZcmRaS6MQZTh4xJYbpyh298S4jRSH/AUAiN/OK3TQ==
+"@nextui-org/card@2.2.9":
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/card/-/card-2.2.9.tgz#f4f4ce075dc8b91e9248ae1f68052e642cf32a35"
+  integrity sha512-Ltvb5Uy4wwkBJj3QvVQmoB6PwLYUNSoWAFo2xxu7LUHKWcETYI0YbUIuwL2nFU2xfJYeBTGjXGQO1ffBsowrtQ==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/ripple" "2.2.7"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@react-aria/button" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/checkbox@2.3.8":
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/checkbox/-/checkbox-2.3.8.tgz#b00e85bd29ccaff5f1193763af576968cc93db7d"
+  integrity sha512-T5+AhzQfbg53qZnPn5rgMcJ7T5rnvSGYTx17wHWtdF9Q4QflZOmLGoxqoTWbTVpM4XzUUPyi7KVSKZScWdBDAA==
+  dependencies:
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-callback-ref" "2.1.1"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/checkbox" "3.15.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/checkbox" "3.6.10"
+    "@react-stately/toggle" "3.8.0"
+    "@react-types/checkbox" "3.9.0"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/chip@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/chip/-/chip-2.2.6.tgz#ffb2c3afa65229a06ef402bbdd04cd86e6e49f67"
+  integrity sha512-HrSYagbrD4u4nblsNMIu7WGnDj9A8YnYCt30tasJmNSyydUVHFkxKOc3S8k+VU3BHPxeENxeBT7w0OlYoKbFIQ==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/checkbox" "3.9.0"
+
+"@nextui-org/code@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/code/-/code-2.2.6.tgz#d1c3c23a5c857e6f575857b632751d9b83e6e835"
+  integrity sha512-8qvAywIKAVh1thy/YHNwqH2xjTcwPiOWwNdKqvJMSk0CNtLHYJmDK8i2vmKZTM3zfB08Q/G94H0Wf+YsyrZdDg==
   dependencies:
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system" "2.2.6"
-    "@nextui-org/use-measure" "2.0.2"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system-rsc" "2.3.5"
+
+"@nextui-org/date-input@2.3.8":
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/date-input/-/date-input-2.3.8.tgz#7be97576a0cd34969ac1ebef034802bda2951907"
+  integrity sha512-phj0Y8F/GpsKjKSiratFwh7HDzmMsIf6G2L2ljgWqA79PvP+RYf/ogEfaMIq1knF8OlssMo5nsFFJNsNB+xKGg==
+  dependencies:
+    "@internationalized/date" "3.6.0"
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/datepicker" "3.12.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/datepicker" "3.11.0"
+    "@react-types/datepicker" "3.9.0"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/date-picker@2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/date-picker/-/date-picker-2.3.9.tgz#4c35874f7ef065215c93348c1359ac8a71c6a016"
+  integrity sha512-RzdVTl/tulTyE5fwGkQfn0is5hsTkPPRJFJZXMqYeci85uhpD+bCreWnTXrGFIXcqUo0ZBJWx3EdtBJZnGp4xQ==
+  dependencies:
+    "@internationalized/date" "3.6.0"
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/calendar" "2.2.9"
+    "@nextui-org/date-input" "2.3.8"
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/popover" "2.3.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/datepicker" "3.12.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/datepicker" "3.11.0"
+    "@react-stately/overlays" "3.6.12"
+    "@react-stately/utils" "3.10.5"
+    "@react-types/datepicker" "3.9.0"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/divider@2.2.5":
+  version "2.2.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/divider/-/divider-2.2.5.tgz#d4531f70ebdfb534f9c9379e9585bffee64a464e"
+  integrity sha512-OB8b3CU4nQ5ARIGL48izhzrAHR0mnwws+Kd5LqRCZ/1R9uRMqsq7L0gpG9FkuV2jf2FuA7xa/GLOLKbIl4CEww==
+  dependencies:
+    "@nextui-org/react-rsc-utils" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system-rsc" "2.3.5"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/dom-animation@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/dom-animation/-/dom-animation-2.1.1.tgz#42611dc7aff1a6ca11ff3d7683ea754a35ec8577"
+  integrity sha512-xLrVNf1EV9zyyZjk6j3RptOvnga1WUCbMpDgJLQHp+oYwxTfBy0SkXHuN5pRdcR0XpR/IqRBDIobMdZI0iyQyg==
 
-"@nextui-org/image@2.0.32":
-  version "2.0.32"
-  resolved "https://registry.npmjs.org/@nextui-org/image/-/image-2.0.32.tgz"
-  integrity sha512-JpE0O8qAeJpQA61ZnXNLH76to+dbx93PR5tTOxSvmTxtnuqVg4wl5ar/SBY3czibJPr0sj33k8Mv2EfULjoH7Q==
+"@nextui-org/drawer@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/drawer/-/drawer-2.2.7.tgz#78f80fb81db1d382892ffccbd5ef118276c87619"
+  integrity sha512-a1Sr3sSjOZD0SiXDYSySKkOelTyCYExPvUsIckzjF5A3TNlBw4KFKnJzaXvabC3SNRy6/Ocq7oqz6VRv37wxQg==
+  dependencies:
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/modal" "2.2.7"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+
+"@nextui-org/dropdown@2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/dropdown/-/dropdown-2.3.9.tgz#b730ce9419772e67af719309b9613a0bb5b5f655"
+  integrity sha512-ElZxiP+nG0CKC+tm6LMZX42cRWXQ0LLjWBZXymupPsEH3XcQpCF9GWb9efJ2hh+qGROg7i0bnFH7P0GTyCyNBA==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/menu" "2.2.9"
+    "@nextui-org/popover" "2.3.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/menu" "3.16.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/menu" "3.9.0"
+    "@react-types/menu" "3.9.13"
+
+"@nextui-org/form@2.1.8":
+  version "2.1.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/form/-/form-2.1.8.tgz#a29bca617c124b852740d37a9027285f266e267b"
+  integrity sha512-Xn/dUO5zDG7zukbql1MDYh4Xwe1vnIVMRTHgckbkBtXXVNqgoTU09TTfy8WOJ0pMDX4GrZSBAZ86o37O+IHbaA==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system" "2.4.6"
+    "@nextui-org/theme" "2.4.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/form" "3.1.0"
+    "@react-types/form" "3.7.8"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/framer-utils@2.1.6":
+  version "2.1.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/framer-utils/-/framer-utils-2.1.6.tgz#425a25a85e1e5712c68d1018420b1ca231448dd3"
+  integrity sha512-b+BxKFox8j9rNAaL+CRe2ZMb1/SKjz9Kl2eLjDSsq3q82K/Hg7lEjlpgE8cu41wIGjH1unQxtP+btiJgl067Ow==
   dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-image" "2.0.6"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system" "2.4.6"
+    "@nextui-org/use-measure" "2.1.1"
 
-"@nextui-org/input@2.2.5":
+"@nextui-org/image@2.2.5":
   version "2.2.5"
-  resolved "https://registry.npmjs.org/@nextui-org/input/-/input-2.2.5.tgz"
-  integrity sha512-xLgyKcnb+RatRZ62AbCFfTpS3exd2bPSSR75UFKylHHhgX+nvVOkX0dQgmr9e0V8IEECeRvbltw2s/laNFPTtg==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/textfield" "3.14.5"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/utils" "3.10.1"
-    "@react-types/shared" "3.23.1"
-    "@react-types/textfield" "3.9.3"
+  resolved "https://registry.yarnpkg.com/@nextui-org/image/-/image-2.2.5.tgz#b621a70a295dfcb3ca7beb786d803449a4b20500"
+  integrity sha512-A6DnEqG+/cMrfvqFKKJIdGD7gD88tVkqGxRkfysVMJJR96sDIYCJlP1jsAEtYKh4PfhmtJWclUvY/x9fMw0H1w==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-image" "2.1.2"
+
+"@nextui-org/input-otp@2.1.8":
+  version "2.1.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/input-otp/-/input-otp-2.1.8.tgz#ae37572e7008ea1bb326d493fe4c985f1c93bda9"
+  integrity sha512-J5Pz0aSfWD+2cSgLTKQamCNF/qHILIj8L0lY3t1R/sgK1ApN3kDNcUGnVm6EDh+dOXITKpCfnsCQw834nxZhsg==
+  dependencies:
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/form" "3.0.11"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/form" "3.1.0"
+    "@react-stately/utils" "3.10.5"
+    "@react-types/textfield" "3.10.0"
+    input-otp "1.4.1"
+
+"@nextui-org/input@2.4.8":
+  version "2.4.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/input/-/input-2.4.8.tgz#c37091c3dc88177e636cf5499f4f55461fb1fd52"
+  integrity sha512-wfkjyl7vRqT3HDXeybhfZ+IAz+Z02U5EiuWPpc9NbdwhJ/LpDRDa6fYcTDr/6j6MiyrEZsM24CtZZKAKBVBquQ==
+  dependencies:
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/textfield" "3.15.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/utils" "3.10.5"
+    "@react-types/shared" "3.26.0"
+    "@react-types/textfield" "3.10.0"
     react-textarea-autosize "^8.5.3"
 
-"@nextui-org/kbd@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/kbd/-/kbd-2.0.34.tgz"
-  integrity sha512-sO6RJPgEFccFV8gmfYMTVeQ4f9PBYh09OieRpsZhN4HqdfWwEaeT6LrmdBko3XnJ0T6Me3tBrYULgKWcDcNogw==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system-rsc" "2.1.6"
-    "@react-aria/utils" "3.24.1"
-
-"@nextui-org/link@2.0.35":
-  version "2.0.35"
-  resolved "https://registry.npmjs.org/@nextui-org/link/-/link-2.0.35.tgz"
-  integrity sha512-0XVUsSsysu+WMssokTlLHiMnjr1N6D2Uh3bIBcdFwSqmTLyq+Llgexlm6Fuv1wADRwsR8/DGFp3Pr826cv2Svg==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-link" "2.0.19"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/link" "3.7.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/link" "3.5.5"
-
-"@nextui-org/listbox@2.1.27":
-  version "2.1.27"
-  resolved "https://registry.npmjs.org/@nextui-org/listbox/-/listbox-2.1.27.tgz"
-  integrity sha512-B9HW/k0awfXsYaNyjaqv/GvEioVzrsCsOdSxVQZgQ3wQ6jNXmGRe1/X6IKg0fIa+P0v379kSgAqrZcwfRpKnWw==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/divider" "2.0.32"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-is-mobile" "2.0.9"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/listbox" "3.12.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/list" "3.10.5"
-    "@react-types/menu" "3.9.9"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/menu@2.0.30":
-  version "2.0.30"
-  resolved "https://registry.npmjs.org/@nextui-org/menu/-/menu-2.0.30.tgz"
-  integrity sha512-hZRr/EQ5JxB6yQFmUhDSv9pyLTJmaB4SFC/t5A17UljRhMexlvTU6QpalYIkbY0R/bUXvOkTJNzsRgI5OOQ/aA==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/divider" "2.0.32"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-menu" "2.0.7"
-    "@nextui-org/use-is-mobile" "2.0.9"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/menu" "3.14.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/menu" "3.7.1"
-    "@react-stately/tree" "3.8.1"
-    "@react-types/menu" "3.9.9"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/modal@2.0.41":
-  version "2.0.41"
-  resolved "https://registry.npmjs.org/@nextui-org/modal/-/modal-2.0.41.tgz"
-  integrity sha512-Sirn319xAf7E4cZqvQ0o0Vd3Xqy0FRSuhOTwp8dALMGTMY61c2nIyurgVCNP6hh8dMvMT7zQEPP9/LE0boFCEQ==
-  dependencies:
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@nextui-org/use-aria-modal-overlay" "2.0.13"
-    "@nextui-org/use-disclosure" "2.0.10"
-    "@react-aria/dialog" "3.5.14"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/overlays" "3.6.7"
-    "@react-types/overlays" "3.8.7"
-
-"@nextui-org/navbar@2.0.37":
-  version "2.0.37"
-  resolved "https://registry.npmjs.org/@nextui-org/navbar/-/navbar-2.0.37.tgz"
-  integrity sha512-HuHXMU+V367LlvSGjqRPBNKmOERLvc4XWceva+KmiT99BLqHmMECkQVTR6ogO36eJUU96aR8JSfAiHLjvw5msw==
-  dependencies:
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-toggle-button" "2.0.10"
-    "@nextui-org/use-scroll-position" "2.0.9"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/toggle" "3.7.4"
-    "@react-stately/utils" "3.10.1"
-    react-remove-scroll "^2.5.6"
-
-"@nextui-org/pagination@2.0.36":
-  version "2.0.36"
-  resolved "https://registry.npmjs.org/@nextui-org/pagination/-/pagination-2.0.36.tgz"
-  integrity sha512-VKs2vMj8dybNzb/WkAMmvFBsxdgBvpVihIA4eXSo2ve7fpcLjIF1iPLHuDgpSyv3h3dy009sQTVo3lVTVT1a6w==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-pagination" "2.0.10"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
+"@nextui-org/kbd@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/kbd/-/kbd-2.2.6.tgz#3d074ed630d23197ee4d8566adcc96e868e14e35"
+  integrity sha512-IwzvvwYLMbhyqX5PjEZyDBO4iNEHY6Nek4ZrVR+Z2dOSj/oZXHWiabNDrvOcGKgUBE6xc95Fi1jVubE9b5ueuA==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system-rsc" "2.3.5"
+    "@react-aria/utils" "3.26.0"
+
+"@nextui-org/link@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/link/-/link-2.2.7.tgz#d64e5ebb35a7d920fab58f60317ed729c801c941"
+  integrity sha512-SAeBBCUtdaKtHfZgRD6OH0De/+cKUEuThiErSuFW+sNm/y8m3cUhQH8UqVBPu6HwmqVTEjvZzp/4uhG6lcSZjA==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-link" "2.2.5"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/link" "3.7.7"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/link" "3.5.9"
+
+"@nextui-org/listbox@2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/listbox/-/listbox-2.3.9.tgz#181969b3adf4e8edbb0c3ef7430223da616434ba"
+  integrity sha512-iGJ8xwkXf8K7chk1iZgC05KGpHiWJXY1dnV7ytIJ7yu4BbsRIHb0QknK5j8A74YeGpouJQ9+jsmCERmySxlqlg==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/divider" "2.2.5"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-is-mobile" "2.2.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/listbox" "3.13.6"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/list" "3.11.1"
+    "@react-types/menu" "3.9.13"
+    "@react-types/shared" "3.26.0"
+    "@tanstack/react-virtual" "3.11.2"
+
+"@nextui-org/menu@2.2.9":
+  version "2.2.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/menu/-/menu-2.2.9.tgz#d56aa498d1a58273db9973445c40f29ef06f492a"
+  integrity sha512-Fztvi3GRYl5a5FO/0LRzcAdnw8Yeq6NX8yLQh8XmwkWCrH0S6nTn69CP/j+EMWQR6G2UK5AbNDmX1Sx9aTQdHQ==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/divider" "2.2.5"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-is-mobile" "2.2.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/menu" "3.16.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/menu" "3.9.0"
+    "@react-stately/tree" "3.8.6"
+    "@react-types/menu" "3.9.13"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/modal@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/modal/-/modal-2.2.7.tgz#fd59ab9da97529a1e1c4552bc863baacb953fc6f"
+  integrity sha512-xxk6B+5s8//qYI4waLjdWoJFwR6Zqym/VHFKkuZAMpNABgTB0FCK022iUdOIP2F2epG69un8zJF0qwMBJF8XAA==
+  dependencies:
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@nextui-org/use-aria-modal-overlay" "2.2.3"
+    "@nextui-org/use-disclosure" "2.2.2"
+    "@nextui-org/use-draggable" "2.1.2"
+    "@react-aria/dialog" "3.5.20"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/overlays" "3.6.12"
+    "@react-types/overlays" "3.8.11"
+
+"@nextui-org/navbar@2.2.8":
+  version "2.2.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/navbar/-/navbar-2.2.8.tgz#73918063485e63a3a777c40d4a0208cba51246e2"
+  integrity sha512-XutioQ75jonZk6TBtjFdV6N3eLe8y85tetjOdOg6X3mKTPZlQuBb+rtb6pVNOOvcuQ7zKigWIq2ammvF9VNKaQ==
+  dependencies:
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-scroll-position" "2.1.1"
+    "@react-aria/button" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/toggle" "3.8.0"
+    "@react-stately/utils" "3.10.5"
+
+"@nextui-org/pagination@2.2.8":
+  version "2.2.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/pagination/-/pagination-2.2.8.tgz#cecec2c5854fc985be2e85637d16670d2ee872be"
+  integrity sha512-sZcriQq/ssOItX3r54tysnItjcb7dw392BNulJxrMMXi6FA6sUGImpJF1jsbtYJvaq346IoZvMrcrba8PXEk0g==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-intersection-observer" "2.2.2"
+    "@nextui-org/use-pagination" "2.2.3"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
     scroll-into-view-if-needed "3.0.10"
 
-"@nextui-org/popover@2.1.29":
-  version "2.1.29"
-  resolved "https://registry.npmjs.org/@nextui-org/popover/-/popover-2.1.29.tgz"
-  integrity sha512-qGjMnAQVHQNfG571h9Tah2MXPs5mhxcTIj4TuBgwPzQTWXjjeffaHV3FlHdg5PxjTpNZOdDfrg0eRhDqIjKocQ==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/dialog" "3.5.14"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/overlays" "3.6.7"
-    "@react-types/button" "3.9.4"
-    "@react-types/overlays" "3.8.7"
-    react-remove-scroll "^2.5.6"
-
-"@nextui-org/progress@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/progress/-/progress-2.0.34.tgz"
-  integrity sha512-rJmZCrLdufJKLsonJ37oPOEHEpZykD4c+0G749zcKOkRXHOD9DiQian2YoZEE/Yyf3pLdFQG3W9vSLbsgED3PQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-is-mounted" "2.0.6"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/progress" "3.4.13"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/progress" "3.5.4"
-
-"@nextui-org/radio@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.npmjs.org/@nextui-org/radio/-/radio-2.1.5.tgz"
-  integrity sha512-0tF/VkMQv+KeYmFQpkrpz9S7j7U8gqCet+F97Cz7fFjdb+Q3w9waBzg84QayD7EZdjsYW4FNSkjPeiBhLdVUsw==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/radio" "3.10.4"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/radio" "3.10.4"
-    "@react-types/radio" "3.8.1"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/react-rsc-utils@2.0.14":
-  version "2.0.14"
-  resolved "https://registry.npmjs.org/@nextui-org/react-rsc-utils/-/react-rsc-utils-2.0.14.tgz"
-  integrity sha512-s0GVgDhScyx+d9FtXd8BXf049REyaPvWsO4RRr7JDHrk91NlQ11Mqxka9o+8g5NX0rphI0rbe3/b1Dz+iQRx3w==
+"@nextui-org/popover@2.3.9":
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/popover/-/popover-2.3.9.tgz#d29d7c1804ec56bcc96bc0a9b09248c5f2722538"
+  integrity sha512-glLYKlFJ4EkFrNMBC3ediFPpQwKzaFlzKoaMum2G3HUtmC4d1HLTSOQJOd2scUzZxD3/K9dp1XHYbEcCnCrYpQ==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/dialog" "3.5.20"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/overlays" "3.6.12"
+    "@react-types/button" "3.10.1"
+    "@react-types/overlays" "3.8.11"
+
+"@nextui-org/progress@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/progress/-/progress-2.2.6.tgz#88209af637971007984ebfc85c59920c66817f21"
+  integrity sha512-FTicOncNcXKpt9avxQWWlVATvhABKVMBgsB81SozFXRcn8QsFntjdMp0l3688DJKBY0GxT+yl/S/by0TwY1Z1A==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-is-mounted" "2.1.1"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/progress" "3.4.18"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/progress" "3.5.8"
+
+"@nextui-org/radio@2.3.8":
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/radio/-/radio-2.3.8.tgz#699dd76e36ba6753a559f5bc0c44aa51f30fae26"
+  integrity sha512-ntwjpQ/WT8zQ3Fw5io65VeH2Q68LOgZ4lII7a6x35NDa7Eda1vlYroMAw/vxK8iyZYlUBSJdsoj2FU/10hBPmg==
+  dependencies:
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/radio" "3.10.10"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/radio" "3.10.9"
+    "@react-types/radio" "3.8.5"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/react-rsc-utils@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/react-rsc-utils/-/react-rsc-utils-2.1.1.tgz#82a545ea952fa0f98769bb446ed448cab292e5bb"
+  integrity sha512-9uKH1XkeomTGaswqlGKt0V0ooUev8mPXtKJolR+6MnpvBUrkqngw1gUGF0bq/EcCCkks2+VOHXZqFT6x9hGkQQ==
 
-"@nextui-org/react-utils@2.0.17":
-  version "2.0.17"
-  resolved "https://registry.npmjs.org/@nextui-org/react-utils/-/react-utils-2.0.17.tgz"
-  integrity sha512-U/b49hToVfhOM4dg4n57ZyUjLpts4JogQ139lfQBYPTb8z/ATNsJ3vLIqW5ZvDK6L0Er+JT11UVQ+03m7QMvaQ==
+"@nextui-org/react-utils@2.1.3":
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/@nextui-org/react-utils/-/react-utils-2.1.3.tgz#444f1b8b4f4f50efdb72abd201660c908a46ba88"
+  integrity sha512-o61fOS+S8p3KtgLLN7ub5gR0y7l517l9eZXJabUdnVcZzZjTqEijWjzjIIIyAtYAlL4d+WTXEOROuc32sCmbqw==
   dependencies:
-    "@nextui-org/react-rsc-utils" "2.0.14"
-    "@nextui-org/shared-utils" "2.0.8"
+    "@nextui-org/react-rsc-utils" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
 
 "@nextui-org/react@^2.4.2":
-  version "2.4.8"
-  resolved "https://registry.npmjs.org/@nextui-org/react/-/react-2.4.8.tgz"
-  integrity sha512-ZwXg6As3A+Gs+Jyc42t4MHNupHEsh9YmEaypE20ikqIPTCLQnrGQ/RWOGwzZ2a9kZWbZ89a/3rJwZMRKdcemxg==
-  dependencies:
-    "@nextui-org/accordion" "2.0.40"
-    "@nextui-org/autocomplete" "2.1.7"
-    "@nextui-org/avatar" "2.0.33"
-    "@nextui-org/badge" "2.0.32"
-    "@nextui-org/breadcrumbs" "2.0.13"
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/calendar" "2.0.12"
-    "@nextui-org/card" "2.0.34"
-    "@nextui-org/checkbox" "2.1.5"
-    "@nextui-org/chip" "2.0.33"
-    "@nextui-org/code" "2.0.33"
-    "@nextui-org/date-input" "2.1.4"
-    "@nextui-org/date-picker" "2.1.8"
-    "@nextui-org/divider" "2.0.32"
-    "@nextui-org/dropdown" "2.1.31"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/image" "2.0.32"
-    "@nextui-org/input" "2.2.5"
-    "@nextui-org/kbd" "2.0.34"
-    "@nextui-org/link" "2.0.35"
-    "@nextui-org/listbox" "2.1.27"
-    "@nextui-org/menu" "2.0.30"
-    "@nextui-org/modal" "2.0.41"
-    "@nextui-org/navbar" "2.0.37"
-    "@nextui-org/pagination" "2.0.36"
-    "@nextui-org/popover" "2.1.29"
-    "@nextui-org/progress" "2.0.34"
-    "@nextui-org/radio" "2.1.5"
-    "@nextui-org/ripple" "2.0.33"
-    "@nextui-org/scroll-shadow" "2.1.20"
-    "@nextui-org/select" "2.2.7"
-    "@nextui-org/skeleton" "2.0.32"
-    "@nextui-org/slider" "2.2.17"
-    "@nextui-org/snippet" "2.0.43"
-    "@nextui-org/spacer" "2.0.33"
-    "@nextui-org/spinner" "2.0.34"
-    "@nextui-org/switch" "2.0.34"
-    "@nextui-org/system" "2.2.6"
-    "@nextui-org/table" "2.0.40"
-    "@nextui-org/tabs" "2.0.37"
-    "@nextui-org/theme" "2.2.11"
-    "@nextui-org/tooltip" "2.0.41"
-    "@nextui-org/user" "2.0.34"
-    "@react-aria/visually-hidden" "3.8.12"
-
-"@nextui-org/ripple@2.0.33":
-  version "2.0.33"
-  resolved "https://registry.npmjs.org/@nextui-org/ripple/-/ripple-2.0.33.tgz"
-  integrity sha512-Zsa60CXtGCF7weTCFbSfT0OlxlGHdd5b/sSJTYrmMZRHOIUpHW8kT0bxVYF/6X8nCCJYxzBKXUqdE3Y31fhNeQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-
-"@nextui-org/scroll-shadow@2.1.20":
-  version "2.1.20"
-  resolved "https://registry.npmjs.org/@nextui-org/scroll-shadow/-/scroll-shadow-2.1.20.tgz"
-  integrity sha512-8ULiUmbZ/Jzr1okI8Yzjzl5M4Ow3pJEm34hT5id0EaMIgklNa3Nnp/Dyp54JwwUbI8Kt3jOAMqkPitGIZyo5Ag==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-data-scroll-overflow" "2.1.7"
-
-"@nextui-org/select@2.2.7":
+  version "2.6.11"
+  resolved "https://registry.yarnpkg.com/@nextui-org/react/-/react-2.6.11.tgz#a8d0695733d67f129d89b0652d9076febffde46b"
+  integrity sha512-MOkBMWI+1nHB6A8YLXakdXrNRFvy5whjFJB1FthwqbP8pVEeksS1e29AbfEFkrzLc5zjN7i24wGNSJ8DKMt9WQ==
+  dependencies:
+    "@nextui-org/accordion" "2.2.7"
+    "@nextui-org/alert" "2.2.9"
+    "@nextui-org/autocomplete" "2.3.9"
+    "@nextui-org/avatar" "2.2.6"
+    "@nextui-org/badge" "2.2.5"
+    "@nextui-org/breadcrumbs" "2.2.6"
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/calendar" "2.2.9"
+    "@nextui-org/card" "2.2.9"
+    "@nextui-org/checkbox" "2.3.8"
+    "@nextui-org/chip" "2.2.6"
+    "@nextui-org/code" "2.2.6"
+    "@nextui-org/date-input" "2.3.8"
+    "@nextui-org/date-picker" "2.3.9"
+    "@nextui-org/divider" "2.2.5"
+    "@nextui-org/drawer" "2.2.7"
+    "@nextui-org/dropdown" "2.3.9"
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/image" "2.2.5"
+    "@nextui-org/input" "2.4.8"
+    "@nextui-org/input-otp" "2.1.8"
+    "@nextui-org/kbd" "2.2.6"
+    "@nextui-org/link" "2.2.7"
+    "@nextui-org/listbox" "2.3.9"
+    "@nextui-org/menu" "2.2.9"
+    "@nextui-org/modal" "2.2.7"
+    "@nextui-org/navbar" "2.2.8"
+    "@nextui-org/pagination" "2.2.8"
+    "@nextui-org/popover" "2.3.9"
+    "@nextui-org/progress" "2.2.6"
+    "@nextui-org/radio" "2.3.8"
+    "@nextui-org/ripple" "2.2.7"
+    "@nextui-org/scroll-shadow" "2.3.5"
+    "@nextui-org/select" "2.4.9"
+    "@nextui-org/skeleton" "2.2.5"
+    "@nextui-org/slider" "2.4.7"
+    "@nextui-org/snippet" "2.2.10"
+    "@nextui-org/spacer" "2.2.6"
+    "@nextui-org/spinner" "2.2.6"
+    "@nextui-org/switch" "2.2.8"
+    "@nextui-org/system" "2.4.6"
+    "@nextui-org/table" "2.2.8"
+    "@nextui-org/tabs" "2.2.7"
+    "@nextui-org/theme" "2.4.5"
+    "@nextui-org/tooltip" "2.2.7"
+    "@nextui-org/user" "2.2.6"
+    "@react-aria/visually-hidden" "3.8.18"
+
+"@nextui-org/ripple@2.2.7":
   version "2.2.7"
-  resolved "https://registry.npmjs.org/@nextui-org/select/-/select-2.2.7.tgz"
-  integrity sha512-lA2EOjquhiHmLSInHFEarq64ZOQV37+ry1d8kvsqJ7R9dsqw1QEuMzH2Kk8/NqwrYMccHh5iAZ7PaLp90NSSxg==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/listbox" "2.1.27"
-    "@nextui-org/popover" "2.1.29"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/scroll-shadow" "2.1.20"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/spinner" "2.0.34"
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@nextui-org/use-aria-multiselect" "2.2.5"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/form" "3.0.5"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/shared-icons@2.0.9":
-  version "2.0.9"
-  resolved "https://registry.npmjs.org/@nextui-org/shared-icons/-/shared-icons-2.0.9.tgz"
-  integrity sha512-WG3yinVY7Tk9VqJgcdF4V8Ok9+fcm5ey7S1els7kujrfqLYxtqoKywgiY/7QHwZlfQkzpykAfy+NAlHkTP5hMg==
-
-"@nextui-org/shared-utils@2.0.8":
-  version "2.0.8"
-  resolved "https://registry.npmjs.org/@nextui-org/shared-utils/-/shared-utils-2.0.8.tgz"
-  integrity sha512-ZEtoMPXS+IjT8GvpJTS9IWDnT1JNCKV+NDqqgysAf1niJmOFLyJgl6dh/9n4ufcGf1GbSEQN+VhJasEw7ajYGQ==
-
-"@nextui-org/skeleton@2.0.32":
-  version "2.0.32"
-  resolved "https://registry.npmjs.org/@nextui-org/skeleton/-/skeleton-2.0.32.tgz"
-  integrity sha512-dS0vuRrc4oWktW3wa/KFhcBNnV0oiDqKXP4BqRj7wgS01fOAqj3cJiqwUDLKO8GbEnxLkbqLBFcUoLgktpRszQ==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-
-"@nextui-org/slider@2.2.17":
-  version "2.2.17"
-  resolved "https://registry.npmjs.org/@nextui-org/slider/-/slider-2.2.17.tgz"
-  integrity sha512-MgeJv3X+bT7Bw+LK1zba4vToOUzv8lCvDuGe0U5suJy1AKGN6uGDgSAxpIZhCYNWsuNRsopwdvsGtyeIjOEStA==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/tooltip" "2.0.41"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/slider" "3.7.8"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/slider" "3.5.4"
-
-"@nextui-org/snippet@2.0.43":
-  version "2.0.43"
-  resolved "https://registry.npmjs.org/@nextui-org/snippet/-/snippet-2.0.43.tgz"
-  integrity sha512-PLxc9ph9CLj52L26XSv4vBmQcSytCNc3ZBxkOTBEqmLSHCWwGQExrqKPnVZTE1etr6dcULiy5vNIpD8R7taO8A==
-  dependencies:
-    "@nextui-org/button" "2.0.38"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/tooltip" "2.0.41"
-    "@nextui-org/use-clipboard" "2.0.7"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/utils" "3.24.1"
-
-"@nextui-org/spacer@2.0.33":
-  version "2.0.33"
-  resolved "https://registry.npmjs.org/@nextui-org/spacer/-/spacer-2.0.33.tgz"
-  integrity sha512-0YDtovMWuAVgBvVXUmplzohObGxMPFhisHXn6v+0nflAE9LiVeiXf121WVOEMrd08S7xvmrAANcMwo4TsYi49g==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system-rsc" "2.1.6"
-
-"@nextui-org/spinner@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/spinner/-/spinner-2.0.34.tgz"
-  integrity sha512-YKw/6xSLhsXU1k22OvYKyWhtJCHzW2bRAiieVSVG5xak3gYwknTds5H9s5uur+oAZVK9AkyAObD19QuZND32Jg==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/system-rsc" "2.1.6"
-
-"@nextui-org/switch@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/switch/-/switch-2.0.34.tgz"
-  integrity sha512-SczQiHswo8eR94ecDgcULIsSIPfYVncqfKllcHEGqAs9BDpZun44KK0/R0xhWuPpx5oqB60VeSABN7JtEAxF+Q==
-  dependencies:
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/switch" "3.6.4"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/toggle" "3.7.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/system-rsc@2.1.6":
-  version "2.1.6"
-  resolved "https://registry.npmjs.org/@nextui-org/system-rsc/-/system-rsc-2.1.6.tgz"
-  integrity sha512-Wl2QwEFjYwuvw26R1RH3ZY81PD8YmfgtIjFvJZRP2VEIT6rPvlQ4ojgqdrkVkQZQ0L/K+5ZLbTKgLEFkj5ysdQ==
+  resolved "https://registry.yarnpkg.com/@nextui-org/ripple/-/ripple-2.2.7.tgz#69a3ebc48f9eb1c34982e33c69c511e741489f43"
+  integrity sha512-cphzlvCjdROh1JWQhO/wAsmBdlU9kv/UA2YRQS4viaWcA3zO+qOZVZ9/YZMan6LBlOLENCaE9CtV2qlzFtVpEg==
+  dependencies:
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+
+"@nextui-org/scroll-shadow@2.3.5":
+  version "2.3.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/scroll-shadow/-/scroll-shadow-2.3.5.tgz#18260dd8b5d6d9fcaa8486552dad940ad393c786"
+  integrity sha512-2H5qro6RHcWo6ZfcG2hHZHsR1LrV3FMZP5Lkc9ZwJdWPg4dXY4erGRE4U+B7me6efj5tBOFmZkIpxVUyMBLtZg==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-data-scroll-overflow" "2.2.2"
+
+"@nextui-org/select@2.4.9":
+  version "2.4.9"
+  resolved "https://registry.yarnpkg.com/@nextui-org/select/-/select-2.4.9.tgz#7a220c0a0f090343fda37bc6ac229c3130c36c39"
+  integrity sha512-R8HHKDH7dA4Dv73Pl80X7qfqdyl+Fw4gi/9bmyby0QJG8LN2zu51xyjjKphmWVkAiE3O35BRVw7vMptHnWFUgQ==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/form" "2.1.8"
+    "@nextui-org/listbox" "2.3.9"
+    "@nextui-org/popover" "2.3.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/scroll-shadow" "2.3.5"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/spinner" "2.2.6"
+    "@nextui-org/use-aria-button" "2.2.4"
+    "@nextui-org/use-aria-multiselect" "2.4.3"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/form" "3.0.11"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-types/shared" "3.26.0"
+    "@tanstack/react-virtual" "3.11.2"
+
+"@nextui-org/shared-icons@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/shared-icons/-/shared-icons-2.1.1.tgz#c2001523e96db8bcbdb46e4fe52d8c38f5e1018d"
+  integrity sha512-mkiTpFJnCzB2M8Dl7IwXVzDKKq9ZW2WC0DaQRs1eWgqboRCP8DDde+MJZq331hC7pfH8BC/4rxXsKECrOUUwCg==
+
+"@nextui-org/shared-utils@2.1.2":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/shared-utils/-/shared-utils-2.1.2.tgz#ab35095d17a2fd53afa29558e03464c2a6b89466"
+  integrity sha512-5n0D+AGB4P9lMD1TxwtdRSuSY0cWgyXKO9mMU11Xl3zoHNiAz/SbCSTc4VBJdQJ7Y3qgNXvZICzf08+bnjjqqA==
+
+"@nextui-org/skeleton@2.2.5":
+  version "2.2.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/skeleton/-/skeleton-2.2.5.tgz#274dd6006af1951594132a599d1976b2eb2ac56b"
+  integrity sha512-CK1O9dqS0xPW3o1SIekEEOjSosJkXNzU0Zd538Nn1XhY1RjNuIPchpY9Pv5YZr2QSKy0zkwPQt/NalwErke0Jg==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+
+"@nextui-org/slider@2.4.7":
+  version "2.4.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/slider/-/slider-2.4.7.tgz#2bdba1b1087c4575510fc9b8b736a7f98468f946"
+  integrity sha512-/RnjnmAPvssebhtElG+ZI8CCot2dEBcEjw7LrHfmVnJOd5jgceMtnXhdJSppQuLvcC4fPpkhd6dY86IezOZwfw==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/tooltip" "2.2.7"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/slider" "3.7.14"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/slider" "3.6.0"
+
+"@nextui-org/snippet@2.2.10":
+  version "2.2.10"
+  resolved "https://registry.yarnpkg.com/@nextui-org/snippet/-/snippet-2.2.10.tgz#2f6b7600c9edc937af7f0a643c0c85fba17ba4aa"
+  integrity sha512-mVjf8muq4TX2PlESN7EeHgFmjuz7PNhrKFP+fb8Lj9J6wvUIUDm5ENv9bs72cRsK+zse6OUNE4JF1er6HllKug==
+  dependencies:
+    "@nextui-org/button" "2.2.9"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/tooltip" "2.2.7"
+    "@nextui-org/use-clipboard" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/utils" "3.26.0"
+
+"@nextui-org/spacer@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/spacer/-/spacer-2.2.6.tgz#8f3c2785122b5b710f36cfd4e47bab0a1f20b558"
+  integrity sha512-1qYtZ6xICfSrFV0MMB/nUH1K2X9mHzIikrjC/okzyzWywibsVNbyRfu5vObVClYlVGY0r4M4+7fpV2QV1tKRGw==
   dependencies:
-    "@react-types/shared" "3.23.1"
-    clsx "^1.2.1"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system-rsc" "2.3.5"
 
-"@nextui-org/system@2.2.6":
+"@nextui-org/spinner@2.2.6":
   version "2.2.6"
-  resolved "https://registry.npmjs.org/@nextui-org/system/-/system-2.2.6.tgz"
-  integrity sha512-tjIkOI0w32g68CGWleuSyIbEz8XBbeoNogR2lu7MWk3QovHCqgr4VVrP1cwMRYnwDPFQP3OpmH+NR9yzt+pIfg==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/system-rsc" "2.1.6"
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/utils" "3.10.1"
-
-"@nextui-org/table@2.0.40":
-  version "2.0.40"
-  resolved "https://registry.npmjs.org/@nextui-org/table/-/table-2.0.40.tgz"
-  integrity sha512-qDbSsu6mpWnr1Mt3DYTBzTFtN8Z5Gv7GDqECGcDVradkDVuJFZvkB9Ke392LcVZoXSk99Rpamq4WSWkEewBhWg==
-  dependencies:
-    "@nextui-org/checkbox" "2.1.5"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-icons" "2.0.9"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/spacer" "2.0.33"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/table" "3.14.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-aria/visually-hidden" "3.8.12"
-    "@react-stately/table" "3.11.8"
-    "@react-stately/virtualizer" "3.7.1"
-    "@react-types/grid" "3.2.6"
-    "@react-types/table" "3.9.5"
-
-"@nextui-org/tabs@2.0.37":
-  version "2.0.37"
-  resolved "https://registry.npmjs.org/@nextui-org/tabs/-/tabs-2.0.37.tgz"
-  integrity sha512-IQicuDggxTL+JeW3fRoZR4Rr24EwinxAdfU1jqcvT6gZywumndV27+I00kARz8P03kobYoY9t73NY92qo8T5gg==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-is-mounted" "2.0.6"
-    "@nextui-org/use-update-effect" "2.0.6"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/tabs" "3.9.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/tabs" "3.6.6"
-    "@react-types/shared" "3.23.1"
-    "@react-types/tabs" "3.3.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/spinner/-/spinner-2.2.6.tgz#df9db9fc0a00196f4990aca54771b101561135f0"
+  integrity sha512-0V0H8jVpgRolgLnCuKDbrQCSK0VFPAZYiyGOE1+dfyIezpta+Nglh+uEl2sEFNh6B9Z8mARB8YEpRnTcA0ePDw==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/system-rsc" "2.3.5"
+
+"@nextui-org/switch@2.2.8":
+  version "2.2.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/switch/-/switch-2.2.8.tgz#750ebc9ba9a12abd1e7a0f72dfed558796367116"
+  integrity sha512-wk9qQSOfUEtmdWR1omKjmEYzgMjJhVizvfW6Z0rKOiMUuSud2d4xYnUmZhU22cv2WtoPV//kBjXkYD/E/t6rdg==
+  dependencies:
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/switch" "3.6.10"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/toggle" "3.8.0"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/system-rsc@2.3.5":
+  version "2.3.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/system-rsc/-/system-rsc-2.3.5.tgz#f1beadfa7ce8d7c5f99298126adccbccf08f698e"
+  integrity sha512-DpVLNV9LkeP1yDULFCXm2mxA9m4ygS7XYy3lwgcF9M1A8QAWB+ut+FcP+8a6va50oSHOqwvUwPDUslgXTPMBfQ==
+  dependencies:
+    "@react-types/shared" "3.26.0"
+    clsx "^1.2.1"
+
+"@nextui-org/system@2.4.6":
+  version "2.4.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/system/-/system-2.4.6.tgz#1af5b9001131cdda23c4fca0d3ec6139cd763cb9"
+  integrity sha512-6ujAriBZMfQ16n6M6Ad9g32KJUa1CzqIVaHN/tymadr/3m8hrr7xDw6z50pVjpCRq2PaaA1hT8Hx7EFU3f2z3Q==
+  dependencies:
+    "@internationalized/date" "3.6.0"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/system-rsc" "2.3.5"
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/utils" "3.10.5"
+    "@react-types/datepicker" "3.9.0"
+
+"@nextui-org/table@2.2.8":
+  version "2.2.8"
+  resolved "https://registry.yarnpkg.com/@nextui-org/table/-/table-2.2.8.tgz#34ecd7f4b3699b70382ed219ae876e3300493b23"
+  integrity sha512-XNM0/Ed7Re3BA1eHL31rzALea9hgsBwD0rMR2qB2SAl2e8KaV2o+4bzgYhpISAzHQtlG8IsXanxiuNDH8OPVyw==
+  dependencies:
+    "@nextui-org/checkbox" "2.3.8"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-icons" "2.1.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/spacer" "2.2.6"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/table" "3.16.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-aria/visually-hidden" "3.8.18"
+    "@react-stately/table" "3.13.0"
+    "@react-stately/virtualizer" "4.2.0"
+    "@react-types/grid" "3.2.10"
+    "@react-types/table" "3.10.3"
+
+"@nextui-org/tabs@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/tabs/-/tabs-2.2.7.tgz#30c97289a78acd51fce0d349598fb16342861220"
+  integrity sha512-EDPK0MOR4DPTfud9Khr5AikLbyEhHTlkGfazbOxg7wFaHysOnV5Y/E6UfvaN69kgIeT7NQcDFdaCKJ/AX1N7AA==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-is-mounted" "2.1.1"
+    "@nextui-org/use-update-effect" "2.1.1"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/tabs" "3.9.8"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/tabs" "3.7.0"
+    "@react-types/shared" "3.26.0"
+    "@react-types/tabs" "3.3.11"
     scroll-into-view-if-needed "3.0.10"
 
-"@nextui-org/theme@2.2.11":
-  version "2.2.11"
-  resolved "https://registry.npmjs.org/@nextui-org/theme/-/theme-2.2.11.tgz"
-  integrity sha512-bg9+KNnFxcP3w/ugivEJtvQibODbTxfl6UdVvx7TCY8Rd269U7F2+nhnw1Qd1xJT5yZQnX6m//9wOoGtJV+6Kg==
+"@nextui-org/theme@2.4.5":
+  version "2.4.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/theme/-/theme-2.4.5.tgz#12668ea604e721563255382436f8f32d57427ee1"
+  integrity sha512-c7Y17n+hBGiFedxMKfg7Qyv93iY5MteamLXV4Po4c1VF1qZJI6I+IKULFh3FxPWzAoz96r6NdYT7OLFjrAJdWg==
   dependencies:
+    "@nextui-org/shared-utils" "2.1.2"
     clsx "^1.2.1"
     color "^4.2.3"
     color2k "^2.0.2"
     deepmerge "4.3.1"
     flat "^5.0.2"
-    lodash.foreach "^4.5.0"
-    lodash.get "^4.4.2"
-    lodash.kebabcase "^4.1.1"
-    lodash.mapkeys "^4.6.0"
-    lodash.omit "^4.5.0"
-    tailwind-merge "^1.14.0"
+    tailwind-merge "^2.5.2"
     tailwind-variants "^0.1.20"
 
-"@nextui-org/tooltip@2.0.41":
-  version "2.0.41"
-  resolved "https://registry.npmjs.org/@nextui-org/tooltip/-/tooltip-2.0.41.tgz"
-  integrity sha512-1c+vkCCszKcKl15HywlZ7UOL7c1UFgLudqBB/dEdWZiclT01BRiracMbcQ7McKHQCRl77Aa7LFv5x4wHOicWHQ==
-  dependencies:
-    "@nextui-org/aria-utils" "2.0.26"
-    "@nextui-org/framer-utils" "2.0.25"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/tooltip" "3.7.4"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/tooltip" "3.4.9"
-    "@react-types/overlays" "3.8.7"
-    "@react-types/tooltip" "3.4.9"
-
-"@nextui-org/use-aria-accordion@2.0.7":
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-accordion/-/use-aria-accordion-2.0.7.tgz"
-  integrity sha512-VzGlxmsu2tWG2Pht1e0PBz40jz95v0OEKYVXq91WpDMwj8Bl1CYvxrw2Qz41/5Xi0X843Mmo4sPwrc/hk0+RHA==
-  dependencies:
-    "@react-aria/button" "3.9.5"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/selection" "3.18.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/tree" "3.8.1"
-    "@react-types/accordion" "3.0.0-alpha.21"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/use-aria-button@2.0.10":
-  version "2.0.10"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-button/-/use-aria-button-2.0.10.tgz"
-  integrity sha512-tUpp4QMr1zugKPevyToeRHIufTuc/g+67/r/oQLRTG0mMo3yGVmggykQuYn22fqqZPpW6nHcB9VYc+XtZZ27TQ==
-  dependencies:
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/button" "3.9.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/use-aria-link@2.0.19":
-  version "2.0.19"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-link/-/use-aria-link-2.0.19.tgz"
-  integrity sha512-ef61cJLlwcR4zBWiaeHZy4K18juFjUup2SslfLIAiZz3kVosBCGKmkJkw1SASYY8+D/oUc2B6BFIk25YEsRKRw==
-  dependencies:
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/utils" "3.24.1"
-    "@react-types/link" "3.5.5"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/use-aria-menu@2.0.7":
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-menu/-/use-aria-menu-2.0.7.tgz"
-  integrity sha512-5U91zFiWTLXsOhE0W3CThsD5TmL3ANeTEtoimtPgSLWV9keZBD9Ja62WsnPZPPAWhmv7jtL0/qk4d/YOra7PVA==
-  dependencies:
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/menu" "3.14.1"
-    "@react-aria/selection" "3.18.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/collections" "3.10.7"
-    "@react-stately/tree" "3.8.1"
-    "@react-types/menu" "3.9.9"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/use-aria-modal-overlay@2.0.13":
-  version "2.0.13"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-modal-overlay/-/use-aria-modal-overlay-2.0.13.tgz"
-  integrity sha512-ifQxJwTX72lhVUofEVQqMbpe9vEUiCIqiimzlUjeVuE0cYOXaoJLEgPozHpYQrdjTNiwD5On0LLMRgz19XyAqw==
+"@nextui-org/tooltip@2.2.7":
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/@nextui-org/tooltip/-/tooltip-2.2.7.tgz#2580623393436fd7d85038e5604fff8d1286110d"
+  integrity sha512-NgoaxcNwuCq/jvp77dmGzyS7JxzX4dvD/lAYi/GUhyxEC3TK3teZ3ADRhrC6tb84OpaelPLaTkhRNSaxVAQzjQ==
+  dependencies:
+    "@nextui-org/aria-utils" "2.2.7"
+    "@nextui-org/dom-animation" "2.1.1"
+    "@nextui-org/framer-utils" "2.1.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/tooltip" "3.7.10"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/tooltip" "3.5.0"
+    "@react-types/overlays" "3.8.11"
+    "@react-types/tooltip" "3.4.13"
+
+"@nextui-org/use-aria-accordion@2.2.2":
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-aria-accordion/-/use-aria-accordion-2.2.2.tgz#01ee2daa51eb7ee584f7015225f479f70edbe0fd"
+  integrity sha512-M8gjX6XmB83cIAZKV2zI1KvmTuuOh+Si50F3SWvYjBXyrDIM5775xCs2PG6AcLjf6OONTl5KwuZ2cbSDHiui6A==
+  dependencies:
+    "@react-aria/button" "3.11.0"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/selection" "3.21.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/tree" "3.8.6"
+    "@react-types/accordion" "3.0.0-alpha.25"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/use-aria-button@2.2.4":
+  version "2.2.4"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-aria-button/-/use-aria-button-2.2.4.tgz#9237999b277ea68c4b7132ea16a992ea89a6cf71"
+  integrity sha512-Bz8l4JGzRKh6V58VX8Laq4rKZDppsnVuNCBHpMJuLo2F9ht7UKvZAEJwXcdbUZ87aui/ZC+IPYqgjvT+d8QlQg==
+  dependencies:
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/button" "3.10.1"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/use-aria-link@2.2.5":
+  version "2.2.5"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-aria-link/-/use-aria-link-2.2.5.tgz#1bbf029628e5da49adb4e95eccc39f93c2689c3b"
+  integrity sha512-LBWXLecvuET4ZcpoHyyuS3yxvCzXdkmFcODhYwUmC8PiFSEUHkuFMC+fLwdXCP5GOqrv6wTGYHf41wNy1ugX1w==
   dependencies:
-    "@react-aria/overlays" "3.22.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/overlays" "3.6.7"
-    "@react-types/shared" "3.23.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/link" "3.5.9"
+    "@react-types/shared" "3.26.0"
 
-"@nextui-org/use-aria-multiselect@2.2.5":
-  version "2.2.5"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-multiselect/-/use-aria-multiselect-2.2.5.tgz"
-  integrity sha512-Gxo2M0LdnFL4/WCi192ziFB8JmSZm6yZYT8RB021Z3iAPBu/Pp9GnWEPZu5g15mKnn3jW5Ecnfw03jTEAQBR+Q==
-  dependencies:
-    "@react-aria/i18n" "3.11.1"
-    "@react-aria/interactions" "3.21.3"
-    "@react-aria/label" "3.7.8"
-    "@react-aria/listbox" "3.12.1"
-    "@react-aria/menu" "3.14.1"
-    "@react-aria/selection" "3.18.1"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/form" "3.0.3"
-    "@react-stately/list" "3.10.5"
-    "@react-stately/menu" "3.7.1"
-    "@react-types/button" "3.9.4"
-    "@react-types/overlays" "3.8.7"
-    "@react-types/select" "3.9.4"
-    "@react-types/shared" "3.23.1"
-
-"@nextui-org/use-aria-toggle-button@2.0.10":
-  version "2.0.10"
-  resolved "https://registry.npmjs.org/@nextui-org/use-aria-toggle-button/-/use-aria-toggle-button-2.0.10.tgz"
-  integrity sha512-U5jOmEO+nMIgYvBF0+gJtdq8C6dynGMjzAboPG4FhuHOzDoNiC12G5FIbGnRe8K1hMsKVuaI72p9986NhfqNgw==
+"@nextui-org/use-aria-modal-overlay@2.2.3":
+  version "2.2.3"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-aria-modal-overlay/-/use-aria-modal-overlay-2.2.3.tgz#90884e1373dca53127e52b83064659ed754c79e7"
+  integrity sha512-55DIVY0u+Ynxy1/DtzZkMsdVW63wC0mafKXACwCi0xV64D0Ggi9MM7BRePLK0mOboSb3gjCwYqn12gmRiy+kmg==
   dependencies:
-    "@nextui-org/use-aria-button" "2.0.10"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/toggle" "3.7.4"
-    "@react-types/button" "3.9.4"
-    "@react-types/shared" "3.23.1"
+    "@react-aria/overlays" "3.24.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/overlays" "3.6.12"
+    "@react-types/shared" "3.26.0"
 
-"@nextui-org/use-callback-ref@2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@nextui-org/use-callback-ref/-/use-callback-ref-2.0.6.tgz"
-  integrity sha512-2WcwWuK1L/wIpTbibnLrysmmkzWomvkVIcgWayB6n/w+bpPrPCG7Zyg2WHzmMmDhe6imV//KKBgNKRi8Xhu/VA==
+"@nextui-org/use-aria-multiselect@2.4.3":
+  version "2.4.3"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-aria-multiselect/-/use-aria-multiselect-2.4.3.tgz#3406607644c49398dcfe86d5693ceddef81a6463"
+  integrity sha512-PwDA4Y5DOx0SMxc277JeZi8tMtaINTwthPhk8SaDrtOBhP+r9owS3T/W9t37xKnmrTerHwaEq4ADGQtm5/VMXQ==
+  dependencies:
+    "@react-aria/i18n" "3.12.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/label" "3.7.13"
+    "@react-aria/listbox" "3.13.6"
+    "@react-aria/menu" "3.16.0"
+    "@react-aria/selection" "3.21.0"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/form" "3.1.0"
+    "@react-stately/list" "3.11.1"
+    "@react-stately/menu" "3.9.0"
+    "@react-types/button" "3.10.1"
+    "@react-types/overlays" "3.8.11"
+    "@react-types/select" "3.9.8"
+    "@react-types/shared" "3.26.0"
+
+"@nextui-org/use-callback-ref@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-callback-ref/-/use-callback-ref-2.1.1.tgz#d920840f23e98f0937e7a912b8b8592b379c333e"
+  integrity sha512-DzlKJ9p7Tm0x3HGjynZ/CgS1jfoBILXKFXnYPLr/SSETXqVaCguixolT/07BRB1yo9AGwELaCEt91BeI0Rb6hQ==
   dependencies:
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
 
-"@nextui-org/use-clipboard@2.0.7":
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/@nextui-org/use-clipboard/-/use-clipboard-2.0.7.tgz"
-  integrity sha512-Bn1fF/goMwOA5DQyw3A4ebfgozwR8U5k5TAZMPiy1RBWgTFw7+lB0GNbH+DOnUGY5Vyztyaw6gtUyc3tVzJxeg==
+"@nextui-org/use-clipboard@2.1.2":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-clipboard/-/use-clipboard-2.1.2.tgz#6935a62122cff85b54f2f98637a7879fda6ba02a"
+  integrity sha512-MUITEPaQAvu9VuMCUQXMc4j3uBgXoD8LVcuuvUVucg/8HK/Xia0dQ4QgK30QlCbZ/BwZ047rgMAgpMZeVKw4MQ==
 
-"@nextui-org/use-data-scroll-overflow@2.1.7":
-  version "2.1.7"
-  resolved "https://registry.npmjs.org/@nextui-org/use-data-scroll-overflow/-/use-data-scroll-overflow-2.1.7.tgz"
-  integrity sha512-MP4YLjBWyIt0KyWPndXyhnkKgOLqTZ2aPY82Czjqn+eZk/l8BNo0nfA+dZFfbfEuPJgqdt/JDkMOrS+uq0+vkQ==
+"@nextui-org/use-data-scroll-overflow@2.2.2":
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-data-scroll-overflow/-/use-data-scroll-overflow-2.2.2.tgz#5ea3cb0c8771e537bdded68c2f375764c77a72f0"
+  integrity sha512-TFB6BuaLOsE++K1UEIPR9StkBgj9Cvvc+ccETYpmn62B7pK44DmxjkwhK0ei59wafJPIyytZ3DgdVDblfSyIXA==
   dependencies:
-    "@nextui-org/shared-utils" "2.0.8"
+    "@nextui-org/shared-utils" "2.1.2"
 
-"@nextui-org/use-disclosure@2.0.10":
-  version "2.0.10"
-  resolved "https://registry.npmjs.org/@nextui-org/use-disclosure/-/use-disclosure-2.0.10.tgz"
-  integrity sha512-s2I58d7x2f1JRriZnNm9ZoxrGmxF+DnC9BXM1sD99Wq1VNMd0dhitmx0mUWfUB7l5HLyZgKOeiSLG+ugy1F1Yw==
+"@nextui-org/use-disclosure@2.2.2":
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-disclosure/-/use-disclosure-2.2.2.tgz#27a35f7904f139e397e446e541e15cf1fafd29e7"
+  integrity sha512-ka+5Fic2MIYtOMHi3zomtkWxCWydmJmcq7+fb6RHspfr0tGYjXWYO/lgtGeHFR1LYksMPLID3c7shT5bqzxJcA==
   dependencies:
-    "@nextui-org/use-callback-ref" "2.0.6"
-    "@react-aria/utils" "3.24.1"
-    "@react-stately/utils" "3.10.1"
+    "@nextui-org/use-callback-ref" "2.1.1"
+    "@react-aria/utils" "3.26.0"
+    "@react-stately/utils" "3.10.5"
 
-"@nextui-org/use-image@2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@nextui-org/use-image/-/use-image-2.0.6.tgz"
-  integrity sha512-VelN9y3vzwIpPfubFMh00YRQ0f4+I5FElcAvAqoo0Kfb0K7sGrTo1lZNApHm6yBN2gJMMeccG9u7bZB+wcDGZQ==
+"@nextui-org/use-draggable@2.1.2":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-draggable/-/use-draggable-2.1.2.tgz#2843143f88d33d75d865c803089de2bb72f93579"
+  integrity sha512-gN4G42uuRyFlAZ3FgMSeZLBg3LIeGlKTOLRe3JvyaBn1D1mA2+I3XONY1oKd9KKmtYCJNwY/2x6MVsBfy8nsgw==
+  dependencies:
+    "@react-aria/interactions" "3.22.5"
+
+"@nextui-org/use-image@2.1.2":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-image/-/use-image-2.1.2.tgz#f1c69da7a5b6bec3cb329472cb00fb1a66adec03"
+  integrity sha512-I46M5gCJK4rZ0qYHPx3kVSF2M2uGaWPwzb3w4Cmx8K9QS+LbUQtRMbD8KOGTHZGA3kBDPvFbAi53Ert4eACrZQ==
   dependencies:
-    "@nextui-org/use-safe-layout-effect" "2.0.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/use-safe-layout-effect" "2.1.1"
 
-"@nextui-org/use-is-mobile@2.0.9":
-  version "2.0.9"
-  resolved "https://registry.npmjs.org/@nextui-org/use-is-mobile/-/use-is-mobile-2.0.9.tgz"
-  integrity sha512-u5pRmPV0wacdpOcAkQnWwE30yNBl2uk1WvbWkrSELxIVRN22+fTIYn8ynnHK0JbJFTA6/5zh7uIfETQu3L6KjA==
+"@nextui-org/use-intersection-observer@2.2.2":
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-intersection-observer/-/use-intersection-observer-2.2.2.tgz#107f4bb270c6f9f5ededd37c10173b36fe794b76"
+  integrity sha512-fS/4m8jnXO7GYpnp/Lp+7bfBEAXPzqsXgqGK6qrp7sfFEAbLzuJp0fONkbIB3F6F3FJrbFOlY+Y5qrHptO7U/Q==
   dependencies:
-    "@react-aria/ssr" "3.9.4"
+    "@react-aria/interactions" "3.22.5"
+    "@react-aria/ssr" "3.9.7"
+    "@react-aria/utils" "3.26.0"
+    "@react-types/shared" "3.26.0"
 
-"@nextui-org/use-is-mounted@2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@nextui-org/use-is-mounted/-/use-is-mounted-2.0.6.tgz"
-  integrity sha512-/lcMdYnwBZ1EuKMLRIhHeAZG8stXWNTz7wBweAlLId23VC4VHgCp/s9K9Vbj1A5/r8FiFQeoTmXQuMAMUoPRtg==
+"@nextui-org/use-is-mobile@2.2.2":
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-is-mobile/-/use-is-mobile-2.2.2.tgz#3d97ffa1b1b967001fd3499f12e3e1109818372d"
+  integrity sha512-gcmUL17fhgGdu8JfXF12FZCGATJIATxV4jSql+FNhR+gc+QRRWBRmCJSpMIE2RvGXL777tDvvoh/tjFMB3pW4w==
+  dependencies:
+    "@react-aria/ssr" "3.9.7"
 
-"@nextui-org/use-measure@2.0.2":
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/@nextui-org/use-measure/-/use-measure-2.0.2.tgz"
-  integrity sha512-H/RSPPA9B5sZ10wiXR3jLlYFEuiVnc0O/sgLLQfrb5M0hvHoaqMThnsZpm//5iyS7tD7kxPeYNLa1EhzlQKxDA==
+"@nextui-org/use-is-mounted@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-is-mounted/-/use-is-mounted-2.1.1.tgz#c880a27f7221f7a7d7f3a6b4616f71e23c784cbb"
+  integrity sha512-osJB3E/DCu4Le0f+pb21ia9/TaSHwme4r0fHjO5/nUBYk/RCvGlRUUCJClf/wi9WfH8QyjuJ27+zBcUSm6AMMg==
 
-"@nextui-org/use-pagination@2.0.10":
-  version "2.0.10"
-  resolved "https://registry.npmjs.org/@nextui-org/use-pagination/-/use-pagination-2.0.10.tgz"
-  integrity sha512-PD6M8QKngUnTJfyoGiZrnrfUtA1A9ZVUjmbONO/1kxPuUegv0ZOQeFECPP2h7SFPxsyOceL1T97rg/2YPS247g==
+"@nextui-org/use-measure@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-measure/-/use-measure-2.1.1.tgz#44ffab28413ff894af1f5cc11b7f407606030383"
+  integrity sha512-2RVn90gXHTgt6fvzBH4fzgv3hMDz+SEJkqaCTbd6WUNWag4AaLb2WU/65CtLcexyu10HrgYf2xG07ZqtJv0zSg==
+
+"@nextui-org/use-pagination@2.2.3":
+  version "2.2.3"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-pagination/-/use-pagination-2.2.3.tgz#e8b4b9046c199f81759415d8e54849bb159a67d4"
+  integrity sha512-V2WGIq4LLkTpq6EUhJg3MVvHY2ZJ63AYV9N0d52Dc3Qqok0tTRuY51dd1P+F58HyTPW84W2z4q2R8XALtzFxQw==
   dependencies:
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/i18n" "3.11.1"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/i18n" "3.12.4"
 
-"@nextui-org/use-safe-layout-effect@2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@nextui-org/use-safe-layout-effect/-/use-safe-layout-effect-2.0.6.tgz"
-  integrity sha512-xzEJXf/g9GaSqjLpQ4+Z2/pw1GPq2Fc5cWRGqEXbGauEMXuH8UboRls1BmIV1RuOpqI6FgxkEmxL1EuVIRVmvQ==
+"@nextui-org/use-safe-layout-effect@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-safe-layout-effect/-/use-safe-layout-effect-2.1.1.tgz#4b87506872c4bc1e4cf499fb2e4073bf088cdb64"
+  integrity sha512-p0vezi2eujC3rxlMQmCLQlc8CNbp+GQgk6YcSm7Rk10isWVlUII5T1L3y+rcFYdgTPObCkCngPPciNQhD7Lf7g==
 
-"@nextui-org/use-scroll-position@2.0.9":
-  version "2.0.9"
-  resolved "https://registry.npmjs.org/@nextui-org/use-scroll-position/-/use-scroll-position-2.0.9.tgz"
-  integrity sha512-tXbpb2bkKIjOp2I1uZ1T4T9Lxp0+Ta/TKu+5qvqsXkHRPbcoukdsquagYUDWK/fcumg72UPR8QP+na8KMn2gCg==
+"@nextui-org/use-scroll-position@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-scroll-position/-/use-scroll-position-2.1.1.tgz#cdf257af6b9e6c5cd8f3cffe28653c44221ff9ed"
+  integrity sha512-RgY1l2POZbSjnEirW51gdb8yNPuQXHqJx3TS8Ut5dk+bhaX9JD3sUdEiJNb3qoHAJInzyjN+27hxnACSlW0gzg==
 
-"@nextui-org/use-update-effect@2.0.6":
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/@nextui-org/use-update-effect/-/use-update-effect-2.0.6.tgz"
-  integrity sha512-n5Qiv3ferKn+cSxU3Vv+96LdG8I/00mzc7Veoan+P9GL0aCTrsPB6RslTsiblaiAXQcqTiFXd8xwsK309DXOXA==
+"@nextui-org/use-update-effect@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@nextui-org/use-update-effect/-/use-update-effect-2.1.1.tgz#9102f57737876a6447b06531de870bb7c3538833"
+  integrity sha512-fKODihHLWcvDk1Sm8xDua9zjdbstxTOw9shB7k/mPkeR3E7SouSpN0+LW67Bczh1EmbRg1pIrFpEOLnbpgMFzA==
 
-"@nextui-org/user@2.0.34":
-  version "2.0.34"
-  resolved "https://registry.npmjs.org/@nextui-org/user/-/user-2.0.34.tgz"
-  integrity sha512-7MN/xBaMhDJ0b+hB2YpGIm2DsC9CTpN1ab+EKwhUuWn26SgXw2FNu8CSHViyDEkvOP7sYKdHLp9UtSo/f3JnsQ==
+"@nextui-org/user@2.2.6":
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@nextui-org/user/-/user-2.2.6.tgz#de1e11de0ada437ab78ffbd0f7f80102689b52eb"
+  integrity sha512-iimFoP3DVK85p78r0ekC7xpVPQiBIbWnyBPdrnBj1UEgQdKoUzGhVbhYUnA8niBz/AS5xLt6aQixsv9/B0/msw==
   dependencies:
-    "@nextui-org/avatar" "2.0.33"
-    "@nextui-org/react-utils" "2.0.17"
-    "@nextui-org/shared-utils" "2.0.8"
-    "@react-aria/focus" "3.17.1"
-    "@react-aria/utils" "3.24.1"
+    "@nextui-org/avatar" "2.2.6"
+    "@nextui-org/react-utils" "2.1.3"
+    "@nextui-org/shared-utils" "2.1.2"
+    "@react-aria/focus" "3.19.0"
+    "@react-aria/utils" "3.26.0"
 
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
   integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
   dependencies:
     "@nodelib/fs.stat" "2.0.5"
@@ -3327,12 +3103,12 @@
 
 "@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
   version "2.0.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
   integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
 
 "@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8":
   version "1.2.8"
-  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
   integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
   dependencies:
     "@nodelib/fs.scandir" "2.1.5"
@@ -3340,55 +3116,225 @@
 
 "@nolyfill/is-core-module@1.0.39":
   version "1.0.39"
-  resolved "https://registry.npmjs.org/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz"
+  resolved "https://registry.yarnpkg.com/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz#3dc35ba0f1e66b403c00b39344f870298ebb1c8e"
   integrity sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==
 
-"@opentelemetry/api-logs@0.203.0":
-  version "0.203.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/api-logs/-/api-logs-0.203.0.tgz#3309a76c51a848ea820cd7f00ee62daf36b06380"
-  integrity sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ==
+"@npmcli/agent@^3.0.0":
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/agent/-/agent-3.0.0.tgz#1685b1fbd4a1b7bb4f930cbb68ce801edfe7aa44"
+  integrity sha512-S79NdEgDQd/NGCay6TCoVzXSj74skRZIKJcpJjC5lOq34SZzyI6MqtiiWoiVWoVrTcGjNeC4ipbh1VIHlpfF5Q==
+  dependencies:
+    agent-base "^7.1.0"
+    http-proxy-agent "^7.0.0"
+    https-proxy-agent "^7.0.1"
+    lru-cache "^10.0.1"
+    socks-proxy-agent "^8.0.3"
+
+"@npmcli/arborist@^8.0.1":
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/@npmcli/arborist/-/arborist-8.0.1.tgz#49cfd50c18e5965797bbdb13406ce417633e15ac"
+  integrity sha512-ZyJWuvP+SdT7JmHkmtGyElm/MkQZP/i4boJXut6HDgx1tmJc/JZ9OwahRuKD+IyowJcLyB/bbaXtYh+RoTCUuw==
+  dependencies:
+    "@isaacs/string-locale-compare" "^1.1.0"
+    "@npmcli/fs" "^4.0.0"
+    "@npmcli/installed-package-contents" "^3.0.0"
+    "@npmcli/map-workspaces" "^4.0.1"
+    "@npmcli/metavuln-calculator" "^8.0.0"
+    "@npmcli/name-from-folder" "^3.0.0"
+    "@npmcli/node-gyp" "^4.0.0"
+    "@npmcli/package-json" "^6.0.1"
+    "@npmcli/query" "^4.0.0"
+    "@npmcli/redact" "^3.0.0"
+    "@npmcli/run-script" "^9.0.1"
+    bin-links "^5.0.0"
+    cacache "^19.0.1"
+    common-ancestor-path "^1.0.1"
+    hosted-git-info "^8.0.0"
+    json-parse-even-better-errors "^4.0.0"
+    json-stringify-nice "^1.1.4"
+    lru-cache "^10.2.2"
+    minimatch "^9.0.4"
+    nopt "^8.0.0"
+    npm-install-checks "^7.1.0"
+    npm-package-arg "^12.0.0"
+    npm-pick-manifest "^10.0.0"
+    npm-registry-fetch "^18.0.1"
+    pacote "^19.0.0"
+    parse-conflict-json "^4.0.0"
+    proc-log "^5.0.0"
+    proggy "^3.0.0"
+    promise-all-reject-late "^1.0.0"
+    promise-call-limit "^3.0.1"
+    read-package-json-fast "^4.0.0"
+    semver "^7.3.7"
+    ssri "^12.0.0"
+    treeverse "^3.0.0"
+    walk-up-path "^3.0.1"
+
+"@npmcli/config@^9.0.0":
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/config/-/config-9.0.0.tgz#bd810a1e9e23fcfad800e40d6c2c8b8f4f4318e1"
+  integrity sha512-P5Vi16Y+c8E0prGIzX112ug7XxqfaPFUVW/oXAV+2VsxplKZEnJozqZ0xnK8V8w/SEsBf+TXhUihrEIAU4CA5Q==
+  dependencies:
+    "@npmcli/map-workspaces" "^4.0.1"
+    "@npmcli/package-json" "^6.0.1"
+    ci-info "^4.0.0"
+    ini "^5.0.0"
+    nopt "^8.0.0"
+    proc-log "^5.0.0"
+    semver "^7.3.5"
+    walk-up-path "^3.0.1"
+
+"@npmcli/fs@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/fs/-/fs-4.0.0.tgz#a1eb1aeddefd2a4a347eca0fab30bc62c0e1c0f2"
+  integrity sha512-/xGlezI6xfGO9NwuJlnwz/K14qD1kCSAGtacBHnGzeAIuJGazcp45KP5NuyARXoKb7cwulAGWVsbeSxdG/cb0Q==
+  dependencies:
+    semver "^7.3.5"
+
+"@npmcli/git@^6.0.0", "@npmcli/git@^6.0.1":
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/@npmcli/git/-/git-6.0.3.tgz#966cbb228514372877de5244db285b199836f3aa"
+  integrity sha512-GUYESQlxZRAdhs3UhbB6pVRNUELQOHXwK9ruDkwmCv2aZ5y0SApQzUJCg02p3A7Ue2J5hxvlk1YI53c00NmRyQ==
+  dependencies:
+    "@npmcli/promise-spawn" "^8.0.0"
+    ini "^5.0.0"
+    lru-cache "^10.0.1"
+    npm-pick-manifest "^10.0.0"
+    proc-log "^5.0.0"
+    promise-retry "^2.0.1"
+    semver "^7.3.5"
+    which "^5.0.0"
+
+"@npmcli/installed-package-contents@^3.0.0":
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/installed-package-contents/-/installed-package-contents-3.0.0.tgz#2c1170ff4f70f68af125e2842e1853a93223e4d1"
+  integrity sha512-fkxoPuFGvxyrH+OQzyTkX2LUEamrF4jZSmxjAtPPHHGO0dqsQ8tTKjnIS8SAnPHdk2I03BDtSMR5K/4loKg79Q==
+  dependencies:
+    npm-bundled "^4.0.0"
+    npm-normalize-package-bin "^4.0.0"
+
+"@npmcli/map-workspaces@^4.0.1", "@npmcli/map-workspaces@^4.0.2":
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/@npmcli/map-workspaces/-/map-workspaces-4.0.2.tgz#d02c5508bf55624f60aaa58fe413748a5c773802"
+  integrity sha512-mnuMuibEbkaBTYj9HQ3dMe6L0ylYW+s/gfz7tBDMFY/la0w9Kf44P9aLn4/+/t3aTR3YUHKoT6XQL9rlicIe3Q==
+  dependencies:
+    "@npmcli/name-from-folder" "^3.0.0"
+    "@npmcli/package-json" "^6.0.0"
+    glob "^10.2.2"
+    minimatch "^9.0.0"
+
+"@npmcli/metavuln-calculator@^8.0.0":
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/@npmcli/metavuln-calculator/-/metavuln-calculator-8.0.1.tgz#c14307a1f0e43524e7ae833d1787c2e0425a9f44"
+  integrity sha512-WXlJx9cz3CfHSt9W9Opi1PTFc4WZLFomm5O8wekxQZmkyljrBRwATwDxfC9iOXJwYVmfiW1C1dUe0W2aN0UrSg==
+  dependencies:
+    cacache "^19.0.0"
+    json-parse-even-better-errors "^4.0.0"
+    pacote "^20.0.0"
+    proc-log "^5.0.0"
+    semver "^7.3.5"
+
+"@npmcli/name-from-folder@^3.0.0":
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/name-from-folder/-/name-from-folder-3.0.0.tgz#ed49b18d16b954149f31240e16630cfec511cd57"
+  integrity sha512-61cDL8LUc9y80fXn+lir+iVt8IS0xHqEKwPu/5jCjxQTVoSCmkXvw4vbMrzAMtmghz3/AkiBjhHkDKUH+kf7kA==
+
+"@npmcli/node-gyp@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/node-gyp/-/node-gyp-4.0.0.tgz#01f900bae62f0f27f9a5a127b40d443ddfb9d4c6"
+  integrity sha512-+t5DZ6mO/QFh78PByMq1fGSAub/agLJZDRfJRMeOSNCt8s9YVlTjmGpIPwPhvXTGUIJk+WszlT0rQa1W33yzNA==
+
+"@npmcli/package-json@^6.0.0", "@npmcli/package-json@^6.0.1", "@npmcli/package-json@^6.2.0":
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/package-json/-/package-json-6.2.0.tgz#7c7e61e466eefdf729cb87a34c3adc15d76e2f97"
+  integrity sha512-rCNLSB/JzNvot0SEyXqWZ7tX2B5dD2a1br2Dp0vSYVo5jh8Z0EZ7lS9TsZ1UtziddB1UfNUaMCc538/HztnJGA==
+  dependencies:
+    "@npmcli/git" "^6.0.0"
+    glob "^10.2.2"
+    hosted-git-info "^8.0.0"
+    json-parse-even-better-errors "^4.0.0"
+    proc-log "^5.0.0"
+    semver "^7.5.3"
+    validate-npm-package-license "^3.0.4"
+
+"@npmcli/promise-spawn@^8.0.0", "@npmcli/promise-spawn@^8.0.2":
+  version "8.0.3"
+  resolved "https://registry.yarnpkg.com/@npmcli/promise-spawn/-/promise-spawn-8.0.3.tgz#08c5e4c1cab7ff848e442e4b19bbf0ee699d133f"
+  integrity sha512-Yb00SWaL4F8w+K8YGhQ55+xE4RUNdMHV43WZGsiTM92gS+lC0mGsn7I4hLug7pbao035S6bj3Y3w0cUNGLfmkg==
+  dependencies:
+    which "^5.0.0"
+
+"@npmcli/query@^4.0.0":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@npmcli/query/-/query-4.0.1.tgz#f8a538807f2d0059c0bee7f4a1f712b73ae47603"
+  integrity sha512-4OIPFb4weUUwkDXJf4Hh1inAn8neBGq3xsH4ZsAaN6FK3ldrFkH7jSpCc7N9xesi0Sp+EBXJ9eGMDrEww2Ztqw==
+  dependencies:
+    postcss-selector-parser "^7.0.0"
+
+"@npmcli/redact@^3.0.0", "@npmcli/redact@^3.2.2":
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/@npmcli/redact/-/redact-3.2.2.tgz#4a6745e0ae269120ad223780ce374d6c59ae34cd"
+  integrity sha512-7VmYAmk4csGv08QzrDKScdzn11jHPFGyqJW39FyPgPuAp3zIaUmuCo1yxw9aGs+NEJuTGQ9Gwqpt93vtJubucg==
+
+"@npmcli/run-script@^9.0.0", "@npmcli/run-script@^9.0.1", "@npmcli/run-script@^9.1.0":
+  version "9.1.0"
+  resolved "https://registry.yarnpkg.com/@npmcli/run-script/-/run-script-9.1.0.tgz#6168c2be4703fe5ed31acb08a2151cb620ed30a4"
+  integrity sha512-aoNSbxtkePXUlbZB+anS1LqsJdctG5n3UVhfU47+CDdwMi6uNTBMF9gPcQRnqghQd2FGzcwwIFBruFMxjhBewg==
+  dependencies:
+    "@npmcli/node-gyp" "^4.0.0"
+    "@npmcli/package-json" "^6.0.0"
+    "@npmcli/promise-spawn" "^8.0.0"
+    node-gyp "^11.0.0"
+    proc-log "^5.0.0"
+    which "^5.0.0"
+
+"@opentelemetry/api-logs@0.204.0":
+  version "0.204.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/api-logs/-/api-logs-0.204.0.tgz#c0285aa5c79625a1c424854393902d21732fd76b"
+  integrity sha512-DqxY8yoAaiBPivoJD4UtgrMS8gEmzZ5lnaxzPojzLVHBGqPxgWm4zcuvcUHZiqQ6kRX2Klel2r9y8cA2HAtqpw==
   dependencies:
     "@opentelemetry/api" "^1.3.0"
 
 "@opentelemetry/api-logs@0.57.2":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/api-logs/-/api-logs-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/api-logs/-/api-logs-0.57.2.tgz#d4001b9aa3580367b40fe889f3540014f766cc87"
   integrity sha512-uIX52NnTM0iBh84MShlpouI7UKqkZ7MrUszTmaypHBu4r7NofznSnQRfJ+uUeDtQDj6w8eFGg5KBLDAwAPz1+A==
   dependencies:
     "@opentelemetry/api" "^1.3.0"
 
 "@opentelemetry/api@^1.3.0", "@opentelemetry/api@^1.9.0":
   version "1.9.0"
-  resolved "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/api/-/api-1.9.0.tgz#d03eba68273dc0f7509e2a3d5cba21eae10379fe"
   integrity sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==
 
 "@opentelemetry/context-async-hooks@1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz#4f76280691a742597fd0bf682982126857622948"
   integrity sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==
 
-"@opentelemetry/context-async-hooks@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/context-async-hooks/-/context-async-hooks-2.0.1.tgz#4416bc2df780c1dda1129afb9392d55831dd861d"
-  integrity sha512-XuY23lSI3d4PEqKA+7SLtAgwqIfc6E/E9eAQWLN1vlpC53ybO3o6jW4BsXo1xvz9lYyyWItfQDDLzezER01mCw==
+"@opentelemetry/context-async-hooks@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/context-async-hooks/-/context-async-hooks-2.1.0.tgz#de1de21d9536abfe73769f822b52a59a8c97b083"
+  integrity sha512-zOyetmZppnwTyPrt4S7jMfXiSX9yyfF0hxlA8B5oo2TtKl+/RGCy7fi4DrBfIf3lCPrkKsRBWZZD7RFojK7FDg==
 
 "@opentelemetry/core@1.30.1", "@opentelemetry/core@^1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-1.30.1.tgz#a0b468bb396358df801881709ea38299fc30ab27"
   integrity sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==
   dependencies:
     "@opentelemetry/semantic-conventions" "1.28.0"
 
-"@opentelemetry/core@2.0.1", "@opentelemetry/core@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-2.0.1.tgz#44e1149d5666a4743cde943ef89841db3ce0f8bc"
-  integrity sha512-MaZk9SJIDgo1peKevlbhP6+IwIiNPNmswNL4AF0WaQJLbHXjr9SrZMgS12+iqr9ToV4ZVosCcc0f8Rg67LXjxw==
+"@opentelemetry/core@2.1.0", "@opentelemetry/core@^2.0.0", "@opentelemetry/core@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-2.1.0.tgz#5539f04eb9e5245e000b0c3f77bdfaa07557e3a7"
+  integrity sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ==
   dependencies:
     "@opentelemetry/semantic-conventions" "^1.29.0"
 
 "@opentelemetry/exporter-trace-otlp-grpc@^0.57.1":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/exporter-trace-otlp-grpc/-/exporter-trace-otlp-grpc-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/exporter-trace-otlp-grpc/-/exporter-trace-otlp-grpc-0.57.2.tgz#1c1e593a987c211a0e9134037b7a2a7f3836f8ba"
   integrity sha512-gHU1vA3JnHbNxEXg5iysqCWxN9j83d7/epTYBZflqQnTyCC4N7yZXn/dMM+bEmyhQPGjhCkNZLx4vZuChH1PYw==
   dependencies:
     "@grpc/grpc-js" "^1.7.1"
@@ -3399,202 +3345,202 @@
     "@opentelemetry/resources" "1.30.1"
     "@opentelemetry/sdk-trace-base" "1.30.1"
 
-"@opentelemetry/instrumentation-amqplib@0.50.0":
-  version "0.50.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-amqplib/-/instrumentation-amqplib-0.50.0.tgz#91899a7e2821db956daeaa803d3bd8f5af8b8050"
-  integrity sha512-kwNs/itehHG/qaQBcVrLNcvXVPW0I4FCOVtw3LHMLdYIqD7GJ6Yv2nX+a4YHjzbzIeRYj8iyMp0Bl7tlkidq5w==
+"@opentelemetry/instrumentation-amqplib@0.51.0":
+  version "0.51.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-amqplib/-/instrumentation-amqplib-0.51.0.tgz#1779326433f1ab8a743bbf8e1957e1b1252cf036"
+  integrity sha512-XGmjYwjVRktD4agFnWBWQXo9SiYHKBxR6Ag3MLXwtLE4R99N3a08kGKM5SC1qOFKIELcQDGFEFT9ydXMH00Luw==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-connect@0.47.0":
-  version "0.47.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-connect/-/instrumentation-connect-0.47.0.tgz#47271b8454fa88d97aa78e175c3d0cb7e10bd9e2"
-  integrity sha512-pjenvjR6+PMRb6/4X85L4OtkQCootgb/Jzh/l/Utu3SJHBid1F+gk9sTGU2FWuhhEfV6P7MZ7BmCdHXQjgJ42g==
+"@opentelemetry/instrumentation-connect@0.48.0":
+  version "0.48.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-connect/-/instrumentation-connect-0.48.0.tgz#4481c84315b33b54a67c6e787be0eb72a84b23b3"
+  integrity sha512-OMjc3SFL4pC16PeK+tDhwP7MRvDPalYCGSvGqUhX5rASkI2H0RuxZHOWElYeXkV0WP+70Gw6JHWac/2Zqwmhdw==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
     "@types/connect" "3.4.38"
 
-"@opentelemetry/instrumentation-dataloader@0.21.1":
-  version "0.21.1"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-dataloader/-/instrumentation-dataloader-0.21.1.tgz#46fbbe59d9d6796980707768cf733225d43adea5"
-  integrity sha512-hNAm/bwGawLM8VDjKR0ZUDJ/D/qKR3s6lA5NV+btNaPVm2acqhPcT47l2uCVi+70lng2mywfQncor9v8/ykuyw==
+"@opentelemetry/instrumentation-dataloader@0.22.0":
+  version "0.22.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-dataloader/-/instrumentation-dataloader-0.22.0.tgz#a34f8ac6ec18e8f1585dcd89f9f611570868d1a2"
+  integrity sha512-bXnTcwtngQsI1CvodFkTemrrRSQjAjZxqHVc+CJZTDnidT0T6wt3jkKhnsjU/Kkkc0lacr6VdRpCu2CUWa0OKw==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation-express@0.52.0":
-  version "0.52.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-express/-/instrumentation-express-0.52.0.tgz#d87d2130fe779dd757db28edb78262af83510d5b"
-  integrity sha512-W7pizN0Wh1/cbNhhTf7C62NpyYw7VfCFTYg0DYieSTrtPBT1vmoSZei19wfKLnrMsz3sHayCg0HxCVL2c+cz5w==
+"@opentelemetry/instrumentation-express@0.53.0":
+  version "0.53.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-express/-/instrumentation-express-0.53.0.tgz#902634e3de640bd4fa5370924397e716608ecb90"
+  integrity sha512-r/PBafQmFYRjuxLYEHJ3ze1iBnP2GDA1nXOSS6E02KnYNZAVjj6WcDA1MSthtdAUUK0XnotHvvWM8/qz7DMO5A==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-fs@0.23.0":
-  version "0.23.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fs/-/instrumentation-fs-0.23.0.tgz#e3cd3a53fa975c69de33e207b35561f3f90106f0"
-  integrity sha512-Puan+QopWHA/KNYvDfOZN6M/JtF6buXEyD934vrb8WhsX1/FuM7OtoMlQyIqAadnE8FqqDL4KDPiEfCQH6pQcQ==
+"@opentelemetry/instrumentation-fs@0.24.0":
+  version "0.24.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fs/-/instrumentation-fs-0.24.0.tgz#edf0f7418f6a1cdcbe135857ab75629e7d94b910"
+  integrity sha512-HjIxJ6CBRD770KNVaTdMXIv29Sjz4C1kPCCK5x1Ujpc6SNnLGPqUVyJYZ3LUhhnHAqdbrl83ogVWjCgeT4Q0yw==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation-generic-pool@0.47.0":
-  version "0.47.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-generic-pool/-/instrumentation-generic-pool-0.47.0.tgz#f5fa9d42236eb7d57fa544954f316faee937b0b4"
-  integrity sha512-UfHqf3zYK+CwDwEtTjaD12uUqGGTswZ7ofLBEdQ4sEJp9GHSSJMQ2hT3pgBxyKADzUdoxQAv/7NqvL42ZI+Qbw==
+"@opentelemetry/instrumentation-generic-pool@0.48.0":
+  version "0.48.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-generic-pool/-/instrumentation-generic-pool-0.48.0.tgz#76fc08d76515db04f3833d730c5cb18cb0b237d4"
+  integrity sha512-TLv/On8pufynNR+pUbpkyvuESVASZZKMlqCm4bBImTpXKTpqXaJJ3o/MUDeMlM91rpen+PEv2SeyOKcHCSlgag==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation-graphql@0.51.0":
-  version "0.51.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-graphql/-/instrumentation-graphql-0.51.0.tgz#1b29aa6330d196d523460e593167dca7dbcd42bb"
-  integrity sha512-LchkOu9X5DrXAnPI1+Z06h/EH/zC7D6sA86hhPrk3evLlsJTz0grPrkL/yUJM9Ty0CL/y2HSvmWQCjbJEz/ADg==
+"@opentelemetry/instrumentation-graphql@0.52.0":
+  version "0.52.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-graphql/-/instrumentation-graphql-0.52.0.tgz#a2d23a669bdd0a1b031f785fe447d5a34ac56343"
+  integrity sha512-3fEJ8jOOMwopvldY16KuzHbRhPk8wSsOTSF0v2psmOCGewh6ad+ZbkTx/xyUK9rUdUMWAxRVU0tFpj4Wx1vkPA==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation-hapi@0.50.0":
-  version "0.50.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-hapi/-/instrumentation-hapi-0.50.0.tgz#c755e9c21bfeb82046221bfd51303f816ae649e8"
-  integrity sha512-5xGusXOFQXKacrZmDbpHQzqYD1gIkrMWuwvlrEPkYOsjUqGUjl1HbxCsn5Y9bUXOCgP1Lj6A4PcKt1UiJ2MujA==
+"@opentelemetry/instrumentation-hapi@0.51.0":
+  version "0.51.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-hapi/-/instrumentation-hapi-0.51.0.tgz#879926dfbb2e1609cc8658392167b1456c75d9e0"
+  integrity sha512-qyf27DaFNL1Qhbo/da+04MSCw982B02FhuOS5/UF+PMhM61CcOiu7fPuXj8TvbqyReQuJFljXE6UirlvoT/62g==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-http@0.203.0":
-  version "0.203.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-http/-/instrumentation-http-0.203.0.tgz#21f198547b5c72fc64e83ed25cdc991aef7b8fee"
-  integrity sha512-y3uQAcCOAwnO6vEuNVocmpVzG3PER6/YZqbPbbffDdJ9te5NkHEkfSMNzlC3+v7KlE+WinPGc3N7MR30G1HY2g==
+"@opentelemetry/instrumentation-http@0.204.0":
+  version "0.204.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-http/-/instrumentation-http-0.204.0.tgz#faaf009b75e6a68729923b0a2a5270dc7d336f1d"
+  integrity sha512-1afJYyGRA4OmHTv0FfNTrTAzoEjPQUYgd+8ih/lX0LlZBnGio/O80vxA0lN3knsJPS7FiDrsDrWq25K7oAzbkw==
   dependencies:
-    "@opentelemetry/core" "2.0.1"
-    "@opentelemetry/instrumentation" "0.203.0"
+    "@opentelemetry/core" "2.1.0"
+    "@opentelemetry/instrumentation" "0.204.0"
     "@opentelemetry/semantic-conventions" "^1.29.0"
     forwarded-parse "2.1.2"
 
-"@opentelemetry/instrumentation-ioredis@0.51.0":
-  version "0.51.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-ioredis/-/instrumentation-ioredis-0.51.0.tgz#47360999ad2b035aa2ac604c410272da671142d3"
-  integrity sha512-9IUws0XWCb80NovS+17eONXsw1ZJbHwYYMXiwsfR9TSurkLV5UNbRSKb9URHO+K+pIJILy9wCxvyiOneMr91Ig==
+"@opentelemetry/instrumentation-ioredis@0.52.0":
+  version "0.52.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-ioredis/-/instrumentation-ioredis-0.52.0.tgz#ca5d7b1a49798ed2d29a0f212a7ca5ef95c173c5"
+  integrity sha512-rUvlyZwI90HRQPYicxpDGhT8setMrlHKokCtBtZgYxQWRF5RBbG4q0pGtbZvd7kyseuHbFpA3I/5z7M8b/5ywg==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/redis-common" "^0.38.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-kafkajs@0.13.0":
-  version "0.13.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-kafkajs/-/instrumentation-kafkajs-0.13.0.tgz#f959fecd0a9d53bed2fd662e41a5c155295ffbc8"
-  integrity sha512-FPQyJsREOaGH64hcxlzTsIEQC4DYANgTwHjiB7z9lldmvua1LRMVn3/FfBlzXoqF179B0VGYviz6rn75E9wsDw==
+"@opentelemetry/instrumentation-kafkajs@0.14.0":
+  version "0.14.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-kafkajs/-/instrumentation-kafkajs-0.14.0.tgz#ffc30728b5845907d2c5b9f3883676c754ef4927"
+  integrity sha512-kbB5yXS47dTIdO/lfbbXlzhvHFturbux4EpP0+6H78Lk0Bn4QXiZQW7rmZY1xBCY16mNcCb8Yt0mhz85hTnSVA==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.30.0"
 
-"@opentelemetry/instrumentation-knex@0.48.0":
-  version "0.48.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-knex/-/instrumentation-knex-0.48.0.tgz#ed24a81dfe6099cfe56136a3fed90565e1259f58"
-  integrity sha512-V5wuaBPv/lwGxuHjC6Na2JFRjtPgstw19jTFl1B1b6zvaX8zVDYUDaR5hL7glnQtUSCMktPttQsgK4dhXpddcA==
+"@opentelemetry/instrumentation-knex@0.49.0":
+  version "0.49.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-knex/-/instrumentation-knex-0.49.0.tgz#8c04c80c00ead5fbdf600cd2460dcd21b4069157"
+  integrity sha512-NKsRRT27fbIYL4Ix+BjjP8h4YveyKc+2gD6DMZbr5R5rUeDqfC8+DTfIt3c3ex3BIc5Vvek4rqHnN7q34ZetLQ==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.33.1"
 
-"@opentelemetry/instrumentation-koa@0.51.0":
-  version "0.51.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-koa/-/instrumentation-koa-0.51.0.tgz#1ff57866b7882033639477d3d2d9bada19a2129f"
-  integrity sha512-XNLWeMTMG1/EkQBbgPYzCeBD0cwOrfnn8ao4hWgLv0fNCFQu1kCsJYygz2cvKuCs340RlnG4i321hX7R8gj3Rg==
+"@opentelemetry/instrumentation-koa@0.52.0":
+  version "0.52.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-koa/-/instrumentation-koa-0.52.0.tgz#7266785ea85334366c3e50dc2b45468df438eb3f"
+  integrity sha512-JJSBYLDx/mNSy8Ibi/uQixu2rH0bZODJa8/cz04hEhRaiZQoeJ5UrOhO/mS87IdgVsHrnBOsZ6vDu09znupyuA==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-lru-memoizer@0.48.0":
-  version "0.48.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-lru-memoizer/-/instrumentation-lru-memoizer-0.48.0.tgz#b9fbbd45b7a742a6795bf7166f65684251f184b1"
-  integrity sha512-KUW29wfMlTPX1wFz+NNrmE7IzN7NWZDrmFWHM/VJcmFEuQGnnBuTIdsP55CnBDxKgQ/qqYFp4udQFNtjeFosPw==
+"@opentelemetry/instrumentation-lru-memoizer@0.49.0":
+  version "0.49.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-lru-memoizer/-/instrumentation-lru-memoizer-0.49.0.tgz#6353b877628339e3f07189f4fb15919a73fe1503"
+  integrity sha512-ctXu+O/1HSadAxtjoEg2w307Z5iPyLOMM8IRNwjaKrIpNAthYGSOanChbk1kqY6zU5CrpkPHGdAT6jk8dXiMqw==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation-mongodb@0.56.0":
-  version "0.56.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongodb/-/instrumentation-mongodb-0.56.0.tgz#81281d2d151c3bfb26864c50b938a82ba2831b2d"
-  integrity sha512-YG5IXUUmxX3Md2buVMvxm9NWlKADrnavI36hbJsihqqvBGsWnIfguf0rUP5Srr0pfPqhQjUP+agLMsvu0GmUpA==
+"@opentelemetry/instrumentation-mongodb@0.57.0":
+  version "0.57.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongodb/-/instrumentation-mongodb-0.57.0.tgz#e697261b2eac05280134e1851b72c89d5b4b3da8"
+  integrity sha512-KD6Rg0KSHWDkik+qjIOWoksi1xqSpix8TSPfquIK1DTmd9OTFb5PHmMkzJe16TAPVEuElUW8gvgP59cacFcrMQ==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-mongoose@0.50.0":
-  version "0.50.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongoose/-/instrumentation-mongoose-0.50.0.tgz#1fae5d2769ca7e67d15291fb91b61403839ad91d"
-  integrity sha512-Am8pk1Ct951r4qCiqkBcGmPIgGhoDiFcRtqPSLbJrUZqEPUsigjtMjoWDRLG1Ki1NHgOF7D0H7d+suWz1AAizw==
+"@opentelemetry/instrumentation-mongoose@0.51.0":
+  version "0.51.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongoose/-/instrumentation-mongoose-0.51.0.tgz#688e9f3448e3d0979c4aaab5b566e14f30a1aa72"
+  integrity sha512-gwWaAlhhV2By7XcbyU3DOLMvzsgeaymwP/jktDC+/uPkCmgB61zurwqOQdeiRq9KAf22Y2dtE5ZLXxytJRbEVA==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-mysql2@0.50.0":
-  version "0.50.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql2/-/instrumentation-mysql2-0.50.0.tgz#259344ba8771fd59c70a1a91360215b4b047a323"
-  integrity sha512-PoOMpmq73rOIE3nlTNLf3B1SyNYGsp7QXHYKmeTZZnJ2Ou7/fdURuOhWOI0e6QZ5gSem18IR1sJi6GOULBQJ9g==
+"@opentelemetry/instrumentation-mysql2@0.51.0":
+  version "0.51.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql2/-/instrumentation-mysql2-0.51.0.tgz#7eec3a0b9e4b27759df5df1c82eaedcf34b27528"
+  integrity sha512-zT2Wg22Xn43RyfU3NOUmnFtb5zlDI0fKcijCj9AcK9zuLZ4ModgtLXOyBJSSfO+hsOCZSC1v/Fxwj+nZJFdzLQ==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
     "@opentelemetry/sql-common" "^0.41.0"
 
-"@opentelemetry/instrumentation-mysql@0.49.0":
-  version "0.49.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql/-/instrumentation-mysql-0.49.0.tgz#24fa7473134867236ed4068ee645e51922bcb654"
-  integrity sha512-QU9IUNqNsrlfE3dJkZnFHqLjlndiU39ll/YAAEvWE40sGOCi9AtOF6rmEGzJ1IswoZ3oyePV7q2MP8SrhJfVAA==
+"@opentelemetry/instrumentation-mysql@0.50.0":
+  version "0.50.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql/-/instrumentation-mysql-0.50.0.tgz#25de9de05191cecf8b01df379544eba50fa6f548"
+  integrity sha512-duKAvMRI3vq6u9JwzIipY9zHfikN20bX05sL7GjDeLKr2qV0LQ4ADtKST7KStdGcQ+MTN5wghWbbVdLgNcB3rA==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
     "@types/mysql" "2.15.27"
 
-"@opentelemetry/instrumentation-pg@0.55.0":
-  version "0.55.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-pg/-/instrumentation-pg-0.55.0.tgz#f411d1e48c50b1c1f0f185d9fe94cfbb8812d8f6"
-  integrity sha512-yfJ5bYE7CnkW/uNsnrwouG/FR7nmg09zdk2MSs7k0ZOMkDDAE3WBGpVFFApGgNu2U+gtzLgEzOQG4I/X+60hXw==
+"@opentelemetry/instrumentation-pg@0.57.0":
+  version "0.57.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-pg/-/instrumentation-pg-0.57.0.tgz#346cb613ccd1100221cef9692271468a3fe92eb0"
+  integrity sha512-dWLGE+r5lBgm2A8SaaSYDE3OKJ/kwwy5WLyGyzor8PLhUL9VnJRiY6qhp4njwhnljiLtzeffRtG2Mf/YyWLeTw==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
-    "@opentelemetry/semantic-conventions" "^1.27.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
+    "@opentelemetry/semantic-conventions" "^1.34.0"
     "@opentelemetry/sql-common" "^0.41.0"
-    "@types/pg" "8.15.4"
+    "@types/pg" "8.15.5"
     "@types/pg-pool" "2.0.6"
 
-"@opentelemetry/instrumentation-redis@0.51.0":
-  version "0.51.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-redis/-/instrumentation-redis-0.51.0.tgz#70504ba6c3856fcb25e436b4915e85efaa7d38a6"
-  integrity sha512-uL/GtBA0u72YPPehwOvthAe+Wf8k3T+XQPBssJmTYl6fzuZjNq8zTfxVFhl9nRFjFVEe+CtiYNT0Q3AyqW1Z0A==
+"@opentelemetry/instrumentation-redis@0.53.0":
+  version "0.53.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-redis/-/instrumentation-redis-0.53.0.tgz#826cfeacebaf7ce571bb932ad410f23caf170b9c"
+  integrity sha512-WUHV8fr+8yo5RmzyU7D5BIE1zwiaNQcTyZPwtxlfr7px6NYYx7IIpSihJK7WA60npWynfxxK1T67RAVF0Gdfjg==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/redis-common" "^0.38.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
 
-"@opentelemetry/instrumentation-tedious@0.22.0":
-  version "0.22.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-tedious/-/instrumentation-tedious-0.22.0.tgz#f71374c52cb9c57a6b879bea3256a1465c02efbb"
-  integrity sha512-XrrNSUCyEjH1ax9t+Uo6lv0S2FCCykcF7hSxBMxKf7Xn0bPRxD3KyFUZy25aQXzbbbUHhtdxj3r2h88SfEM3aA==
+"@opentelemetry/instrumentation-tedious@0.23.0":
+  version "0.23.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-tedious/-/instrumentation-tedious-0.23.0.tgz#a781de2cb33ff71ef65bbefba11c9fe2d79c4b32"
+  integrity sha512-3TMTk/9VtlRonVTaU4tCzbg4YqW+Iq/l5VnN2e5whP6JgEg/PKfrGbqQ+CxQWNLfLaQYIUgEZqAn5gk/inh1uQ==
   dependencies:
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
     "@opentelemetry/semantic-conventions" "^1.27.0"
     "@types/tedious" "^4.0.14"
 
-"@opentelemetry/instrumentation-undici@0.14.0":
-  version "0.14.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-undici/-/instrumentation-undici-0.14.0.tgz#7a9cd276f7664773b5daf5ae53365b3593e6e7a9"
-  integrity sha512-2HN+7ztxAReXuxzrtA3WboAKlfP5OsPA57KQn2AdYZbJ3zeRPcLXyW4uO/jpLE6PLm0QRtmeGCmfYpqRlwgSwg==
+"@opentelemetry/instrumentation-undici@0.15.0":
+  version "0.15.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-undici/-/instrumentation-undici-0.15.0.tgz#c8193a162d4abe61c2fd247912e0cb8c0c3bc10c"
+  integrity sha512-sNFGA/iCDlVkNjzTzPRcudmI11vT/WAfAguRdZY9IspCw02N4WSC72zTuQhSMheh2a1gdeM9my1imnKRvEEvEg==
   dependencies:
     "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
 
-"@opentelemetry/instrumentation@0.203.0", "@opentelemetry/instrumentation@^0.203.0":
-  version "0.203.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation/-/instrumentation-0.203.0.tgz#5c74a41cd6868f7ba47b346ff5a58ea7b18cf381"
-  integrity sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ==
+"@opentelemetry/instrumentation@0.204.0", "@opentelemetry/instrumentation@^0.204.0":
+  version "0.204.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation/-/instrumentation-0.204.0.tgz#587c104c02c9ccb38932ce508d9c81514ec7a7c4"
+  integrity sha512-vV5+WSxktzoMP8JoYWKeopChy6G3HKk4UQ2hESCRDUUTZqQ3+nM3u8noVG0LmNfRWwcFBnbZ71GKC7vaYYdJ1g==
   dependencies:
-    "@opentelemetry/api-logs" "0.203.0"
+    "@opentelemetry/api-logs" "0.204.0"
     import-in-the-middle "^1.8.1"
     require-in-the-middle "^7.1.1"
 
@@ -3612,7 +3558,7 @@
 
 "@opentelemetry/otlp-exporter-base@0.57.2":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/otlp-exporter-base/-/otlp-exporter-base-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/otlp-exporter-base/-/otlp-exporter-base-0.57.2.tgz#10636c8d0e377f3311e55741b0550b06f32a3e98"
   integrity sha512-XdxEzL23Urhidyebg5E6jZoaiW5ygP/mRjxLHixogbqwDy2Faduzb5N0o/Oi+XTIJu+iyxXdVORjXax+Qgfxag==
   dependencies:
     "@opentelemetry/core" "1.30.1"
@@ -3620,7 +3566,7 @@
 
 "@opentelemetry/otlp-grpc-exporter-base@0.57.2":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/otlp-grpc-exporter-base/-/otlp-grpc-exporter-base-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/otlp-grpc-exporter-base/-/otlp-grpc-exporter-base-0.57.2.tgz#655ecb3a2a67da90c0042e34cbeaa57df266794e"
   integrity sha512-USn173KTWy0saqqRB5yU9xUZ2xdgb1Rdu5IosJnm9aV4hMTuFFRTUsQxbgc24QxpCHeoKzzCSnS/JzdV0oM2iQ==
   dependencies:
     "@grpc/grpc-js" "^1.7.1"
@@ -3630,7 +3576,7 @@
 
 "@opentelemetry/otlp-transformer@0.57.2":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/otlp-transformer/-/otlp-transformer-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/otlp-transformer/-/otlp-transformer-0.57.2.tgz#a3bdd2c82ddd6fd87f513860fb4f6260e555d2c0"
   integrity sha512-48IIRj49gbQVK52jYsw70+Jv+JbahT8BqT2Th7C4H7RCM9d0gZ5sgNPoMpWldmfjvIsSgiGJtjfk9MeZvjhoig==
   dependencies:
     "@opentelemetry/api-logs" "0.57.2"
@@ -3643,14 +3589,14 @@
 
 "@opentelemetry/propagator-b3@1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz#b73321e5f30f062a9229887a4aa80c771107fdd2"
   integrity sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==
   dependencies:
     "@opentelemetry/core" "1.30.1"
 
 "@opentelemetry/propagator-jaeger@1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz#c06c9dacbe818b80cfb13c4dbf0b57df1ad26b71"
   integrity sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==
   dependencies:
     "@opentelemetry/core" "1.30.1"
@@ -3662,23 +3608,23 @@
 
 "@opentelemetry/resources@1.30.1", "@opentelemetry/resources@^1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-1.30.1.tgz#a4eae17ebd96947fdc7a64f931ca4b71e18ce964"
   integrity sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==
   dependencies:
     "@opentelemetry/core" "1.30.1"
     "@opentelemetry/semantic-conventions" "1.28.0"
 
-"@opentelemetry/resources@2.0.1", "@opentelemetry/resources@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-2.0.1.tgz#0365d134291c0ed18d96444a1e21d0e6a481c840"
-  integrity sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw==
+"@opentelemetry/resources@2.1.0", "@opentelemetry/resources@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-2.1.0.tgz#11772e732af4f27953cf55567a6630d8b4d8282d"
+  integrity sha512-1CJjf3LCvoefUOgegxi8h6r4B/wLSzInyhGP2UmIBYNlo4Qk5CZ73e1eEyWmfXvFtm1ybkmfb2DqWvspsYLrWw==
   dependencies:
-    "@opentelemetry/core" "2.0.1"
+    "@opentelemetry/core" "2.1.0"
     "@opentelemetry/semantic-conventions" "^1.29.0"
 
 "@opentelemetry/sdk-logs@0.57.2":
   version "0.57.2"
-  resolved "https://registry.npmjs.org/@opentelemetry/sdk-logs/-/sdk-logs-0.57.2.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-logs/-/sdk-logs-0.57.2.tgz#ddc9d1e2b86052b4b6bb954dd90fa3878bed8a23"
   integrity sha512-TXFHJ5c+BKggWbdEQ/inpgIzEmS2BGQowLE9UhsMd7YYlUfBQJ4uax0VF/B5NYigdM/75OoJGhAV3upEhK+3gg==
   dependencies:
     "@opentelemetry/api-logs" "0.57.2"
@@ -3687,7 +3633,7 @@
 
 "@opentelemetry/sdk-metrics@1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/sdk-metrics/-/sdk-metrics-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-metrics/-/sdk-metrics-1.30.1.tgz#70e2bcd275b9df6e7e925e3fe53cfe71329b5fc8"
   integrity sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog==
   dependencies:
     "@opentelemetry/core" "1.30.1"
@@ -3695,25 +3641,25 @@
 
 "@opentelemetry/sdk-trace-base@1.30.1", "@opentelemetry/sdk-trace-base@^1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz#41a42234096dc98e8f454d24551fc80b816feb34"
   integrity sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==
   dependencies:
     "@opentelemetry/core" "1.30.1"
     "@opentelemetry/resources" "1.30.1"
     "@opentelemetry/semantic-conventions" "1.28.0"
 
-"@opentelemetry/sdk-trace-base@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.0.1.tgz#25808bb6a3d08a501ad840249e4d43d3493eb6e5"
-  integrity sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ==
+"@opentelemetry/sdk-trace-base@^2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.1.0.tgz#9d31474824e9ed215f94bf71260d5321f64d402a"
+  integrity sha512-uTX9FBlVQm4S2gVQO1sb5qyBLq/FPjbp+tmGoxu4tIgtYGmBYB44+KX/725RFDe30yBSaA9Ml9fqphe1hbUyLQ==
   dependencies:
-    "@opentelemetry/core" "2.0.1"
-    "@opentelemetry/resources" "2.0.1"
+    "@opentelemetry/core" "2.1.0"
+    "@opentelemetry/resources" "2.1.0"
     "@opentelemetry/semantic-conventions" "^1.29.0"
 
 "@opentelemetry/sdk-trace-node@^1.30.1":
   version "1.30.1"
-  resolved "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz#bd7d68fcfb4d4ae76ea09810df9668b7dd09a2e5"
   integrity sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==
   dependencies:
     "@opentelemetry/context-async-hooks" "1.30.1"
@@ -3725,18 +3671,13 @@
 
 "@opentelemetry/semantic-conventions@1.28.0":
   version "1.28.0"
-  resolved "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz#337fb2bca0453d0726696e745f50064411f646d6"
   integrity sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==
 
-"@opentelemetry/semantic-conventions@^1.27.0", "@opentelemetry/semantic-conventions@^1.29.0", "@opentelemetry/semantic-conventions@^1.30.0", "@opentelemetry/semantic-conventions@^1.33.1", "@opentelemetry/semantic-conventions@^1.34.0":
-  version "1.36.0"
-  resolved "https://registry.yarnpkg.com/@opentelemetry/semantic-conventions/-/semantic-conventions-1.36.0.tgz#149449bd4df4d0464220915ad4164121e0d75d4d"
-  integrity sha512-TtxJSRD8Ohxp6bKkhrm27JRHAxPczQA7idtcTOMYI+wQRRrfgqxHv1cFbCApcSnNjtXkmzFozn6jQtFrOmbjPQ==
-
-"@opentelemetry/semantic-conventions@^1.28.0":
-  version "1.32.0"
-  resolved "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.32.0.tgz"
-  integrity sha512-s0OpmpQFSfMrmedAn9Lhg4KWJELHCU6uU9dtIJ28N8UGhf9Y55im5X8fEzwhwDwiSqN+ZPSNrDJF7ivf/AuRPQ==
+"@opentelemetry/semantic-conventions@^1.27.0", "@opentelemetry/semantic-conventions@^1.28.0", "@opentelemetry/semantic-conventions@^1.29.0", "@opentelemetry/semantic-conventions@^1.30.0", "@opentelemetry/semantic-conventions@^1.33.1", "@opentelemetry/semantic-conventions@^1.34.0", "@opentelemetry/semantic-conventions@^1.37.0":
+  version "1.37.0"
+  resolved "https://registry.yarnpkg.com/@opentelemetry/semantic-conventions/-/semantic-conventions-1.37.0.tgz#aa2b4fa0b910b66a050c5ddfcac1d262e91a321a"
+  integrity sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA==
 
 "@opentelemetry/sql-common@^0.41.0":
   version "0.41.0"
@@ -3747,49 +3688,49 @@
 
 "@pkgjs/parseargs@^0.11.0":
   version "0.11.0"
-  resolved "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz"
+  resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
   integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==
 
-"@pkgr/core@^0.1.0":
-  version "0.1.1"
-  resolved "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz"
-  integrity sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==
+"@pkgr/core@^0.2.9":
+  version "0.2.9"
+  resolved "https://registry.yarnpkg.com/@pkgr/core/-/core-0.2.9.tgz#d229a7b7f9dac167a156992ef23c7f023653f53b"
+  integrity sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==
 
 "@polka/url@^1.0.0-next.24":
-  version "1.0.0-next.28"
-  resolved "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz"
-  integrity sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==
+  version "1.0.0-next.29"
+  resolved "https://registry.yarnpkg.com/@polka/url/-/url-1.0.0-next.29.tgz#5a40109a1ab5f84d6fd8fc928b19f367cbe7e7b1"
+  integrity sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==
 
-"@prisma/instrumentation@6.14.0":
-  version "6.14.0"
-  resolved "https://registry.yarnpkg.com/@prisma/instrumentation/-/instrumentation-6.14.0.tgz#8f6e43b73ee2b88b98cec901457f4da7da13aea3"
-  integrity sha512-Po/Hry5bAeunRDq0yAQueKookW3glpP+qjjvvyOfm6dI2KG5/Y6Bgg3ahyWd7B0u2E+Wf9xRk2rtdda7ySgK1A==
+"@prisma/instrumentation@6.15.0":
+  version "6.15.0"
+  resolved "https://registry.yarnpkg.com/@prisma/instrumentation/-/instrumentation-6.15.0.tgz#40b066dc6b1ea621aa5ae0fd6d54319550b7d8c9"
+  integrity sha512-6TXaH6OmDkMOQvOxwLZ8XS51hU2v4A3vmE2pSijCIiGRJYyNeMcL6nMHQMyYdZRD8wl7LF3Wzc+AMPMV/9Oo7A==
   dependencies:
     "@opentelemetry/instrumentation" "^0.52.0 || ^0.53.0 || ^0.54.0 || ^0.55.0 || ^0.56.0 || ^0.57.0"
 
 "@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf"
   integrity sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==
 
 "@protobufjs/base64@^1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735"
   integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==
 
 "@protobufjs/codegen@^2.0.4":
   version "2.0.4"
-  resolved "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb"
   integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==
 
 "@protobufjs/eventemitter@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70"
   integrity sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==
 
 "@protobufjs/fetch@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45"
   integrity sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==
   dependencies:
     "@protobufjs/aspromise" "^1.1.1"
@@ -3797,49 +3738,51 @@
 
 "@protobufjs/float@^1.0.2":
   version "1.0.2"
-  resolved "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1"
   integrity sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==
 
 "@protobufjs/inquire@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089"
   integrity sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==
 
 "@protobufjs/path@^1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d"
   integrity sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==
 
 "@protobufjs/pool@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54"
   integrity sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==
 
 "@protobufjs/utf8@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570"
   integrity sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==
 
+"@radix-ui/number@1.1.1":
 "@radix-ui/number@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/number/-/number-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/number/-/number-1.1.1.tgz#7b2c9225fbf1b126539551f5985769d0048d9090"
   integrity sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==
 
-"@radix-ui/primitive@1.1.2":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.2.tgz"
-  integrity sha512-XnbHrrprsNqZKQhStrSwgRUQzoCI1glLzdw79xiZPoofhGICeZRSQ3dIxAKH1gb3OHfNf4d6f+vAv3kil2eggA==
+"@radix-ui/primitive@1.1.3":
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/@radix-ui/primitive/-/primitive-1.1.3.tgz#e2dbc13bdc5e4168f4334f75832d7bdd3e2de5ba"
+  integrity sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==
 
 "@radix-ui/react-arrow@1.1.7":
   version "1.1.7"
-  resolved "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz#e14a2657c81d961598c5e72b73dd6098acc04f09"
   integrity sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==
   dependencies:
     "@radix-ui/react-primitive" "2.1.3"
 
+"@radix-ui/react-collection@1.1.7":
 "@radix-ui/react-collection@1.1.7":
   version "1.1.7"
-  resolved "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.7.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-collection/-/react-collection-1.1.7.tgz#d05c25ca9ac4695cc19ba91f42f686e3ea2d9aec"
   integrity sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==
   dependencies:
     "@radix-ui/react-compose-refs" "1.1.2"
@@ -3847,65 +3790,62 @@
     "@radix-ui/react-primitive" "2.1.3"
     "@radix-ui/react-slot" "1.2.3"
 
-"@radix-ui/react-compose-refs@1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.0.tgz"
-  integrity sha512-b4inOtiaOnYf9KWyO3jAeeCG6FeyfY6ldiEPanbUjWd+xIk5wZeHa8yVwmrJ2vderhu/BQvzCrJI0lHd+wIiqw==
-
 "@radix-ui/react-compose-refs@1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz#a2c4c47af6337048ee78ff6dc0d090b390d2bb30"
   integrity sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==
 
+"@radix-ui/react-context@1.1.2":
 "@radix-ui/react-context@1.1.2":
   version "1.1.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-context/-/react-context-1.1.2.tgz#61628ef269a433382c364f6f1e3788a6dc213a36"
   integrity sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==
 
 "@radix-ui/react-dialog@^1.1.1":
-  version "1.1.14"
-  resolved "https://registry.npmjs.org/@radix-ui/react-dialog/-/react-dialog-1.1.14.tgz"
-  integrity sha512-+CpweKjqpzTmwRwcYECQcNYbI8V9VSQt0SNFKeEBLgfucbsLssU6Ppq7wUdNXEGb573bMjFhVjKVll8rmV6zMw==
+  version "1.1.15"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-dialog/-/react-dialog-1.1.15.tgz#1de3d7a7e9a17a9874d29c07f5940a18a119b632"
+  integrity sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==
   dependencies:
-    "@radix-ui/primitive" "1.1.2"
+    "@radix-ui/primitive" "1.1.3"
     "@radix-ui/react-compose-refs" "1.1.2"
     "@radix-ui/react-context" "1.1.2"
-    "@radix-ui/react-dismissable-layer" "1.1.10"
-    "@radix-ui/react-focus-guards" "1.1.2"
+    "@radix-ui/react-dismissable-layer" "1.1.11"
+    "@radix-ui/react-focus-guards" "1.1.3"
     "@radix-ui/react-focus-scope" "1.1.7"
     "@radix-ui/react-id" "1.1.1"
     "@radix-ui/react-portal" "1.1.9"
-    "@radix-ui/react-presence" "1.1.4"
+    "@radix-ui/react-presence" "1.1.5"
     "@radix-ui/react-primitive" "2.1.3"
     "@radix-ui/react-slot" "1.2.3"
     "@radix-ui/react-use-controllable-state" "1.2.2"
     aria-hidden "^1.2.4"
     react-remove-scroll "^2.6.3"
 
+"@radix-ui/react-direction@1.1.1":
 "@radix-ui/react-direction@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-direction/-/react-direction-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-direction/-/react-direction-1.1.1.tgz#39e5a5769e676c753204b792fbe6cf508e550a14"
   integrity sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==
 
-"@radix-ui/react-dismissable-layer@1.1.10":
-  version "1.1.10"
-  resolved "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.10.tgz"
-  integrity sha512-IM1zzRV4W3HtVgftdQiiOmA0AdJlCtMLe00FXaHwgt3rAnNsIyDqshvkIW3hj/iu5hu8ERP7KIYki6NkqDxAwQ==
+"@radix-ui/react-dismissable-layer@1.1.11":
+  version "1.1.11"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz#e33ab6f6bdaa00f8f7327c408d9f631376b88b37"
+  integrity sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==
   dependencies:
-    "@radix-ui/primitive" "1.1.2"
+    "@radix-ui/primitive" "1.1.3"
     "@radix-ui/react-compose-refs" "1.1.2"
     "@radix-ui/react-primitive" "2.1.3"
     "@radix-ui/react-use-callback-ref" "1.1.1"
     "@radix-ui/react-use-escape-keydown" "1.1.1"
 
-"@radix-ui/react-focus-guards@1.1.2":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.2.tgz"
-  integrity sha512-fyjAACV62oPV925xFCrH8DR5xWhg9KYtJT4s3u54jxp+L/hbpTY2kIeEFFbFe+a/HCE94zGQMZLIpVTPVZDhaA==
+"@radix-ui/react-focus-guards@1.1.3":
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz#2a5669e464ad5fde9f86d22f7fdc17781a4dfa7f"
+  integrity sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==
 
 "@radix-ui/react-focus-scope@1.1.7":
   version "1.1.7"
-  resolved "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz#dfe76fc103537d80bf42723a183773fd07bfb58d"
   integrity sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==
   dependencies:
     "@radix-ui/react-compose-refs" "1.1.2"
@@ -3914,20 +3854,21 @@
 
 "@radix-ui/react-icons@^1.3.0":
   version "1.3.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-icons/-/react-icons-1.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-icons/-/react-icons-1.3.2.tgz#09be63d178262181aeca5fb7f7bc944b10a7f441"
   integrity sha512-fyQIhGDhzfc9pK2kH6Pl9c4BDJGfMkPqkyIgYDthyNYoNg3wVhoJMMh19WS4Up/1KMPFVpNsT2q3WmXn2N1m6g==
 
+"@radix-ui/react-id@1.1.1":
 "@radix-ui/react-id@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-id/-/react-id-1.1.1.tgz#1404002e79a03fe062b7e3864aa01e24bd1471f7"
   integrity sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==
   dependencies:
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
-"@radix-ui/react-popper@1.2.7":
-  version "1.2.7"
-  resolved "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.7.tgz"
-  integrity sha512-IUFAccz1JyKcf/RjB552PlWwxjeCJB8/4KxT7EhBHOJM+mN7LdW+B3kacJXILm32xawcMMjb2i0cIZpo+f9kiQ==
+"@radix-ui/react-popper@1.2.8":
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-popper/-/react-popper-1.2.8.tgz#a79f39cdd2b09ab9fb50bf95250918422c4d9602"
+  integrity sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==
   dependencies:
     "@floating-ui/react-dom" "^2.0.0"
     "@radix-ui/react-arrow" "1.1.7"
@@ -3940,60 +3881,45 @@
     "@radix-ui/react-use-size" "1.1.1"
     "@radix-ui/rect" "1.1.1"
 
-"@radix-ui/react-portal@1.1.9":
+"@radix-ui/react-portal@1.1.9", "@radix-ui/react-portal@^1.0.1":
   version "1.1.9"
-  resolved "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-portal/-/react-portal-1.1.9.tgz#14c3649fe48ec474ac51ed9f2b9f5da4d91c4472"
   integrity sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==
   dependencies:
     "@radix-ui/react-primitive" "2.1.3"
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
-"@radix-ui/react-portal@^1.0.1":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.2.tgz"
-  integrity sha512-WeDYLGPxJb/5EGBoedyJbT0MpoULmwnIPMJMSldkuiMsBAv7N1cRdsTWZWht9vpPOiN3qyiGAtbK2is47/uMFg==
-  dependencies:
-    "@radix-ui/react-primitive" "2.0.0"
-    "@radix-ui/react-use-layout-effect" "1.1.0"
-
-"@radix-ui/react-presence@1.1.4":
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.4.tgz"
-  integrity sha512-ueDqRbdc4/bkaQT3GIpLQssRlFgWaL/U2z/S31qRwwLWoxHLgry3SIfCwhxeQNbirEUXFa+lq3RL3oBYXtcmIA==
+"@radix-ui/react-presence@1.1.5":
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-presence/-/react-presence-1.1.5.tgz#5d8f28ac316c32f078afce2996839250c10693db"
+  integrity sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==
   dependencies:
     "@radix-ui/react-compose-refs" "1.1.2"
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
-"@radix-ui/react-primitive@2.0.0":
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.0.0.tgz"
-  integrity sha512-ZSpFm0/uHa8zTvKBDjLFWLo8dkr4MBsiDLz0g3gMUwqgLHz9rTaRRGYDgvZPtBJgYCBKXkS9fzmoySgr8CO6Cw==
-  dependencies:
-    "@radix-ui/react-slot" "1.1.0"
-
 "@radix-ui/react-primitive@2.1.3":
   version "2.1.3"
-  resolved "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz#db9b8bcff49e01be510ad79893fb0e4cda50f1bc"
   integrity sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==
   dependencies:
     "@radix-ui/react-slot" "1.2.3"
 
 "@radix-ui/react-select@^2.2.5":
-  version "2.2.5"
-  resolved "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.5.tgz"
-  integrity sha512-HnMTdXEVuuyzx63ME0ut4+sEMYW6oouHWNGUZc7ddvUWIcfCva/AMoqEW/3wnEllriMWBa0RHspCYnfCWJQYmA==
+  version "2.2.6"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-select/-/react-select-2.2.6.tgz#022cf8dab16bf05d0d1b4df9e53e4bea1b744fd9"
+  integrity sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==
   dependencies:
     "@radix-ui/number" "1.1.1"
-    "@radix-ui/primitive" "1.1.2"
+    "@radix-ui/primitive" "1.1.3"
     "@radix-ui/react-collection" "1.1.7"
     "@radix-ui/react-compose-refs" "1.1.2"
     "@radix-ui/react-context" "1.1.2"
     "@radix-ui/react-direction" "1.1.1"
-    "@radix-ui/react-dismissable-layer" "1.1.10"
-    "@radix-ui/react-focus-guards" "1.1.2"
+    "@radix-ui/react-dismissable-layer" "1.1.11"
+    "@radix-ui/react-focus-guards" "1.1.3"
     "@radix-ui/react-focus-scope" "1.1.7"
     "@radix-ui/react-id" "1.1.1"
-    "@radix-ui/react-popper" "1.2.7"
+    "@radix-ui/react-popper" "1.2.8"
     "@radix-ui/react-portal" "1.1.9"
     "@radix-ui/react-primitive" "2.1.3"
     "@radix-ui/react-slot" "1.2.3"
@@ -4005,28 +3931,23 @@
     aria-hidden "^1.2.4"
     react-remove-scroll "^2.6.3"
 
-"@radix-ui/react-slot@1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.1.0.tgz"
-  integrity sha512-FUCf5XMfmW4dtYl69pdS4DbxKy8nj4M7SafBgPllysxmdachynNflAdp/gCsnYWNDnge6tI9onzMp5ARYc1KNw==
-  dependencies:
-    "@radix-ui/react-compose-refs" "1.1.0"
-
 "@radix-ui/react-slot@1.2.3", "@radix-ui/react-slot@^1.1.1", "@radix-ui/react-slot@^1.2.0":
   version "1.2.3"
-  resolved "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-slot/-/react-slot-1.2.3.tgz#502d6e354fc847d4169c3bc5f189de777f68cfe1"
   integrity sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==
   dependencies:
     "@radix-ui/react-compose-refs" "1.1.2"
 
+"@radix-ui/react-use-callback-ref@1.1.1":
 "@radix-ui/react-use-callback-ref@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz#62a4dba8b3255fdc5cc7787faeac1c6e4cc58d40"
   integrity sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==
 
+"@radix-ui/react-use-controllable-state@1.2.2":
 "@radix-ui/react-use-controllable-state@1.2.2":
   version "1.2.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz#905793405de57d61a439f4afebbb17d0645f3190"
   integrity sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==
   dependencies:
     "@radix-ui/react-use-effect-event" "0.0.2"
@@ -4034,597 +3955,714 @@
 
 "@radix-ui/react-use-effect-event@0.0.2":
   version "0.0.2"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz#090cf30d00a4c7632a15548512e9152217593907"
   integrity sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==
   dependencies:
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
 "@radix-ui/react-use-escape-keydown@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz#b3fed9bbea366a118f40427ac40500aa1423cc29"
   integrity sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==
   dependencies:
     "@radix-ui/react-use-callback-ref" "1.1.1"
 
-"@radix-ui/react-use-layout-effect@1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.0.tgz"
-  integrity sha512-+FPE0rOdziWSrH9athwI1R0HDVbWlEhd+FR+aSDk4uWGmSJ9Z54sdZVDQPZAinJhJXwfT+qnj969mCsT2gfm5w==
-
 "@radix-ui/react-use-layout-effect@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz#0c4230a9eed49d4589c967e2d9c0d9d60a23971e"
   integrity sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==
 
 "@radix-ui/react-use-previous@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz#1a1ad5568973d24051ed0af687766f6c7cb9b5b5"
   integrity sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==
 
 "@radix-ui/react-use-rect@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz#01443ca8ed071d33023c1113e5173b5ed8769152"
   integrity sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==
   dependencies:
     "@radix-ui/rect" "1.1.1"
 
 "@radix-ui/react-use-size@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz#6de276ffbc389a537ffe4316f5b0f24129405b37"
   integrity sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==
   dependencies:
     "@radix-ui/react-use-layout-effect" "1.1.1"
 
 "@radix-ui/react-visually-hidden@1.2.3":
   version "1.2.3"
-  resolved "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz#a8c38c8607735dc9f05c32f87ab0f9c2b109efbf"
   integrity sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==
   dependencies:
     "@radix-ui/react-primitive" "2.1.3"
 
 "@radix-ui/rect@1.1.1":
   version "1.1.1"
-  resolved "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@radix-ui/rect/-/rect-1.1.1.tgz#78244efe12930c56fd255d7923865857c41ac8cb"
   integrity sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==
 
 "@reach/observe-rect@^1.1.0":
   version "1.2.0"
-  resolved "https://registry.npmjs.org/@reach/observe-rect/-/observe-rect-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@reach/observe-rect/-/observe-rect-1.2.0.tgz#d7a6013b8aafcc64c778a0ccb83355a11204d3b2"
   integrity sha512-Ba7HmkFgfQxZqqaeIWWkNK0rEhpxVQHIoVyW1YDSkGsGIXzcaW4deC8B0pZrNSSyLTdIk7y+5olKt5+g0GmFIQ==
 
-"@react-aria/breadcrumbs@3.5.13":
-  version "3.5.13"
-  resolved "https://registry.npmjs.org/@react-aria/breadcrumbs/-/breadcrumbs-3.5.13.tgz"
-  integrity sha512-G1Gqf/P6kVdfs94ovwP18fTWuIxadIQgHsXS08JEVcFVYMjb9YjqnEBaohUxD1tq2WldMbYw53ahQblT4NTG+g==
+"@react-aria/breadcrumbs@3.5.19":
+  version "3.5.19"
+  resolved "https://registry.yarnpkg.com/@react-aria/breadcrumbs/-/breadcrumbs-3.5.19.tgz#e0a67e0e7017089fa0ee5eadd51a6da505b94cd4"
+  integrity sha512-mVngOPFYVVhec89rf/CiYQGTfaLRfHFtX+JQwY7sNYNqSA+gO8p4lNARe3Be6bJPgH+LUQuruIY9/ZDL6LT3HA==
   dependencies:
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/link" "^3.7.1"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/breadcrumbs" "^3.7.5"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/link" "^3.7.7"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/breadcrumbs" "^3.7.9"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/button@3.9.5":
-  version "3.9.5"
-  resolved "https://registry.npmjs.org/@react-aria/button/-/button-3.9.5.tgz"
-  integrity sha512-dgcYR6j8WDOMLKuVrtxzx4jIC05cVKDzc+HnPO8lNkBAOfjcuN5tkGRtIjLtqjMvpZHhQT5aDbgFpIaZzxgFIg==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/toggle" "^3.7.4"
-    "@react-types/button" "^3.9.4"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/button@3.11.0":
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/button/-/button-3.11.0.tgz#cb7790db23949ec9c1e698fa531ee5471cf2b515"
+  integrity sha512-b37eIV6IW11KmNIAm65F3SEl2/mgj5BrHIysW6smZX3KoKWTGYsYfcQkmtNgY0GOSFfDxMCoolsZ6mxC00nSDA==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/toolbar" "3.0.0-beta.11"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/toggle" "^3.8.0"
+    "@react-types/button" "^3.10.1"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/calendar@3.5.8":
-  version "3.5.8"
-  resolved "https://registry.npmjs.org/@react-aria/calendar/-/calendar-3.5.8.tgz"
-  integrity sha512-Whlp4CeAA5/ZkzrAHUv73kgIRYjw088eYGSc+cvSOCxfrc/2XkBm9rNrnSBv0DvhJ8AG0Fjz3vYakTmF3BgZBw==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/live-announcer" "^3.3.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/calendar" "^3.5.1"
-    "@react-types/button" "^3.9.4"
-    "@react-types/calendar" "^3.4.6"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/calendar@3.6.0":
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/calendar/-/calendar-3.6.0.tgz#d5e7cf4beb8724648a7042dbc5bb519de4351906"
+  integrity sha512-tZ3nd5DP8uxckbj83Pt+4RqgcTWDlGi7njzc7QqFOG2ApfnYDUXbIpb/Q4KY6JNlJskG8q33wo0XfOwNy8J+eg==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/live-announcer" "^3.4.1"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/calendar" "^3.6.0"
+    "@react-types/button" "^3.10.1"
+    "@react-types/calendar" "^3.5.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/checkbox@3.14.3":
-  version "3.14.3"
-  resolved "https://registry.npmjs.org/@react-aria/checkbox/-/checkbox-3.14.3.tgz"
-  integrity sha512-EtBJL6iu0gvrw3A4R7UeVLR6diaVk/mh4kFBc7c8hQjpEJweRr4hmJT3hrNg3MBcTWLxFiMEXPGgWEwXDBygtA==
-  dependencies:
-    "@react-aria/form" "^3.0.5"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/toggle" "^3.10.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/checkbox" "^3.6.5"
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/toggle" "^3.7.4"
-    "@react-types/checkbox" "^3.8.1"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/checkbox@3.15.0":
+  version "3.15.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/checkbox/-/checkbox-3.15.0.tgz#4d224b71c65d6a079ff935ab22c806323f84b746"
+  integrity sha512-z/8xd4em7o0MroBXwkkwv7QRwiJaA1FwqMhRUb7iqtBGP2oSytBEDf0N7L09oci32a1P4ZPz2rMK5GlLh/PD6g==
+  dependencies:
+    "@react-aria/form" "^3.0.11"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/toggle" "^3.10.10"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/checkbox" "^3.6.10"
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/toggle" "^3.8.0"
+    "@react-types/checkbox" "^3.9.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/combobox@3.9.1":
-  version "3.9.1"
-  resolved "https://registry.npmjs.org/@react-aria/combobox/-/combobox-3.9.1.tgz"
-  integrity sha512-SpK92dCmT8qn8aEcUAihRQrBb5LZUhwIbDExFII8PvUvEFy/PoQHXIo3j1V29WkutDBDpMvBv/6XRCHGXPqrhQ==
-  dependencies:
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/listbox" "^3.12.1"
-    "@react-aria/live-announcer" "^3.3.4"
-    "@react-aria/menu" "^3.14.1"
-    "@react-aria/overlays" "^3.22.1"
-    "@react-aria/selection" "^3.18.1"
-    "@react-aria/textfield" "^3.14.5"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/combobox" "^3.8.4"
-    "@react-stately/form" "^3.0.3"
-    "@react-types/button" "^3.9.4"
-    "@react-types/combobox" "^3.11.1"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/combobox@3.11.0":
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/combobox/-/combobox-3.11.0.tgz#9489aaad342d092bf1fe1c4c382f6714316ac1c4"
+  integrity sha512-s88YMmPkMO1WSoiH1KIyZDLJqUwvM2wHXXakj3cYw1tBHGo4rOUFq+JWQIbM5EDO4HOR4AUUqzIUd0NO7t3zyg==
+  dependencies:
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/listbox" "^3.13.6"
+    "@react-aria/live-announcer" "^3.4.1"
+    "@react-aria/menu" "^3.16.0"
+    "@react-aria/overlays" "^3.24.0"
+    "@react-aria/selection" "^3.21.0"
+    "@react-aria/textfield" "^3.15.0"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/combobox" "^3.10.1"
+    "@react-stately/form" "^3.1.0"
+    "@react-types/button" "^3.10.1"
+    "@react-types/combobox" "^3.13.1"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/datepicker@3.10.1":
-  version "3.10.1"
-  resolved "https://registry.npmjs.org/@react-aria/datepicker/-/datepicker-3.10.1.tgz"
-  integrity sha512-4HZL593nrNMa1GjBmWEN/OTvNS6d3/16G1YJWlqiUlv11ADulSbqBIjMmkgwrJVFcjrgqtXFy+yyrTA/oq94Zw==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@internationalized/number" "^3.5.3"
-    "@internationalized/string" "^3.2.3"
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/form" "^3.0.5"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/spinbutton" "^3.6.5"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/datepicker" "^3.9.4"
-    "@react-stately/form" "^3.0.3"
-    "@react-types/button" "^3.9.4"
-    "@react-types/calendar" "^3.4.6"
-    "@react-types/datepicker" "^3.7.4"
-    "@react-types/dialog" "^3.5.10"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/datepicker@3.12.0":
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/datepicker/-/datepicker-3.12.0.tgz#a82ff3ebd3ead20a00096d082c1e6be47bbd5886"
+  integrity sha512-VYNXioLfddIHpwQx211+rTYuunDmI7VHWBRetCpH3loIsVFuhFSRchTQpclAzxolO3g0vO7pMVj9VYt7Swp6kg==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@internationalized/number" "^3.6.0"
+    "@internationalized/string" "^3.2.5"
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/form" "^3.0.11"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/spinbutton" "^3.6.10"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/datepicker" "^3.11.0"
+    "@react-stately/form" "^3.1.0"
+    "@react-types/button" "^3.10.1"
+    "@react-types/calendar" "^3.5.0"
+    "@react-types/datepicker" "^3.9.0"
+    "@react-types/dialog" "^3.5.14"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/dialog@3.5.14":
-  version "3.5.14"
-  resolved "https://registry.npmjs.org/@react-aria/dialog/-/dialog-3.5.14.tgz"
-  integrity sha512-oqDCjQ8hxe3GStf48XWBf2CliEnxlR9GgSYPHJPUc69WBj68D9rVcCW3kogJnLAnwIyf3FnzbX4wSjvUa88sAQ==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/overlays" "^3.22.1"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/dialog" "^3.5.10"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/dialog@3.5.20":
+  version "3.5.20"
+  resolved "https://registry.yarnpkg.com/@react-aria/dialog/-/dialog-3.5.20.tgz#6404d2c1bab1ea9ecce3ebc7adce64733ecea985"
+  integrity sha512-l0GZVLgeOd3kL3Yj8xQW7wN3gn9WW3RLd/SGI9t7ciTq+I/FhftjXCWzXLlOCCTLMf+gv7eazecECtmoWUaZWQ==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/overlays" "^3.24.0"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/dialog" "^3.5.14"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/focus@3.17.1":
-  version "3.17.1"
-  resolved "https://registry.npmjs.org/@react-aria/focus/-/focus-3.17.1.tgz"
-  integrity sha512-FLTySoSNqX++u0nWZJPPN5etXY0WBxaIe/YuL/GTEeuqUIuC/2bJSaw5hlsM6T2yjy6Y/VAxBcKSdAFUlU6njQ==
+"@react-aria/focus@3.19.0":
+  version "3.19.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/focus/-/focus-3.19.0.tgz#82b9a5b83f023b943a7970df3d059f49d61df05d"
+  integrity sha512-hPF9EXoUQeQl1Y21/rbV2H4FdUR2v+4/I0/vB+8U3bT1CJ+1AFj1hc/rqx2DqEwDlEwOHN+E4+mRahQmlybq0A==
   dependencies:
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
     clsx "^2.0.0"
 
-"@react-aria/focus@^3.17.1", "@react-aria/focus@^3.18.2":
-  version "3.18.2"
-  resolved "https://registry.npmjs.org/@react-aria/focus/-/focus-3.18.2.tgz"
-  integrity sha512-Jc/IY+StjA3uqN73o6txKQ527RFU7gnG5crEl5Xy3V+gbYp2O5L3ezAo/E0Ipi2cyMbG6T5Iit1IDs7hcGu8aw==
+"@react-aria/focus@^3.19.0", "@react-aria/focus@^3.20.2", "@react-aria/focus@^3.21.1":
+  version "3.21.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/focus/-/focus-3.21.1.tgz#fad9d0803e0e4423bb6e14ed3208fffd694e5e42"
+  integrity sha512-hmH1IhHlcQ2lSIxmki1biWzMbGgnhdxJUM0MFfzc71Rv6YAzhlx4kX3GYn4VNcjCeb6cdPv4RZ5vunV4kgMZYQ==
   dependencies:
-    "@react-aria/interactions" "^3.22.2"
-    "@react-aria/utils" "^3.25.2"
-    "@react-types/shared" "^3.24.1"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
     clsx "^2.0.0"
 
-"@react-aria/form@3.0.5", "@react-aria/form@^3.0.5":
-  version "3.0.5"
-  resolved "https://registry.npmjs.org/@react-aria/form/-/form-3.0.5.tgz"
-  integrity sha512-n290jRwrrRXO3fS82MyWR+OKN7yznVesy5Q10IclSTVYHHI3VI53xtAPr/WzNjJR1um8aLhOcDNFKwnNIUUCsQ==
+"@react-aria/form@3.0.11":
+  version "3.0.11"
+  resolved "https://registry.yarnpkg.com/@react-aria/form/-/form-3.0.11.tgz#84511874e1fad5f981bae97ebd4d549923849455"
+  integrity sha512-oXzjTiwVuuWjZ8muU0hp3BrDH5qjVctLOF50mjPvqUbvXQTHhoDxWweyIXPQjGshaqBd2w4pWaE4A2rG2O/apw==
   dependencies:
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/form" "^3.0.3"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/form" "^3.1.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/grid@^3.9.1":
-  version "3.10.3"
-  resolved "https://registry.npmjs.org/@react-aria/grid/-/grid-3.10.3.tgz"
-  integrity sha512-l0r9mz05Gwjq3t6JOTNQOf+oAoWN0bXELPJtIr8m0XyXMPFCQe1xsTaX8igVQdrDmXyBc75RAWS0BJo2JF2fIA==
-  dependencies:
-    "@react-aria/focus" "^3.18.2"
-    "@react-aria/i18n" "^3.12.2"
-    "@react-aria/interactions" "^3.22.2"
-    "@react-aria/live-announcer" "^3.3.4"
-    "@react-aria/selection" "^3.19.3"
-    "@react-aria/utils" "^3.25.2"
-    "@react-stately/collections" "^3.10.9"
-    "@react-stately/grid" "^3.9.2"
-    "@react-stately/selection" "^3.16.2"
-    "@react-types/checkbox" "^3.8.3"
-    "@react-types/grid" "^3.2.8"
-    "@react-types/shared" "^3.24.1"
+"@react-aria/form@^3.0.11", "@react-aria/form@^3.1.1":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/form/-/form-3.1.1.tgz#76b3eb4a6985fb27b1d437db89b5a69c54be292f"
+  integrity sha512-PjZC25UgH5orit9p56Ymbbo288F3eaDd3JUvD8SG+xgx302HhlFAOYsQLLAb4k4H03bp0gWtlUEkfX6KYcE1Tw==
+  dependencies:
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/form" "^3.2.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/i18n@3.11.1", "@react-aria/i18n@^3.11.1":
-  version "3.11.1"
-  resolved "https://registry.npmjs.org/@react-aria/i18n/-/i18n-3.11.1.tgz"
-  integrity sha512-vuiBHw1kZruNMYeKkTGGnmPyMnM5T+gT8bz97H1FqIq1hQ6OPzmtBZ6W6l6OIMjeHI5oJo4utTwfZl495GALFQ==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@internationalized/message" "^3.1.4"
-    "@internationalized/number" "^3.5.3"
-    "@internationalized/string" "^3.2.3"
-    "@react-aria/ssr" "^3.9.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/grid@^3.11.0":
+  version "3.14.4"
+  resolved "https://registry.yarnpkg.com/@react-aria/grid/-/grid-3.14.4.tgz#0511ae807fe7ff6df03b96edfb0e23624f137804"
+  integrity sha512-l1FLQNKnoHpY4UClUTPUV0AqJ5bfAULEE0ErY86KznWLd+Hqzo7mHLqqDV02CDa/8mIUcdoax/MrYYIbPDlOZA==
+  dependencies:
+    "@react-aria/focus" "^3.21.1"
+    "@react-aria/i18n" "^3.12.12"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/live-announcer" "^3.4.4"
+    "@react-aria/selection" "^3.25.1"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/grid" "^3.11.5"
+    "@react-stately/selection" "^3.20.5"
+    "@react-types/checkbox" "^3.10.1"
+    "@react-types/grid" "^3.3.5"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/i18n@3.12.4":
+  version "3.12.4"
+  resolved "https://registry.yarnpkg.com/@react-aria/i18n/-/i18n-3.12.4.tgz#4520ce48a1b6ebe4aa470d72eba300e65de01814"
+  integrity sha512-j9+UL3q0Ls8MhXV9gtnKlyozq4aM95YywXqnmJtzT1rYeBx7w28hooqrWkCYLfqr4OIryv1KUnPiCSLwC2OC7w==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@internationalized/message" "^3.1.6"
+    "@internationalized/number" "^3.6.0"
+    "@internationalized/string" "^3.2.5"
+    "@react-aria/ssr" "^3.9.7"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/i18n@^3.12.2":
-  version "3.12.2"
-  resolved "https://registry.npmjs.org/@react-aria/i18n/-/i18n-3.12.2.tgz"
-  integrity sha512-PvEyC6JWylTpe8dQEWqQwV6GiA+pbTxHQd//BxtMSapRW3JT9obObAnb/nFhj3HthkUvqHyj0oO1bfeN+mtD8A==
-  dependencies:
-    "@internationalized/date" "^3.5.5"
-    "@internationalized/message" "^3.1.4"
-    "@internationalized/number" "^3.5.3"
-    "@internationalized/string" "^3.2.3"
-    "@react-aria/ssr" "^3.9.5"
-    "@react-aria/utils" "^3.25.2"
-    "@react-types/shared" "^3.24.1"
+"@react-aria/i18n@^3.12.12", "@react-aria/i18n@^3.12.4":
+  version "3.12.12"
+  resolved "https://registry.yarnpkg.com/@react-aria/i18n/-/i18n-3.12.12.tgz#186eadf0c5dd3c38eb31c40b7c0191df07cef185"
+  integrity sha512-JN6p+Xc6Pu/qddGRoeYY6ARsrk2Oz7UiQc9nLEPOt3Ch+blJZKWwDjcpo/p6/wVZdD/2BgXS7El6q6+eMg7ibw==
+  dependencies:
+    "@internationalized/date" "^3.9.0"
+    "@internationalized/message" "^3.1.8"
+    "@internationalized/number" "^3.6.5"
+    "@internationalized/string" "^3.2.7"
+    "@react-aria/ssr" "^3.9.10"
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/interactions@3.21.3":
-  version "3.21.3"
-  resolved "https://registry.npmjs.org/@react-aria/interactions/-/interactions-3.21.3.tgz"
-  integrity sha512-BWIuf4qCs5FreDJ9AguawLVS0lV9UU+sK4CCnbCNNmYqOWY+1+gRXCsnOM32K+oMESBxilAjdHW5n1hsMqYMpA==
+"@react-aria/interactions@3.22.5":
+  version "3.22.5"
+  resolved "https://registry.yarnpkg.com/@react-aria/interactions/-/interactions-3.22.5.tgz#9cd8c93b8b6988f1d315d3efb450119d1432bbb8"
+  integrity sha512-kMwiAD9E0TQp+XNnOs13yVJghiy8ET8L0cbkeuTgNI96sOAp/63EJ1FSrDf17iD8sdjt41LafwX/dKXW9nCcLQ==
   dependencies:
-    "@react-aria/ssr" "^3.9.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/ssr" "^3.9.7"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/interactions@^3.21.3", "@react-aria/interactions@^3.22.2":
-  version "3.22.2"
-  resolved "https://registry.npmjs.org/@react-aria/interactions/-/interactions-3.22.2.tgz"
-  integrity sha512-xE/77fRVSlqHp2sfkrMeNLrqf2amF/RyuAS6T5oDJemRSgYM3UoxTbWjucPhfnoW7r32pFPHHgz4lbdX8xqD/g==
+"@react-aria/interactions@^3.22.5", "@react-aria/interactions@^3.25.0", "@react-aria/interactions@^3.25.5":
+  version "3.25.5"
+  resolved "https://registry.yarnpkg.com/@react-aria/interactions/-/interactions-3.25.5.tgz#f7f69467c899f9673460c3401fcaac08d2dcac7d"
+  integrity sha512-EweYHOEvMwef/wsiEqV73KurX/OqnmbzKQa2fLxdULbec5+yDj6wVGaRHIzM4NiijIDe+bldEl5DG05CAKOAHA==
   dependencies:
-    "@react-aria/ssr" "^3.9.5"
-    "@react-aria/utils" "^3.25.2"
-    "@react-types/shared" "^3.24.1"
+    "@react-aria/ssr" "^3.9.10"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/flags" "^3.1.2"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/label@3.7.8", "@react-aria/label@^3.7.8":
-  version "3.7.8"
-  resolved "https://registry.npmjs.org/@react-aria/label/-/label-3.7.8.tgz"
-  integrity sha512-MzgTm5+suPA3KX7Ug6ZBK2NX9cin/RFLsv1BdafJ6CZpmUSpWnGE/yQfYUB7csN7j31OsZrD3/P56eShYWAQfg==
+"@react-aria/label@3.7.13":
+  version "3.7.13"
+  resolved "https://registry.yarnpkg.com/@react-aria/label/-/label-3.7.13.tgz#9e7153a1ded878b5147d141effc3eb226f3c6c1f"
+  integrity sha512-brSAXZVTey5RG/Ex6mTrV/9IhGSQFU4Al34qmjEDho+Z2qT4oPwf8k7TRXWWqzOU0ugYxekYbsLd2zlN3XvWcg==
   dependencies:
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/link@3.7.1", "@react-aria/link@^3.7.1":
-  version "3.7.1"
-  resolved "https://registry.npmjs.org/@react-aria/link/-/link-3.7.1.tgz"
-  integrity sha512-a4IaV50P3fXc7DQvEIPYkJJv26JknFbRzFT5MJOMgtzuhyJoQdILEUK6XHYjcSSNCA7uLgzpojArVk5Hz3lCpw==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/link" "^3.5.5"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/label@^3.7.13", "@react-aria/label@^3.7.21":
+  version "3.7.21"
+  resolved "https://registry.yarnpkg.com/@react-aria/label/-/label-3.7.21.tgz#1deeb3886bc5110f76659137c3e21811fa1606d1"
+  integrity sha512-8G+059/GZahgQbrhMcCcVcrjm7W+pfzrypH/Qkjo7C1yqPGt6geeFwWeOIbiUZoI0HD9t9QvQPryd6m46UC7Tg==
+  dependencies:
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/listbox@3.12.1", "@react-aria/listbox@^3.12.1":
-  version "3.12.1"
-  resolved "https://registry.npmjs.org/@react-aria/listbox/-/listbox-3.12.1.tgz"
-  integrity sha512-7JiUp0NGykbv/HgSpmTY1wqhuf/RmjFxs1HZcNaTv8A+DlzgJYc7yQqFjP3ZA/z5RvJFuuIxggIYmgIFjaRYdA==
-  dependencies:
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/selection" "^3.18.1"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/list" "^3.10.5"
-    "@react-types/listbox" "^3.4.9"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/link@3.7.7":
+  version "3.7.7"
+  resolved "https://registry.yarnpkg.com/@react-aria/link/-/link-3.7.7.tgz#5879c75068b63d55353b3e96b4fda0fa8753d1ad"
+  integrity sha512-eVBRcHKhNSsATYWv5wRnZXRqPVcKAWWakyvfrYePIKpC3s4BaHZyTGYdefk8ZwZdEOuQZBqLMnjW80q1uhtkuA==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/link" "^3.5.9"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/live-announcer@^3.3.4":
-  version "3.3.4"
-  resolved "https://registry.npmjs.org/@react-aria/live-announcer/-/live-announcer-3.3.4.tgz"
-  integrity sha512-w8lxs35QrRrn6pBNzVfyGOeqWdxeVKf9U6bXIVwhq7rrTqRULL8jqy8RJIMfIs1s8G5FpwWYjyBOjl2g5Cu1iA==
+"@react-aria/link@^3.7.7":
+  version "3.8.5"
+  resolved "https://registry.yarnpkg.com/@react-aria/link/-/link-3.8.5.tgz#d8bade7e3f1012c77a1e147942310520796e7b0b"
+  integrity sha512-klhV4roPp5MLRXJv1N+7SXOj82vx4gzVpuwQa3vouA+YI1my46oNzwgtkLGSTvE9OvDqYzPDj2YxFYhMywrkuw==
   dependencies:
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/link" "^3.6.4"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/menu@3.14.1", "@react-aria/menu@^3.14.1":
-  version "3.14.1"
-  resolved "https://registry.npmjs.org/@react-aria/menu/-/menu-3.14.1.tgz"
-  integrity sha512-BYliRb38uAzq05UOFcD5XkjA5foQoXRbcH3ZufBsc4kvh79BcP1PMW6KsXKGJ7dC/PJWUwCui6QL1kUg8PqMHA==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/overlays" "^3.22.1"
-    "@react-aria/selection" "^3.18.1"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/menu" "^3.7.1"
-    "@react-stately/tree" "^3.8.1"
-    "@react-types/button" "^3.9.4"
-    "@react-types/menu" "^3.9.9"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/listbox@3.13.6":
+  version "3.13.6"
+  resolved "https://registry.yarnpkg.com/@react-aria/listbox/-/listbox-3.13.6.tgz#43ff24f4a6540a9952729833201460fa6ab081f7"
+  integrity sha512-6hEXEXIZVau9lgBZ4VVjFR3JnGU+fJaPmV3HP0UZ2ucUptfG0MZo24cn+ZQJsWiuaCfNFv5b8qribiv+BcO+Kg==
+  dependencies:
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/selection" "^3.21.0"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/list" "^3.11.1"
+    "@react-types/listbox" "^3.5.3"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/overlays@3.22.1", "@react-aria/overlays@^3.22.1":
-  version "3.22.1"
-  resolved "https://registry.npmjs.org/@react-aria/overlays/-/overlays-3.22.1.tgz"
-  integrity sha512-GHiFMWO4EQ6+j6b5QCnNoOYiyx1Gk8ZiwLzzglCI4q1NY5AG2EAmfU4Z1+Gtrf2S5Y0zHbumC7rs9GnPoGLUYg==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/ssr" "^3.9.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-aria/visually-hidden" "^3.8.12"
-    "@react-stately/overlays" "^3.6.7"
-    "@react-types/button" "^3.9.4"
-    "@react-types/overlays" "^3.8.7"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/listbox@^3.13.6":
+  version "3.14.8"
+  resolved "https://registry.yarnpkg.com/@react-aria/listbox/-/listbox-3.14.8.tgz#c46d79ba3f2d389a95cad4eba8bdbf0a53c4a0b6"
+  integrity sha512-uRgbuD9afFv0PDhQ/VXCmAwlYctIyKRzxztkqp1p/1yz/tn/hs+bG9kew9AI02PtlRO1mSc+32O+mMDXDer8hA==
+  dependencies:
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/label" "^3.7.21"
+    "@react-aria/selection" "^3.25.1"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/list" "^3.13.0"
+    "@react-types/listbox" "^3.7.3"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/progress@3.4.13":
-  version "3.4.13"
-  resolved "https://registry.npmjs.org/@react-aria/progress/-/progress-3.4.13.tgz"
-  integrity sha512-YBV9bOO5JzKvG8QCI0IAA00o6FczMgIDiK8Q9p5gKorFMatFUdRayxlbIPoYHMi+PguLil0jHgC7eOyaUcrZ0g==
-  dependencies:
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/progress" "^3.5.4"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/live-announcer@^3.4.1", "@react-aria/live-announcer@^3.4.4":
+  version "3.4.4"
+  resolved "https://registry.yarnpkg.com/@react-aria/live-announcer/-/live-announcer-3.4.4.tgz#0e6533940222208b323b71d56ac8e115b2121e6a"
+  integrity sha512-PTTBIjNRnrdJOIRTDGNifY2d//kA7GUAwRFJNOEwSNG4FW+Bq9awqLiflw0JkpyB0VNIwou6lqKPHZVLsGWOXA==
+  dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/radio@3.10.4":
-  version "3.10.4"
-  resolved "https://registry.npmjs.org/@react-aria/radio/-/radio-3.10.4.tgz"
-  integrity sha512-3fmoMcQtCpgjTwJReFjnvIE/C7zOZeCeWUn4JKDqz9s1ILYsC3Rk5zZ4q66tFn6v+IQnecrKT52wH6+hlVLwTA==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/form" "^3.0.5"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/radio" "^3.10.4"
-    "@react-types/radio" "^3.8.1"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/menu@3.16.0":
+  version "3.16.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/menu/-/menu-3.16.0.tgz#119e562806e9f8a39fd468ab790d788905c6df83"
+  integrity sha512-TNk+Vd3TbpBPUxEloAdHRTaRxf9JBK7YmkHYiq0Yj5Lc22KS0E2eTyhpPM9xJvEWN2TlC5TEvNfdyui2kYWFFQ==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/overlays" "^3.24.0"
+    "@react-aria/selection" "^3.21.0"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/menu" "^3.9.0"
+    "@react-stately/selection" "^3.18.0"
+    "@react-stately/tree" "^3.8.6"
+    "@react-types/button" "^3.10.1"
+    "@react-types/menu" "^3.9.13"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/selection@3.18.1", "@react-aria/selection@^3.18.1":
-  version "3.18.1"
-  resolved "https://registry.npmjs.org/@react-aria/selection/-/selection-3.18.1.tgz"
-  integrity sha512-GSqN2jX6lh7v+ldqhVjAXDcrWS3N4IsKXxO6L6Ygsye86Q9q9Mq9twWDWWu5IjHD6LoVZLUBCMO+ENGbOkyqeQ==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/selection" "^3.15.1"
-    "@react-types/shared" "^3.23.1"
+"@react-aria/menu@^3.16.0":
+  version "3.19.2"
+  resolved "https://registry.yarnpkg.com/@react-aria/menu/-/menu-3.19.2.tgz#a506d0cd4443f4ddfb89df341937fc77ed77b47d"
+  integrity sha512-WzDLW2MotL0L5/LEwc5oGgISf2ODuw4FnRpF0Zk+J4tKFfC88odvKz848ubBvThRXuXEvL0BHY+WqtM+j9fn3g==
+  dependencies:
+    "@react-aria/focus" "^3.21.1"
+    "@react-aria/i18n" "^3.12.12"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/overlays" "^3.29.1"
+    "@react-aria/selection" "^3.25.1"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/menu" "^3.9.7"
+    "@react-stately/selection" "^3.20.5"
+    "@react-stately/tree" "^3.9.2"
+    "@react-types/button" "^3.14.0"
+    "@react-types/menu" "^3.10.4"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/selection@^3.19.3":
-  version "3.19.3"
-  resolved "https://registry.npmjs.org/@react-aria/selection/-/selection-3.19.3.tgz"
-  integrity sha512-GYoObXCXlmGK08hp7Qfl6Bk0U+bKP5YDWSsX+MzNjJsqzQSLm4S06tRB9ACM7gIo9dDCvL4IRxdSYTJAlJc6bw==
-  dependencies:
-    "@react-aria/focus" "^3.18.2"
-    "@react-aria/i18n" "^3.12.2"
-    "@react-aria/interactions" "^3.22.2"
-    "@react-aria/utils" "^3.25.2"
-    "@react-stately/selection" "^3.16.2"
-    "@react-types/shared" "^3.24.1"
+"@react-aria/overlays@3.24.0":
+  version "3.24.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/overlays/-/overlays-3.24.0.tgz#7f97cd12506961abfab3ae653822cea05d1cacd3"
+  integrity sha512-0kAXBsMNTc/a3M07tK9Cdt/ea8CxTAEJ223g8YgqImlmoBBYAL7dl5G01IOj67TM64uWPTmZrOklBchHWgEm3A==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/ssr" "^3.9.7"
+    "@react-aria/utils" "^3.26.0"
+    "@react-aria/visually-hidden" "^3.8.18"
+    "@react-stately/overlays" "^3.6.12"
+    "@react-types/button" "^3.10.1"
+    "@react-types/overlays" "^3.8.11"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/slider@3.7.8":
-  version "3.7.8"
-  resolved "https://registry.npmjs.org/@react-aria/slider/-/slider-3.7.8.tgz"
-  integrity sha512-MYvPcM0K8jxEJJicUK2+WxUkBIM/mquBxOTOSSIL3CszA80nXIGVnLlCUnQV3LOUzpWtabbWaZokSPtGgOgQOw==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/slider" "^3.5.4"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/slider" "^3.7.3"
+"@react-aria/overlays@^3.24.0", "@react-aria/overlays@^3.29.1":
+  version "3.29.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/overlays/-/overlays-3.29.1.tgz#1a43a29709ad10971116b3d77de4e9b02107193d"
+  integrity sha512-Yz92XNPnbrTnxrvNrY/fXJ3iWaYNrj0q24ddvZNNKDcWak0S1/mQeUwNb+PwS2AryhFU5VQqKz5rNsM96TKmPQ==
+  dependencies:
+    "@react-aria/focus" "^3.21.1"
+    "@react-aria/i18n" "^3.12.12"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/ssr" "^3.9.10"
+    "@react-aria/utils" "^3.30.1"
+    "@react-aria/visually-hidden" "^3.8.27"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-types/button" "^3.14.0"
+    "@react-types/overlays" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/progress@3.4.18":
+  version "3.4.18"
+  resolved "https://registry.yarnpkg.com/@react-aria/progress/-/progress-3.4.18.tgz#948859ce1b0e13d935da7d4cbe6812d451472fe4"
+  integrity sha512-FOLgJ9t9i1u3oAAimybJG6r7/soNPBnJfWo4Yr6MmaUv90qVGa1h6kiuM5m9H/bm5JobAebhdfHit9lFlgsCmg==
+  dependencies:
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/progress" "^3.5.8"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/radio@3.10.10":
+  version "3.10.10"
+  resolved "https://registry.yarnpkg.com/@react-aria/radio/-/radio-3.10.10.tgz#18e2811fb3e72298414c880bd9405ea3f1d83f1f"
+  integrity sha512-NVdeOVrsrHgSfwL2jWCCXFsWZb+RMRZErj5vthHQW4nkHECGOzeX56VaLWTSvdoCPqi9wdIX8A6K9peeAIgxzA==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/form" "^3.0.11"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/radio" "^3.10.9"
+    "@react-types/radio" "^3.8.5"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/spinbutton@^3.6.5":
-  version "3.6.8"
-  resolved "https://registry.npmjs.org/@react-aria/spinbutton/-/spinbutton-3.6.8.tgz"
-  integrity sha512-OJMAYRIZ0WrWE+5tZsywrSg4t+aOwl6vl/e1+J64YcGMM+p+AKd61KGG5T0OgNSORXjoVIZOmj6wZ6Od4xfPMw==
+"@react-aria/selection@3.21.0":
+  version "3.21.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/selection/-/selection-3.21.0.tgz#c5660e73a38db5e3e1cdc722e408b4489f5f589a"
+  integrity sha512-52JJ6hlPcM+gt0VV3DBmz6Kj1YAJr13TfutrKfGWcK36LvNCBm1j0N+TDqbdnlp8Nue6w0+5FIwZq44XPYiBGg==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/selection" "^3.18.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/selection@^3.21.0", "@react-aria/selection@^3.25.1":
+  version "3.25.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/selection/-/selection-3.25.1.tgz#fdd7724bd251ee72082d3b62aa891ce8957d4e8a"
+  integrity sha512-HG+k3rDjuhnXPdVyv9CKiebee2XNkFYeYZBxEGlK3/pFVBzndnc8BXNVrXSgtCHLs2d090JBVKl1k912BPbj0Q==
+  dependencies:
+    "@react-aria/focus" "^3.21.1"
+    "@react-aria/i18n" "^3.12.12"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/selection" "^3.20.5"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/slider@3.7.14":
+  version "3.7.14"
+  resolved "https://registry.yarnpkg.com/@react-aria/slider/-/slider-3.7.14.tgz#25a362725d6cd71e9b86477362a36c847c73384e"
+  integrity sha512-7rOiKjLkEZ0j7mPMlwrqivc+K4OSfL14slaQp06GHRiJkhiWXh2/drPe15hgNq55HmBQBpA0umKMkJcqVgmXPA==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/slider" "^3.6.0"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/slider" "^3.7.7"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/spinbutton@^3.6.10":
+  version "3.6.18"
+  resolved "https://registry.yarnpkg.com/@react-aria/spinbutton/-/spinbutton-3.6.18.tgz#cabc24687fab7c311b97c490faeced41688e43e2"
+  integrity sha512-dnmh7sNsprhYTpqCJhcuc9QJ9C/IG/o9TkgW5a9qcd2vS+dzEgqAiJKIMbJFG9kiJymv2NwIPysF12IWix+J3A==
   dependencies:
-    "@react-aria/i18n" "^3.12.2"
-    "@react-aria/live-announcer" "^3.3.4"
-    "@react-aria/utils" "^3.25.2"
-    "@react-types/button" "^3.9.6"
-    "@react-types/shared" "^3.24.1"
+    "@react-aria/i18n" "^3.12.12"
+    "@react-aria/live-announcer" "^3.4.4"
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/button" "^3.14.0"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/ssr@3.9.4", "@react-aria/ssr@^3.9.4":
-  version "3.9.4"
-  resolved "https://registry.npmjs.org/@react-aria/ssr/-/ssr-3.9.4.tgz"
-  integrity sha512-4jmAigVq409qcJvQyuorsmBR4+9r3+JEC60wC+Y0MZV0HCtTmm8D9guYXlJMdx0SSkgj0hHAyFm/HvPNFofCoQ==
+"@react-aria/ssr@3.9.7":
+  version "3.9.7"
+  resolved "https://registry.yarnpkg.com/@react-aria/ssr/-/ssr-3.9.7.tgz#d89d129f7bbc5148657e6c952ac31c9353183770"
+  integrity sha512-GQygZaGlmYjmYM+tiNBA5C6acmiDWF52Nqd40bBp0Znk4M4hP+LTmI0lpI1BuKMw45T8RIhrAsICIfKwZvi2Gg==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/ssr@^3.9.5":
-  version "3.9.5"
-  resolved "https://registry.npmjs.org/@react-aria/ssr/-/ssr-3.9.5.tgz"
-  integrity sha512-xEwGKoysu+oXulibNUSkXf8itW0npHHTa6c4AyYeZIJyRoegeteYuFpZUBPtIDE8RfHdNsSmE1ssOkxRnwbkuQ==
+"@react-aria/ssr@^3.9.10", "@react-aria/ssr@^3.9.7":
+  version "3.9.10"
+  resolved "https://registry.yarnpkg.com/@react-aria/ssr/-/ssr-3.9.10.tgz#7fdc09e811944ce0df1d7e713de1449abd7435e6"
+  integrity sha512-hvTm77Pf+pMBhuBm760Li0BVIO38jv1IBws1xFm1NoL26PU+fe+FMW5+VZWyANR6nYL65joaJKZqOdTQMkO9IQ==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/switch@3.6.4":
-  version "3.6.4"
-  resolved "https://registry.npmjs.org/@react-aria/switch/-/switch-3.6.4.tgz"
-  integrity sha512-2nVqz4ZuJyof47IpGSt3oZRmp+EdS8wzeDYgf42WHQXrx4uEOk1mdLJ20+NnsYhj/2NHZsvXVrjBeKMjlMs+0w==
+"@react-aria/switch@3.6.10":
+  version "3.6.10"
+  resolved "https://registry.yarnpkg.com/@react-aria/switch/-/switch-3.6.10.tgz#8fa5729bc4e76ac3df51389a8996873142daedb8"
+  integrity sha512-FtaI9WaEP1tAmra1sYlAkYXg9x75P5UtgY8pSbe9+1WRyWbuE1QZT+RNCTi3IU4fZ7iJQmXH6+VaMyzPlSUagw==
   dependencies:
-    "@react-aria/toggle" "^3.10.4"
-    "@react-stately/toggle" "^3.7.4"
-    "@react-types/switch" "^3.5.3"
+    "@react-aria/toggle" "^3.10.10"
+    "@react-stately/toggle" "^3.8.0"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/switch" "^3.5.7"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/table@3.14.1":
-  version "3.14.1"
-  resolved "https://registry.npmjs.org/@react-aria/table/-/table-3.14.1.tgz"
-  integrity sha512-WaPgQe4zQF5OaluO5rm+Y2nEoFR63vsLd4BT4yjK1uaFhKhDY2Zk+1SCVQvBLLKS4WK9dhP05nrNzT0vp/ZPOw==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/grid" "^3.9.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/live-announcer" "^3.3.4"
-    "@react-aria/utils" "^3.24.1"
-    "@react-aria/visually-hidden" "^3.8.12"
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/flags" "^3.0.3"
-    "@react-stately/table" "^3.11.8"
-    "@react-stately/virtualizer" "^3.7.1"
-    "@react-types/checkbox" "^3.8.1"
-    "@react-types/grid" "^3.2.6"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/table" "^3.9.5"
+"@react-aria/table@3.16.0":
+  version "3.16.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/table/-/table-3.16.0.tgz#f0ffb51f52494e68f2c3b81fba44278fbdc48c28"
+  integrity sha512-9xF9S3CJ7XRiiK92hsIKxPedD0kgcQWwqTMtj3IBynpQ4vsnRiW3YNIzrn9C3apjknRZDTSta8O2QPYCUMmw2A==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/grid" "^3.11.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/live-announcer" "^3.4.1"
+    "@react-aria/utils" "^3.26.0"
+    "@react-aria/visually-hidden" "^3.8.18"
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/flags" "^3.0.5"
+    "@react-stately/table" "^3.13.0"
+    "@react-types/checkbox" "^3.9.0"
+    "@react-types/grid" "^3.2.10"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/table" "^3.10.3"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/tabs@3.9.1":
-  version "3.9.1"
-  resolved "https://registry.npmjs.org/@react-aria/tabs/-/tabs-3.9.1.tgz"
-  integrity sha512-S5v/0sRcOaSXaJYZuuy1ZVzYc7JD4sDyseG1133GjyuNjJOFHgoWMb+b4uxNIJbZxnLgynn/ZDBZSO+qU+fIxw==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/i18n" "^3.11.1"
-    "@react-aria/selection" "^3.18.1"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/tabs" "^3.6.6"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/tabs" "^3.3.7"
+"@react-aria/tabs@3.9.8":
+  version "3.9.8"
+  resolved "https://registry.yarnpkg.com/@react-aria/tabs/-/tabs-3.9.8.tgz#a0a647a4e2d1783125779473536419fd8caa9cfa"
+  integrity sha512-Nur/qRFBe+Zrt4xcCJV/ULXCS3Mlae+B89bp1Gl20vSDqk6uaPtGk+cS5k03eugOvas7AQapqNJsJgKd66TChw==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/selection" "^3.21.0"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/tabs" "^3.7.0"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/tabs" "^3.3.11"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/textfield@3.15.0":
+  version "3.15.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/textfield/-/textfield-3.15.0.tgz#17ebac0b73f084622aaf9697576b82155bed67cb"
+  integrity sha512-V5mg7y1OR6WXYHdhhm4FC7QyGc9TideVRDFij1SdOJrIo5IFB7lvwpOS0GmgwkVbtr71PTRMjZnNbrJUFU6VNA==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/form" "^3.0.11"
+    "@react-aria/label" "^3.7.13"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/textfield" "^3.10.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/textfield@3.14.5", "@react-aria/textfield@^3.14.5":
-  version "3.14.5"
-  resolved "https://registry.npmjs.org/@react-aria/textfield/-/textfield-3.14.5.tgz"
-  integrity sha512-hj7H+66BjB1iTKKaFXwSZBZg88YT+wZboEXZ0DNdQB2ytzoz/g045wBItUuNi4ZjXI3P+0AOZznVMYadWBAmiA==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/form" "^3.0.5"
-    "@react-aria/label" "^3.7.8"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/textfield" "^3.9.3"
+"@react-aria/textfield@^3.15.0":
+  version "3.18.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/textfield/-/textfield-3.18.1.tgz#73f40b30b2e5c09af9c2970473397035e315da72"
+  integrity sha512-8yCoirnQzbbQgdk5J5bqimEu3GhHZ9FXeMHez1OF+H+lpTwyTYQ9XgioEN3HKnVUBNEufG4lYkQMxTKJdq1v9g==
+  dependencies:
+    "@react-aria/form" "^3.1.1"
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/label" "^3.7.21"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
+    "@react-types/textfield" "^3.12.5"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/toggle@^3.10.4":
-  version "3.10.7"
-  resolved "https://registry.npmjs.org/@react-aria/toggle/-/toggle-3.10.7.tgz"
-  integrity sha512-/RJQU8QlPZXRElZ3Tt10F5K5STgUBUGPpfuFUGuwF3Kw3GpPxYsA1YAVjxXz2MMGwS0+y6+U/J1xIs1AF0Jwzg==
-  dependencies:
-    "@react-aria/focus" "^3.18.2"
-    "@react-aria/interactions" "^3.22.2"
-    "@react-aria/utils" "^3.25.2"
-    "@react-stately/toggle" "^3.7.7"
-    "@react-types/checkbox" "^3.8.3"
-    "@react-types/shared" "^3.24.1"
+"@react-aria/toggle@^3.10.10":
+  version "3.12.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/toggle/-/toggle-3.12.1.tgz#2a32b7e8e2cbc0a8494350ba4981000093af882e"
+  integrity sha512-XaFiRs1KEcIT6bTtVY/KTQxw4kinemj/UwXw2iJTu9XS43hhJ/9cvj8KzNGrKGqaxTpOYj62TnSHZbSiFViHDA==
+  dependencies:
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-stately/toggle" "^3.9.1"
+    "@react-types/checkbox" "^3.10.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/tooltip@3.7.4":
-  version "3.7.4"
-  resolved "https://registry.npmjs.org/@react-aria/tooltip/-/tooltip-3.7.4.tgz"
-  integrity sha512-+XRx4HlLYqWY3fB8Z60bQi/rbWDIGlFUtXYbtoa1J+EyRWfhpvsYImP8qeeNO/vgjUtDy1j9oKa8p6App9mBMQ==
-  dependencies:
-    "@react-aria/focus" "^3.17.1"
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-stately/tooltip" "^3.4.9"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/tooltip" "^3.4.9"
+"@react-aria/toolbar@3.0.0-beta.11":
+  version "3.0.0-beta.11"
+  resolved "https://registry.yarnpkg.com/@react-aria/toolbar/-/toolbar-3.0.0-beta.11.tgz#019c9ff2a47ad207504a95afeb0f863cf71a114b"
+  integrity sha512-LM3jTRFNDgoEpoL568WaiuqiVM7eynSQLJis1hV0vlVnhTd7M7kzt7zoOjzxVb5Uapz02uCp1Fsm4wQMz09qwQ==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/i18n" "^3.12.4"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/tooltip@3.7.10":
+  version "3.7.10"
+  resolved "https://registry.yarnpkg.com/@react-aria/tooltip/-/tooltip-3.7.10.tgz#d710532e80337e50be818dfbf2cc54d0a9b8c592"
+  integrity sha512-Udi3XOnrF/SYIz72jw9bgB74MG/yCOzF5pozHj2FH2HiJlchYv/b6rHByV/77IZemdlkmL/uugrv/7raPLSlnw==
+  dependencies:
+    "@react-aria/focus" "^3.19.0"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-stately/tooltip" "^3.5.0"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/tooltip" "^3.4.13"
     "@swc/helpers" "^0.5.0"
 
-"@react-aria/utils@3.24.1", "@react-aria/utils@^3.24.1":
-  version "3.24.1"
-  resolved "https://registry.npmjs.org/@react-aria/utils/-/utils-3.24.1.tgz"
-  integrity sha512-O3s9qhPMd6n42x9sKeJ3lhu5V1Tlnzhu6Yk8QOvDuXf7UGuUjXf9mzfHJt1dYzID4l9Fwm8toczBzPM9t0jc8Q==
+"@react-aria/utils@3.26.0":
+  version "3.26.0"
+  resolved "https://registry.yarnpkg.com/@react-aria/utils/-/utils-3.26.0.tgz#833cbfa33e75d15835b757791b3f754432d2f948"
+  integrity sha512-LkZouGSjjQ0rEqo4XJosS4L3YC/zzQkfRM3KoqK6fUOmUJ9t0jQ09WjiF+uOoG9u+p30AVg3TrZRUWmoTS+koQ==
   dependencies:
-    "@react-aria/ssr" "^3.9.4"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/ssr" "^3.9.7"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
     clsx "^2.0.0"
 
-"@react-aria/utils@^3.25.2":
-  version "3.25.2"
-  resolved "https://registry.npmjs.org/@react-aria/utils/-/utils-3.25.2.tgz"
-  integrity sha512-GdIvG8GBJJZygB4L2QJP1Gabyn2mjFsha73I2wSe+o4DYeGWoJiMZRM06PyTIxLH4S7Sn7eVDtsSBfkc2VY/NA==
+"@react-aria/utils@^3.26.0", "@react-aria/utils@^3.30.1":
+  version "3.30.1"
+  resolved "https://registry.yarnpkg.com/@react-aria/utils/-/utils-3.30.1.tgz#9eb704d4193674816e1e0eab758b12c2d69d7b0b"
+  integrity sha512-zETcbDd6Vf9GbLndO6RiWJadIZsBU2MMm23rBACXLmpRztkrIqPEb2RVdlLaq1+GklDx0Ii6PfveVjx+8S5U6A==
   dependencies:
-    "@react-aria/ssr" "^3.9.5"
-    "@react-stately/utils" "^3.10.3"
-    "@react-types/shared" "^3.24.1"
+    "@react-aria/ssr" "^3.9.10"
+    "@react-stately/flags" "^3.1.2"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
     clsx "^2.0.0"
 
-"@react-aria/visually-hidden@3.8.12", "@react-aria/visually-hidden@^3.8.12":
-  version "3.8.12"
-  resolved "https://registry.npmjs.org/@react-aria/visually-hidden/-/visually-hidden-3.8.12.tgz"
-  integrity sha512-Bawm+2Cmw3Xrlr7ARzl2RLtKh0lNUdJ0eNqzWcyx4c0VHUAWtThmH5l+HRqFUGzzutFZVo89SAy40BAbd0gjVw==
+"@react-aria/visually-hidden@3.8.18":
+  version "3.8.18"
+  resolved "https://registry.yarnpkg.com/@react-aria/visually-hidden/-/visually-hidden-3.8.18.tgz#13c168736944cbe19cd8917ec33a4e6f5f694119"
+  integrity sha512-l/0igp+uub/salP35SsNWq5mGmg3G5F5QMS1gDZ8p28n7CgjvzyiGhJbbca7Oxvaw1HRFzVl9ev+89I7moNnFQ==
   dependencies:
-    "@react-aria/interactions" "^3.21.3"
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/interactions" "^3.22.5"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-aria/visually-hidden@^3.8.18", "@react-aria/visually-hidden@^3.8.27":
+  version "3.8.27"
+  resolved "https://registry.yarnpkg.com/@react-aria/visually-hidden/-/visually-hidden-3.8.27.tgz#5e73b761b2ea932b30f818f88c9b290e6437f991"
+  integrity sha512-hD1DbL3WnjPnCdlQjwe19bQVRAGJyN0Aaup+s7NNtvZUn7AjoEH78jo8TE+L8yM7z/OZUQF26laCfYqeIwWn4g==
+  dependencies:
+    "@react-aria/interactions" "^3.25.5"
+    "@react-aria/utils" "^3.30.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
 "@react-hook/debounce@^3.0.0":
   version "3.0.0"
-  resolved "https://registry.npmjs.org/@react-hook/debounce/-/debounce-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/debounce/-/debounce-3.0.0.tgz#9eea8b5d81d4cb67cd72dd8657b3ff724afc7cad"
   integrity sha512-ir/kPrSfAzY12Gre0sOHkZ2rkEmM4fS5M5zFxCi4BnCeXh2nvx9Ujd+U4IGpKCuPA+EQD0pg1eK2NGLvfWejag==
   dependencies:
     "@react-hook/latest" "^1.0.2"
 
 "@react-hook/event@^1.2.1":
   version "1.2.6"
-  resolved "https://registry.npmjs.org/@react-hook/event/-/event-1.2.6.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/event/-/event-1.2.6.tgz#52f91578add934acc1203328ca09ab14fc7ee58e"
   integrity sha512-JUL5IluaOdn5w5Afpe/puPa1rj8X6udMlQ9dt4hvMuKmTrBS1Ya6sb4sVgvfe2eU4yDuOfAhik8xhbcCekbg9Q==
 
 "@react-hook/latest@^1.0.2":
   version "1.0.3"
-  resolved "https://registry.npmjs.org/@react-hook/latest/-/latest-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/latest/-/latest-1.0.3.tgz#c2d1d0b0af8b69ec6e2b3a2412ba0768ac82db80"
   integrity sha512-dy6duzl+JnAZcDbNTfmaP3xHiKtbXYOaz3G51MGVljh548Y8MWzTr+PHLOfvpypEVW9zwvl+VyKjbWKEVbV1Rg==
 
 "@react-hook/passive-layout-effect@^1.2.0":
   version "1.2.1"
-  resolved "https://registry.npmjs.org/@react-hook/passive-layout-effect/-/passive-layout-effect-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/passive-layout-effect/-/passive-layout-effect-1.2.1.tgz#c06dac2d011f36d61259aa1c6df4f0d5e28bc55e"
   integrity sha512-IwEphTD75liO8g+6taS+4oqz+nnroocNfWVHWz7j+N+ZO2vYrc6PV1q7GQhuahL0IOR7JccFTsFKQ/mb6iZWAg==
 
 "@react-hook/resize-observer@^1.2.1":
   version "1.2.6"
-  resolved "https://registry.npmjs.org/@react-hook/resize-observer/-/resize-observer-1.2.6.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/resize-observer/-/resize-observer-1.2.6.tgz#9a8cf4c5abb09becd60d1d65f6bf10eec211e291"
   integrity sha512-DlBXtLSW0DqYYTW3Ft1/GQFZlTdKY5VAFIC4+km6IK5NiPPDFchGbEJm1j6pSgMqPRHbUQgHJX7RaR76ic1LWA==
   dependencies:
     "@juggle/resize-observer" "^3.3.1"
@@ -4633,7 +4671,7 @@
 
 "@react-hook/size@^2.1.1":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/@react-hook/size/-/size-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/size/-/size-2.1.2.tgz#87ed634ffb200f65d3e823501e5559aa3d584451"
   integrity sha512-BmE5asyRDxSuQ9p14FUKJ0iBRgV9cROjqNG9jT/EjCM+xHha1HVqbPoT+14FQg1K7xIydabClCibUY4+1tw/iw==
   dependencies:
     "@react-hook/passive-layout-effect" "^1.2.0"
@@ -4641,545 +4679,773 @@
 
 "@react-hook/throttle@^2.2.0":
   version "2.2.0"
-  resolved "https://registry.npmjs.org/@react-hook/throttle/-/throttle-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@react-hook/throttle/-/throttle-2.2.0.tgz#d0402714a06e1ba0bc1da1fdf5c3c5cd0e08d45a"
   integrity sha512-LJ5eg+yMV8lXtqK3lR+OtOZ2WH/EfWvuiEEu0M3bhR7dZRfTyEJKxH1oK9uyBxiXPtWXiQggWbZirMCXam51tg==
   dependencies:
-    "@react-hook/latest" "^1.0.2"
+    "@react-hook/latest" "^1.0.2"
+
+"@react-hook/window-size@^3.0.7":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@react-hook/window-size/-/window-size-3.1.1.tgz#1a564902cfe212e8c27ffc2e74adcaa18a7d65b3"
+  integrity sha512-yWnVS5LKnOUIrEsI44oz3bIIUYqflamPL27n+k/PC//PsX/YeWBky09oPeAoc9As6jSH16Wgo8plI+ECZaHk3g==
+  dependencies:
+    "@react-hook/debounce" "^3.0.0"
+    "@react-hook/event" "^1.2.1"
+    "@react-hook/throttle" "^2.2.0"
+
+"@react-stately/calendar@3.6.0":
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/calendar/-/calendar-3.6.0.tgz#c770890160c33826206a015eb7da32fe8ece81d5"
+  integrity sha512-GqUtOtGnwWjtNrJud8nY/ywI4VBP5byToNVRTnxbMl+gYO1Qe/uc5NG7zjwMxhb2kqSBHZFdkF0DXVqG2Ul+BA==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/calendar" "^3.5.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/calendar@^3.6.0":
+  version "3.8.4"
+  resolved "https://registry.yarnpkg.com/@react-stately/calendar/-/calendar-3.8.4.tgz#c64b29010dc0aba78592cb9a85a09b3ee5a49e17"
+  integrity sha512-q9mq0ydOLS5vJoHLnYfSCS/vppfjbg0XHJlAoPR+w+WpYZF4wPP453SrlX9T1DbxCEYFTpcxcMk/O8SDW3miAw==
+  dependencies:
+    "@internationalized/date" "^3.9.0"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/calendar" "^3.7.4"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/checkbox@3.6.10":
+  version "3.6.10"
+  resolved "https://registry.yarnpkg.com/@react-stately/checkbox/-/checkbox-3.6.10.tgz#69b619fdfcf1e15d2d93392e13289a36d85a8a6c"
+  integrity sha512-LHm7i4YI8A/RdgWAuADrnSAYIaYYpQeZqsp1a03Og0pJHAlZL0ymN3y2IFwbZueY0rnfM+yF+kWNXjJqbKrFEQ==
+  dependencies:
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/checkbox" "^3.9.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/checkbox@^3.6.10":
+  version "3.7.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/checkbox/-/checkbox-3.7.1.tgz#7a0a42f94705acc21ca702ad14b067a69cef4d47"
+  integrity sha512-ezfKRJsDuRCLtNoNOi9JXCp6PjffZWLZ/vENW/gbRDL8i46RKC/HpfJrJhvTPmsLYazxPC99Me9iq3v0VoNCsw==
+  dependencies:
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/checkbox" "^3.10.1"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/collections@3.12.0":
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/collections/-/collections-3.12.0.tgz#6240d3517d0d86f7d9eb4997108fb432d569e8d7"
+  integrity sha512-MfR9hwCxe5oXv4qrLUnjidwM50U35EFmInUeFf8i9mskYwWlRYS0O1/9PZ0oF1M0cKambaRHKEy98jczgb9ycA==
+  dependencies:
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
 
-"@react-hook/window-size@^3.0.7":
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/@react-hook/window-size/-/window-size-3.1.1.tgz"
-  integrity sha512-yWnVS5LKnOUIrEsI44oz3bIIUYqflamPL27n+k/PC//PsX/YeWBky09oPeAoc9As6jSH16Wgo8plI+ECZaHk3g==
+"@react-stately/collections@^3.12.0", "@react-stately/collections@^3.12.7":
+  version "3.12.7"
+  resolved "https://registry.yarnpkg.com/@react-stately/collections/-/collections-3.12.7.tgz#6e01a8988696e62301690eb7cd1497568236f222"
+  integrity sha512-0kQc0mI986GOCQHvRy4L0JQiotIK/KmEhR9Mu/6V0GoSdqg5QeUe4kyoNWj3bl03uQXme80v0L2jLHt+fOHHjA==
   dependencies:
-    "@react-hook/debounce" "^3.0.0"
-    "@react-hook/event" "^1.2.1"
-    "@react-hook/throttle" "^2.2.0"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/combobox@3.10.1":
+  version "3.10.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/combobox/-/combobox-3.10.1.tgz#ebae28c5341d06d69cc8e50055fa816dee19522b"
+  integrity sha512-Rso+H+ZEDGFAhpKWbnRxRR/r7YNmYVtt+Rn0eNDNIUp3bYaxIBCdCySyAtALs4I8RZXZQ9zoUznP7YeVwG3cLg==
+  dependencies:
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/list" "^3.11.1"
+    "@react-stately/overlays" "^3.6.12"
+    "@react-stately/select" "^3.6.9"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/combobox" "^3.13.1"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/combobox@^3.10.1":
+  version "3.11.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/combobox/-/combobox-3.11.1.tgz#8bc48b9e9725db3382c6d1afa3946394fc097a20"
+  integrity sha512-ZZh+SaAmddoY+MeJr470oDYA0nGaJm4xoHCBapaBA0JNakGC/wTzF/IRz3tKQT2VYK4rumr1BJLZQydGp7zzeg==
+  dependencies:
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/list" "^3.13.0"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-stately/select" "^3.7.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/combobox" "^3.13.8"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/datepicker@3.11.0":
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/datepicker/-/datepicker-3.11.0.tgz#5f4daff449f756dc40b4201ae337dd4a3f29facc"
+  integrity sha512-d9MJF34A0VrhL5y5S8mAISA8uwfNCQKmR2k4KoQJm3De1J8SQeNzSjLviAwh1faDow6FXGlA6tVbTrHyDcBgBg==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@internationalized/string" "^3.2.5"
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/overlays" "^3.6.12"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/datepicker" "^3.9.0"
+    "@react-types/shared" "^3.26.0"
+    "@swc/helpers" "^0.5.0"
 
-"@react-stately/calendar@3.5.1", "@react-stately/calendar@^3.5.1":
-  version "3.5.1"
-  resolved "https://registry.npmjs.org/@react-stately/calendar/-/calendar-3.5.1.tgz"
-  integrity sha512-7l7QhqGUJ5AzWHfvZzbTe3J4t72Ht5BmhW4hlVI7flQXtfrmYkVtl3ZdytEZkkHmWGYZRW9b4IQTQGZxhtlElA==
+"@react-stately/datepicker@^3.11.0":
+  version "3.15.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/datepicker/-/datepicker-3.15.1.tgz#ca18ba954c1c1e083fb31a00c3ea76f1ed7bafab"
+  integrity sha512-t64iYPms9y+MEQgOAu0XUHccbEXWVUWBHJWnYvAmILCHY8ZAOeSPAT1g4v9nzyiApcflSNXgpsvbs9BBEsrWww==
+  dependencies:
+    "@internationalized/date" "^3.9.0"
+    "@internationalized/string" "^3.2.7"
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/datepicker" "^3.13.1"
+    "@react-types/shared" "^3.32.0"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/flags@^3.0.5", "@react-stately/flags@^3.1.2":
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/@react-stately/flags/-/flags-3.1.2.tgz#5c8e5ae416d37d37e2e583d2fcb3a046293504f2"
+  integrity sha512-2HjFcZx1MyQXoPqcBGALwWWmgFVUk2TuKVIQxCbRq7fPyWXIl6VHcakCLurdtYC2Iks7zizvz0Idv48MQ38DWg==
   dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/calendar" "^3.4.6"
-    "@react-types/shared" "^3.23.1"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/checkbox@3.6.5", "@react-stately/checkbox@^3.6.5":
-  version "3.6.5"
-  resolved "https://registry.npmjs.org/@react-stately/checkbox/-/checkbox-3.6.5.tgz"
-  integrity sha512-IXV3f9k+LtmfQLE+DKIN41Q5QB/YBLDCB1YVx5PEdRp52S9+EACD5683rjVm8NVRDwjMi2SP6RnFRk7fVb5Azg==
+"@react-stately/form@3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/form/-/form-3.1.0.tgz#7fdb4ca153be18e7516a02e507ada393ad38945d"
+  integrity sha512-E2wxNQ0QaTyDHD0nJFtTSnEH9A3bpJurwxhS4vgcUmESHgjFEMLlC9irUSZKgvOgb42GAq+fHoWBsgKeTp9Big==
   dependencies:
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/checkbox" "^3.8.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/collections@3.10.7", "@react-stately/collections@^3.10.7":
-  version "3.10.7"
-  resolved "https://registry.npmjs.org/@react-stately/collections/-/collections-3.10.7.tgz"
-  integrity sha512-KRo5O2MWVL8n3aiqb+XR3vP6akmHLhLWYZEmPKjIv0ghQaEebBTrN3wiEjtd6dzllv0QqcWvDLM1LntNfJ2TsA==
+"@react-stately/form@^3.1.0", "@react-stately/form@^3.2.1":
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/form/-/form-3.2.1.tgz#5c8caad11ea952f0fa1835ae31da67c208e96a54"
+  integrity sha512-btgOPXkwvd6fdWKoepy5Ue43o2932OSkQxozsR7US1ffFLcQc3SNlADHaRChIXSG8ffPo9t0/Sl4eRzaKu3RgQ==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/collections@^3.10.9":
-  version "3.10.9"
-  resolved "https://registry.npmjs.org/@react-stately/collections/-/collections-3.10.9.tgz"
-  integrity sha512-plyrng6hOQMG8LrjArMA6ts/DgWyXln3g90/hFNbqe/hdVYF53sDVsj8Jb+5LtoYTpiAlV6eOvy1XR0vPZUf8w==
+"@react-stately/grid@^3.10.0", "@react-stately/grid@^3.11.5":
+  version "3.11.5"
+  resolved "https://registry.yarnpkg.com/@react-stately/grid/-/grid-3.11.5.tgz#1e523cee3048cee0a812050fd5383c4eb3e0c0e3"
+  integrity sha512-4cNjGYaNkcVS2wZoNHUrMRICBpkHStYw57EVemP7MjiWEVu53kzPgR1Iwmti2WFCpi1Lwu0qWNeCfzKpXW4BTg==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/selection" "^3.20.5"
+    "@react-types/grid" "^3.3.5"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/combobox@3.8.4", "@react-stately/combobox@^3.8.4":
-  version "3.8.4"
-  resolved "https://registry.npmjs.org/@react-stately/combobox/-/combobox-3.8.4.tgz"
-  integrity sha512-iLVGvKRRz0TeJXZhZyK783hveHpYA6xovOSdzSD+WGYpiPXo1QrcrNoH3AE0Z2sHtorU+8nc0j58vh5PB+m2AA==
-  dependencies:
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/list" "^3.10.5"
-    "@react-stately/overlays" "^3.6.7"
-    "@react-stately/select" "^3.6.4"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/combobox" "^3.11.1"
-    "@react-types/shared" "^3.23.1"
+"@react-stately/list@3.11.1":
+  version "3.11.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/list/-/list-3.11.1.tgz#d1493e5b9c5cac6cafb3cb3a6edb852bf3cb208f"
+  integrity sha512-UCOpIvqBOjwLtk7zVTYWuKU1m1Oe61Q5lNar/GwHaV1nAiSQ8/yYlhr40NkBEs9X3plEfsV28UIpzOrYnu1tPg==
+  dependencies:
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/selection" "^3.18.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/datepicker@3.9.4", "@react-stately/datepicker@^3.9.4":
-  version "3.9.4"
-  resolved "https://registry.npmjs.org/@react-stately/datepicker/-/datepicker-3.9.4.tgz"
-  integrity sha512-yBdX01jn6gq4NIVvHIqdjBUPo+WN8Bujc4OnPw+ZnfA4jI0eIgq04pfZ84cp1LVXW0IB0VaCu1AlQ/kvtZjfGA==
-  dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@internationalized/string" "^3.2.3"
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/overlays" "^3.6.7"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/datepicker" "^3.7.4"
-    "@react-types/shared" "^3.23.1"
+"@react-stately/list@^3.11.1", "@react-stately/list@^3.13.0":
+  version "3.13.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/list/-/list-3.13.0.tgz#0429c212cbb674d585ec68a3d440300f60021c73"
+  integrity sha512-Panv8TmaY8lAl3R7CRhyUadhf2yid6VKsRDBCBB1FHQOOeL7lqIraz/oskvpabZincuaIUWqQhqYslC4a6dvuA==
+  dependencies:
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/selection" "^3.20.5"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/flags@^3.0.3":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@react-stately/flags/-/flags-3.0.3.tgz"
-  integrity sha512-/ha7XFA0RZTQsbzSPwu3KkbNMgbvuM0GuMTYLTBWpgBrovBNTM+QqI/PfZTdHg8PwCYF4H5Y8gjdSpdulCvJFw==
+"@react-stately/menu@3.9.0":
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/menu/-/menu-3.9.0.tgz#b1e55996405f4e43ff844cbd325df9842914efe4"
+  integrity sha512-++sm0fzZeUs9GvtRbj5RwrP+KL9KPANp9f4SvtI3s+MP+Y/X3X7LNNePeeccGeyikB5fzMsuyvd82bRRW9IhDQ==
   dependencies:
+    "@react-stately/overlays" "^3.6.12"
+    "@react-types/menu" "^3.9.13"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/form@3.0.3", "@react-stately/form@^3.0.3":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@react-stately/form/-/form-3.0.3.tgz"
-  integrity sha512-92YYBvlHEWUGUpXgIaQ48J50jU9XrxfjYIN8BTvvhBHdD63oWgm8DzQnyT/NIAMzdLnhkg7vP+fjG8LjHeyIAg==
+"@react-stately/menu@^3.9.0", "@react-stately/menu@^3.9.7":
+  version "3.9.7"
+  resolved "https://registry.yarnpkg.com/@react-stately/menu/-/menu-3.9.7.tgz#f7bab58d8ced5a2e4d960efbaf18dd27b13ac510"
+  integrity sha512-mfz1YoCgtje61AGxVdQaAFLlOXt9vV5dd1lQljYUPRafA/qu5Ursz4fNVlcavWW9GscebzFQErx+y0oSP7EUtQ==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-types/menu" "^3.10.4"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/form@^3.0.5":
-  version "3.0.5"
-  resolved "https://registry.npmjs.org/@react-stately/form/-/form-3.0.5.tgz"
-  integrity sha512-J3plwJ63HQz109OdmaTqTA8Qhvl3gcYYK7DtgKyNP6mc/Me2Q4tl2avkWoA+22NRuv5m+J8TpBk4AVHUEOwqeQ==
+"@react-stately/overlays@3.6.12":
+  version "3.6.12"
+  resolved "https://registry.yarnpkg.com/@react-stately/overlays/-/overlays-3.6.12.tgz#beb594a0e140dbd7957bfa181006854f91480bea"
+  integrity sha512-QinvZhwZgj8obUyPIcyURSCjTZlqZYRRCS60TF8jH8ZpT0tEAuDb3wvhhSXuYA3Xo9EHLwvLjEf3tQKKdAQArw==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/overlays" "^3.8.11"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/grid@^3.8.7", "@react-stately/grid@^3.9.2":
-  version "3.9.2"
-  resolved "https://registry.npmjs.org/@react-stately/grid/-/grid-3.9.2.tgz"
-  integrity sha512-2gK//sqAqg2Xaq6UITTFQwFUJnBRgcW+cKBVbFt+F8d152xB6UwwTS/K79E5PUkOotwqZgTEpkrSFs/aVxCLpw==
+"@react-stately/overlays@^3.6.12", "@react-stately/overlays@^3.6.19":
+  version "3.6.19"
+  resolved "https://registry.yarnpkg.com/@react-stately/overlays/-/overlays-3.6.19.tgz#8c5fbe20cc56c594a13ad19ae1a1ef424e67c954"
+  integrity sha512-swZXfDvxTYd7tKEpijEHBFFaEmbbnCvEhGlmrAz4K72cuRR9O5u+lcla8y1veGBbBSzrIdKNdBoIIJ+qQH+1TQ==
   dependencies:
-    "@react-stately/collections" "^3.10.9"
-    "@react-stately/selection" "^3.16.2"
-    "@react-types/grid" "^3.2.8"
-    "@react-types/shared" "^3.24.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/overlays" "^3.9.1"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/list@3.10.5", "@react-stately/list@^3.10.5":
-  version "3.10.5"
-  resolved "https://registry.npmjs.org/@react-stately/list/-/list-3.10.5.tgz"
-  integrity sha512-fV9plO+6QDHiewsYIhboxcDhF17GO95xepC5ki0bKXo44gr14g/LSo/BMmsaMnV+1BuGdBunB05bO4QOIaigXA==
+"@react-stately/radio@3.10.9":
+  version "3.10.9"
+  resolved "https://registry.yarnpkg.com/@react-stately/radio/-/radio-3.10.9.tgz#cf74b8f47cbef56836424d2e7d06c01fe9d9ea05"
+  integrity sha512-kUQ7VdqFke8SDRCatw2jW3rgzMWbvw+n2imN2THETynI47NmNLzNP11dlGO2OllRtTrsLhmBNlYHa3W62pFpAw==
   dependencies:
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/selection" "^3.15.1"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-stately/form" "^3.1.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/radio" "^3.8.5"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/list@^3.10.8":
-  version "3.10.8"
-  resolved "https://registry.npmjs.org/@react-stately/list/-/list-3.10.8.tgz"
-  integrity sha512-rHCiPLXd+Ry3ztR9DkLA5FPQeH4Zd4/oJAEDWJ77W3oBBOdiMp3ZdHDLP7KBRh17XGNLO/QruYoHWAQTPiMF4g==
+"@react-stately/radio@^3.10.9":
+  version "3.11.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/radio/-/radio-3.11.1.tgz#a4c2eb9296699fed7040b97ccdf088d3d6355f66"
+  integrity sha512-ld9KWztI64gssg7zSZi9li21sG85Exb+wFPXtCim1TtpnEpmRtB05pXDDS3xkkIU/qOL4eMEnnLO7xlNm0CRIA==
   dependencies:
-    "@react-stately/collections" "^3.10.9"
-    "@react-stately/selection" "^3.16.2"
-    "@react-stately/utils" "^3.10.3"
-    "@react-types/shared" "^3.24.1"
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/radio" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/menu@3.7.1", "@react-stately/menu@^3.7.1":
+"@react-stately/select@^3.6.9", "@react-stately/select@^3.7.1":
   version "3.7.1"
-  resolved "https://registry.npmjs.org/@react-stately/menu/-/menu-3.7.1.tgz"
-  integrity sha512-mX1w9HHzt+xal1WIT2xGrTQsoLvDwuB2R1Er1MBABs//MsJzccycatcgV/J/28m6tO5M9iuFQQvLV+i1dCtodg==
-  dependencies:
-    "@react-stately/overlays" "^3.6.7"
-    "@react-types/menu" "^3.9.9"
-    "@react-types/shared" "^3.23.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/select/-/select-3.7.1.tgz#2bb1a52f345b301a3073aa62dba4934697b5bf0c"
+  integrity sha512-vZt4j9yVyOTWWJoP9plXmYaPZH2uMxbjcGMDbiShwsFiK8C2m9b3Cvy44TZehfzCWzpMVR/DYxEYuonEIGA82Q==
+  dependencies:
+    "@react-stately/form" "^3.2.1"
+    "@react-stately/list" "^3.13.0"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-types/select" "^3.10.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/overlays@3.6.7", "@react-stately/overlays@^3.6.7":
-  version "3.6.7"
-  resolved "https://registry.npmjs.org/@react-stately/overlays/-/overlays-3.6.7.tgz"
-  integrity sha512-6zp8v/iNUm6YQap0loaFx6PlvN8C0DgWHNlrlzMtMmNuvjhjR0wYXVaTfNoUZBWj25tlDM81ukXOjpRXg9rLrw==
+"@react-stately/selection@^3.18.0", "@react-stately/selection@^3.20.5":
+  version "3.20.5"
+  resolved "https://registry.yarnpkg.com/@react-stately/selection/-/selection-3.20.5.tgz#11f4fae7b6038ca167a9bd1513a57c353d308bbd"
+  integrity sha512-YezWUNEn2pz5mQlbhmngiX9HqQsruLSXlkrAzB1DD6aliGrUvPKufTTGCixOaB8KVeCamdiFAgx1WomNplzdQA==
   dependencies:
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/overlays" "^3.8.7"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/overlays@^3.6.10":
-  version "3.6.10"
-  resolved "https://registry.npmjs.org/@react-stately/overlays/-/overlays-3.6.10.tgz"
-  integrity sha512-XxZ2qScT5JPwGk9qiVJE4dtVh3AXTcYwGRA5RsHzC26oyVVsegPqY2PmNJGblAh6Q57VyodoVUyebE0Eo5CzRw==
+"@react-stately/slider@3.6.0":
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/slider/-/slider-3.6.0.tgz#20439e08915725c4f6ba2285a561ae92fe59d997"
+  integrity sha512-w5vJxVh267pmD1X+Ppd9S3ZzV1hcg0cV8q5P4Egr160b9WMcWlUspZPtsthwUlN7qQe/C8y5IAhtde4s29eNag==
   dependencies:
-    "@react-stately/utils" "^3.10.3"
-    "@react-types/overlays" "^3.8.9"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/slider" "^3.7.7"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/radio@3.10.4", "@react-stately/radio@^3.10.4":
-  version "3.10.4"
-  resolved "https://registry.npmjs.org/@react-stately/radio/-/radio-3.10.4.tgz"
-  integrity sha512-kCIc7tAl4L7Hu4Wt9l2jaa+MzYmAJm0qmC8G8yPMbExpWbLRu6J8Un80GZu+JxvzgDlqDyrVvyv9zFifwH/NkQ==
+"@react-stately/slider@^3.6.0":
+  version "3.7.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/slider/-/slider-3.7.1.tgz#14f7b995eec95c3b25baa270480547afd4d62d51"
+  integrity sha512-J+G18m1bZBCNQSXhxGd4GNGDUVonv4Sg7fZL+uLhXUy1x71xeJfFdKaviVvZcggtl0/q5InW41PXho7EouMDEg==
   dependencies:
-    "@react-stately/form" "^3.0.3"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/radio" "^3.8.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
+    "@react-types/slider" "^3.8.1"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/select@^3.6.4":
-  version "3.6.7"
-  resolved "https://registry.npmjs.org/@react-stately/select/-/select-3.6.7.tgz"
-  integrity sha512-hCUIddw0mPxVy1OH6jhyaDwgNea9wESjf+MYdnnTG/abRB+OZv/dWScd87OjzVsHTHWcw7CN4ZzlJoXm0FJbKQ==
-  dependencies:
-    "@react-stately/form" "^3.0.5"
-    "@react-stately/list" "^3.10.8"
-    "@react-stately/overlays" "^3.6.10"
-    "@react-types/select" "^3.9.6"
-    "@react-types/shared" "^3.24.1"
+"@react-stately/table@3.13.0":
+  version "3.13.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/table/-/table-3.13.0.tgz#8465030f568b5ee779623d99b2ef22940a99a6cd"
+  integrity sha512-mRbNYrwQIE7xzVs09Lk3kPteEVFVyOc20vA8ph6EP54PiUf/RllJpxZe/WUYLf4eom9lUkRYej5sffuUBpxjCA==
+  dependencies:
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/flags" "^3.0.5"
+    "@react-stately/grid" "^3.10.0"
+    "@react-stately/selection" "^3.18.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/grid" "^3.2.10"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/table" "^3.10.3"
+    "@swc/helpers" "^0.5.0"
+
+"@react-stately/table@^3.13.0":
+  version "3.15.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/table/-/table-3.15.0.tgz#eb84fcf530140fb2e269c22cef21bd3c3b1da1e2"
+  integrity sha512-KbvkrVF3sb25IPwyte9JcG5/4J7TgjHSsw7D61d/T/oUFMYPYVeolW9/2y+6u48WPkDJE8HJsurme+HbTN0FQA==
+  dependencies:
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/flags" "^3.1.2"
+    "@react-stately/grid" "^3.11.5"
+    "@react-stately/selection" "^3.20.5"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/grid" "^3.3.5"
+    "@react-types/shared" "^3.32.0"
+    "@react-types/table" "^3.13.3"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/selection@^3.15.1", "@react-stately/selection@^3.16.2":
-  version "3.16.2"
-  resolved "https://registry.npmjs.org/@react-stately/selection/-/selection-3.16.2.tgz"
-  integrity sha512-C4eSKw7BIZHJLPzwqGqCnsyFHiUIEyryVQZTJDt6d0wYBOHU6k1pW+Q4VhrZuzSv+IMiI2RkiXeJKc55f0ZXrg==
+"@react-stately/tabs@3.7.0":
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/tabs/-/tabs-3.7.0.tgz#f849b334c5e7d39a37c2e9ffa3114531bf8ce6e4"
+  integrity sha512-ox4hTkfZCoR4Oyr3Op3rBlWNq2Wxie04vhEYpTZQ2hobR3l4fYaOkd7CPClILktJ3TC104j8wcb0knWxIBRx9w==
   dependencies:
-    "@react-stately/collections" "^3.10.9"
-    "@react-stately/utils" "^3.10.3"
-    "@react-types/shared" "^3.24.1"
+    "@react-stately/list" "^3.11.1"
+    "@react-types/shared" "^3.26.0"
+    "@react-types/tabs" "^3.3.11"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/slider@3.5.4", "@react-stately/slider@^3.5.4":
-  version "3.5.4"
-  resolved "https://registry.npmjs.org/@react-stately/slider/-/slider-3.5.4.tgz"
-  integrity sha512-Jsf7K17dr93lkNKL9ij8HUcoM1sPbq8TvmibD6DhrK9If2lje+OOL8y4n4qreUnfMT56HCAeS9wCO3fg3eMyrw==
+"@react-stately/tabs@^3.7.0":
+  version "3.8.5"
+  resolved "https://registry.yarnpkg.com/@react-stately/tabs/-/tabs-3.8.5.tgz#2447fd3aba1ea05ce9536f3626f9bdafb97bfd67"
+  integrity sha512-gdeI+NUH3hfqrxkJQSZkt+Zw4G2DrYJRloq/SGxu/9Bu5QD/U0psU2uqxQNtavW5qTChFK+D30rCPXpKlslWAA==
   dependencies:
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/slider" "^3.7.3"
+    "@react-stately/list" "^3.13.0"
+    "@react-types/shared" "^3.32.0"
+    "@react-types/tabs" "^3.3.18"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/table@3.11.8", "@react-stately/table@^3.11.8":
-  version "3.11.8"
-  resolved "https://registry.npmjs.org/@react-stately/table/-/table-3.11.8.tgz"
-  integrity sha512-EdyRW3lT1/kAVDp5FkEIi1BQ7tvmD2YgniGdLuW/l9LADo0T+oxZqruv60qpUS6sQap+59Riaxl91ClDxrJnpg==
-  dependencies:
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/flags" "^3.0.3"
-    "@react-stately/grid" "^3.8.7"
-    "@react-stately/selection" "^3.15.1"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/grid" "^3.2.6"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/table" "^3.9.5"
+"@react-stately/toggle@3.8.0":
+  version "3.8.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/toggle/-/toggle-3.8.0.tgz#39a3e45989f56e236809d8fe69c160cc88a616f5"
+  integrity sha512-pyt/k/J8BwE/2g6LL6Z6sMSWRx9HEJB83Sm/MtovXnI66sxJ2EfQ1OaXB7Su5PEL9OMdoQF6Mb+N1RcW3zAoPw==
+  dependencies:
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/checkbox" "^3.9.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/tabs@3.6.6", "@react-stately/tabs@^3.6.6":
-  version "3.6.6"
-  resolved "https://registry.npmjs.org/@react-stately/tabs/-/tabs-3.6.6.tgz"
-  integrity sha512-sOLxorH2uqjAA+v1ppkMCc2YyjgqvSGeBDgtR/lyPSDd4CVMoTExszROX2dqG0c8il9RQvzFuufUtQWMY6PgSA==
+"@react-stately/toggle@^3.8.0", "@react-stately/toggle@^3.9.1":
+  version "3.9.1"
+  resolved "https://registry.yarnpkg.com/@react-stately/toggle/-/toggle-3.9.1.tgz#ae706abfebce11989ea370cdf54e821b70b6672f"
+  integrity sha512-L6yUdE8xZfQhw4aEFZduF8u4v0VrpYrwWEA4Tu/4qwGIPukH0wd2W21Zpw+vAiLOaDKnxel1nXX68MWnm4QXpw==
   dependencies:
-    "@react-stately/list" "^3.10.5"
-    "@react-types/shared" "^3.23.1"
-    "@react-types/tabs" "^3.3.7"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/checkbox" "^3.10.1"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/toggle@3.7.4", "@react-stately/toggle@^3.7.4":
-  version "3.7.4"
-  resolved "https://registry.npmjs.org/@react-stately/toggle/-/toggle-3.7.4.tgz"
-  integrity sha512-CoYFe9WrhLkDP4HGDpJYQKwfiYCRBAeoBQHv+JWl5eyK61S8xSwoHsveYuEZ3bowx71zyCnNAqWRrmNOxJ4CKA==
+"@react-stately/tooltip@3.5.0":
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/tooltip/-/tooltip-3.5.0.tgz#1016952eb4427d5b848e2efcb24eee47e2a26b59"
+  integrity sha512-+xzPNztJDd2XJD0X3DgWKlrgOhMqZpSzsIssXeJgO7uCnP8/Z513ESaipJhJCFC8fxj5caO/DK4Uu8hEtlB8cQ==
   dependencies:
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/checkbox" "^3.8.1"
+    "@react-stately/overlays" "^3.6.12"
+    "@react-types/tooltip" "^3.4.13"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/toggle@^3.7.7":
-  version "3.7.7"
-  resolved "https://registry.npmjs.org/@react-stately/toggle/-/toggle-3.7.7.tgz"
-  integrity sha512-AS+xB4+hHWa3wzYkbS6pwBkovPfIE02B9SnuYTe0stKcuejpWKo5L3QMptW0ftFYsW3ZPCXuneImfObEw2T01A==
+"@react-stately/tooltip@^3.5.0":
+  version "3.5.7"
+  resolved "https://registry.yarnpkg.com/@react-stately/tooltip/-/tooltip-3.5.7.tgz#7c86942a8b5ee2fad890c09e01718a4939694e7f"
+  integrity sha512-GYh764BcYZz+Lclyutyir5I3elNo+vVNYzeNOKmPGZCE3p5B+/8lgZAHKxnRc9qmBlxvofnhMcuQxAPlBhoEkw==
   dependencies:
-    "@react-stately/utils" "^3.10.3"
-    "@react-types/checkbox" "^3.8.3"
+    "@react-stately/overlays" "^3.6.19"
+    "@react-types/tooltip" "^3.4.20"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/tooltip@3.4.9", "@react-stately/tooltip@^3.4.9":
-  version "3.4.9"
-  resolved "https://registry.npmjs.org/@react-stately/tooltip/-/tooltip-3.4.9.tgz"
-  integrity sha512-P7CDJsdoKarz32qFwf3VNS01lyC+63gXpDZG31pUu+EO5BeQd4WKN/AH1Beuswpr4GWzxzFc1aXQgERFGVzraA==
+"@react-stately/tree@3.8.6":
+  version "3.8.6"
+  resolved "https://registry.yarnpkg.com/@react-stately/tree/-/tree-3.8.6.tgz#85dc33c5d5b9a455ffc0b474300957e511db1ea4"
+  integrity sha512-lblUaxf1uAuIz5jm6PYtcJ+rXNNVkqyFWTIMx6g6gW/mYvm8GNx1G/0MLZE7E6CuDGaO9dkLSY2bB1uqyKHidA==
   dependencies:
-    "@react-stately/overlays" "^3.6.7"
-    "@react-types/tooltip" "^3.4.9"
+    "@react-stately/collections" "^3.12.0"
+    "@react-stately/selection" "^3.18.0"
+    "@react-stately/utils" "^3.10.5"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/tree@3.8.1", "@react-stately/tree@^3.8.1":
-  version "3.8.1"
-  resolved "https://registry.npmjs.org/@react-stately/tree/-/tree-3.8.1.tgz"
-  integrity sha512-LOdkkruJWch3W89h4B/bXhfr0t0t1aRfEp+IMrrwdRAl23NaPqwl5ILHs4Xu5XDHqqhg8co73pHrJwUyiTWEjw==
+"@react-stately/tree@^3.8.6", "@react-stately/tree@^3.9.2":
+  version "3.9.2"
+  resolved "https://registry.yarnpkg.com/@react-stately/tree/-/tree-3.9.2.tgz#f9960d7e6a5418a637ad9ea17e607308fcd393e5"
+  integrity sha512-jsT1WZZhb7GRmg1iqoib9bULsilIK5KhbE8WrcfIml8NYr4usP4DJMcIYfRuiRtPLhKtUvHSoZ5CMbinPp8PUQ==
   dependencies:
-    "@react-stately/collections" "^3.10.7"
-    "@react-stately/selection" "^3.15.1"
-    "@react-stately/utils" "^3.10.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-stately/collections" "^3.12.7"
+    "@react-stately/selection" "^3.20.5"
+    "@react-stately/utils" "^3.10.8"
+    "@react-types/shared" "^3.32.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/utils@3.10.1", "@react-stately/utils@^3.10.1":
-  version "3.10.1"
-  resolved "https://registry.npmjs.org/@react-stately/utils/-/utils-3.10.1.tgz"
-  integrity sha512-VS/EHRyicef25zDZcM/ClpzYMC5i2YGN6uegOeQawmgfGjb02yaCX0F0zR69Pod9m2Hr3wunTbtpgVXvYbZItg==
+"@react-stately/utils@3.10.5":
+  version "3.10.5"
+  resolved "https://registry.yarnpkg.com/@react-stately/utils/-/utils-3.10.5.tgz#47bb91cd5afd1bafe39353614e5e281b818ebccc"
+  integrity sha512-iMQSGcpaecghDIh3mZEpZfoFH3ExBwTtuBEcvZ2XnGzCgQjeYXcMdIUwAfVQLXFTdHUHGF6Gu6/dFrYsCzySBQ==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/utils@^3.10.3":
-  version "3.10.3"
-  resolved "https://registry.npmjs.org/@react-stately/utils/-/utils-3.10.3.tgz"
-  integrity sha512-moClv7MlVSHpbYtQIkm0Cx+on8Pgt1XqtPx6fy9rQFb2DNc9u1G3AUVnqA17buOkH1vLxAtX4MedlxMWyRCYYA==
+"@react-stately/utils@^3.10.5", "@react-stately/utils@^3.10.8":
+  version "3.10.8"
+  resolved "https://registry.yarnpkg.com/@react-stately/utils/-/utils-3.10.8.tgz#fdb9d172f7bbc2d083e69190f5ef0edfa4b4392f"
+  integrity sha512-SN3/h7SzRsusVQjQ4v10LaVsDc81jyyR0DD5HnsQitm/I5WDpaSr2nRHtyloPFU48jlql1XX/S04T2DLQM7Y3g==
   dependencies:
     "@swc/helpers" "^0.5.0"
 
-"@react-stately/virtualizer@3.7.1", "@react-stately/virtualizer@^3.7.1":
-  version "3.7.1"
-  resolved "https://registry.npmjs.org/@react-stately/virtualizer/-/virtualizer-3.7.1.tgz"
-  integrity sha512-voHgE6EQ+oZaLv6u2umKxakvIKNkCQuUihqKACTjdslp7SJh4Mvs3oLBI0hf0JOh+rCcFIKDvQtFwy1fXFRYBA==
+"@react-stately/virtualizer@4.2.0":
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/@react-stately/virtualizer/-/virtualizer-4.2.0.tgz#5906ac9d10ec48bc12a81879991a0b05154605d6"
+  integrity sha512-aTMpa9AQoz/xLqn8AI1BR/caUUY7/OUo9GbuF434w2u5eGCL7+SAn3Fmq7WSCwqYyDsO+jEIERek4JTX7pEW0A==
   dependencies:
-    "@react-aria/utils" "^3.24.1"
-    "@react-types/shared" "^3.23.1"
+    "@react-aria/utils" "^3.26.0"
+    "@react-types/shared" "^3.26.0"
     "@swc/helpers" "^0.5.0"
 
-"@react-types/accordion@3.0.0-alpha.21":
-  version "3.0.0-alpha.21"
-  resolved "https://registry.npmjs.org/@react-types/accordion/-/accordion-3.0.0-alpha.21.tgz"
-  integrity sha512-cbE06jH/ZoI+1898xd7ocQ/A/Rtkz8wTJAVOYgc8VRY1SYNQ/XZTGH5T6dD6aERAmiDwL/kjD7xhsE80DyaEKA==
+"@react-types/accordion@3.0.0-alpha.25":
+  version "3.0.0-alpha.25"
+  resolved "https://registry.yarnpkg.com/@react-types/accordion/-/accordion-3.0.0-alpha.25.tgz#046caa26d277f2119174201b39e68215edd4c023"
+  integrity sha512-nPTRrMA5jS4QcwQ0H8J9Tzzw7+yq+KbwsPNA1ukVIfOGIB45by/1ke/eiZAXGqXxkElxi2fQuaXuWm79BWZ8zg==
+  dependencies:
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/breadcrumbs@3.7.9":
+  version "3.7.9"
+  resolved "https://registry.yarnpkg.com/@react-types/breadcrumbs/-/breadcrumbs-3.7.9.tgz#c75eae6158bd3631854bff7521c2373b42b0e37c"
+  integrity sha512-eARYJo8J+VfNV8vP4uw3L2Qliba9wLV2bx9YQCYf5Lc/OE5B/y4gaTLz+Y2P3Rtn6gBPLXY447zCs5i7gf+ICg==
+  dependencies:
+    "@react-types/link" "^3.5.9"
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/breadcrumbs@^3.7.9":
+  version "3.7.16"
+  resolved "https://registry.yarnpkg.com/@react-types/breadcrumbs/-/breadcrumbs-3.7.16.tgz#f9842047a1e7b4eac9d2ea911fd35e221d2a192f"
+  integrity sha512-4J+7b9y6z8QGZqvsBSWQfebx6aIbc+1unQqnZCAlJl9EGzlI6SGdXRsURGkOUGJCV2GqY8bSocc8AZbRXpQ0XQ==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/link" "^3.6.4"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/breadcrumbs@3.7.5", "@react-types/breadcrumbs@^3.7.5":
-  version "3.7.5"
-  resolved "https://registry.npmjs.org/@react-types/breadcrumbs/-/breadcrumbs-3.7.5.tgz"
-  integrity sha512-lV9IDYsMiu2TgdMIjEmsOE0YWwjb3jhUNK1DCZZfq6uWuiHLgyx2EncazJBUWSjHJ4ta32j7xTuXch+8Ai6u/A==
+"@react-types/button@3.10.1":
+  version "3.10.1"
+  resolved "https://registry.yarnpkg.com/@react-types/button/-/button-3.10.1.tgz#fc7ada2e83bc661b31c1473a82ec86dc11de057c"
+  integrity sha512-XTtap8o04+4QjPNAshFWOOAusUTxQlBjU2ai0BTVLShQEjHhRVDBIWsI2B2FKJ4KXT6AZ25llaxhNrreWGonmA==
   dependencies:
-    "@react-types/link" "^3.5.5"
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
 "@react-types/button@3.4.1":
   version "3.4.1"
-  resolved "https://registry.npmjs.org/@react-types/button/-/button-3.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/@react-types/button/-/button-3.4.1.tgz#715ac9d4997c79233be4d9020b58f85936b8252b"
   integrity sha512-B54M84LxdEppwjXNlkBEJyMfe9fd+bvFV7R6+NJvupGrZm/LuFNYjFcHk7yjMKWTdWm6DbpIuQz54n5qTW7Vlg==
   dependencies:
     "@react-types/shared" "^3.8.0"
 
-"@react-types/button@3.9.4", "@react-types/button@^3.9.4":
-  version "3.9.4"
-  resolved "https://registry.npmjs.org/@react-types/button/-/button-3.9.4.tgz"
-  integrity sha512-raeQBJUxBp0axNF74TXB8/H50GY8Q3eV6cEKMbZFP1+Dzr09Ngv0tJBeW0ewAxAguNH5DRoMUAUGIXtSXskVdA==
+"@react-types/button@^3.10.1", "@react-types/button@^3.14.0":
+  version "3.14.0"
+  resolved "https://registry.yarnpkg.com/@react-types/button/-/button-3.14.0.tgz#8b7d1387960bd81ff2c0aa5565d3fb407f6a59b2"
+  integrity sha512-pXt1a+ElxiZyWpX0uznyjy5Z6EHhYxPcaXpccZXyn6coUo9jmCbgg14xR7Odo+JcbfaaISzZTDO7oGLVTcHnpA==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/button@^3.9.6":
-  version "3.9.6"
-  resolved "https://registry.npmjs.org/@react-types/button/-/button-3.9.6.tgz"
-  integrity sha512-8lA+D5JLbNyQikf8M/cPP2cji91aVTcqjrGpDqI7sQnaLFikM8eFR6l1ZWGtZS5MCcbfooko77ha35SYplSQvw==
+"@react-types/calendar@3.5.0":
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/@react-types/calendar/-/calendar-3.5.0.tgz#a72fa15e08c7785b145005560baa35ad9b44627b"
+  integrity sha512-O3IRE7AGwAWYnvJIJ80cOy7WwoJ0m8GtX/qSmvXQAjC4qx00n+b5aFNBYAQtcyc3RM5QpW6obs9BfwGetFiI8w==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@internationalized/date" "^3.6.0"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/calendar@3.4.6", "@react-types/calendar@^3.4.6":
-  version "3.4.6"
-  resolved "https://registry.npmjs.org/@react-types/calendar/-/calendar-3.4.6.tgz"
-  integrity sha512-WSntZPwtvsIYWvBQRAPvuCn55UTJBZroTvX0vQvWykJRQnPAI20G1hMQ3dNsnAL+gLZUYxBXn66vphmjUuSYew==
+"@react-types/calendar@^3.5.0", "@react-types/calendar@^3.7.4":
+  version "3.7.4"
+  resolved "https://registry.yarnpkg.com/@react-types/calendar/-/calendar-3.7.4.tgz#8a630b75ce081bb656620ec64204a2b0b27ba84d"
+  integrity sha512-MZDyXtvdHl8CKQGYBkjYwc4ABBq6Mb4Fu7k/4boQAmMQ5Rtz29ouBCJrAs0BpR14B8ZMGzoNIolxS5RLKBmFSA==
   dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@react-types/shared" "^3.23.1"
+    "@internationalized/date" "^3.9.0"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/checkbox@3.8.1", "@react-types/checkbox@^3.2.3", "@react-types/checkbox@^3.8.1":
-  version "3.8.1"
-  resolved "https://registry.npmjs.org/@react-types/checkbox/-/checkbox-3.8.1.tgz"
-  integrity sha512-5/oVByPw4MbR/8QSdHCaalmyWC71H/QGgd4aduTJSaNi825o+v/hsN2/CH7Fq9atkLKsC8fvKD00Bj2VGaKriQ==
+"@react-types/checkbox@3.9.0":
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/@react-types/checkbox/-/checkbox-3.9.0.tgz#d4621fef81850543f7a028917e9c2781cd871443"
+  integrity sha512-9hbHx0Oo2Hp5a8nV8Q75LQR0DHtvOIJbFaeqESSopqmV9EZoYjtY/h0NS7cZetgahQgnqYWQi44XGooMDCsmxA==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/checkbox@^3.8.3":
-  version "3.8.3"
-  resolved "https://registry.npmjs.org/@react-types/checkbox/-/checkbox-3.8.3.tgz"
-  integrity sha512-f4c1mnLEt0iS1NMkyZXgT3q3AgcxzDk7w6MSONOKydcnh0xG5L2oefY14DhVDLkAuQS7jThlUFwiAs+MxiO3MA==
+"@react-types/checkbox@^3.10.1", "@react-types/checkbox@^3.2.3", "@react-types/checkbox@^3.9.0":
+  version "3.10.1"
+  resolved "https://registry.yarnpkg.com/@react-types/checkbox/-/checkbox-3.10.1.tgz#6cd2e7dd4e27ba017593b8140d0571afcf2b7114"
+  integrity sha512-8ZqBoGBxtn6U/znpmyutGtBBaafUzcZnbuvYjwyRSONTrqQ0IhUq6jI/jbnE9r9SslIkbMB8IS1xRh2e63qmEQ==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/combobox@3.11.1", "@react-types/combobox@^3.11.1":
-  version "3.11.1"
-  resolved "https://registry.npmjs.org/@react-types/combobox/-/combobox-3.11.1.tgz"
-  integrity sha512-UNc3OHt5cUt5gCTHqhQIqhaWwKCpaNciD8R7eQazmHiA9fq8ROlV+7l3gdNgdhJbTf5Bu/V5ISnN7Y1xwL3zqQ==
+"@react-types/combobox@3.13.1":
+  version "3.13.1"
+  resolved "https://registry.yarnpkg.com/@react-types/combobox/-/combobox-3.13.1.tgz#d7d843f45501ad141f74ba62ed46d2e991b2d6a0"
+  integrity sha512-7xr+HknfhReN4QPqKff5tbKTe2kGZvH+DGzPYskAtb51FAAiZsKo+WvnNAvLwg3kRoC9Rkn4TAiVBp/HgymRDw==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/datepicker@3.7.4", "@react-types/datepicker@^3.7.4":
-  version "3.7.4"
-  resolved "https://registry.npmjs.org/@react-types/datepicker/-/datepicker-3.7.4.tgz"
-  integrity sha512-ZfvgscvNzBJpYyVWg3nstJtA/VlWLwErwSkd1ivZYam859N30w8yH+4qoYLa6FzWLCFlrsRHyvtxlEM7lUAt5A==
+"@react-types/combobox@^3.13.1", "@react-types/combobox@^3.13.8":
+  version "3.13.8"
+  resolved "https://registry.yarnpkg.com/@react-types/combobox/-/combobox-3.13.8.tgz#de88e8eb51ec057f5004630668f910e1afd11c96"
+  integrity sha512-HGC3X9hmDRsjSZcFiflvJ7vbIgQ2gX/ZDxo1HVtvQqUDbgQCVakCcCdrB44aYgHFnyDiO6hyp7Y7jXtDBaEIIA==
+  dependencies:
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/datepicker@3.9.0":
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/@react-types/datepicker/-/datepicker-3.9.0.tgz#86e2a4e23e9fbf8299a12bd8aba9b1a52cf44725"
+  integrity sha512-dbKL5Qsm2MQwOTtVQdOcKrrphcXAqDD80WLlSQrBLg+waDuuQ7H+TrvOT0thLKloNBlFUGnZZfXGRHINpih/0g==
+  dependencies:
+    "@internationalized/date" "^3.6.0"
+    "@react-types/calendar" "^3.5.0"
+    "@react-types/overlays" "^3.8.11"
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/datepicker@^3.13.1", "@react-types/datepicker@^3.9.0":
+  version "3.13.1"
+  resolved "https://registry.yarnpkg.com/@react-types/datepicker/-/datepicker-3.13.1.tgz#488989d4ff7605cf80af6fb0d31cb227456201d2"
+  integrity sha512-ub+g5pS3WOo5P/3FRNsQSwvlb9CuLl2m6v6KBkRXc5xqKhFd7UjvVpL6Oi/1zwwfow4itvD1t7l1XxgCo7wZ6Q==
   dependencies:
-    "@internationalized/date" "^3.5.4"
-    "@react-types/calendar" "^3.4.6"
-    "@react-types/overlays" "^3.8.7"
-    "@react-types/shared" "^3.23.1"
+    "@internationalized/date" "^3.9.0"
+    "@react-types/calendar" "^3.7.4"
+    "@react-types/overlays" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/dialog@^3.5.10":
-  version "3.5.12"
-  resolved "https://registry.npmjs.org/@react-types/dialog/-/dialog-3.5.12.tgz"
-  integrity sha512-JmpQbSpXltqEyYfEwoqDolABIiojeExkqolHNdQlayIsfFuSxZxNwXZPOpz58Ri/iwv21JP7K3QF0Gb2Ohxl9w==
+"@react-types/dialog@^3.5.14":
+  version "3.5.21"
+  resolved "https://registry.yarnpkg.com/@react-types/dialog/-/dialog-3.5.21.tgz#f47302e0a15e75dfe57e868f3496f5c0a0cecd7b"
+  integrity sha512-jF1gN4bvwYamsLjefaFDnaSKxTa3Wtvn5f7WLjNVZ8ICVoiMBMdUJXTlPQHAL4YWqtCj4hK/3uimR1E+Pwd7Xw==
   dependencies:
-    "@react-types/overlays" "^3.8.9"
-    "@react-types/shared" "^3.24.1"
+    "@react-types/overlays" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/grid@3.2.6", "@react-types/grid@^3.2.6":
-  version "3.2.6"
-  resolved "https://registry.npmjs.org/@react-types/grid/-/grid-3.2.6.tgz"
-  integrity sha512-XfHenL2jEBUYrhKiPdeM24mbLRXUn79wVzzMhrNYh24nBwhsPPpxF+gjFddT3Cy8dt6tRInfT6pMEu9nsXwaHw==
+"@react-types/form@3.7.8":
+  version "3.7.8"
+  resolved "https://registry.yarnpkg.com/@react-types/form/-/form-3.7.8.tgz#4d6b9e78770b9345cc9e1041990a7a26fb65e0ee"
+  integrity sha512-0wOS97/X0ijTVuIqik1lHYTZnk13QkvMTKvIEhM7c6YMU3vPiirBwLbT2kJiAdwLiymwcCkrBdDF1NTRG6kPFA==
+  dependencies:
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/grid@3.2.10":
+  version "3.2.10"
+  resolved "https://registry.yarnpkg.com/@react-types/grid/-/grid-3.2.10.tgz#d2d1d124ed9472e3dedc48e91c941a7ad23bdc83"
+  integrity sha512-Z5cG0ITwqjUE4kWyU5/7VqiPl4wqMJ7kG/ZP7poAnLmwRsR8Ai0ceVn+qzp5nTA19cgURi8t3LsXn3Ar1FBoog==
+  dependencies:
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/grid@^3.2.10", "@react-types/grid@^3.3.5":
+  version "3.3.5"
+  resolved "https://registry.yarnpkg.com/@react-types/grid/-/grid-3.3.5.tgz#5764d4fed4a7f2a721bd77d1043e27686c5dbeee"
+  integrity sha512-hG6J2KDfmOHitkWoCa/9DvY1nTO2wgMIApcFoqLv7AWJr9CzvVqo5tIhZZCXiT1AvU2kafJxu9e7sr5GxAT2YA==
+  dependencies:
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/link@3.5.9":
+  version "3.5.9"
+  resolved "https://registry.yarnpkg.com/@react-types/link/-/link-3.5.9.tgz#bf61ff2780581de03920e6e43260844a81a38d2f"
+  integrity sha512-JcKDiDMqrq/5Vpn+BdWQEuXit4KN4HR/EgIi3yKnNbYkLzxBoeQZpQgvTaC7NEQeZnSqkyXQo3/vMUeX/ZNIKw==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/grid@^3.2.8":
-  version "3.2.8"
-  resolved "https://registry.npmjs.org/@react-types/grid/-/grid-3.2.8.tgz"
-  integrity sha512-6PJrpukwMqlv3IhJSDkJuVbhHM8Oe6hd2supWqd9adMXrlSP7QHt9a8SgFcFblCCTx8JzUaA0PvY5sTudcEtOQ==
+"@react-types/link@^3.5.9", "@react-types/link@^3.6.4":
+  version "3.6.4"
+  resolved "https://registry.yarnpkg.com/@react-types/link/-/link-3.6.4.tgz#99d6cc04e0d5e768c51dc1261fceeecf47557234"
+  integrity sha512-eLpIgOPf7GW4DpdMq8UqiRJkriend1kWglz5O9qU+/FM6COtvRnQkEeRhHICUaU2NZUvMRQ30KaGUo3eeZ6b+g==
+  dependencies:
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/listbox@^3.5.3", "@react-types/listbox@^3.7.3":
+  version "3.7.3"
+  resolved "https://registry.yarnpkg.com/@react-types/listbox/-/listbox-3.7.3.tgz#20946c0fd253be35e83180b21bd27676553ad0a3"
+  integrity sha512-ONgror9uyGmIer5XxpRRNcc8QFVWiOzINrMKyaS8G4l3aP52ZwYpRfwMAVtra8lkVNvXDmO7hthPZkB6RYdNOA==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/link@3.5.5", "@react-types/link@^3.5.5":
-  version "3.5.5"
-  resolved "https://registry.npmjs.org/@react-types/link/-/link-3.5.5.tgz"
-  integrity sha512-G6P5WagHDR87npN7sEuC5IIgL1GsoY4WFWKO4734i2CXRYx24G9P0Su3AX4GA3qpspz8sK1AWkaCzBMmvnunfw==
+"@react-types/menu@3.9.13":
+  version "3.9.13"
+  resolved "https://registry.yarnpkg.com/@react-types/menu/-/menu-3.9.13.tgz#a666c2233cbdb495202586df86a798601788f74d"
+  integrity sha512-7SuX6E2tDsqQ+HQdSvIda1ji/+ujmR86dtS9CUu5yWX91P25ufRjZ72EvLRqClWNQsj1Xl4+2zBDLWlceznAjw==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/overlays" "^3.8.11"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/listbox@^3.4.9":
-  version "3.5.1"
-  resolved "https://registry.npmjs.org/@react-types/listbox/-/listbox-3.5.1.tgz"
-  integrity sha512-n5bOgD9lgfK1qaLtag9WPnu151SwXBCNn/OgGY/Br9mWRl+nPUEYtFcPX+2VCld7uThf54kwrTmzlFnaraIlcw==
+"@react-types/menu@^3.10.4", "@react-types/menu@^3.9.13":
+  version "3.10.4"
+  resolved "https://registry.yarnpkg.com/@react-types/menu/-/menu-3.10.4.tgz#57c0259b149f80fde9230cc1a494d6ac581d09b4"
+  integrity sha512-jCFVShLq3eASiuznenjoKBv3j0Jy2KQilAjBxdEp56WkZ5D338y/oY5zR6d25u9M0QslpI0DgwC8BwU7MCsPnw==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/overlays" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/menu@3.9.9", "@react-types/menu@^3.9.9":
-  version "3.9.9"
-  resolved "https://registry.npmjs.org/@react-types/menu/-/menu-3.9.9.tgz"
-  integrity sha512-FamUaPVs1Fxr4KOMI0YcR2rYZHoN7ypGtgiEiJ11v/tEPjPPGgeKDxii0McCrdOkjheatLN1yd2jmMwYj6hTDg==
+"@react-types/overlays@3.8.11":
+  version "3.8.11"
+  resolved "https://registry.yarnpkg.com/@react-types/overlays/-/overlays-3.8.11.tgz#313964703b2a23572138120b619d35da33445dfd"
+  integrity sha512-aw7T0rwVI3EuyG5AOaEIk8j7dZJQ9m34XAztXJVZ/W2+4pDDkLDbJ/EAPnuo2xGYRGhowuNDn4tDju01eHYi+w==
   dependencies:
-    "@react-types/overlays" "^3.8.7"
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/overlays@3.8.7", "@react-types/overlays@^3.8.7":
-  version "3.8.7"
-  resolved "https://registry.npmjs.org/@react-types/overlays/-/overlays-3.8.7.tgz"
-  integrity sha512-zCOYvI4at2DkhVpviIClJ7bRrLXYhSg3Z3v9xymuPH3mkiuuP/dm8mUCtkyY4UhVeUTHmrQh1bzaOP00A+SSQA==
+"@react-types/overlays@^3.8.11", "@react-types/overlays@^3.9.1":
+  version "3.9.1"
+  resolved "https://registry.yarnpkg.com/@react-types/overlays/-/overlays-3.9.1.tgz#b6e750d6e4bcf3aaf38fa8a5f69a817f37840934"
+  integrity sha512-UCG3TOu8FLk4j0Pr1nlhv0opcwMoqbGEOUvsSr6ITN6Qs2y0j+KYSYQ7a4+04m3dN//8+9Wjkkid8k+V1dV2CA==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/overlays@^3.8.9":
-  version "3.8.9"
-  resolved "https://registry.npmjs.org/@react-types/overlays/-/overlays-3.8.9.tgz"
-  integrity sha512-9ni9upQgXPnR+K9cWmbYWvm3ll9gH8P/XsEZprqIV5zNLMF334jADK48h4jafb1X9RFnj0WbHo6BqcSObzjTig==
+"@react-types/progress@3.5.8":
+  version "3.5.8"
+  resolved "https://registry.yarnpkg.com/@react-types/progress/-/progress-3.5.8.tgz#62ce4207c7e8d640b794c6d89063ce21bdb5970d"
+  integrity sha512-PR0rN5mWevfblR/zs30NdZr+82Gka/ba7UHmYOW9/lkKlWeD7PHgl1iacpd/3zl/jUF22evAQbBHmk1mS6Mpqw==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/progress@3.5.4", "@react-types/progress@^3.5.4":
-  version "3.5.4"
-  resolved "https://registry.npmjs.org/@react-types/progress/-/progress-3.5.4.tgz"
-  integrity sha512-JNc246sTjasPyx5Dp7/s0rp3Bz4qlu4LrZTulZlxWyb53WgBNL7axc26CCi+I20rWL9+c7JjhrRxnLl/1cLN5g==
+"@react-types/progress@^3.5.8":
+  version "3.5.15"
+  resolved "https://registry.yarnpkg.com/@react-types/progress/-/progress-3.5.15.tgz#f676d003b9595d216a831eed58966ed91ceb305c"
+  integrity sha512-3SYvEyRt7vq7w0sc6wBYmkPqLMZbhH8FI3Lrnn9r3y8+69/efRjVmmJvwjm1z+c6rukszc2gCjUGTsMPQxVk2w==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
 
 "@react-types/radio@3.1.2":
   version "3.1.2"
-  resolved "https://registry.npmjs.org/@react-types/radio/-/radio-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@react-types/radio/-/radio-3.1.2.tgz#a2a6aed62c0036b9c3647edd9ce944aa80624346"
   integrity sha512-vkIic8abrVUyl/YjKU3yTVwn8QgebzuadfV89PsaKc3hdmSiHhDsln5wYsfWOEotqMwPrG1aEv9yRMYO78OQXQ==
   dependencies:
     "@react-types/shared" "^3.8.0"
 
-"@react-types/radio@3.8.1", "@react-types/radio@^3.8.1":
-  version "3.8.1"
-  resolved "https://registry.npmjs.org/@react-types/radio/-/radio-3.8.1.tgz"
-  integrity sha512-bK0gio/qj1+0Ldu/3k/s9BaOZvnnRgvFtL3u5ky479+aLG5qf1CmYed3SKz8ErZ70JkpuCSrSwSCFf0t1IHovw==
+"@react-types/radio@3.8.5":
+  version "3.8.5"
+  resolved "https://registry.yarnpkg.com/@react-types/radio/-/radio-3.8.5.tgz#8e2dd1911fba829b7f1ebb40bccf9ca483f021fc"
+  integrity sha512-gSImTPid6rsbJmwCkTliBIU/npYgJHOFaI3PNJo7Y0QTAnFelCtYeFtBiWrFodSArSv7ASqpLLUEj9hZu/rxIg==
+  dependencies:
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/radio@^3.8.5", "@react-types/radio@^3.9.1":
+  version "3.9.1"
+  resolved "https://registry.yarnpkg.com/@react-types/radio/-/radio-3.9.1.tgz#4d37e935cd3cc482a5dfaf92cf51068f07e70750"
+  integrity sha512-DUCN3msm8QZ0MJrP55FmqMONaadYq6JTxihYFGMLP+NoKRnkxvXqNZ2PlkAOLGy3y4RHOnOF8O1LuJqFCCuxDw==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/select@3.9.4":
-  version "3.9.4"
-  resolved "https://registry.npmjs.org/@react-types/select/-/select-3.9.4.tgz"
-  integrity sha512-xI7dnOW2st91fPPcv6hdtrTdcfetYiqZuuVPZ5TRobY7Q10/Zqqe/KqtOw1zFKUj9xqNJe4Ov3xP5GSdcO60Eg==
+"@react-types/select@3.9.8":
+  version "3.9.8"
+  resolved "https://registry.yarnpkg.com/@react-types/select/-/select-3.9.8.tgz#2443b82549b65821f85876a5b803e6d04ae6343e"
+  integrity sha512-RGsYj2oFjXpLnfcvWMBQnkcDuKkwT43xwYWZGI214/gp/B64tJiIUgTM5wFTRAeGDX23EePkhCQF+9ctnqFd6g==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/select@^3.9.6":
-  version "3.9.6"
-  resolved "https://registry.npmjs.org/@react-types/select/-/select-3.9.6.tgz"
-  integrity sha512-cVSFR0eJLup/ht1Uto+y8uyLmHO89J6wNh65SIHb3jeVz9oLBAedP3YNI2qB+F9qFMUcA8PBSLXIIuT6gXzLgQ==
+"@react-types/select@^3.10.1":
+  version "3.10.1"
+  resolved "https://registry.yarnpkg.com/@react-types/select/-/select-3.10.1.tgz#4c19deb68250233d1acffc929b0beb1b04de2dd0"
+  integrity sha512-teANUr1byOzGsS/r2j7PatV470JrOhKP8En9lscfnqW5CeUghr+0NxkALnPkiEhCObi/Vu8GIcPareD0HNhtFA==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/shared@3.23.1", "@react-types/shared@^3.23.1":
-  version "3.23.1"
-  resolved "https://registry.npmjs.org/@react-types/shared/-/shared-3.23.1.tgz"
-  integrity sha512-5d+3HbFDxGZjhbMBeFHRQhexMFt4pUce3okyRtUVKbbedQFUrtXSBg9VszgF2RTeQDKDkMCIQDtz5ccP/Lk1gw==
+"@react-types/shared@3.26.0":
+  version "3.26.0"
+  resolved "https://registry.yarnpkg.com/@react-types/shared/-/shared-3.26.0.tgz#21a8b579f0097ee78de18e3e580421ced89e4c8c"
+  integrity sha512-6FuPqvhmjjlpEDLTiYx29IJCbCNWPlsyO+ZUmCUXzhUv2ttShOXfw8CmeHWHftT/b2KweAWuzqSlfeXPR76jpw==
 
-"@react-types/shared@3.9.0", "@react-types/shared@^3.8.0", "@react-types/shared@^3.9.0":
+"@react-types/shared@3.9.0":
   version "3.9.0"
-  resolved "https://registry.npmjs.org/@react-types/shared/-/shared-3.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/@react-types/shared/-/shared-3.9.0.tgz#d834f3e6e2c992089192f3c83fb7963e3a6f5207"
   integrity sha512-YYksINfR6q92P10AhPEGo47Hd7oz1hrnZ6Vx8Gsrq62IbqDdv1XOTzPBaj17Z1ymNY2pitLUSEXsLmozt4wxxQ==
 
-"@react-types/shared@^3.24.1":
-  version "3.24.1"
-  resolved "https://registry.npmjs.org/@react-types/shared/-/shared-3.24.1.tgz"
-  integrity sha512-AUQeGYEm/zDTN6zLzdXolDxz3Jk5dDL7f506F07U8tBwxNNI3WRdhU84G0/AaFikOZzDXhOZDr3MhQMzyE7Ydw==
+"@react-types/shared@^3.26.0", "@react-types/shared@^3.32.0", "@react-types/shared@^3.8.0", "@react-types/shared@^3.9.0":
+  version "3.32.0"
+  resolved "https://registry.yarnpkg.com/@react-types/shared/-/shared-3.32.0.tgz#6c105ef05e1bd84ab04531e707074dc2a0b3ce07"
+  integrity sha512-t+cligIJsZYFMSPFMvsJMjzlzde06tZMOIOFa1OV5Z0BcMowrb2g4mB57j/9nP28iJIRYn10xCniQts+qadrqQ==
 
-"@react-types/slider@^3.7.3":
-  version "3.7.5"
-  resolved "https://registry.npmjs.org/@react-types/slider/-/slider-3.7.5.tgz"
-  integrity sha512-bRitwQRQjQoOcKEdPMljnvm474dwrmsc6pdsVQDh/qynzr+KO9IHuYc3qPW53WVE2hMQJDohlqtCAWQXWQ5Vcg==
+"@react-types/slider@^3.7.7", "@react-types/slider@^3.8.1":
+  version "3.8.1"
+  resolved "https://registry.yarnpkg.com/@react-types/slider/-/slider-3.8.1.tgz#e2b1a11491cb6957584dc725513e574eddde4105"
+  integrity sha512-WxiQWj6iQr5Uft0/KcB9XSr361XnyTmL6eREZZacngA9CjPhRWYP3BRDPcCTuP7fj9Yi4QKMrryyjHqMHP8OKQ==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.32.0"
 
 "@react-types/switch@3.1.2":
   version "3.1.2"
-  resolved "https://registry.npmjs.org/@react-types/switch/-/switch-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/@react-types/switch/-/switch-3.1.2.tgz#f7015e5e66035c9ae517966842a4f9e5d589fa26"
   integrity sha512-EaYWoLvUCpOnt//Ov8VBxOjbs4hBpYE/rBAzzIknXaFvKOu867iZBFL7FJbcemOgC8/dwyaj6GUZ1Gw3Z1g59w==
   dependencies:
     "@react-types/checkbox" "^3.2.3"
     "@react-types/shared" "^3.8.0"
 
-"@react-types/switch@^3.5.3":
-  version "3.5.5"
-  resolved "https://registry.npmjs.org/@react-types/switch/-/switch-3.5.5.tgz"
-  integrity sha512-SZx1Bd+COhAOs/RTifbZG+uq/llwba7VAKx7XBeX4LeIz1dtguy5bigOBgFTMQi4qsIVCpybSWEEl+daj4XFPw==
+"@react-types/switch@^3.5.7":
+  version "3.5.14"
+  resolved "https://registry.yarnpkg.com/@react-types/switch/-/switch-3.5.14.tgz#827e841b5f8948569650f7bac1784c685a7ab21e"
+  integrity sha512-M8kIv97i+ejCel4Ho+Y7tDbpOehymGwPA4ChxibeyD32+deyxu5B6BXxgKiL3l+oTLQ8ihLo3sRESdPFw8vpQg==
+  dependencies:
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/table@3.10.3":
+  version "3.10.3"
+  resolved "https://registry.yarnpkg.com/@react-types/table/-/table-3.10.3.tgz#33959348641500e406abe330074f84b0c75ae4ac"
+  integrity sha512-Ac+W+m/zgRzlTU8Z2GEg26HkuJFswF9S6w26r+R3MHwr8z2duGPvv37XRtE1yf3dbpRBgHEAO141xqS2TqGwNg==
+  dependencies:
+    "@react-types/grid" "^3.2.10"
+    "@react-types/shared" "^3.26.0"
+
+"@react-types/table@^3.10.3", "@react-types/table@^3.13.3":
+  version "3.13.3"
+  resolved "https://registry.yarnpkg.com/@react-types/table/-/table-3.13.3.tgz#83fb11c63e71e726a63246dd3d12caa7c97e90d7"
+  integrity sha512-/kY/VlXN+8l9saySd6igcsDQ3x8pOVFJAWyMh6gOaOVN7HOJkTMIchmqS+ATa4nege8jZqcdzyGeAmv7mN655A==
+  dependencies:
+    "@react-types/grid" "^3.3.5"
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/tabs@3.3.11":
+  version "3.3.11"
+  resolved "https://registry.yarnpkg.com/@react-types/tabs/-/tabs-3.3.11.tgz#b7db710ce2ca42a4e72cd2a581070212d2b07793"
+  integrity sha512-BjF2TqBhZaIcC4lc82R5pDJd1F7kstj1K0Nokhz99AGYn8C0ITdp6lR+DPVY9JZRxKgP9R2EKfWGI90Lo7NQdA==
   dependencies:
-    "@react-types/shared" "^3.24.1"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/table@3.9.5", "@react-types/table@^3.9.5":
-  version "3.9.5"
-  resolved "https://registry.npmjs.org/@react-types/table/-/table-3.9.5.tgz"
-  integrity sha512-fgM2j9F/UR4Anmd28CueghCgBwOZoCVyN8fjaIFPd2MN4gCwUUfANwxLav65gZk4BpwUXGoQdsW+X50L3555mg==
+"@react-types/tabs@^3.3.11", "@react-types/tabs@^3.3.18":
+  version "3.3.18"
+  resolved "https://registry.yarnpkg.com/@react-types/tabs/-/tabs-3.3.18.tgz#c84bf3d113d606d2af8ba52f5465e8b6bb61b707"
+  integrity sha512-yX/AVlGS7VXCuy2LSm8y8nxUrKVBgnLv+FrtkLqf6jUMtD4KP3k1c4+GPHeScR0HcYzCQF7gCF3Skba1RdYoug==
   dependencies:
-    "@react-types/grid" "^3.2.6"
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.32.0"
 
-"@react-types/tabs@3.3.7", "@react-types/tabs@^3.3.7":
-  version "3.3.7"
-  resolved "https://registry.npmjs.org/@react-types/tabs/-/tabs-3.3.7.tgz"
-  integrity sha512-ZdLe5xOcFX6+/ni45Dl2jO0jFATpTnoSqj6kLIS/BYv8oh0n817OjJkLf+DS3CLfNjApJWrHqAk34xNh6nRnEg==
+"@react-types/textfield@3.10.0":
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/@react-types/textfield/-/textfield-3.10.0.tgz#10df39b75334174490a539ecae71ad19f5ea074d"
+  integrity sha512-ShU3d6kLJGQjPXccVFjM3KOXdj3uyhYROqH9YgSIEVxgA9W6LRflvk/IVBamD9pJYTPbwmVzuP0wQkTDupfZ1w==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/shared" "^3.26.0"
 
 "@react-types/textfield@3.3.0":
   version "3.3.0"
-  resolved "https://registry.npmjs.org/@react-types/textfield/-/textfield-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/@react-types/textfield/-/textfield-3.3.0.tgz#07a447fda327df4843e7d36cbd00f87f8a73e725"
   integrity sha512-lOf0tx3c3dVaomH/uvKpOKFVTXQ232kLnMhOJTtj97JDX7fTr3SNhDUV0G8Zf4M0vr+l+xkTrJkywYE23rzliw==
   dependencies:
     "@react-types/shared" "^3.9.0"
 
-"@react-types/textfield@3.9.3", "@react-types/textfield@^3.9.3":
-  version "3.9.3"
-  resolved "https://registry.npmjs.org/@react-types/textfield/-/textfield-3.9.3.tgz"
-  integrity sha512-DoAY6cYOL0pJhgNGI1Rosni7g72GAt4OVr2ltEx2S9ARmFZ0DBvdhA9lL2nywcnKMf27PEJcKMXzXc10qaHsJw==
+"@react-types/textfield@^3.10.0", "@react-types/textfield@^3.12.5":
+  version "3.12.5"
+  resolved "https://registry.yarnpkg.com/@react-types/textfield/-/textfield-3.12.5.tgz#b9b4cd1b8f8b907d756c8323fb7fc2ac5b39a225"
+  integrity sha512-VXez8KIcop87EgIy00r+tb30xokA309TfJ32Qv5qOYB5SMqoHnb6SYvWL8Ih2PDqCo5eBiiGesSaWYrHnRIL8Q==
+  dependencies:
+    "@react-types/shared" "^3.32.0"
+
+"@react-types/tooltip@3.4.13":
+  version "3.4.13"
+  resolved "https://registry.yarnpkg.com/@react-types/tooltip/-/tooltip-3.4.13.tgz#f73fdc5c56790b7bd7c0d5382d0c758bd659e9d7"
+  integrity sha512-KPekFC17RTT8kZlk7ZYubueZnfsGTDOpLw7itzolKOXGddTXsrJGBzSB4Bb060PBVllaDO0MOrhPap8OmrIl1Q==
   dependencies:
-    "@react-types/shared" "^3.23.1"
+    "@react-types/overlays" "^3.8.11"
+    "@react-types/shared" "^3.26.0"
 
-"@react-types/tooltip@3.4.9", "@react-types/tooltip@^3.4.9":
-  version "3.4.9"
-  resolved "https://registry.npmjs.org/@react-types/tooltip/-/tooltip-3.4.9.tgz"
-  integrity sha512-wZ+uF1+Zc43qG+cOJzioBmLUNjRa7ApdcT0LI1VvaYvH5GdfjzUJOorLX9V/vAci0XMJ50UZ+qsh79aUlw2yqg==
+"@react-types/tooltip@^3.4.13", "@react-types/tooltip@^3.4.20":
+  version "3.4.20"
+  resolved "https://registry.yarnpkg.com/@react-types/tooltip/-/tooltip-3.4.20.tgz#af71dde12afb8a33a7b5bb3d8ff0cda6c4ee3999"
+  integrity sha512-tF1yThwvgSgW8Gu/CLL0p92AUldHR6szlwhwW+ewT318sQlfabMGO4xlCNFdxJYtqTpEXk2rlaVrBuaC//du0w==
   dependencies:
-    "@react-types/overlays" "^3.8.7"
-    "@react-types/shared" "^3.23.1"
+    "@react-types/overlays" "^3.9.1"
+    "@react-types/shared" "^3.32.0"
 
 "@rehooks/component-size@^1.0.3":
   version "1.0.3"
-  resolved "https://registry.npmjs.org/@rehooks/component-size/-/component-size-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@rehooks/component-size/-/component-size-1.0.3.tgz#823eabeb42084893d46d43e3a9d1d0e34252b3cb"
   integrity sha512-pnYld+8SSF2vXwdLOqBGUyOrv/SjzwLjIUcs/4c1JJgR0q4E9eBtBfuZMD6zUD51fvSehSsbnlQMzotSmPTXPg==
 
 "@rollup/plugin-commonjs@28.0.1":
@@ -5196,130 +5462,140 @@
     picomatch "^4.0.2"
 
 "@rollup/pluginutils@^5.0.1":
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.2.0.tgz#eac25ca5b0bdda4ba735ddaca5fbf26bd435f602"
-  integrity sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw==
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.3.0.tgz#57ba1b0cbda8e7a3c597a4853c807b156e21a7b4"
+  integrity sha512-5EdhGZtnu3V88ces7s53hhfK5KSASnJZv8Lulpc04cWO3REESroJXg73DFsOmgbU2BhwV0E20bu2IDZb3VKW4Q==
   dependencies:
     "@types/estree" "^1.0.0"
     estree-walker "^2.0.2"
     picomatch "^4.0.2"
 
-"@rollup/rollup-android-arm-eabi@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.49.0.tgz#ba432433f5e7b419dba2be407d1d59fea6b8de48"
-  integrity sha512-rlKIeL854Ed0e09QGYFlmDNbka6I3EQFw7iZuugQjMb11KMpJCLPFL4ZPbMfaEhLADEL1yx0oujGkBQ7+qW3eA==
-
-"@rollup/rollup-android-arm64@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.49.0.tgz#4e05c86e0fb9af6eaf52fc298dcdec577477e35c"
-  integrity sha512-cqPpZdKUSQYRtLLr6R4X3sD4jCBO1zUmeo3qrWBCqYIeH8Q3KRL4F3V7XJ2Rm8/RJOQBZuqzQGWPjjvFUcYa/w==
-
-"@rollup/rollup-darwin-arm64@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.49.0.tgz#788fad425b4129875639e0c14b6441c5f3b69d46"
-  integrity sha512-99kMMSMQT7got6iYX3yyIiJfFndpojBmkHfTc1rIje8VbjhmqBXE+nb7ZZP3A5skLyujvT0eIUCUsxAe6NjWbw==
-
-"@rollup/rollup-darwin-x64@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.49.0.tgz#d44e05bee55b781d7c2cf535d9f9169787c3599d"
-  integrity sha512-y8cXoD3wdWUDpjOLMKLx6l+NFz3NlkWKcBCBfttUn+VGSfgsQ5o/yDUGtzE9HvsodkP0+16N0P4Ty1VuhtRUGg==
-
-"@rollup/rollup-freebsd-arm64@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.49.0.tgz#107786b4d604495224c3543bfd2cae33ddf76500"
-  integrity sha512-3mY5Pr7qv4GS4ZvWoSP8zha8YoiqrU+e0ViPvB549jvliBbdNLrg2ywPGkgLC3cmvN8ya3za+Q2xVyT6z+vZqA==
-
-"@rollup/rollup-freebsd-x64@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.49.0.tgz#54e105c3da27f31084ca6913fed603627755abde"
-  integrity sha512-C9KzzOAQU5gU4kG8DTk+tjdKjpWhVWd5uVkinCwwFub2m7cDYLOdtXoMrExfeBmeRy9kBQMkiyJ+HULyF1yj9w==
-
-"@rollup/rollup-linux-arm-gnueabihf@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.49.0.tgz#725c23e0766b5d9368180bc2c427a51e31d0e147"
-  integrity sha512-OVSQgEZDVLnTbMq5NBs6xkmz3AADByCWI4RdKSFNlDsYXdFtlxS59J+w+LippJe8KcmeSSM3ba+GlsM9+WwC1w==
-
-"@rollup/rollup-linux-arm-musleabihf@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.49.0.tgz#6946b0d2f132f2baf5657945b81565d8abd51cc0"
-  integrity sha512-ZnfSFA7fDUHNa4P3VwAcfaBLakCbYaxCk0jUnS3dTou9P95kwoOLAMlT3WmEJDBCSrOEFFV0Y1HXiwfLYJuLlA==
-
-"@rollup/rollup-linux-arm64-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.49.0.tgz#83510a6d03e748619241a17f5a879418a963c5ed"
-  integrity sha512-Z81u+gfrobVK2iV7GqZCBfEB1y6+I61AH466lNK+xy1jfqFLiQ9Qv716WUM5fxFrYxwC7ziVdZRU9qvGHkYIJg==
-
-"@rollup/rollup-linux-arm64-musl@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.49.0.tgz#085b98d44c10908626dd40f26bf924433bbd8471"
-  integrity sha512-zoAwS0KCXSnTp9NH/h9aamBAIve0DXeYpll85shf9NJ0URjSTzzS+Z9evmolN+ICfD3v8skKUPyk2PO0uGdFqg==
-
-"@rollup/rollup-linux-loongarch64-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.49.0.tgz#13e0a4808e9f7924f2cc8c133603f627c7a00543"
-  integrity sha512-2QyUyQQ1ZtwZGiq0nvODL+vLJBtciItC3/5cYN8ncDQcv5avrt2MbKt1XU/vFAJlLta5KujqyHdYtdag4YEjYQ==
-
-"@rollup/rollup-linux-ppc64-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.49.0.tgz#aeee4e47fc9ca5d6687e686fea4696202af6b2f4"
-  integrity sha512-k9aEmOWt+mrMuD3skjVJSSxHckJp+SiFzFG+v8JLXbc/xi9hv2icSkR3U7uQzqy+/QbbYY7iNB9eDTwrELo14g==
-
-"@rollup/rollup-linux-riscv64-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.49.0.tgz#603e4591643f1d7851a96d096cf7fcd273f7b0e1"
-  integrity sha512-rDKRFFIWJ/zJn6uk2IdYLc09Z7zkE5IFIOWqpuU0o6ZpHcdniAyWkwSUWE/Z25N/wNDmFHHMzin84qW7Wzkjsw==
-
-"@rollup/rollup-linux-riscv64-musl@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.49.0.tgz#f8fd9b01f1888e1816d5a398789d430511286c00"
-  integrity sha512-FkkhIY/hYFVnOzz1WeV3S9Bd1h0hda/gRqvZCMpHWDHdiIHn6pqsY3b5eSbvGccWHMQ1uUzgZTKS4oGpykf8Tw==
-
-"@rollup/rollup-linux-s390x-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.49.0.tgz#37a1fd372d9b93d2b75b2f37c482ecf52f52849b"
-  integrity sha512-gRf5c+A7QiOG3UwLyOOtyJMD31JJhMjBvpfhAitPAoqZFcOeK3Kc1Veg1z/trmt+2P6F/biT02fU19GGTS529A==
-
-"@rollup/rollup-linux-x64-gnu@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.49.0.tgz#131e66dbf7e71cb2a389acc45319bd4c990e093a"
-  integrity sha512-BR7+blScdLW1h/2hB/2oXM+dhTmpW3rQt1DeSiCP9mc2NMMkqVgjIN3DDsNpKmezffGC9R8XKVOLmBkRUcK/sA==
-
-"@rollup/rollup-linux-x64-musl@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.49.0.tgz#b7245a5ea57db9679e8bf3032c25a5d2c5f54056"
-  integrity sha512-hDMOAe+6nX3V5ei1I7Au3wcr9h3ktKzDvF2ne5ovX8RZiAHEtX1A5SNNk4zt1Qt77CmnbqT+upb/umzoPMWiPg==
-
-"@rollup/rollup-win32-arm64-msvc@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.49.0.tgz#768a128bb5da3c5472c3c56aec77507d28bc7209"
-  integrity sha512-wkNRzfiIGaElC9kXUT+HLx17z7D0jl+9tGYRKwd8r7cUqTL7GYAvgUY++U2hK6Ar7z5Z6IRRoWC8kQxpmM7TDA==
-
-"@rollup/rollup-win32-ia32-msvc@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.49.0.tgz#ce3f3b2eebe585340631498666718f00983a6a62"
-  integrity sha512-gq5aW/SyNpjp71AAzroH37DtINDcX1Qw2iv9Chyz49ZgdOP3NV8QCyKZUrGsYX9Yyggj5soFiRCgsL3HwD8TdA==
-
-"@rollup/rollup-win32-x64-msvc@4.49.0":
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.49.0.tgz#c2a0e3b81262a7e9dd12ce18b350a97558dd50bc"
-  integrity sha512-gEtqFbzmZLFk2xKh7g0Rlo8xzho8KrEFEkzvHbfUGkrgXOpZ4XagQ6n+wIZFNh1nTb8UD16J4nFSFKXYgnbdBg==
+"@rollup/rollup-android-arm-eabi@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.3.tgz#7050c2acdc1214a730058e21f613ab0e1fe1ced9"
+  integrity sha512-h6cqHGZ6VdnwliFG1NXvMPTy/9PS3h8oLh7ImwR+kl+oYnQizgjxsONmmPSb2C66RksfkfIxEVtDSEcJiO0tqw==
+
+"@rollup/rollup-android-arm64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.3.tgz#3f5b2afbfcbe9021649701cf6ff0d54b1fb7e4a5"
+  integrity sha512-wd+u7SLT/u6knklV/ifG7gr5Qy4GUbH2hMWcDauPFJzmCZUAJ8L2bTkVXC2niOIxp8lk3iH/QX8kSrUxVZrOVw==
+
+"@rollup/rollup-darwin-arm64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.3.tgz#70a1679fb4393ba7bafb730ee56a5278cbcdafb0"
+  integrity sha512-lj9ViATR1SsqycwFkJCtYfQTheBdvlWJqzqxwc9f2qrcVrQaF/gCuBRTiTolkRWS6KvNxSk4KHZWG7tDktLgjg==
+
+"@rollup/rollup-darwin-x64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.3.tgz#ae75aec88fa72069de9bca3a3ec22bf4e6a962bf"
+  integrity sha512-+Dyo7O1KUmIsbzx1l+4V4tvEVnVQqMOIYtrxK7ncLSknl1xnMHLgn7gddJVrYPNZfEB8CIi3hK8gq8bDhb3h5A==
+
+"@rollup/rollup-freebsd-arm64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.3.tgz#8a2bda997faa1d7e335ce1961ce71d1a76ac6288"
+  integrity sha512-u9Xg2FavYbD30g3DSfNhxgNrxhi6xVG4Y6i9Ur1C7xUuGDW3banRbXj+qgnIrwRN4KeJ396jchwy9bCIzbyBEQ==
+
+"@rollup/rollup-freebsd-x64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.3.tgz#fc287bcc39b9a9c0df97336d68fd5f4458f87977"
+  integrity sha512-5M8kyi/OX96wtD5qJR89a/3x5x8x5inXBZO04JWhkQb2JWavOWfjgkdvUqibGJeNNaz1/Z1PPza5/tAPXICI6A==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.3.tgz#5b5a2a55dffaa64d7c7a231e80e491219e33d4f3"
+  integrity sha512-IoerZJ4l1wRMopEHRKOO16e04iXRDyZFZnNZKrWeNquh5d6bucjezgd+OxG03mOMTnS1x7hilzb3uURPkJ0OfA==
+
+"@rollup/rollup-linux-arm-musleabihf@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.3.tgz#979eab95003c21837ea0fdd8a721aa3e69fa4aa3"
+  integrity sha512-ZYdtqgHTDfvrJHSh3W22TvjWxwOgc3ThK/XjgcNGP2DIwFIPeAPNsQxrJO5XqleSlgDux2VAoWQ5iJrtaC1TbA==
+
+"@rollup/rollup-linux-arm64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.3.tgz#53b89f1289cbeca5ed9b6ca1602a6fe1a29dd4e2"
+  integrity sha512-NcViG7A0YtuFDA6xWSgmFb6iPFzHlf5vcqb2p0lGEbT+gjrEEz8nC/EeDHvx6mnGXnGCC1SeVV+8u+smj0CeGQ==
+
+"@rollup/rollup-linux-arm64-musl@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.3.tgz#3bbcf5e13c09d0c4c55bd9c75ec6a7aeee56fe28"
+  integrity sha512-d3pY7LWno6SYNXRm6Ebsq0DJGoiLXTb83AIPCXl9fmtIQs/rXoS8SJxxUNtFbJ5MiOvs+7y34np77+9l4nfFMw==
+
+"@rollup/rollup-linux-loong64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.3.tgz#1cc71838465a8297f92ccc5cc9c29756b71f6e73"
+  integrity sha512-3y5GA0JkBuirLqmjwAKwB0keDlI6JfGYduMlJD/Rl7fvb4Ni8iKdQs1eiunMZJhwDWdCvrcqXRY++VEBbvk6Eg==
+
+"@rollup/rollup-linux-ppc64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.3.tgz#fe3fdf2ef57dc2d58fedd4f1e0678660772c843a"
+  integrity sha512-AUUH65a0p3Q0Yfm5oD2KVgzTKgwPyp9DSXc3UA7DtxhEb/WSPfbG4wqXeSN62OG5gSo18em4xv6dbfcUGXcagw==
+
+"@rollup/rollup-linux-riscv64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.3.tgz#eebc99e75832891d58532501879ca749b1592f93"
+  integrity sha512-1makPhFFVBqZE+XFg3Dkq+IkQ7JvmUrwwqaYBL2CE+ZpxPaqkGaiWFEWVGyvTwZace6WLJHwjVh/+CXbKDGPmg==
+
+"@rollup/rollup-linux-riscv64-musl@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.3.tgz#9a2df234d61763a44601eba17c36844a18f20539"
+  integrity sha512-OOFJa28dxfl8kLOPMUOQBCO6z3X2SAfzIE276fwT52uXDWUS178KWq0pL7d6p1kz7pkzA0yQwtqL0dEPoVcRWg==
+
+"@rollup/rollup-linux-s390x-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.3.tgz#f0e45ea7e41ee473c85458b1ec8fab9572cc1834"
+  integrity sha512-jMdsML2VI5l+V7cKfZx3ak+SLlJ8fKvLJ0Eoa4b9/vCUrzXKgoKxvHqvJ/mkWhFiyp88nCkM5S2v6nIwRtPcgg==
+
+"@rollup/rollup-linux-x64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.3.tgz#ed63dec576799fa5571eee5b2040f65faa82b49b"
+  integrity sha512-tPgGd6bY2M2LJTA1uGq8fkSPK8ZLYjDjY+ZLK9WHncCnfIz29LIXIqUgzCR0hIefzy6Hpbe8Th5WOSwTM8E7LA==
+
+"@rollup/rollup-linux-x64-musl@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.3.tgz#755c56ac79b17fbdf0359bce7e2293a11de30ad0"
+  integrity sha512-BCFkJjgk+WFzP+tcSMXq77ymAPIxsX9lFJWs+2JzuZTLtksJ2o5hvgTdIcZ5+oKzUDMwI0PfWzRBYAydAHF2Mw==
+
+"@rollup/rollup-openharmony-arm64@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.3.tgz#84b4170fe28c2b41e406add6ccf8513bf91195ea"
+  integrity sha512-KTD/EqjZF3yvRaWUJdD1cW+IQBk4fbQaHYJUmP8N4XoKFZilVL8cobFSTDnjTtxWJQ3JYaMgF4nObY/+nYkumA==
+
+"@rollup/rollup-win32-arm64-msvc@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.3.tgz#4fb0cd004183da819bec804eba70f1ef6936ccbf"
+  integrity sha512-+zteHZdoUYLkyYKObGHieibUFLbttX2r+58l27XZauq0tcWYYuKUwY2wjeCN9oK1Um2YgH2ibd6cnX/wFD7DuA==
+
+"@rollup/rollup-win32-ia32-msvc@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.3.tgz#1788ba80313477a31e6214390906201604ee38eb"
+  integrity sha512-of1iHkTQSo3kr6dTIRX6t81uj/c/b15HXVsPcEElN5sS859qHrOepM5p9G41Hah+CTqSh2r8Bm56dL2z9UQQ7g==
+
+"@rollup/rollup-win32-x64-gnu@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.3.tgz#867222f288a9557487900c7836998123ebbadc9d"
+  integrity sha512-s0hybmlHb56mWVZQj8ra9048/WZTPLILKxcvcq+8awSZmyiSUZjjem1AhU3Tf4ZKpYhK4mg36HtHDOe8QJS5PQ==
+
+"@rollup/rollup-win32-x64-msvc@4.52.3":
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.3.tgz#3f55b6e8fe809a7d29959d6bc686cce1804581f0"
+  integrity sha512-zGIbEVVXVtauFgl3MRwGWEN36P5ZGenHRMgNw88X5wEhEBpq0XrMEZwOn07+ICrwM17XO5xfMZqh0OldCH5VTA==
 
 "@rtsao/scc@^1.1.0":
   version "1.1.0"
-  resolved "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@rtsao/scc/-/scc-1.1.0.tgz#927dd2fae9bc3361403ac2c7a00c32ddce9ad7e8"
   integrity sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==
 
 "@rushstack/eslint-patch@^1.3.3":
-  version "1.10.4"
-  resolved "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.10.4.tgz"
-  integrity sha512-WJgX9nzTqknM393q1QJDJmoW28kUfEnybeTfVNcNAPnIx210RXm2DiXiHzfNPJNIUUb1tJnz/l4QGtJ30PgWmA==
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/@rushstack/eslint-patch/-/eslint-patch-1.12.0.tgz#326a7b46f6d4cfa54ae25bb888551697873069b4"
+  integrity sha512-5EwMtOqvJMMa3HbmxLlF74e+3/HhwBTMcvt3nqVJgGCozO6hzIPOBlwm8mGVNR9SN2IJpxSnlxczyDjcn7qIyw==
 
-"@sentry-internal/browser-utils@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry-internal/browser-utils/-/browser-utils-10.7.0.tgz#5edfcd84f8d0745be4e06cff2c4edd01d2a2493f"
-  integrity sha512-M5L1XKVkhRhIV2nfUwNxBoqir4SVDcHdqRBq+k1EK6Z6DCVF9GMTiLg46+egBwgUDlAAGIQImdKgtJTH/47Z9g==
+"@sentry-internal/browser-utils@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry-internal/browser-utils/-/browser-utils-10.15.0.tgz#9aac3f19e1678729e8580c8c561a3364d05b0f0a"
+  integrity sha512-hJxo6rj3cMqiYlZd6PC8o/i2FG6hRnZdHcJkfm1HXgWCRgdCPilKghL6WU+B2H5dLyRKJ17nWjDAVQPRdCxO9w==
   dependencies:
-    "@sentry/core" "10.7.0"
+    "@sentry/core" "10.15.0"
 
 "@sentry-internal/feedback@7.120.4":
   version "7.120.4"
@@ -5349,10 +5625,10 @@
     "@sentry/types" "7.120.4"
     "@sentry/utils" "7.120.4"
 
-"@sentry/babel-plugin-component-annotate@4.1.1":
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/@sentry/babel-plugin-component-annotate/-/babel-plugin-component-annotate-4.1.1.tgz#371415afc602f6b2ba0987b51123bd34d1603193"
-  integrity sha512-HUpqrCK7zDVojTV6KL6BO9ZZiYrEYQqvYQrscyMsq04z+WCupXaH6YEliiNRvreR8DBJgdsG3lBRpebhUGmvfA==
+"@sentry/babel-plugin-component-annotate@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@sentry/babel-plugin-component-annotate/-/babel-plugin-component-annotate-4.3.0.tgz#c5b6cbb986952596d3ad233540a90a1fd18bad80"
+  integrity sha512-OuxqBprXRyhe8Pkfyz/4yHQJc5c3lm+TmYWSSx8u48g5yKewSQDOxkiLU5pAk3WnbLPy8XwU/PN+2BG0YFU9Nw==
 
 "@sentry/browser@7.120.4", "@sentry/browser@^7.19.1":
   version "7.120.4"
@@ -5368,13 +5644,13 @@
     "@sentry/types" "7.120.4"
     "@sentry/utils" "7.120.4"
 
-"@sentry/bundler-plugin-core@4.1.1":
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/@sentry/bundler-plugin-core/-/bundler-plugin-core-4.1.1.tgz#7e273b83cc8b44f4067f05ab9ed5a7ec7ac6d625"
-  integrity sha512-Hx9RgXaD1HEYmL5aYoWwCKkVvPp4iklwfD9mvmdpQtcwLg6b6oLnPVDQaOry1ak6Pxt8smlrWcKy4IiKASlvig==
+"@sentry/bundler-plugin-core@4.3.0", "@sentry/bundler-plugin-core@^4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@sentry/bundler-plugin-core/-/bundler-plugin-core-4.3.0.tgz#cf302522a3e5b8a3bf727635d0c6a7bece981460"
+  integrity sha512-dmR4DJhJ4jqVWGWppuTL2blNFqOZZnt4aLkewbD1myFG3KVfUx8CrMQWEmGjkgPOtj5TO6xH9PyTJjXC6o5tnA==
   dependencies:
     "@babel/core" "^7.18.5"
-    "@sentry/babel-plugin-component-annotate" "4.1.1"
+    "@sentry/babel-plugin-component-annotate" "4.3.0"
     "@sentry/cli" "^2.51.0"
     dotenv "^16.3.1"
     find-up "^5.0.0"
@@ -5382,50 +5658,50 @@
     magic-string "0.30.8"
     unplugin "1.0.1"
 
-"@sentry/cli-darwin@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-darwin/-/cli-darwin-2.52.0.tgz#05178cd819c2a33eb22a6e90bf7bb8f853f1b476"
-  integrity sha512-ieQs/p4yTHT27nBzy0wtAb8BSISfWlpXdgsACcwXimYa36NJRwyCqgOXUaH/BYiTdwWSHpuANbUHGJW6zljzxw==
-
-"@sentry/cli-linux-arm64@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm64/-/cli-linux-arm64-2.52.0.tgz#1979141afc93022614f868374ecc4d3090e84833"
-  integrity sha512-RxT5uzxjCkcvplmx0bavJIEYerRex2Rg/2RAVBdVvWLKFOcmeerTn/VVxPZVuDIVMVyjlZsteWPYwfUm+Ia3wQ==
-
-"@sentry/cli-linux-arm@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm/-/cli-linux-arm-2.52.0.tgz#6957e11af62e50d1040488ec75b3d96ae33fbb5a"
-  integrity sha512-tWMLU+hj+iip5Akx+S76biAOE1eMMWTDq8c0MqMv/ahHgb6/HiVngMcUsp59Oz3EczJGbTkcnS3vRTDodEcMDw==
-
-"@sentry/cli-linux-i686@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-i686/-/cli-linux-i686-2.52.0.tgz#e369ce3afa4b83a482d34cfd25fae4af792b211a"
-  integrity sha512-sKcJmIg7QWFtlNU5Bs5OZprwdIzzyYMRpFkWioPZ4TE82yvP1+2SAX31VPUlTx+7NLU6YVEWNwvSxh8LWb7iOw==
-
-"@sentry/cli-linux-x64@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-x64/-/cli-linux-x64-2.52.0.tgz#2b447afac1bb96624823a49c0d9f23c54475bff2"
-  integrity sha512-aPZ7bP02zGkuEqTiOAm4np/ggfgtzrq4ti1Xze96Csi/DV3820SCfLrPlsvcvnqq7x69IL9cI3kXjdEpgrfGxw==
-
-"@sentry/cli-win32-arm64@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-arm64/-/cli-win32-arm64-2.52.0.tgz#059063774ab5437ea05d82ce316faa77582b8b51"
-  integrity sha512-90hrB5XdwJVhRpCmVrEcYoKW8nl5/V9OfVvOGeKUPvUkApLzvsInK74FYBZEVyAn1i/NdUv+Xk9q2zqUGK1aLQ==
-
-"@sentry/cli-win32-i686@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-i686/-/cli-win32-i686-2.52.0.tgz#bee3cded721fcf45db2e77bf84ea8653e4d803d9"
-  integrity sha512-HXlSE4CaLylNrELx4KVmOQjV5bURCNuky6sjCWiTH7HyDqHEak2Rk8iLE0JNLj5RETWMvmaZnZZFfmyGlY1opg==
-
-"@sentry/cli-win32-x64@2.52.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-x64/-/cli-win32-x64-2.52.0.tgz#16e501e5f00834b1f64765774c59740580043dfc"
-  integrity sha512-hJT0C3FwHk1Mt9oFqcci88wbO1D+yAWUL8J29HEGM5ZAqlhdh7sAtPDIC3P2LceUJOjnXihow47Bkj62juatIQ==
+"@sentry/cli-darwin@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-darwin/-/cli-darwin-2.55.0.tgz#79513547d15223d51905e94d8c1e2bc7377cfdf1"
+  integrity sha512-jGHE7SHHzqXUmnsmRLgorVH6nmMmTjQQXdPZbSL5tRtH8d3OIYrVNr5D72DSgD26XAPBDMV0ibqOQ9NKoiSpfA==
+
+"@sentry/cli-linux-arm64@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm64/-/cli-linux-arm64-2.55.0.tgz#5a2e8ea6e088f4884cbe272525f0781f8c748ff3"
+  integrity sha512-jNB/0/gFcOuDCaY/TqeuEpsy/k52dwyk1SOV3s1ku4DUsln6govTppeAGRewY3T1Rj9B2vgIWTrnB8KVh9+Rgg==
+
+"@sentry/cli-linux-arm@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-arm/-/cli-linux-arm-2.55.0.tgz#54c330471c4b23ff6769bfd886f092afba3380ce"
+  integrity sha512-ATjU0PsiWADSPLF/kZroLZ7FPKd5W9TDWHVkKNwIUNTei702LFgTjNeRwOIzTgSvG3yTmVEqtwFQfFN/7hnVXQ==
+
+"@sentry/cli-linux-i686@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-i686/-/cli-linux-i686-2.55.0.tgz#12c64453ef7014ba89c885497e3c9764a5f3e0a0"
+  integrity sha512-8LZjo6PncTM6bWdaggscNOi5r7F/fqRREsCwvd51dcjGj7Kp1plqo9feEzYQ+jq+KUzVCiWfHrUjddFmYyZJrg==
+
+"@sentry/cli-linux-x64@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-linux-x64/-/cli-linux-x64-2.55.0.tgz#c640464fe533fe87e57d0ca5585e0c504e0ef5b3"
+  integrity sha512-5LUVvq74Yj2cZZy5g5o/54dcWEaX4rf3myTHy73AKhRj1PABtOkfexOLbF9xSrZy95WXWaXyeH+k5n5z/vtHfA==
+
+"@sentry/cli-win32-arm64@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-arm64/-/cli-win32-arm64-2.55.0.tgz#da1e8ba13083c281fcdf72d1dd35255df7fdb5c5"
+  integrity sha512-cWIQdzm1pfLwPARsV6dUb8TVd6Y3V1A2VWxjTons3Ift6GvtVmiAe0OWL8t2Yt95i8v61kTD/6Tq21OAaogqzA==
+
+"@sentry/cli-win32-i686@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-i686/-/cli-win32-i686-2.55.0.tgz#c2eae0a75fc55f101c31de0999214d7e613d65c4"
+  integrity sha512-ldepCn2t9r4I0wvgk7NRaA7coJyy4rTQAzM66u9j5nTEsUldf66xym6esd5ZZRAaJUjffqvHqUIr/lrieTIrVg==
+
+"@sentry/cli-win32-x64@2.55.0":
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli-win32-x64/-/cli-win32-x64-2.55.0.tgz#499e6697663a3e1453ff2e921bf3876f774520b5"
+  integrity sha512-4hPc/I/9tXx+HLTdTGwlagtAfDSIa2AoTUP30tl32NAYQhx9a6niUbPAemK2qfxesiufJ7D2djX83rCw6WnJVA==
 
 "@sentry/cli@^2.51.0":
-  version "2.52.0"
-  resolved "https://registry.yarnpkg.com/@sentry/cli/-/cli-2.52.0.tgz#5162900bbfae57ddfc414bbe5780837622125aed"
-  integrity sha512-PXyo7Yv7+rVMSBGZfI/eFEzzhiKedTs25sDCjz4a3goAZ/F5R5tn3MKq30pnze5wNnoQmLujAa0uUjfNcWP+uQ==
+  version "2.55.0"
+  resolved "https://registry.yarnpkg.com/@sentry/cli/-/cli-2.55.0.tgz#c22d2edbd320242e7881c15ecf89649378c05387"
+  integrity sha512-cynvcIM2xL8ddwELyFRSpZQw4UtFZzoM2rId2l9vg7+wDREPDocMJB9lEQpBIo3eqhp9JswqUT037yjO6iJ5Sw==
   dependencies:
     https-proxy-agent "^5.0.0"
     node-fetch "^2.6.7"
@@ -5433,19 +5709,19 @@
     proxy-from-env "^1.1.0"
     which "^2.0.2"
   optionalDependencies:
-    "@sentry/cli-darwin" "2.52.0"
-    "@sentry/cli-linux-arm" "2.52.0"
-    "@sentry/cli-linux-arm64" "2.52.0"
-    "@sentry/cli-linux-i686" "2.52.0"
-    "@sentry/cli-linux-x64" "2.52.0"
-    "@sentry/cli-win32-arm64" "2.52.0"
-    "@sentry/cli-win32-i686" "2.52.0"
-    "@sentry/cli-win32-x64" "2.52.0"
-
-"@sentry/core@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/core/-/core-10.7.0.tgz#4a371b3449879956be665a6747c6792d14205b5a"
-  integrity sha512-y1Ni71O6TqeSi2Ug78StkVLHnybHZVYhnbYtj2w4g89XnQcqo4GUeR8dQRQBJpCX98UrHw22OAE8BXtKb03yXw==
+    "@sentry/cli-darwin" "2.55.0"
+    "@sentry/cli-linux-arm" "2.55.0"
+    "@sentry/cli-linux-arm64" "2.55.0"
+    "@sentry/cli-linux-i686" "2.55.0"
+    "@sentry/cli-linux-x64" "2.55.0"
+    "@sentry/cli-win32-arm64" "2.55.0"
+    "@sentry/cli-win32-i686" "2.55.0"
+    "@sentry/cli-win32-x64" "2.55.0"
+
+"@sentry/core@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/core/-/core-10.15.0.tgz#9b445d0d8bba1742eb76c53edb01b38e05702b00"
+  integrity sha512-J7WsQvb9G6nsVgWkTHwyX7wR2djtEACYCx19hAnRbSGIg+ysVG+7Ti3RL4bz9/VXfcxsz346cleKc7ljhynYlQ==
 
 "@sentry/core@7.120.4":
   version "7.120.4"
@@ -5466,83 +5742,84 @@
     localforage "^1.8.1"
 
 "@sentry/nextjs@^10":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/nextjs/-/nextjs-10.7.0.tgz#6ad21fc80a4d302362d0f597dd9b2f6ae0bfe09f"
-  integrity sha512-zGATwmUYd5rgy0G6Zi29GglxFYnn38FQQPjS+gnRPXaVIbck6Dtrjh+cJ3QDsttgUvfuZKpEE03JSrAA7D5QOA==
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/nextjs/-/nextjs-10.15.0.tgz#ff04095803569dbd9a687cd8ac1fe5828e5a1579"
+  integrity sha512-u3WLeeYgQH2Ug2SSdUu5ChMDKnWXeDXP7Bn+dRO01Y1/5NrMjoXO2w33ak03SLaZltPJFsRuMcfBtYoLA9BNlw==
   dependencies:
     "@opentelemetry/api" "^1.9.0"
-    "@opentelemetry/semantic-conventions" "^1.34.0"
+    "@opentelemetry/semantic-conventions" "^1.37.0"
     "@rollup/plugin-commonjs" "28.0.1"
-    "@sentry-internal/browser-utils" "10.7.0"
-    "@sentry/core" "10.7.0"
-    "@sentry/node" "10.7.0"
-    "@sentry/opentelemetry" "10.7.0"
-    "@sentry/react" "10.7.0"
-    "@sentry/vercel-edge" "10.7.0"
-    "@sentry/webpack-plugin" "^4.1.1"
+    "@sentry-internal/browser-utils" "10.15.0"
+    "@sentry/bundler-plugin-core" "^4.3.0"
+    "@sentry/core" "10.15.0"
+    "@sentry/node" "10.15.0"
+    "@sentry/opentelemetry" "10.15.0"
+    "@sentry/react" "10.15.0"
+    "@sentry/vercel-edge" "10.15.0"
+    "@sentry/webpack-plugin" "^4.3.0"
     chalk "3.0.0"
     resolve "1.22.8"
     rollup "^4.35.0"
     stacktrace-parser "^0.1.10"
 
-"@sentry/node-core@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/node-core/-/node-core-10.7.0.tgz#01d0ebb77d4da468fc181e0879153057148eb111"
-  integrity sha512-iafuG3Fp0pleuk1WaL4UW7wpT6C86pMEQBZ7ARZ7UHc9ujRi/dewKFi0Stu0SxJm6PZ706VZ8Igz9xpvQ0aEEg==
+"@sentry/node-core@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/node-core/-/node-core-10.15.0.tgz#d52644060d7792aa332ba1e19665b0a10ae3ccea"
+  integrity sha512-X6QAHulgfkpONYrXNK2QXfW02ja5FS31sn5DWfCDO8ggHej/u2mrf5nwnUU8vilSwbInHmiMpkUswGEKYDEKTA==
   dependencies:
-    "@sentry/core" "10.7.0"
-    "@sentry/opentelemetry" "10.7.0"
+    "@sentry/core" "10.15.0"
+    "@sentry/opentelemetry" "10.15.0"
     import-in-the-middle "^1.14.2"
 
-"@sentry/node@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/node/-/node-10.7.0.tgz#a84ba5ce6b644cebe22052d04b2b3f0a97888568"
-  integrity sha512-VtUFyf8avWUqN5RRTTmcU8aGdyNUGHzz/f+3n86BR5gBL3lziKOajyc0VClfc80VLsih+PWQ/5FrIHl+S1S1YQ==
+"@sentry/node@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/node/-/node-10.15.0.tgz#133c168d8944b5852a162d265834a9fbb1c58b6a"
+  integrity sha512-5V9BX55DEIscU/S5+AEIQuIMKKbSd+MVo1/x5UkOceBxfiA0KUmgQ0POIpUEZqGCS9rpQ5fEajByRXAQ7bjaWA==
   dependencies:
     "@opentelemetry/api" "^1.9.0"
-    "@opentelemetry/context-async-hooks" "^2.0.0"
-    "@opentelemetry/core" "^2.0.0"
-    "@opentelemetry/instrumentation" "^0.203.0"
-    "@opentelemetry/instrumentation-amqplib" "0.50.0"
-    "@opentelemetry/instrumentation-connect" "0.47.0"
-    "@opentelemetry/instrumentation-dataloader" "0.21.1"
-    "@opentelemetry/instrumentation-express" "0.52.0"
-    "@opentelemetry/instrumentation-fs" "0.23.0"
-    "@opentelemetry/instrumentation-generic-pool" "0.47.0"
-    "@opentelemetry/instrumentation-graphql" "0.51.0"
-    "@opentelemetry/instrumentation-hapi" "0.50.0"
-    "@opentelemetry/instrumentation-http" "0.203.0"
-    "@opentelemetry/instrumentation-ioredis" "0.51.0"
-    "@opentelemetry/instrumentation-kafkajs" "0.13.0"
-    "@opentelemetry/instrumentation-knex" "0.48.0"
-    "@opentelemetry/instrumentation-koa" "0.51.0"
-    "@opentelemetry/instrumentation-lru-memoizer" "0.48.0"
-    "@opentelemetry/instrumentation-mongodb" "0.56.0"
-    "@opentelemetry/instrumentation-mongoose" "0.50.0"
-    "@opentelemetry/instrumentation-mysql" "0.49.0"
-    "@opentelemetry/instrumentation-mysql2" "0.50.0"
-    "@opentelemetry/instrumentation-pg" "0.55.0"
-    "@opentelemetry/instrumentation-redis" "0.51.0"
-    "@opentelemetry/instrumentation-tedious" "0.22.0"
-    "@opentelemetry/instrumentation-undici" "0.14.0"
-    "@opentelemetry/resources" "^2.0.0"
-    "@opentelemetry/sdk-trace-base" "^2.0.0"
-    "@opentelemetry/semantic-conventions" "^1.34.0"
-    "@prisma/instrumentation" "6.14.0"
-    "@sentry/core" "10.7.0"
-    "@sentry/node-core" "10.7.0"
-    "@sentry/opentelemetry" "10.7.0"
+    "@opentelemetry/context-async-hooks" "^2.1.0"
+    "@opentelemetry/core" "^2.1.0"
+    "@opentelemetry/instrumentation" "^0.204.0"
+    "@opentelemetry/instrumentation-amqplib" "0.51.0"
+    "@opentelemetry/instrumentation-connect" "0.48.0"
+    "@opentelemetry/instrumentation-dataloader" "0.22.0"
+    "@opentelemetry/instrumentation-express" "0.53.0"
+    "@opentelemetry/instrumentation-fs" "0.24.0"
+    "@opentelemetry/instrumentation-generic-pool" "0.48.0"
+    "@opentelemetry/instrumentation-graphql" "0.52.0"
+    "@opentelemetry/instrumentation-hapi" "0.51.0"
+    "@opentelemetry/instrumentation-http" "0.204.0"
+    "@opentelemetry/instrumentation-ioredis" "0.52.0"
+    "@opentelemetry/instrumentation-kafkajs" "0.14.0"
+    "@opentelemetry/instrumentation-knex" "0.49.0"
+    "@opentelemetry/instrumentation-koa" "0.52.0"
+    "@opentelemetry/instrumentation-lru-memoizer" "0.49.0"
+    "@opentelemetry/instrumentation-mongodb" "0.57.0"
+    "@opentelemetry/instrumentation-mongoose" "0.51.0"
+    "@opentelemetry/instrumentation-mysql" "0.50.0"
+    "@opentelemetry/instrumentation-mysql2" "0.51.0"
+    "@opentelemetry/instrumentation-pg" "0.57.0"
+    "@opentelemetry/instrumentation-redis" "0.53.0"
+    "@opentelemetry/instrumentation-tedious" "0.23.0"
+    "@opentelemetry/instrumentation-undici" "0.15.0"
+    "@opentelemetry/resources" "^2.1.0"
+    "@opentelemetry/sdk-trace-base" "^2.1.0"
+    "@opentelemetry/semantic-conventions" "^1.37.0"
+    "@prisma/instrumentation" "6.15.0"
+    "@sentry/core" "10.15.0"
+    "@sentry/node-core" "10.15.0"
+    "@sentry/opentelemetry" "10.15.0"
     import-in-the-middle "^1.14.2"
     minimatch "^9.0.0"
 
-"@sentry/opentelemetry@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/opentelemetry/-/opentelemetry-10.7.0.tgz#ae6a12a9a1bc30d0e260398085a691cabb7bd814"
-  integrity sha512-8SrRZyERDfCYYett6dklGe+qWMDZSytKPIZpS0nDb0IqZGC02ZVIhRISbBTy4Gctowu/gMK9XaOXfBNN0pI1sg==
+"@sentry/opentelemetry@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/opentelemetry/-/opentelemetry-10.15.0.tgz#9204876f81a061173b3d4105a64cb57035627550"
+  integrity sha512-j+uk3bfxGgsBejwpq78iRZ+aBOKR/fWcJi72MBTboTEK3B4LINO65PyJqwOhcZOJVVAPL6IK1+sWQp4RL24GTg==
   dependencies:
-    "@sentry/core" "10.7.0"
+    "@sentry/core" "10.15.0"
 
-"@sentry/react@10.7.0", "@sentry/react@^6.13.2", "@sentry/react@^7.19.1":
+"@sentry/react@10.15.0", "@sentry/react@^6.13.2", "@sentry/react@^7.19.1":
   version "7.120.4"
   resolved "https://registry.yarnpkg.com/@sentry/react/-/react-7.120.4.tgz#8c475128625b425a31a7ee8dae89126dad0b3c3b"
   integrity sha512-Pj1MSezEncE+5riuwsk8peMncuz5HR72Yr1/RdZhMZvUxoxAR/tkwD3aPcK6ddQJTagd2TGwhdr9SHuDLtONew==
@@ -5575,21 +5852,21 @@
   dependencies:
     "@sentry/types" "7.120.4"
 
-"@sentry/vercel-edge@10.7.0":
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/@sentry/vercel-edge/-/vercel-edge-10.7.0.tgz#e887486cf619e24ad16caaccb6082a6db93e6731"
-  integrity sha512-HSmpxuar6hXhGdLHa0C3ZOx1tDzUuvVs31RAoRfShychIQp2904OOw5edOa9jM4AnhG1Qk/ZeF7sYJZAzdFnGQ==
+"@sentry/vercel-edge@10.15.0":
+  version "10.15.0"
+  resolved "https://registry.yarnpkg.com/@sentry/vercel-edge/-/vercel-edge-10.15.0.tgz#2c06ca6ea0865a97ed967d775698bf8f33405d46"
+  integrity sha512-QNruocfQy2P3rrgCKHCWNq7bsy+cFVNY25Y5PDaYsFKSiIge482g4Tjvfi7VMohy5jozcC1y82efFhicp3UqYg==
   dependencies:
     "@opentelemetry/api" "^1.9.0"
-    "@opentelemetry/resources" "^2.0.0"
-    "@sentry/core" "10.7.0"
+    "@opentelemetry/resources" "^2.1.0"
+    "@sentry/core" "10.15.0"
 
-"@sentry/webpack-plugin@^4.1.1":
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/@sentry/webpack-plugin/-/webpack-plugin-4.1.1.tgz#638c6b65cbc19b5027ffbb6bcd68094e0b0f82c6"
-  integrity sha512-2gFWcQMW1HdJDo/7rADeFs9crkH02l+mW4O1ORbxSjuegauyp1W8SBe7EfPoXbUmLdA3zwnpIxEXjjQpP5Etzg==
+"@sentry/webpack-plugin@^4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@sentry/webpack-plugin/-/webpack-plugin-4.3.0.tgz#a96db7d8ada8646ec3ffdec2a7db6143c8061e85"
+  integrity sha512-K4nU1SheK/tvyakBws2zfd+MN6hzmpW+wPTbSbDWn1+WL9+g9hsPh8hjFFiVe47AhhUoUZ3YgiH2HyeHXjHflA==
   dependencies:
-    "@sentry/bundler-plugin-core" "4.1.1"
+    "@sentry/bundler-plugin-core" "4.3.0"
     unplugin "1.0.1"
     uuid "^9.0.0"
 
@@ -5608,12 +5885,12 @@
 
 "@signozhq/design-tokens@1.1.4":
   version "1.1.4"
-  resolved "https://registry.npmjs.org/@signozhq/design-tokens/-/design-tokens-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/@signozhq/design-tokens/-/design-tokens-1.1.4.tgz#5d5de5bd9d19b6a3631383db015cc4b70c3f7661"
   integrity sha512-ICZz5szxTq8NcKAsk6LP+nSybPyEcyy8eu2zfxlPQCnJ1YjJP1PglaKLlF0N6+D60gAd3yC5he06BqR8/HxjNg==
 
 "@signozhq/icons@^0.0.1":
   version "0.0.1"
-  resolved "https://registry.npmjs.org/@signozhq/icons/-/icons-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@signozhq/icons/-/icons-0.0.1.tgz#efb960bee54ba82f04eda12ec28655cb8533219d"
   integrity sha512-8IJBec9fHHlZKwxKsLFDHaFx/jXFvn84Zjp6zBIRHFLiIcXFtMlZYn73jraT63c+sTXoRig7BXz5s1jKE7FLKw==
   dependencies:
     "@babel/runtime" "^7.22.5"
@@ -5622,7 +5899,7 @@
 
 "@signozhq/pagination@^0.0.1":
   version "0.0.1"
-  resolved "https://registry.npmjs.org/@signozhq/pagination/-/pagination-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/@signozhq/pagination/-/pagination-0.0.1.tgz#1afbe9ca6be7ccc758a33dfa087c372d9a9db2d2"
   integrity sha512-1AkxNk9HClAPJLd6gKpze6NEM5/wOqziLAbhCodn8i7F8IxtLIoXKJzf2cJCIA1K2x6op3oI8PUa00I1TWv92A==
   dependencies:
     "@radix-ui/react-icons" "^1.3.0"
@@ -5634,10 +5911,56 @@
     tailwind-merge "^2.5.2"
     tailwindcss-animate "^1.0.7"
 
-"@stoplight/elements-core@^8.5.0":
-  version "8.5.0"
-  resolved "https://registry.npmjs.org/@stoplight/elements-core/-/elements-core-8.5.0.tgz"
-  integrity sha512-o31OhA7TCdOS+T72l7tpOWjAiqy6zu0PK32G0KPBNCSneImI8j5fNfTxTRCvtZRdJveFXMA+BhSzpUMXqb+8cg==
+"@sigstore/bundle@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@sigstore/bundle/-/bundle-3.1.0.tgz#74f8f3787148400ddd364be8a9a9212174c66646"
+  integrity sha512-Mm1E3/CmDDCz3nDhFKTuYdB47EdRFRQMOE/EAbiG1MJW77/w1b3P7Qx7JSrVJs8PfwOLOVcKQCHErIwCTyPbag==
+  dependencies:
+    "@sigstore/protobuf-specs" "^0.4.0"
+
+"@sigstore/core@^2.0.0":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@sigstore/core/-/core-2.0.0.tgz#f888a8e4c8fdaa27848514a281920b6fd8eca955"
+  integrity sha512-nYxaSb/MtlSI+JWcwTHQxyNmWeWrUXJJ/G4liLrGG7+tS4vAz6LF3xRXqLH6wPIVUoZQel2Fs4ddLx4NCpiIYg==
+
+"@sigstore/protobuf-specs@^0.4.0", "@sigstore/protobuf-specs@^0.4.1":
+  version "0.4.3"
+  resolved "https://registry.yarnpkg.com/@sigstore/protobuf-specs/-/protobuf-specs-0.4.3.tgz#5d974eb16c0a1d44a3f0af6e3e7219b35ac57953"
+  integrity sha512-fk2zjD9117RL9BjqEwF7fwv7Q/P9yGsMV4MUJZ/DocaQJ6+3pKr+syBq1owU5Q5qGw5CUbXzm+4yJ2JVRDQeSA==
+
+"@sigstore/sign@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@sigstore/sign/-/sign-3.1.0.tgz#5d098d4d2b59a279e9ac9b51c794104cda0c649e"
+  integrity sha512-knzjmaOHOov1Ur7N/z4B1oPqZ0QX5geUfhrVaqVlu+hl0EAoL4o+l0MSULINcD5GCWe3Z0+YJO8ues6vFlW0Yw==
+  dependencies:
+    "@sigstore/bundle" "^3.1.0"
+    "@sigstore/core" "^2.0.0"
+    "@sigstore/protobuf-specs" "^0.4.0"
+    make-fetch-happen "^14.0.2"
+    proc-log "^5.0.0"
+    promise-retry "^2.0.1"
+
+"@sigstore/tuf@^3.1.0", "@sigstore/tuf@^3.1.1":
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@sigstore/tuf/-/tuf-3.1.1.tgz#b01b261288f646e0da57737782893e7d2695c52e"
+  integrity sha512-eFFvlcBIoGwVkkwmTi/vEQFSva3xs5Ot3WmBcjgjVdiaoelBLQaQ/ZBfhlG0MnG0cmTYScPpk7eDdGDWUcFUmg==
+  dependencies:
+    "@sigstore/protobuf-specs" "^0.4.1"
+    tuf-js "^3.0.1"
+
+"@sigstore/verify@^2.1.0":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@sigstore/verify/-/verify-2.1.1.tgz#f67730012cd474f595044c3717f32ac2a1e9d2bc"
+  integrity sha512-hVJD77oT67aowHxwT4+M6PGOp+E2LtLdTK3+FC0lBO9T7sYwItDMXZ7Z07IDCvR1M717a4axbIWckrW67KMP/w==
+  dependencies:
+    "@sigstore/bundle" "^3.1.0"
+    "@sigstore/core" "^2.0.0"
+    "@sigstore/protobuf-specs" "^0.4.1"
+
+"@stoplight/elements-core@^8.5.2":
+  version "8.5.2"
+  resolved "https://registry.yarnpkg.com/@stoplight/elements-core/-/elements-core-8.5.2.tgz#a8e42421cf61c2bbb93a77acba851d879129c43f"
+  integrity sha512-hr2BxJeSHz3TpoejH088GDwxRikSYT52K/+NFd6FvJDyQDZhlicgqsPwoveUCWZwGpIDppV1dBnuLHj6CncA0g==
   dependencies:
     "@stoplight/http-spec" "^7.1.0"
     "@stoplight/json" "^3.21.0"
@@ -5669,11 +5992,11 @@
     xml-formatter "^3.6.3"
 
 "@stoplight/elements@^8.5.0":
-  version "8.5.0"
-  resolved "https://registry.npmjs.org/@stoplight/elements/-/elements-8.5.0.tgz"
-  integrity sha512-E0gK8Vj7PUnPBS6ayZM/3EZzOmCXnBCS1xzjfgngiytegQHd8puEdxAsMqax+u/PxMFxFM65+7FkTl+4VrZ/tg==
+  version "8.5.2"
+  resolved "https://registry.yarnpkg.com/@stoplight/elements/-/elements-8.5.2.tgz#c84c8fdc9ca3cea0b57a24a4af84e764c5ee2596"
+  integrity sha512-M36IxjakZlhfEhclIYwNBMqyH1svHDoOePHizkp4tc+UvS1Xdv2uKghq/mDuGaUP53ZRD1SkW4HQAIrs3jBctg==
   dependencies:
-    "@stoplight/elements-core" "^8.5.0"
+    "@stoplight/elements-core" "^8.5.2"
     "@stoplight/http-spec" "^7.1.0"
     "@stoplight/json" "^3.18.1"
     "@stoplight/mosaic" "^1.53.4"
@@ -5687,7 +6010,7 @@
 
 "@stoplight/http-spec@^7.1.0":
   version "7.1.0"
-  resolved "https://registry.npmjs.org/@stoplight/http-spec/-/http-spec-7.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/http-spec/-/http-spec-7.1.0.tgz#516fec5f4b08cc93dadfb4969a6f9616165b0553"
   integrity sha512-Z2XqKX2SV8a1rrgSzFqccX2TolfcblT+l4pNvUU+THaLl50tKDoeidwWWZTzYUzqU0+UV97ponvqEbWWN3PaXg==
   dependencies:
     "@stoplight/json" "^3.18.1"
@@ -5705,7 +6028,7 @@
 
 "@stoplight/json-schema-generator@1.0.2":
   version "1.0.2"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-generator/-/json-schema-generator-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-generator/-/json-schema-generator-1.0.2.tgz#9db1b05bc6c79f7dd5bdab86985ed9eccc964d93"
   integrity sha512-FzSLFoIZc6Lmw3oRE7kU6YUrl5gBmUs//rY59jdFipBoSyTPv5NyqeyTg5mvT6rY1F3qTLU3xgzRi/9Pb9eZpA==
   dependencies:
     cross-fetch "^3.1.5"
@@ -5716,7 +6039,7 @@
 
 "@stoplight/json-schema-merge-allof@^0.8.0":
   version "0.8.0"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-merge-allof/-/json-schema-merge-allof-0.8.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-merge-allof/-/json-schema-merge-allof-0.8.0.tgz#62f8116f59d9df5a910d037b1965decd2efab472"
   integrity sha512-g8e0s43v96Xbzvd8d6KKUuJTO16CS2oJglJrviUi8ASIUxzFvAJqTHWLtGmpTryisQopqg1evXGJfi0+164+Qw==
   dependencies:
     compute-lcm "^1.1.0"
@@ -5725,7 +6048,7 @@
 
 "@stoplight/json-schema-ref-parser@^9.2.7":
   version "9.2.7"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-ref-parser/-/json-schema-ref-parser-9.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-ref-parser/-/json-schema-ref-parser-9.2.7.tgz#b1320b3a8ac9783663af870667fae9a616c4bfd3"
   integrity sha512-1vNzJ7iSrFTAFNbZHPyhI6GiJJw74+WaV61bARUQEDR4Jm80f9s0Tq9uCvGoMYwIFmWDJAoTiyegnUs6SvVxDw==
   dependencies:
     "@jsdevtools/ono" "^7.1.3"
@@ -5738,7 +6061,7 @@
 
 "@stoplight/json-schema-sampler@0.3.0":
   version "0.3.0"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-sampler/-/json-schema-sampler-0.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-sampler/-/json-schema-sampler-0.3.0.tgz#0d20ccc37e886cdcb4ec1955efe7fad60938f635"
   integrity sha512-G7QImi2xr9+8iPEg0D9YUi1BWhIiiEm19aMb91oWBSdxuhezOAqqRP3XNY6wczHV9jLWW18f+KkghTy9AG0BQA==
   dependencies:
     "@types/json-schema" "^7.0.7"
@@ -5746,7 +6069,7 @@
 
 "@stoplight/json-schema-tree@^4.0.0":
   version "4.0.0"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-tree/-/json-schema-tree-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-tree/-/json-schema-tree-4.0.0.tgz#402790a21e076d69c1b8f5dded0bbe158134ab77"
   integrity sha512-SAGtof+ihIdPqETR+7XXOaqZJcrbSih/xEahaw5t1nXk5sVW6ss2l5A1WCIuvtvnQiUKnBfanmZU4eoM1ZvItg==
   dependencies:
     "@stoplight/json" "^3.12.0"
@@ -5757,7 +6080,7 @@
 
 "@stoplight/json-schema-viewer@4.16.3":
   version "4.16.3"
-  resolved "https://registry.npmjs.org/@stoplight/json-schema-viewer/-/json-schema-viewer-4.16.3.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json-schema-viewer/-/json-schema-viewer-4.16.3.tgz#d9ccdea065eb869ad2a3b70be4f3976b8986794d"
   integrity sha512-cQDxmyAkR3l8Pem1EuGMR+JKM8ePTSr/aqzJscp+hJ4R2geUNbdEleBHnJkZLLLfNr+PMlP+WiFO6GajCSxzUA==
   dependencies:
     "@stoplight/json" "^3.20.1"
@@ -5771,7 +6094,7 @@
 
 "@stoplight/json@^3.12.0", "@stoplight/json@^3.18.1", "@stoplight/json@^3.20.1", "@stoplight/json@^3.21.0":
   version "3.21.7"
-  resolved "https://registry.npmjs.org/@stoplight/json/-/json-3.21.7.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/json/-/json-3.21.7.tgz#102f5fd11921984c96672ce4307850daa1cbfc7b"
   integrity sha512-xcJXgKFqv/uCEgtGlPxy3tPA+4I+ZI4vAuMJ885+ThkTHFVkC+0Fm58lA9NlsyjnkpxFh4YiQWpH+KefHdbA0A==
   dependencies:
     "@stoplight/ordered-object-literal" "^1.0.3"
@@ -5783,7 +6106,7 @@
 
 "@stoplight/lifecycle@^2.3.2":
   version "2.3.3"
-  resolved "https://registry.npmjs.org/@stoplight/lifecycle/-/lifecycle-2.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/lifecycle/-/lifecycle-2.3.3.tgz#415c9506f1f70ccad76779e5562747475a5208c1"
   integrity sha512-JbPRTIzPZabeYPAk5+gdsnfwAxqW35G9e0ZjOG3toUmNViLOsEzuK4vpWd+Prv2Mw8HRmu+haiYizteZp6mk0w==
   dependencies:
     tslib "^2.3.1"
@@ -5791,7 +6114,7 @@
 
 "@stoplight/markdown-viewer@^5.7.1":
   version "5.7.1"
-  resolved "https://registry.npmjs.org/@stoplight/markdown-viewer/-/markdown-viewer-5.7.1.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/markdown-viewer/-/markdown-viewer-5.7.1.tgz#c29a6c1e03f0bac8a40405c096cbe87c274e00a6"
   integrity sha512-EiJC0w/l+Juc49fVCBOEOOg/NdCWDC8o1lS7d6P5skHS5G+hw1c3GNlCZ2BSqs8z8kkmSzSDWo5XY1S16NVJbQ==
   dependencies:
     "@rehooks/component-size" "^1.0.3"
@@ -5811,7 +6134,7 @@
 
 "@stoplight/markdown@^3.1.3":
   version "3.2.0"
-  resolved "https://registry.npmjs.org/@stoplight/markdown/-/markdown-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/markdown/-/markdown-3.2.0.tgz#c52b2874de3bbda5cb4747a1ce7d870342e218bd"
   integrity sha512-Hhnrj7xb+f4iMQQeZBKLgfst3OJyV8T4BKr8BSYnKpp070B6fE63V/lkPuKqrpvidcv6kz3INDBU/GE7K2Q0uw==
   dependencies:
     "@stoplight/types" "^12.3.0"
@@ -5831,7 +6154,7 @@
 
 "@stoplight/mosaic-code-editor@^1.53.4":
   version "1.53.4"
-  resolved "https://registry.npmjs.org/@stoplight/mosaic-code-editor/-/mosaic-code-editor-1.53.4.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/mosaic-code-editor/-/mosaic-code-editor-1.53.4.tgz#a8d2c9f38d735cff4a187950de05c03a3a69caf8"
   integrity sha512-StVEXVq5ZlVGvfdsKIYw/h76jb22CKCBUcgNmGyKSQx9ZmLc1wA24CWvbRvSxXKm3/0/P/IyVZ61aaYItqhmrg==
   dependencies:
     "@fortawesome/fontawesome-svg-core" "^6.1.1"
@@ -5861,7 +6184,7 @@
 
 "@stoplight/mosaic-code-viewer@1.53.4", "@stoplight/mosaic-code-viewer@^1.53.4":
   version "1.53.4"
-  resolved "https://registry.npmjs.org/@stoplight/mosaic-code-viewer/-/mosaic-code-viewer-1.53.4.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/mosaic-code-viewer/-/mosaic-code-viewer-1.53.4.tgz#650ea524d62baada0c0b92f19c1de2135f0ed179"
   integrity sha512-RZEZ7+UodFQtuuVHyCONg/8wNDlFCuDz0knneGrDaQ1vDa3ddePPjBQnpqVFY0ndXqoaxZTuQu4GvcC8wKdk0Q==
   dependencies:
     "@fortawesome/fontawesome-svg-core" "^6.1.1"
@@ -5890,7 +6213,7 @@
 
 "@stoplight/mosaic@1.53.4", "@stoplight/mosaic@^1.53.4":
   version "1.53.4"
-  resolved "https://registry.npmjs.org/@stoplight/mosaic/-/mosaic-1.53.4.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/mosaic/-/mosaic-1.53.4.tgz#04e03a4dfb95e0a451cd2bde6e14ad66103a684d"
   integrity sha512-k3D9B2bM/Ko7ibKKWxJuhomHCOAxooPNPZNX0aY+3kTmQf7tJL+70iwcwD7TbrMyOj7L8SzJPRpJ9fcM8LaDNA==
   dependencies:
     "@fortawesome/fontawesome-svg-core" "^6.1.1"
@@ -5920,29 +6243,29 @@
 
 "@stoplight/ordered-object-literal@^1.0.3", "@stoplight/ordered-object-literal@^1.0.5":
   version "1.0.5"
-  resolved "https://registry.npmjs.org/@stoplight/ordered-object-literal/-/ordered-object-literal-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/ordered-object-literal/-/ordered-object-literal-1.0.5.tgz#06689095a4f1a53e9d9a5f0055f707c387af966a"
   integrity sha512-COTiuCU5bgMUtbIFBuyyh2/yVVzlr5Om0v5utQDgBCuQUOPgU1DwoffkTfg4UBQOvByi5foF4w4T+H9CoRe5wg==
 
 "@stoplight/path@^1.3.2":
   version "1.3.2"
-  resolved "https://registry.npmjs.org/@stoplight/path/-/path-1.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/path/-/path-1.3.2.tgz#96e591496b72fde0f0cdae01a61d64f065bd9ede"
   integrity sha512-lyIc6JUlUA8Ve5ELywPC8I2Sdnh1zc1zmbYgVarhXIp9YeAB0ReeqmGEOWNtlHkbP2DAA1AL65Wfn2ncjK/jtQ==
 
 "@stoplight/react-error-boundary@^2.0.0":
   version "2.0.0"
-  resolved "https://registry.npmjs.org/@stoplight/react-error-boundary/-/react-error-boundary-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/react-error-boundary/-/react-error-boundary-2.0.0.tgz#63a2dcbaced4c77b4a9b6c3fb2be582de1d60236"
   integrity sha512-r9cyaaH2h0kFe5c0aP+yJuY9CyXgfbBaMO6660M/wRQXqM49K5Ul7kexE4ei2cqYgo+Cd6ALl6RXSZFYwf2kCA==
   dependencies:
     "@sentry/react" "^6.13.2"
 
 "@stoplight/react-error-boundary@^3.0.0":
   version "3.0.0"
-  resolved "https://registry.npmjs.org/@stoplight/react-error-boundary/-/react-error-boundary-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/react-error-boundary/-/react-error-boundary-3.0.0.tgz#aaeb7edd3ff0dbe7ab5508464038c4c88cfb4772"
   integrity sha512-lFuTpGy2fu4hffmRTnJot1URa9/ifVLyPPQg62WW3RYo9LsxxHF0PrnFzAeXEQb40g1kc55S/oX6zQc8YJrKXg==
 
 "@stoplight/types@14.1.0":
   version "14.1.0"
-  resolved "https://registry.npmjs.org/@stoplight/types/-/types-14.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/types/-/types-14.1.0.tgz#36b04488acc1d8ab5bb712416f50d3bc99610b34"
   integrity sha512-fL8Nzw03+diALw91xHEHA5Q0WCGeW9WpPgZQjodNUWogAgJ56aJs03P9YzsQ1J6fT7/XjDqHMgn7/RlsBzB/SQ==
   dependencies:
     "@types/json-schema" "^7.0.4"
@@ -5950,7 +6273,7 @@
 
 "@stoplight/types@^12.3.0":
   version "12.5.0"
-  resolved "https://registry.npmjs.org/@stoplight/types/-/types-12.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/types/-/types-12.5.0.tgz#ebbeeb8c874de30e4cd9a1a2a6c8d6062c155da0"
   integrity sha512-dwqYcDrGmEyUv5TWrDam5TGOxU72ufyQ7hnOIIDdmW5ezOwZaBFoR5XQ9AsH49w7wgvOqB2Bmo799pJPWnpCbg==
   dependencies:
     "@types/json-schema" "^7.0.4"
@@ -5958,7 +6281,7 @@
 
 "@stoplight/types@^13.6.0", "@stoplight/types@^13.7.0":
   version "13.20.0"
-  resolved "https://registry.npmjs.org/@stoplight/types/-/types-13.20.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/types/-/types-13.20.0.tgz#d42682f1e3a14a3c60bdf0df08bff4023518763d"
   integrity sha512-2FNTv05If7ib79VPDA/r9eUet76jewXFH2y2K5vuge6SXbRHtWBhcaRmu+6QpF4/WRNoJj5XYRSwLGXDxysBGA==
   dependencies:
     "@types/json-schema" "^7.0.4"
@@ -5966,7 +6289,7 @@
 
 "@stoplight/types@^14.1.1":
   version "14.1.1"
-  resolved "https://registry.npmjs.org/@stoplight/types/-/types-14.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/types/-/types-14.1.1.tgz#0dd5761aac25673a951955e984c724c138368b7a"
   integrity sha512-/kjtr+0t0tjKr+heVfviO9FrU/uGLc+QNX3fHJc19xsCNYqU7lVhaXxDmEID9BZTjG+/r9pK9xP/xU02XGg65g==
   dependencies:
     "@types/json-schema" "^7.0.4"
@@ -5974,12 +6297,12 @@
 
 "@stoplight/yaml-ast-parser@0.0.50":
   version "0.0.50"
-  resolved "https://registry.npmjs.org/@stoplight/yaml-ast-parser/-/yaml-ast-parser-0.0.50.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/yaml-ast-parser/-/yaml-ast-parser-0.0.50.tgz#ed625a1d9ae63eb61980446e058fa745386ab61e"
   integrity sha512-Pb6M8TDO9DtSVla9yXSTAxmo9GVEouq5P40DWXdOie69bXogZTkgvopCq+yEvTMA0F6PEvdJmbtTV3ccIp11VQ==
 
 "@stoplight/yaml@^4.0.2", "@stoplight/yaml@^4.2.2", "@stoplight/yaml@^4.3.0":
   version "4.3.0"
-  resolved "https://registry.npmjs.org/@stoplight/yaml/-/yaml-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/@stoplight/yaml/-/yaml-4.3.0.tgz#ca403157472509812ccec6f277185e7e65d7bd7d"
   integrity sha512-JZlVFE6/dYpP9tQmV0/ADfn32L9uFarHWxfcRhReKUnljz1ZiUM5zpX+PH8h5CJs6lao3TuFqnPm9IJJCEkE2w==
   dependencies:
     "@stoplight/ordered-object-literal" "^1.0.5"
@@ -5989,47 +6312,47 @@
 
 "@svgr/babel-plugin-add-jsx-attribute@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz#4001f5d5dd87fa13303e36ee106e3ff3a7eb8b22"
   integrity sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==
 
 "@svgr/babel-plugin-remove-jsx-attribute@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-8.0.0.tgz#69177f7937233caca3a1afb051906698f2f59186"
   integrity sha512-BcCkm/STipKvbCl6b7QFrMh/vx00vIP63k2eM66MfHJzPr6O2U0jYEViXkHJWqXqQYjdeA9cuCl5KWmlwjDvbA==
 
 "@svgr/babel-plugin-remove-jsx-empty-expression@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-8.0.0.tgz#c2c48104cfd7dcd557f373b70a56e9e3bdae1d44"
   integrity sha512-5BcGCBfBxB5+XSDSWnhTThfI9jcO5f0Ai2V24gZpG+wXF14BzwxxdDb4g6trdOux0rhibGs385BeFMSmxtS3uA==
 
 "@svgr/babel-plugin-replace-jsx-attribute-value@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz#8fbb6b2e91fa26ac5d4aa25c6b6e4f20f9c0ae27"
   integrity sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==
 
 "@svgr/babel-plugin-svg-dynamic-title@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz#1d5ba1d281363fc0f2f29a60d6d936f9bbc657b0"
   integrity sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==
 
 "@svgr/babel-plugin-svg-em-dimensions@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz#35e08df300ea8b1d41cb8f62309c241b0369e501"
   integrity sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==
 
 "@svgr/babel-plugin-transform-react-native-svg@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz#90a8b63998b688b284f255c6a5248abd5b28d754"
   integrity sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==
 
 "@svgr/babel-plugin-transform-svg-component@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz#013b4bfca88779711f0ed2739f3f7efcefcf4f7e"
   integrity sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==
 
 "@svgr/babel-preset@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/babel-preset/-/babel-preset-8.1.0.tgz#0e87119aecdf1c424840b9d4565b7137cabf9ece"
   integrity sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==
   dependencies:
     "@svgr/babel-plugin-add-jsx-attribute" "8.0.0"
@@ -6043,7 +6366,7 @@
 
 "@svgr/core@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/core/-/core-8.1.0.tgz#41146f9b40b1a10beaf5cc4f361a16a3c1885e88"
   integrity sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -6054,7 +6377,7 @@
 
 "@svgr/hast-util-to-babel-ast@8.0.0":
   version "8.0.0"
-  resolved "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz#6952fd9ce0f470e1aded293b792a2705faf4ffd4"
   integrity sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==
   dependencies:
     "@babel/types" "^7.21.3"
@@ -6062,7 +6385,7 @@
 
 "@svgr/plugin-jsx@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz#96969f04a24b58b174ee4cd974c60475acbd6928"
   integrity sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -6072,7 +6395,7 @@
 
 "@svgr/plugin-svgo@8.1.0":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz#b115b7b967b564f89ac58feae89b88c3decd0f00"
   integrity sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==
   dependencies:
     cosmiconfig "^8.1.3"
@@ -6081,7 +6404,7 @@
 
 "@svgr/webpack@^8.0.1":
   version "8.1.0"
-  resolved "https://registry.npmjs.org/@svgr/webpack/-/webpack-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/@svgr/webpack/-/webpack-8.1.0.tgz#16f1b5346f102f89fda6ec7338b96a701d8be0c2"
   integrity sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==
   dependencies:
     "@babel/core" "^7.21.3"
@@ -6095,84 +6418,106 @@
 
 "@swc/counter@^0.1.3":
   version "0.1.3"
-  resolved "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/@swc/counter/-/counter-0.1.3.tgz#cc7463bd02949611c6329596fccd2b0ec782b0e9"
   integrity sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==
 
 "@swc/helpers@0.5.5":
   version "0.5.5"
-  resolved "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/@swc/helpers/-/helpers-0.5.5.tgz#12689df71bfc9b21c4f4ca00ae55f2f16c8b77c0"
   integrity sha512-KGYxvIOXcceOAbEk4bi/dVLEK9z8sZ0uBB3Il5b1rhfClSpcX0yfRO0KmTkqR2cnQDymwLB+25ZyMzICg/cm/A==
   dependencies:
     "@swc/counter" "^0.1.3"
     tslib "^2.4.0"
 
 "@swc/helpers@^0.5.0":
-  version "0.5.13"
-  resolved "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.13.tgz"
-  integrity sha512-UoKGxQ3r5kYI9dALKJapMmuK+1zWM/H17Z1+iwnNmzcJRnfFuevZs375TA5rW31pu4BS4NoSy1fRsexDXfWn5w==
+  version "0.5.17"
+  resolved "https://registry.yarnpkg.com/@swc/helpers/-/helpers-0.5.17.tgz#5a7be95ac0f0bf186e7e6e890e7a6f6cda6ce971"
+  integrity sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==
   dependencies:
-    tslib "^2.4.0"
+    tslib "^2.8.0"
 
 "@tailwindcss/forms@^0.5.7":
-  version "0.5.9"
-  resolved "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.9.tgz"
-  integrity sha512-tM4XVr2+UVTxXJzey9Twx48c1gcxFStqn1pQz0tRsX8o3DvxhN5oY5pvyAbUx7VTaZxpej4Zzvc6h+1RJBzpIg==
+  version "0.5.10"
+  resolved "https://registry.yarnpkg.com/@tailwindcss/forms/-/forms-0.5.10.tgz#0a1cd67b6933402f1985a04595bd24f9785aa302"
+  integrity sha512-utI1ONF6uf/pPNO68kmN1b8rEwNXv3czukalo8VtJH8ksIkZXr3Q3VYudZLkCsDd4Wku120uF02hYK25XGPorw==
   dependencies:
     mini-svg-data-uri "^1.2.3"
 
 "@tailwindcss/typography@^0.5.12":
-  version "0.5.15"
-  resolved "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.15.tgz"
-  integrity sha512-AqhlCXl+8grUz8uqExv5OTtgpjuVIwFTSXTrh8y9/pw6q2ek7fJ+Y8ZEVw7EB2DCcuCOtEjf9w3+J3rzts01uA==
+  version "0.5.19"
+  resolved "https://registry.yarnpkg.com/@tailwindcss/typography/-/typography-0.5.19.tgz#ecb734af2569681eb40932f09f60c2848b909456"
+  integrity sha512-w31dd8HOx3k9vPtcQh5QHP9GwKcgbMp87j58qi6xgiBnFFtKEAgCWnDw4qUT8aHwkCp8bKvb/KGKWWHedP0AAg==
   dependencies:
-    lodash.castarray "^4.4.0"
-    lodash.isplainobject "^4.0.6"
-    lodash.merge "^4.6.2"
     postcss-selector-parser "6.0.10"
 
-"@tanstack/react-virtual@^3.8.1":
-  version "3.10.8"
-  resolved "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.10.8.tgz"
-  integrity sha512-VbzbVGSsZlQktyLrP5nxE+vE1ZR+U0NFAWPbJLoG2+DKPwd2D7dVICTVIIaYlJqX1ZCEnYDbaOpmMwbsyhBoIA==
+"@tanstack/react-virtual@3.11.2":
+  version "3.11.2"
+  resolved "https://registry.yarnpkg.com/@tanstack/react-virtual/-/react-virtual-3.11.2.tgz#d6b9bd999c181f0a2edce270c87a2febead04322"
+  integrity sha512-OuFzMXPF4+xZgx8UzJha0AieuMihhhaWG0tCqpp6tDzlFwOmNBPYMuLOtMJ1Tr4pXLHmgjcWhG6RlknY2oNTdQ==
   dependencies:
-    "@tanstack/virtual-core" "3.10.8"
+    "@tanstack/virtual-core" "3.11.2"
 
-"@tanstack/virtual-core@3.10.8":
-  version "3.10.8"
-  resolved "https://registry.npmjs.org/@tanstack/virtual-core/-/virtual-core-3.10.8.tgz"
-  integrity sha512-PBu00mtt95jbKFi6Llk9aik8bnR3tR/oQP1o3TSi+iG//+Q2RTIzCEgKkHG8BB86kxMNW6O8wku+Lmi+QFR6jA==
+"@tanstack/react-virtual@^3.13.9":
+  version "3.13.12"
+  resolved "https://registry.yarnpkg.com/@tanstack/react-virtual/-/react-virtual-3.13.12.tgz#d372dc2783739cc04ec1a728ca8203937687a819"
+  integrity sha512-Gd13QdxPSukP8ZrkbgS2RwoZseTTbQPLnQEn7HY/rqtM+8Zt95f7xKC7N0EsKs7aoz0WzZ+fditZux+F8EzYxA==
+  dependencies:
+    "@tanstack/virtual-core" "3.13.12"
+
+"@tanstack/virtual-core@3.11.2":
+  version "3.11.2"
+  resolved "https://registry.yarnpkg.com/@tanstack/virtual-core/-/virtual-core-3.11.2.tgz#00409e743ac4eea9afe5b7708594d5fcebb00212"
+  integrity sha512-vTtpNt7mKCiZ1pwU9hfKPhpdVO2sVzFQsxoVBGtOSHxlrRRzYr8iQ2TlwbAcRYCcEiZ9ECAM8kBzH0v2+VzfKw==
+
+"@tanstack/virtual-core@3.13.12":
+  version "3.13.12"
+  resolved "https://registry.yarnpkg.com/@tanstack/virtual-core/-/virtual-core-3.13.12.tgz#1dff176df9cc8f93c78c5e46bcea11079b397578"
+  integrity sha512-1YBOJfRHV4sXUmWsFSf5rQor4Ss82G8dQWLRbnk3GA4jeP8hQt1hxXh0tmflpC0dz3VgEv/1+qwPyLeWkQuPFA==
 
 "@trysound/sax@0.2.0":
   version "0.2.0"
-  resolved "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/@trysound/sax/-/sax-0.2.0.tgz#cccaab758af56761eb7bf37af6f03f326dd798ad"
   integrity sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==
 
 "@tsconfig/node10@^1.0.7":
   version "1.0.11"
-  resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.11.tgz#6ee46400685f130e278128c7b38b7e031ff5b2f2"
   integrity sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==
 
 "@tsconfig/node12@^1.0.7":
   version "1.0.11"
-  resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d"
   integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
 
 "@tsconfig/node14@^1.0.0":
   version "1.0.3"
-  resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1"
   integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
 
 "@tsconfig/node16@^1.0.2":
   version "1.0.4"
-  resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
   integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
 
-"@types/acorn@^4.0.0":
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz"
-  integrity sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==
+"@tufjs/canonical-json@2.0.0":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@tufjs/canonical-json/-/canonical-json-2.0.0.tgz#a52f61a3d7374833fca945b2549bc30a2dd40d0a"
+  integrity sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==
+
+"@tufjs/models@3.0.1":
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/@tufjs/models/-/models-3.0.1.tgz#5aebb782ebb9e06f071ae7831c1f35b462b0319c"
+  integrity sha512-UUYHISyhCU3ZgN8yaear3cGATHb3SMuKHsQ/nVbHXcmnBf+LzQ/cQfhNG+rfaSHgqGKNEm2cOCLVLELStUQ1JA==
   dependencies:
-    "@types/estree" "*"
+    "@tufjs/canonical-json" "2.0.0"
+    minimatch "^9.0.5"
+
+"@tybys/wasm-util@^0.10.0":
+  version "0.10.1"
+  resolved "https://registry.yarnpkg.com/@tybys/wasm-util/-/wasm-util-0.10.1.tgz#ecddd3205cf1e2d5274649ff0eedd2991ed7f414"
+  integrity sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==
+  dependencies:
+    tslib "^2.4.0"
 
 "@types/connect@3.4.38":
   version "3.4.38"
@@ -6182,59 +6527,59 @@
     "@types/node" "*"
 
 "@types/d3-array@^3.0.3":
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.1.tgz"
-  integrity sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg==
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/@types/d3-array/-/d3-array-3.2.2.tgz#e02151464d02d4a1b44646d0fcdb93faf88fde8c"
+  integrity sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==
 
 "@types/d3-color@*":
   version "3.1.3"
-  resolved "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/d3-color/-/d3-color-3.1.3.tgz#368c961a18de721da8200e80bf3943fb53136af2"
   integrity sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==
 
 "@types/d3-ease@^3.0.0":
   version "3.0.2"
-  resolved "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@types/d3-ease/-/d3-ease-3.0.2.tgz#e28db1bfbfa617076f7770dd1d9a48eaa3b6c51b"
   integrity sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==
 
 "@types/d3-interpolate@^3.0.1":
   version "3.0.4"
-  resolved "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz#412b90e84870285f2ff8a846c6eb60344f12a41c"
   integrity sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==
   dependencies:
     "@types/d3-color" "*"
 
 "@types/d3-path@*":
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.0.tgz"
-  integrity sha512-P2dlU/q51fkOc/Gfl3Ul9kicV7l+ra934qBFXCFhrZMOL6du1TM0pm1ThYvENukyOn5h9v+yMJ9Fn5JK4QozrQ==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/@types/d3-path/-/d3-path-3.1.1.tgz#f632b380c3aca1dba8e34aa049bcd6a4af23df8a"
+  integrity sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==
 
 "@types/d3-scale@^4.0.2":
-  version "4.0.8"
-  resolved "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.8.tgz"
-  integrity sha512-gkK1VVTr5iNiYJ7vWDI+yUFFlszhNMtVeneJ6lUTKPjprsvLLI9/tgEGiXJOnlINJA8FyA88gfnQsHbybVZrYQ==
+  version "4.0.9"
+  resolved "https://registry.yarnpkg.com/@types/d3-scale/-/d3-scale-4.0.9.tgz#57a2f707242e6fe1de81ad7bfcccaaf606179afb"
+  integrity sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==
   dependencies:
     "@types/d3-time" "*"
 
 "@types/d3-shape@^3.1.0":
-  version "3.1.6"
-  resolved "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.6.tgz"
-  integrity sha512-5KKk5aKGu2I+O6SONMYSNflgiP0WfZIQvVUMan50wHsLG1G94JlxEVnCpQARfTtzytuY0p/9PXXZb3I7giofIA==
+  version "3.1.7"
+  resolved "https://registry.yarnpkg.com/@types/d3-shape/-/d3-shape-3.1.7.tgz#2b7b423dc2dfe69c8c93596e673e37443348c555"
+  integrity sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==
   dependencies:
     "@types/d3-path" "*"
 
 "@types/d3-time@*", "@types/d3-time@^3.0.0":
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.3.tgz"
-  integrity sha512-2p6olUZ4w3s+07q3Tm2dbiMZy5pCDfYwtLXXHUnVzXgQlZ/OyPtUz6OL382BkOuGlLXqfT+wqv8Fw2v8/0geBw==
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/@types/d3-time/-/d3-time-3.0.4.tgz#8472feecd639691450dd8000eb33edd444e1323f"
+  integrity sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==
 
 "@types/d3-timer@^3.0.0":
   version "3.0.2"
-  resolved "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/@types/d3-timer/-/d3-timer-3.0.2.tgz#70bbda77dc23aa727413e22e214afa3f0e852f70"
   integrity sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==
 
 "@types/debug@^4.0.0":
   version "4.1.12"
-  resolved "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.12.tgz#a155f21690871953410df4b6b6f53187f0500917"
   integrity sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==
   dependencies:
     "@types/ms" "*"
@@ -6253,17 +6598,12 @@
 
 "@types/estree-jsx@^1.0.0":
   version "1.0.5"
-  resolved "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@types/estree-jsx/-/estree-jsx-1.0.5.tgz#858a88ea20f34fe65111f005a689fa1ebf70dc18"
   integrity sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==
   dependencies:
     "@types/estree" "*"
 
-"@types/estree@*", "@types/estree@^1.0.0":
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz"
-  integrity sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==
-
-"@types/estree@1.0.8":
+"@types/estree@*", "@types/estree@1.0.8", "@types/estree@^1.0.0":
   version "1.0.8"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.8.tgz#958b91c991b1867ced318bedea0e215ee050726e"
   integrity sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==
@@ -6274,20 +6614,20 @@
   integrity sha512-X9QTSvGJ0nCfMzYOnaVs/k6/4L+7F5uCS+4iUmkLEls6J9S/Phv+m/i3mDeyc49ZBgwab3EFO1HEoBY7k98EGQ==
 
 "@types/har-format@^1.2.10":
-  version "1.2.15"
-  resolved "https://registry.npmjs.org/@types/har-format/-/har-format-1.2.15.tgz"
-  integrity sha512-RpQH4rXLuvTXKR0zqHq3go0RVXYv/YVqv4TnPH95VbwUxZdQlK1EtcMvQvMpDngHbt13Csh9Z4qT9AbkiQH5BA==
+  version "1.2.16"
+  resolved "https://registry.yarnpkg.com/@types/har-format/-/har-format-1.2.16.tgz#b71ede8681400cc08b3685f061c31e416cf94944"
+  integrity sha512-fluxdy7ryD3MV6h8pTfTYpy/xQzCFC7m89nOH9y94cNqJ1mDIDPut7MnRHI3F6qRmh/cT2fUjG1MLdCNb4hE9A==
 
 "@types/hast@^2.0.0":
   version "2.3.10"
-  resolved "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz"
+  resolved "https://registry.yarnpkg.com/@types/hast/-/hast-2.3.10.tgz#5c9d9e0b304bbb8879b857225c5ebab2d81d7643"
   integrity sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==
   dependencies:
     "@types/unist" "^2"
 
 "@types/hast@^3.0.0":
   version "3.0.4"
-  resolved "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/hast/-/hast-3.0.4.tgz#1d6b39993b82cea6ad783945b0508c25903e15aa"
   integrity sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==
   dependencies:
     "@types/unist" "*"
@@ -6299,74 +6639,74 @@
 
 "@types/js-cookie@^2.2.6":
   version "2.2.7"
-  resolved "https://registry.npmjs.org/@types/js-cookie/-/js-cookie-2.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/@types/js-cookie/-/js-cookie-2.2.7.tgz#226a9e31680835a6188e887f3988e60c04d3f6a3"
   integrity sha512-aLkWa0C0vO5b4Sr798E26QgOkss68Un0bLjs7u9qxzPT5CG+8DuNTffWES58YzJs3hrVAOs1wonycqEBqNJubA==
 
-"@types/json-schema@7.0.11", "@types/json-schema@^7.0.4", "@types/json-schema@^7.0.7":
+"@types/json-schema@7.0.11":
   version "7.0.11"
-  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
   integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
 
-"@types/json-schema@^7.0.12":
+"@types/json-schema@^7.0.12", "@types/json-schema@^7.0.4", "@types/json-schema@^7.0.7":
   version "7.0.15"
-  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841"
   integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==
 
 "@types/json5@^0.0.29":
   version "0.0.29"
-  resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz"
+  resolved "https://registry.yarnpkg.com/@types/json5/-/json5-0.0.29.tgz#ee28707ae94e11d2b827bcbe5270bcea7f3e71ee"
   integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==
 
 "@types/katex@^0.16.0":
   version "0.16.7"
-  resolved "https://registry.npmjs.org/@types/katex/-/katex-0.16.7.tgz"
+  resolved "https://registry.yarnpkg.com/@types/katex/-/katex-0.16.7.tgz#03ab680ab4fa4fbc6cb46ecf987ecad5d8019868"
   integrity sha512-HMwFiRujE5PjrgwHQ25+bsLJgowjGjm5Z8FVSf0N6PwgJrwxH0QxzHYDcKsTfV3wva0vzrpqMTJS2jXPr5BMEQ==
 
 "@types/lodash.debounce@^4.0.7":
   version "4.0.9"
-  resolved "https://registry.npmjs.org/@types/lodash.debounce/-/lodash.debounce-4.0.9.tgz"
+  resolved "https://registry.yarnpkg.com/@types/lodash.debounce/-/lodash.debounce-4.0.9.tgz#0f5f21c507bce7521b5e30e7a24440975ac860a5"
   integrity sha512-Ma5JcgTREwpLRwMM+XwBR7DaWe96nC38uCBDFKZWbNKD+osjVzdpnUSwBcqCptrp16sSOLBAUb50Car5I0TCsQ==
   dependencies:
     "@types/lodash" "*"
 
 "@types/lodash@*":
-  version "4.17.9"
-  resolved "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.9.tgz"
-  integrity sha512-w9iWudx1XWOHW5lQRS9iKpK/XuRhnN+0T7HvdCCd802FYkT1AMTnxndJHGrNJwRoRHkslGr4S29tjm1cT7x/7w==
+  version "4.17.20"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.17.20.tgz#1ca77361d7363432d29f5e55950d9ec1e1c6ea93"
+  integrity sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==
 
 "@types/mdast@^3.0.0":
   version "3.0.15"
-  resolved "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-3.0.15.tgz#49c524a263f30ffa28b71ae282f813ed000ab9f5"
   integrity sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==
   dependencies:
     "@types/unist" "^2"
 
 "@types/mdast@^4.0.0":
   version "4.0.4"
-  resolved "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdast/-/mdast-4.0.4.tgz#7ccf72edd2f1aa7dd3437e180c64373585804dd6"
   integrity sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==
   dependencies:
     "@types/unist" "*"
 
 "@types/mdurl@^1.0.0":
   version "1.0.5"
-  resolved "https://registry.npmjs.org/@types/mdurl/-/mdurl-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdurl/-/mdurl-1.0.5.tgz#3e0d2db570e9fb6ccb2dc8fde0be1d79ac810d39"
   integrity sha512-6L6VymKTzYSrEf4Nev4Xa1LCHKrlTlYCBMTlQKFuddo1CvQcE52I0mwfOJayueUC7MJuXOeHTcIU683lzd0cUA==
 
 "@types/mdx@^2.0.0", "@types/mdx@^2.0.12":
   version "2.0.13"
-  resolved "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz"
+  resolved "https://registry.yarnpkg.com/@types/mdx/-/mdx-2.0.13.tgz#68f6877043d377092890ff5b298152b0a21671bd"
   integrity sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==
 
 "@types/minimist@^1.2.0":
   version "1.2.5"
-  resolved "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.5.tgz"
+  resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.5.tgz#ec10755e871497bcd83efe927e43ec46e8c0747e"
   integrity sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==
 
-"@types/ms@*":
-  version "0.7.34"
-  resolved "https://registry.npmjs.org/@types/ms/-/ms-0.7.34.tgz"
-  integrity sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==
+"@types/ms@*", "@types/ms@2.1.0":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@types/ms/-/ms-2.1.0.tgz#052aa67a48eccc4309d7f0191b7e41434b90bb78"
+  integrity sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==
 
 "@types/mysql@2.15.27":
   version "2.15.27"
@@ -6375,26 +6715,26 @@
   dependencies:
     "@types/node" "*"
 
-"@types/node@*", "@types/node@20.5.1":
+"@types/node@*", "@types/node@>=13.7.0":
+  version "24.5.2"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-24.5.2.tgz#52ceb83f50fe0fcfdfbd2a9fab6db2e9e7ef6446"
+  integrity sha512-FYxk1I7wPv3K2XBaoyH2cTnocQEu8AOZ60hPbsyukMPLv5/5qr7V1i8PLHdl6Zf87I+xZXFvPCXYjiTFq+YSDQ==
+  dependencies:
+    undici-types "~7.12.0"
+
+"@types/node@20.5.1":
   version "20.5.1"
-  resolved "https://registry.npmjs.org/@types/node/-/node-20.5.1.tgz"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.5.1.tgz#178d58ee7e4834152b0e8b4d30cbfab578b9bb30"
   integrity sha512-4tT2UrL5LBqDwoed9wZ6N3umC4Yhz3W3FloMmiiG4JwmUJWpie0c7lcnUNd4gtMKuDEO4wRVS8B6Xa0uMRsMKg==
 
-"@types/node@>=13.7.0":
-  version "22.7.1"
-  resolved "https://registry.npmjs.org/@types/node/-/node-22.7.1.tgz"
-  integrity sha512-adOMRLVmleuWs/5V/w5/l7o0chDK/az+5ncCsIapTKogsu/3MVWvSgP58qVTXi5IwpfGt8pMobNq9rOWtJyu5Q==
-  dependencies:
-    undici-types "~6.19.2"
-
 "@types/normalize-package-data@^2.4.0":
   version "2.4.4"
-  resolved "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz"
+  resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz#56e2cc26c397c038fab0e3a917a12d5c5909e901"
   integrity sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==
 
 "@types/parse5@^6.0.0":
   version "6.0.3"
-  resolved "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/parse5/-/parse5-6.0.3.tgz#705bb349e789efa06f43f128cef51240753424cb"
   integrity sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==
 
 "@types/pg-pool@2.0.6":
@@ -6404,7 +6744,7 @@
   dependencies:
     "@types/pg" "*"
 
-"@types/pg@*":
+"@types/pg@*", "@types/pg@8.15.5":
   version "8.15.5"
   resolved "https://registry.yarnpkg.com/@types/pg/-/pg-8.15.5.tgz#ef43e0f33b62dac95cae2f042888ec7980b30c09"
   integrity sha512-LF7lF6zWEKxuT3/OR8wAZGzkg4ENGXFNyiV/JeOt9z5B+0ZVwbql9McqX5c/WStFq1GaGso7H1AzP/qSzmlCKQ==
@@ -6413,23 +6753,15 @@
     pg-protocol "*"
     pg-types "^2.2.0"
 
-"@types/pg@8.15.4":
-  version "8.15.4"
-  resolved "https://registry.yarnpkg.com/@types/pg/-/pg-8.15.4.tgz#419f791c6fac8e0bed66dd8f514b60f8ba8db46d"
-  integrity sha512-I6UNVBAoYbvuWkkU3oosC8yxqH21f4/Jc4DK71JLG3dT2mdlGe1z+ep/LQGXaKaOgcvUrsQoPRqfgtMcvZiJhg==
-  dependencies:
-    "@types/node" "*"
-    pg-protocol "*"
-    pg-types "^2.2.0"
-
 "@types/prismjs@^1.0.0":
-  version "1.26.4"
-  resolved "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.4.tgz"
-  integrity sha512-rlAnzkW2sZOjbqZ743IHUhFcvzaGbqijwOu8QZnZCjfQzBqFE3s4lOTJEsxikImav9uzz/42I+O7YUs1mWgMlg==
+  version "1.26.5"
+  resolved "https://registry.yarnpkg.com/@types/prismjs/-/prismjs-1.26.5.tgz#72499abbb4c4ec9982446509d2f14fb8483869d6"
+  integrity sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ==
 
+"@types/prop-types@*":
 "@types/prop-types@*":
   version "15.7.15"
-  resolved "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz"
+  resolved "https://registry.yarnpkg.com/@types/prop-types/-/prop-types-15.7.15.tgz#e6e5a86d602beaca71ce5163fadf5f95d70931c7"
   integrity sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==
 
 "@types/qs@^6.5.3":
@@ -6438,43 +6770,41 @@
   integrity sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==
 
 "@types/react-dom@^17.0.3":
-  version "17.0.25"
-  resolved "https://registry.npmjs.org/@types/react-dom/-/react-dom-17.0.25.tgz"
-  integrity sha512-urx7A7UxkZQmThYA4So0NelOVjx3V4rNFVJwp0WZlbIK5eM4rNJDiN3R/E9ix0MBh6kAEojk/9YL+Te6D9zHNA==
-  dependencies:
-    "@types/react" "^17"
+  version "17.0.26"
+  resolved "https://registry.yarnpkg.com/@types/react-dom/-/react-dom-17.0.26.tgz#fa7891ba70fd39ddbaa7e85b6ff9175bb546bc1b"
+  integrity sha512-Z+2VcYXJwOqQ79HreLU/1fyQ88eXSSFh6I3JdrEHQIfYSI0kCQpTGvOrbE6jFGGYXKsHuwY9tBa/w5Uo6KzrEg==
 
-"@types/react@^17", "@types/react@^17.0.3":
-  version "17.0.82"
-  resolved "https://registry.npmjs.org/@types/react/-/react-17.0.82.tgz"
-  integrity sha512-wTW8Lu/PARGPFE8tOZqCvprOKg5sen/2uS03yKn2xbCDFP9oLncm7vMDQ2+dEQXHVIXrOpW6u72xUXEXO0ypSw==
+"@types/react@^17.0.3":
+  version "17.0.88"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-17.0.88.tgz#d926ade927fcad5a79338fb283dc93fc84bcf1d9"
+  integrity sha512-HEOvpzcFWkEcHq4EsTChnpimRc3Lz1/qzYRDFtobFp4obVa6QVjCDMjWmkgxgaTYttNvyjnldY8MUflGp5YiUw==
   dependencies:
     "@types/prop-types" "*"
     "@types/scheduler" "^0.16"
     csstype "^3.0.2"
 
 "@types/react@^18.2.73":
-  version "18.3.9"
-  resolved "https://registry.npmjs.org/@types/react/-/react-18.3.9.tgz"
-  integrity sha512-+BpAVyTpJkNWWSSnaLBk6ePpHLOGJKnEQNbINNovPWzvEUyAe3e+/d494QdEh71RekM/qV7lw6jzf1HGrJyAtQ==
+  version "18.3.24"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-18.3.24.tgz#f6a5a4c613242dfe3af0dcee2b4ec47b92d9b6bd"
+  integrity sha512-0dLEBsA1kI3OezMBF8nSsb7Nk19ZnsyE1LLhB8r27KbgU5H4pvuqZLdtE+aUkJVoXgTVuA+iLIwmZ0TuK4tx6A==
   dependencies:
     "@types/prop-types" "*"
     csstype "^3.0.2"
 
 "@types/resolve@^1.17.1":
   version "1.20.6"
-  resolved "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.6.tgz"
+  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.20.6.tgz#e6e60dad29c2c8c206c026e6dd8d6d1bdda850b8"
   integrity sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==
 
 "@types/scheduler@^0.16":
   version "0.16.8"
-  resolved "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.8.tgz"
+  resolved "https://registry.yarnpkg.com/@types/scheduler/-/scheduler-0.16.8.tgz#ce5ace04cfeabe7ef87c0091e50752e36707deff"
   integrity sha512-WZLiwShhwLRmeV6zH+GkbOFT6Z6VklCItrDioxUnv+u4Ll+8vKeFySoFyK/0ctcRpOmwAicELfmys1sDc/Rw+A==
 
 "@types/semver@^7.5.0":
-  version "7.5.8"
-  resolved "https://registry.npmjs.org/@types/semver/-/semver-7.5.8.tgz"
-  integrity sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==
+  version "7.7.1"
+  resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.7.1.tgz#3ce3af1a5524ef327d2da9e4fd8b6d95c8d70528"
+  integrity sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==
 
 "@types/shimmer@^1.2.0":
   version "1.2.0"
@@ -6483,7 +6813,7 @@
 
 "@types/swagger-schema-official@~2.0.22":
   version "2.0.25"
-  resolved "https://registry.npmjs.org/@types/swagger-schema-official/-/swagger-schema-official-2.0.25.tgz"
+  resolved "https://registry.yarnpkg.com/@types/swagger-schema-official/-/swagger-schema-official-2.0.25.tgz#c8073914004d0a9c5412aeaf458d96e34c504840"
   integrity sha512-T92Xav+Gf/Ik1uPW581nA+JftmjWPgskw/WBf4TJzxRG/SJ+DfNnNE+WuZ4mrXuzflQMqMkm1LSYjzYW7MB1Cg==
 
 "@types/tedious@^4.0.14":
@@ -6499,25 +6829,25 @@
   integrity sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==
 
 "@types/type-is@^1.6.3":
-  version "1.6.6"
-  resolved "https://registry.npmjs.org/@types/type-is/-/type-is-1.6.6.tgz"
-  integrity sha512-fs1KHv/f9OvmTMsu4sBNaUu32oyda9Y9uK25naJG8gayxNrfqGIjPQsbLIYyfe7xFkppnPlJB+BuTldOaX9bXw==
+  version "1.6.7"
+  resolved "https://registry.yarnpkg.com/@types/type-is/-/type-is-1.6.7.tgz#4d7934d2c795749800e767cd9af7ffbd4f16cf1c"
+  integrity sha512-gEsh7n8824nusZ2Sidh6POxNsIdTSvIAl5gXbeFj+TUaD1CO2r4i7MQYNMfEQkChU42s2bVWAda6x6BzIhtFbQ==
   dependencies:
     "@types/node" "*"
 
-"@types/unist@*", "@types/unist@^2", "@types/unist@^2.0.0", "@types/unist@^2.0.2", "@types/unist@^2.0.3":
-  version "2.0.11"
-  resolved "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz"
-  integrity sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==
-
-"@types/unist@^3.0.0":
+"@types/unist@*", "@types/unist@^3.0.0":
   version "3.0.3"
-  resolved "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-3.0.3.tgz#acaab0f919ce69cce629c2d4ed2eb4adc1b6c20c"
   integrity sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==
 
+"@types/unist@^2", "@types/unist@^2.0.0", "@types/unist@^2.0.2", "@types/unist@^2.0.3":
+  version "2.0.11"
+  resolved "https://registry.yarnpkg.com/@types/unist/-/unist-2.0.11.tgz#11af57b127e32487774841f7a4e54eab166d03c4"
+  integrity sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==
+
 "@typescript-eslint/eslint-plugin@^6.1.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.21.0.tgz#30830c1ca81fd5f3c2714e524c4303e0194f9cd3"
   integrity sha512-oy9+hTPCUFpngkEZUSzbf9MxI65wbKFoQYsgPdILTfbUldp5ovUuphZVe4i30emU9M/kP+T64Di0mxl7dSw3MA==
   dependencies:
     "@eslint-community/regexpp" "^4.5.1"
@@ -6532,9 +6862,20 @@
     semver "^7.5.4"
     ts-api-utils "^1.0.1"
 
-"@typescript-eslint/parser@^5.4.2 || ^6.0.0 || 7.0.0 - 7.2.0", "@typescript-eslint/parser@^6.1.0":
+"@typescript-eslint/parser@^5.4.2 || ^6.0.0 || 7.0.0 - 7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-7.2.0.tgz#44356312aea8852a3a82deebdacd52ba614ec07a"
+  integrity sha512-5FKsVcHTk6TafQKQbuIVkXq58Fnbkd2wDL4LB7AURN7RUOu1utVP+G8+6u3ZhEroW3DF6hyo3ZEXxgKgp4KeCg==
+  dependencies:
+    "@typescript-eslint/scope-manager" "7.2.0"
+    "@typescript-eslint/types" "7.2.0"
+    "@typescript-eslint/typescript-estree" "7.2.0"
+    "@typescript-eslint/visitor-keys" "7.2.0"
+    debug "^4.3.4"
+
+"@typescript-eslint/parser@^6.1.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-6.21.0.tgz#af8fcf66feee2edc86bc5d1cf45e33b0630bf35b"
   integrity sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==
   dependencies:
     "@typescript-eslint/scope-manager" "6.21.0"
@@ -6545,15 +6886,23 @@
 
 "@typescript-eslint/scope-manager@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-6.21.0.tgz#ea8a9bfc8f1504a6ac5d59a6df308d3a0630a2b1"
   integrity sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==
   dependencies:
     "@typescript-eslint/types" "6.21.0"
     "@typescript-eslint/visitor-keys" "6.21.0"
 
+"@typescript-eslint/scope-manager@7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-7.2.0.tgz#cfb437b09a84f95a0930a76b066e89e35d94e3da"
+  integrity sha512-Qh976RbQM/fYtjx9hs4XkayYujB/aPwglw2choHmf3zBjB4qOywWSdt9+KLRdHubGcoSwBnXUH2sR3hkyaERRg==
+  dependencies:
+    "@typescript-eslint/types" "7.2.0"
+    "@typescript-eslint/visitor-keys" "7.2.0"
+
 "@typescript-eslint/type-utils@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-6.21.0.tgz#6473281cfed4dacabe8004e8521cee0bd9d4c01e"
   integrity sha512-rZQI7wHfao8qMX3Rd3xqeYSMCL3SoiSQLBATSiVKARdFGCYSRvmViieZjqc58jKgs8Y8i9YvVVhRbHSTA4VBag==
   dependencies:
     "@typescript-eslint/typescript-estree" "6.21.0"
@@ -6563,12 +6912,17 @@
 
 "@typescript-eslint/types@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-6.21.0.tgz#205724c5123a8fef7ecd195075fa6e85bac3436d"
   integrity sha512-1kFmZ1rOm5epu9NZEZm1kckCDGj5UJEf7P1kliH4LKu/RkwpsfqqGmY2OOcUs18lSlQBKLDYBOGxRVtrMN5lpg==
 
+"@typescript-eslint/types@7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-7.2.0.tgz#0feb685f16de320e8520f13cca30779c8b7c403f"
+  integrity sha512-XFtUHPI/abFhm4cbCDc5Ykc8npOKBSJePY3a3s+lwumt7XWJuzP5cZcfZ610MIPHjQjNsOLlYK8ASPaNG8UiyA==
+
 "@typescript-eslint/typescript-estree@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-6.21.0.tgz#c47ae7901db3b8bddc3ecd73daff2d0895688c46"
   integrity sha512-6npJTkZcO+y2/kr+z0hc4HwNfrrP4kNYh57ek7yCNlrBjWQ1Y0OS7jiZTkgumrvkX5HkEKXFZkkdFNkaW2wmUQ==
   dependencies:
     "@typescript-eslint/types" "6.21.0"
@@ -6580,9 +6934,23 @@
     semver "^7.5.4"
     ts-api-utils "^1.0.1"
 
+"@typescript-eslint/typescript-estree@7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-7.2.0.tgz#5beda2876c4137f8440c5a84b4f0370828682556"
+  integrity sha512-cyxS5WQQCoBwSakpMrvMXuMDEbhOo9bNHHrNcEWis6XHx6KF518tkF1wBvKIn/tpq5ZpUYK7Bdklu8qY0MsFIA==
+  dependencies:
+    "@typescript-eslint/types" "7.2.0"
+    "@typescript-eslint/visitor-keys" "7.2.0"
+    debug "^4.3.4"
+    globby "^11.1.0"
+    is-glob "^4.0.3"
+    minimatch "9.0.3"
+    semver "^7.5.4"
+    ts-api-utils "^1.0.1"
+
 "@typescript-eslint/utils@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-6.21.0.tgz#4714e7a6b39e773c1c8e97ec587f520840cd8134"
   integrity sha512-NfWVaC8HP9T8cbKQxHcsJBY5YE1O33+jpMwN45qzWWaPDZgLIbo12toGMWnmhvCpd3sIxkpDw3Wv1B3dYrbDQQ==
   dependencies:
     "@eslint-community/eslint-utils" "^4.4.0"
@@ -6595,45 +6963,153 @@
 
 "@typescript-eslint/visitor-keys@6.21.0":
   version "6.21.0"
-  resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.21.0.tgz"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-6.21.0.tgz#87a99d077aa507e20e238b11d56cc26ade45fe47"
   integrity sha512-JJtkDduxLi9bivAB+cYOVMtbkqdPOhZ+ZI5LC47MIRrDV4Yn2o+ZnW10Nkmr28xRpSpdJ6Sm42Hjf2+REYXm0A==
   dependencies:
     "@typescript-eslint/types" "6.21.0"
     eslint-visitor-keys "^3.4.1"
 
+"@typescript-eslint/visitor-keys@7.2.0":
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-7.2.0.tgz#5035f177752538a5750cca1af6044b633610bf9e"
+  integrity sha512-c6EIQRHhcpl6+tO8EMR+kjkkV+ugUNXOmeASA1rlzkd8EPIriavpWoiEz1HR/VLhbVIdhqnV6E7JZm00cBDx2A==
+  dependencies:
+    "@typescript-eslint/types" "7.2.0"
+    eslint-visitor-keys "^3.4.1"
+
 "@ungap/structured-clone@^1.0.0", "@ungap/structured-clone@^1.2.0":
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz"
-  integrity sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.3.0.tgz#d06bbb384ebcf6c505fde1c3d0ed4ddffe0aaff8"
+  integrity sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==
+
+"@unrs/resolver-binding-android-arm-eabi@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.11.1.tgz#9f5b04503088e6a354295e8ea8fe3cb99e43af81"
+  integrity sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==
+
+"@unrs/resolver-binding-android-arm64@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.11.1.tgz#7414885431bd7178b989aedc4d25cccb3865bc9f"
+  integrity sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==
+
+"@unrs/resolver-binding-darwin-arm64@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.11.1.tgz#b4a8556f42171fb9c9f7bac8235045e82aa0cbdf"
+  integrity sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==
+
+"@unrs/resolver-binding-darwin-x64@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.11.1.tgz#fd4d81257b13f4d1a083890a6a17c00de571f0dc"
+  integrity sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==
+
+"@unrs/resolver-binding-freebsd-x64@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.11.1.tgz#d2513084d0f37c407757e22f32bd924a78cfd99b"
+  integrity sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==
+
+"@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.11.1.tgz#844d2605d057488d77fab09705f2866b86164e0a"
+  integrity sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==
+
+"@unrs/resolver-binding-linux-arm-musleabihf@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.11.1.tgz#204892995cefb6bd1d017d52d097193bc61ddad3"
+  integrity sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==
+
+"@unrs/resolver-binding-linux-arm64-gnu@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.11.1.tgz#023eb0c3aac46066a10be7a3f362e7b34f3bdf9d"
+  integrity sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==
+
+"@unrs/resolver-binding-linux-arm64-musl@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.11.1.tgz#9e6f9abb06424e3140a60ac996139786f5d99be0"
+  integrity sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==
+
+"@unrs/resolver-binding-linux-ppc64-gnu@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.11.1.tgz#b111417f17c9d1b02efbec8e08398f0c5527bb44"
+  integrity sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==
+
+"@unrs/resolver-binding-linux-riscv64-gnu@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.11.1.tgz#92ffbf02748af3e99873945c9a8a5ead01d508a9"
+  integrity sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==
+
+"@unrs/resolver-binding-linux-riscv64-musl@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.11.1.tgz#0bec6f1258fc390e6b305e9ff44256cb207de165"
+  integrity sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==
+
+"@unrs/resolver-binding-linux-s390x-gnu@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.11.1.tgz#577843a084c5952f5906770633ccfb89dac9bc94"
+  integrity sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==
+
+"@unrs/resolver-binding-linux-x64-gnu@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.11.1.tgz#36fb318eebdd690f6da32ac5e0499a76fa881935"
+  integrity sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==
+
+"@unrs/resolver-binding-linux-x64-musl@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.11.1.tgz#bfb9af75f783f98f6a22c4244214efe4df1853d6"
+  integrity sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==
+
+"@unrs/resolver-binding-wasm32-wasi@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.11.1.tgz#752c359dd875684b27429500d88226d7cc72f71d"
+  integrity sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==
+  dependencies:
+    "@napi-rs/wasm-runtime" "^0.2.11"
+
+"@unrs/resolver-binding-win32-arm64-msvc@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.11.1.tgz#ce5735e600e4c2fbb409cd051b3b7da4a399af35"
+  integrity sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==
+
+"@unrs/resolver-binding-win32-ia32-msvc@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.11.1.tgz#72fc57bc7c64ec5c3de0d64ee0d1810317bc60a6"
+  integrity sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==
+
+"@unrs/resolver-binding-win32-x64-msvc@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.11.1.tgz#538b1e103bf8d9864e7b85cc96fa8d6fb6c40777"
+  integrity sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==
 
 "@vercel/functions@^2.2.8":
-  version "2.2.8"
-  resolved "https://registry.npmjs.org/@vercel/functions/-/functions-2.2.8.tgz"
-  integrity sha512-Y4G2MEYCVTBtEeo6/+Ydwu5ehwryThJ7or3EM0oZa+oMDLm+z6VchDDc7rNmNIrtTS1ULcUYNqAItjs0mHMgKw==
+  version "2.2.13"
+  resolved "https://registry.yarnpkg.com/@vercel/functions/-/functions-2.2.13.tgz#8b290efb46967cd5e02b366a62176987a765fad5"
+  integrity sha512-14ArBSIIcOBx9nrEgaJb4Bw+en1gl6eSoJWh8qjifLl5G3E4dRXCFOT8HP+w66vb9Wqyd1lAQBrmRhRwOj9X9A==
   dependencies:
-    "@vercel/oidc" "2.0.0"
+    "@vercel/oidc" "2.0.2"
 
-"@vercel/oidc@2.0.0":
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/@vercel/oidc/-/oidc-2.0.0.tgz"
-  integrity sha512-U0hncpXof7gC9xtmSrjz6vrDqdwJXi8z/zSc9FyS80AoXKfCZtpkBz9gtL3x30Agmpxpwe35P1W2dP9Epa/RGA==
+"@vercel/oidc@2.0.2":
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/@vercel/oidc/-/oidc-2.0.2.tgz#ca96b3dd690fd6d6f835b6638a9c9d836ed2e228"
+  integrity sha512-59PBFx3T+k5hLTEWa3ggiMpGRz1OVvl9eN8SUai+A43IsqiOuAe7qPBf+cray/Fj6mkgnxm/D7IAtjc8zSHi7g==
+  dependencies:
+    "@types/ms" "2.1.0"
+    ms "2.1.3"
 
 "@vimeo/player@^2.23.0":
-  version "2.24.0"
-  resolved "https://registry.npmjs.org/@vimeo/player/-/player-2.24.0.tgz"
-  integrity sha512-oIpucg40ijdV1hGvAwHZitgbzSB/FFl1NbU82IHasG9e4EHNRYqJLetQjPk9oxMgeR06Pt/xB2wne/3jqKtLUg==
+  version "2.29.7"
+  resolved "https://registry.yarnpkg.com/@vimeo/player/-/player-2.29.7.tgz#7667762003b2e2fddbcf8c62caad9afef1258efb"
+  integrity sha512-z3C+uwPxEDgQFpJvlaSf9QuzZnybmMOrH//DyQtTF8L2HefPkB8N7o1w44r6H6XaGfIFvSW9MPFHRTppA2uwIQ==
   dependencies:
     native-promise-only "0.8.1"
     weakmap-polyfill "2.0.4"
 
 "@xobotyi/scrollbar-width@^1.9.5":
   version "1.9.5"
-  resolved "https://registry.npmjs.org/@xobotyi/scrollbar-width/-/scrollbar-width-1.9.5.tgz"
+  resolved "https://registry.yarnpkg.com/@xobotyi/scrollbar-width/-/scrollbar-width-1.9.5.tgz#80224a6919272f405b87913ca13b92929bdf3c4d"
   integrity sha512-N8tkAACJx2ww8vFMneJmaAgmjAG1tnVBZJRLRcx061tmsLRZHSEZSLuGWnwPtunsSLvSqXQ2wfp7Mgqg1I+2dQ==
 
 JSONStream@^1.3.5:
   version "1.3.5"
-  resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz"
+  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
   integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
   dependencies:
     jsonparse "^1.2.0"
@@ -6644,6 +7120,11 @@ abbrev@1:
   resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
   integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
 
+abbrev@^3.0.0, abbrev@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-3.0.1.tgz#8ac8b3b5024d31464fe2a5feeea9f4536bf44025"
+  integrity sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg==
+
 acorn-import-attributes@^1.9.5:
   version "1.9.5"
   resolved "https://registry.yarnpkg.com/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz#7eb1557b1ba05ef18b5ed0ec67591bfab04688ef"
@@ -6651,22 +7132,17 @@ acorn-import-attributes@^1.9.5:
 
 acorn-jsx@^5.0.0, acorn-jsx@^5.3.2:
   version "5.3.2"
-  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
 acorn-walk@^8.0.0, acorn-walk@^8.1.1:
   version "8.3.4"
-  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.3.4.tgz#794dd169c3977edf4ba4ea47583587c5866236b7"
   integrity sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==
   dependencies:
     acorn "^8.11.0"
 
-acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.9.0:
-  version "8.12.1"
-  resolved "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz"
-  integrity sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==
-
-acorn@^8.14.0, acorn@^8.4.1, acorn@^8.8.1:
+acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.14.0, acorn@^8.4.1, acorn@^8.8.1, acorn@^8.9.0:
   version "8.15.0"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.15.0.tgz#a360898bc415edaac46c8241f6383975b930b816"
   integrity sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==
@@ -6678,9 +7154,14 @@ agent-base@6:
   dependencies:
     debug "4"
 
+agent-base@^7.1.0, agent-base@^7.1.2:
+  version "7.1.4"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-7.1.4.tgz#e3cd76d4c548ee895d3c3fd8dc1f6c5b9032e7a8"
+  integrity sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==
+
 ajv@^6.12.4:
   version "6.12.6"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
   dependencies:
     fast-deep-equal "^3.1.1"
@@ -6690,7 +7171,7 @@ ajv@^6.12.4:
 
 ajv@^8.11.0:
   version "8.17.1"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.17.1.tgz#37d9a5c776af6bc92d7f4f9510eba4c0a60d11a6"
   integrity sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==
   dependencies:
     fast-deep-equal "^3.1.3"
@@ -6705,168 +7186,152 @@ algoliasearch-helper@3.26.0:
   dependencies:
     "@algolia/events" "^4.0.1"
 
-algoliasearch@^5.14.2:
-  version "5.23.3"
-  resolved "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.23.3.tgz"
-  integrity sha512-0JlUaY/hl3LrKvbidI5FysEi2ggAlcTHM8AHV2UsrJUXnNo8/lWBfhzc1b7o8bK3YZNiU26JtLyT9exoj5VBgA==
-  dependencies:
-    "@algolia/client-abtesting" "5.23.3"
-    "@algolia/client-analytics" "5.23.3"
-    "@algolia/client-common" "5.23.3"
-    "@algolia/client-insights" "5.23.3"
-    "@algolia/client-personalization" "5.23.3"
-    "@algolia/client-query-suggestions" "5.23.3"
-    "@algolia/client-search" "5.23.3"
-    "@algolia/ingestion" "1.23.3"
-    "@algolia/monitoring" "1.23.3"
-    "@algolia/recommend" "5.23.3"
-    "@algolia/requester-browser-xhr" "5.23.3"
-    "@algolia/requester-fetch" "5.23.3"
-    "@algolia/requester-node-http" "5.23.3"
-
-algoliasearch@^5.37.0:
-  version "5.37.0"
-  resolved "https://registry.yarnpkg.com/algoliasearch/-/algoliasearch-5.37.0.tgz#73dc4a09654e6e02b529300018d639706b95b47b"
-  integrity sha512-y7gau/ZOQDqoInTQp0IwTOjkrHc4Aq4R8JgpmCleFwiLl+PbN2DMWoDUWZnrK8AhNJwT++dn28Bt4NZYNLAmuA==
-  dependencies:
-    "@algolia/abtesting" "1.3.0"
-    "@algolia/client-abtesting" "5.37.0"
-    "@algolia/client-analytics" "5.37.0"
-    "@algolia/client-common" "5.37.0"
-    "@algolia/client-insights" "5.37.0"
-    "@algolia/client-personalization" "5.37.0"
-    "@algolia/client-query-suggestions" "5.37.0"
-    "@algolia/client-search" "5.37.0"
-    "@algolia/ingestion" "1.37.0"
-    "@algolia/monitoring" "1.37.0"
-    "@algolia/recommend" "5.37.0"
-    "@algolia/requester-browser-xhr" "5.37.0"
-    "@algolia/requester-fetch" "5.37.0"
-    "@algolia/requester-node-http" "5.37.0"
+algoliasearch@^5.14.2, algoliasearch@^5.37.0:
+  version "5.39.0"
+  resolved "https://registry.yarnpkg.com/algoliasearch/-/algoliasearch-5.39.0.tgz#4c1b1091125c935cd3a6a0d7fc9558b82f66664d"
+  integrity sha512-DzTfhUxzg9QBNGzU/0kZkxEV72TeA4MmPJ7RVfLnQwHNhhliPo7ynglEWJS791rNlLFoTyrKvkapwr/P3EXV9A==
+  dependencies:
+    "@algolia/abtesting" "1.5.0"
+    "@algolia/client-abtesting" "5.39.0"
+    "@algolia/client-analytics" "5.39.0"
+    "@algolia/client-common" "5.39.0"
+    "@algolia/client-insights" "5.39.0"
+    "@algolia/client-personalization" "5.39.0"
+    "@algolia/client-query-suggestions" "5.39.0"
+    "@algolia/client-search" "5.39.0"
+    "@algolia/ingestion" "1.39.0"
+    "@algolia/monitoring" "1.39.0"
+    "@algolia/recommend" "5.39.0"
+    "@algolia/requester-browser-xhr" "5.39.0"
+    "@algolia/requester-fetch" "5.39.0"
+    "@algolia/requester-node-http" "5.39.0"
 
 ansi-escapes@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz"
-  integrity sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-7.1.1.tgz#fdd39427a7e5a26233e48a8b4366351629ffea1b"
+  integrity sha512-Zhl0ErHcSRUaVfGUeUdDuLgpkEo8KIFjB4Y9uAc46ScOpdDiU1Dbyplh7qWJeJ/ZHpbyMSM26+X3BySgnIz40Q==
   dependencies:
     environment "^1.0.0"
 
 ansi-regex@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
   integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
 
 ansi-regex@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz"
-  integrity sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==
-
-ansi-styles@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz"
-  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
-  dependencies:
-    color-convert "^1.9.0"
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.2.2.tgz#60216eea464d864597ce2832000738a0589650c1"
+  integrity sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==
 
 ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
   dependencies:
     color-convert "^2.0.1"
 
 ansi-styles@^6.0.0, ansi-styles@^6.1.0, ansi-styles@^6.2.1:
-  version "6.2.1"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz"
-  integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
+  version "6.2.3"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.3.tgz#c044d5dcc521a076413472597a1acb1f103c4041"
+  integrity sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==
 
 any-promise@^1.0.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/any-promise/-/any-promise-1.3.0.tgz#abc6afeedcea52e809cdc0376aed3ce39635d17f"
   integrity sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==
 
 anymatch@~3.1.2:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
   integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
   dependencies:
     normalize-path "^3.0.0"
     picomatch "^2.0.4"
 
+aproba@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/aproba/-/aproba-2.1.0.tgz#75500a190313d95c64e871e7e4284c6ac219f0b1"
+  integrity sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==
+
+archy@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40"
+  integrity sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==
+
 arg@^4.1.0:
   version "4.1.3"
-  resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
   integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
 
 arg@^5.0.2:
   version "5.0.2"
-  resolved "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
   integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
 
 argparse@^1.0.7:
   version "1.0.10"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
   dependencies:
     sprintf-js "~1.0.2"
 
 argparse@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
   integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
 
 aria-hidden@^1.2.4:
   version "1.2.6"
-  resolved "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz"
+  resolved "https://registry.yarnpkg.com/aria-hidden/-/aria-hidden-1.2.6.tgz#73051c9b088114c795b1ea414e9c0fff874ffc1a"
   integrity sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==
   dependencies:
     tslib "^2.0.0"
 
-aria-query@~5.1.3:
-  version "5.1.3"
-  resolved "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz"
-  integrity sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==
-  dependencies:
-    deep-equal "^2.0.5"
+aria-query@^5.3.2:
+  version "5.3.2"
+  resolved "https://registry.yarnpkg.com/aria-query/-/aria-query-5.3.2.tgz#93f81a43480e33a338f19163a3d10a50c01dcd59"
+  integrity sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==
 
-array-buffer-byte-length@^1.0.0, array-buffer-byte-length@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz"
-  integrity sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==
+array-buffer-byte-length@^1.0.1, array-buffer-byte-length@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz#384d12a37295aec3769ab022ad323a18a51ccf8b"
+  integrity sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==
   dependencies:
-    call-bind "^1.0.5"
-    is-array-buffer "^3.0.4"
+    call-bound "^1.0.3"
+    is-array-buffer "^3.0.5"
 
 array-ify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/array-ify/-/array-ify-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
   integrity sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==
 
-array-includes@^3.1.6, array-includes@^3.1.8:
-  version "3.1.8"
-  resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.8.tgz"
-  integrity sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==
+array-includes@^3.1.6, array-includes@^3.1.8, array-includes@^3.1.9:
+  version "3.1.9"
+  resolved "https://registry.yarnpkg.com/array-includes/-/array-includes-3.1.9.tgz#1f0ccaa08e90cdbc3eb433210f903ad0f17c3f3a"
+  integrity sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
     define-properties "^1.2.1"
-    es-abstract "^1.23.2"
-    es-object-atoms "^1.0.0"
-    get-intrinsic "^1.2.4"
-    is-string "^1.0.7"
+    es-abstract "^1.24.0"
+    es-object-atoms "^1.1.1"
+    get-intrinsic "^1.3.0"
+    is-string "^1.1.1"
+    math-intrinsics "^1.1.0"
 
 array-timsort@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/array-timsort/-/array-timsort-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/array-timsort/-/array-timsort-1.0.3.tgz#3c9e4199e54fb2b9c3fe5976396a21614ef0d926"
   integrity sha512-/+3GRL7dDAGEfM6TseQk/U+mi18TU2Ms9I3UlLdUMhz2hbvGNTKdj9xniwXfUqgYhHxRx0+8UnKkvlNwVU+cWQ==
 
 array-union@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
   integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
 
 array.prototype.findlast@^1.2.5:
   version "1.2.5"
-  resolved "https://registry.npmjs.org/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz"
+  resolved "https://registry.yarnpkg.com/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz#3e4fbcb30a15a7f5bf64cf2faae22d139c2e4904"
   integrity sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==
   dependencies:
     call-bind "^1.0.7"
@@ -6876,41 +7341,42 @@ array.prototype.findlast@^1.2.5:
     es-object-atoms "^1.0.0"
     es-shim-unscopables "^1.0.2"
 
-array.prototype.findlastindex@^1.2.5:
-  version "1.2.5"
-  resolved "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.5.tgz"
-  integrity sha512-zfETvRFA8o7EiNn++N5f/kaCw221hrpGsDmcpndVupkPzEc1Wuf3VgC0qby1BbHs7f5DVYjgtEU2LLh5bqeGfQ==
+array.prototype.findlastindex@^1.2.6:
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz#cfa1065c81dcb64e34557c9b81d012f6a421c564"
+  integrity sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
     define-properties "^1.2.1"
-    es-abstract "^1.23.2"
+    es-abstract "^1.23.9"
     es-errors "^1.3.0"
-    es-object-atoms "^1.0.0"
-    es-shim-unscopables "^1.0.2"
+    es-object-atoms "^1.1.1"
+    es-shim-unscopables "^1.1.0"
 
-array.prototype.flat@^1.3.1, array.prototype.flat@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz"
-  integrity sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==
+array.prototype.flat@^1.3.1, array.prototype.flat@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz#534aaf9e6e8dd79fb6b9a9917f839ef1ec63afe5"
+  integrity sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==
   dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.2.0"
-    es-abstract "^1.22.1"
-    es-shim-unscopables "^1.0.0"
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-shim-unscopables "^1.0.2"
 
-array.prototype.flatmap@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz"
-  integrity sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==
+array.prototype.flatmap@^1.3.2, array.prototype.flatmap@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz#712cc792ae70370ae40586264629e33aab5dd38b"
+  integrity sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==
   dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.2.0"
-    es-abstract "^1.22.1"
-    es-shim-unscopables "^1.0.0"
+    call-bind "^1.0.8"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.5"
+    es-shim-unscopables "^1.0.2"
 
 array.prototype.tosorted@^1.1.4:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz#fe954678ff53034e717ea3352a03f0b0b86f7ffc"
   integrity sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==
   dependencies:
     call-bind "^1.0.7"
@@ -6919,116 +7385,125 @@ array.prototype.tosorted@^1.1.4:
     es-errors "^1.3.0"
     es-shim-unscopables "^1.0.2"
 
-arraybuffer.prototype.slice@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz"
-  integrity sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==
+arraybuffer.prototype.slice@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz#9d760d84dbdd06d0cbf92c8849615a1a7ab3183c"
+  integrity sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==
   dependencies:
     array-buffer-byte-length "^1.0.1"
-    call-bind "^1.0.5"
+    call-bind "^1.0.8"
     define-properties "^1.2.1"
-    es-abstract "^1.22.3"
-    es-errors "^1.2.1"
-    get-intrinsic "^1.2.3"
+    es-abstract "^1.23.5"
+    es-errors "^1.3.0"
+    get-intrinsic "^1.2.6"
     is-array-buffer "^3.0.4"
-    is-shared-array-buffer "^1.0.2"
 
 arrify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==
 
 ast-types-flow@^0.0.8:
   version "0.0.8"
-  resolved "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/ast-types-flow/-/ast-types-flow-0.0.8.tgz#0a85e1c92695769ac13a428bb653e7538bea27d6"
   integrity sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==
 
 astring@^1.8.0:
   version "1.9.0"
-  resolved "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/astring/-/astring-1.9.0.tgz#cc73e6062a7eb03e7d19c22d8b0b3451fd9bfeef"
   integrity sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==
 
+async-function@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/async-function/-/async-function-1.0.0.tgz#509c9fca60eaf85034c6829838188e4e4c8ffb2b"
+  integrity sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==
+
 asynckit@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
   integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
 
 autoprefixer@^10.4.13:
-  version "10.4.20"
-  resolved "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz"
-  integrity sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==
+  version "10.4.21"
+  resolved "https://registry.yarnpkg.com/autoprefixer/-/autoprefixer-10.4.21.tgz#77189468e7a8ad1d9a37fbc08efc9f480cf0a95d"
+  integrity sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==
   dependencies:
-    browserslist "^4.23.3"
-    caniuse-lite "^1.0.30001646"
+    browserslist "^4.24.4"
+    caniuse-lite "^1.0.30001702"
     fraction.js "^4.3.7"
     normalize-range "^0.1.2"
-    picocolors "^1.0.1"
+    picocolors "^1.1.1"
     postcss-value-parser "^4.2.0"
 
 available-typed-arrays@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz#a5cc375d6a03c2efc87a553f3e0b1522def14846"
   integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==
   dependencies:
     possible-typed-array-names "^1.0.0"
 
 axe-core@^4.10.0:
-  version "4.10.0"
-  resolved "https://registry.npmjs.org/axe-core/-/axe-core-4.10.0.tgz"
-  integrity sha512-Mr2ZakwQ7XUAjp7pAwQWRhhK8mQQ6JAaNWSjmjxil0R8BPioMtQsTLOolGYkji1rcL++3dCqZA3zWqpT+9Ew6g==
+  version "4.10.3"
+  resolved "https://registry.yarnpkg.com/axe-core/-/axe-core-4.10.3.tgz#04145965ac7894faddbac30861e5d8f11bfd14fc"
+  integrity sha512-Xm7bpRXnDSX2YE2YFfBk2FnF0ep6tmG7xPh8iHee8MIcrgq762Nkce856dYtJYLkuIoYZvGfTs/PbZhideTcEg==
 
 axobject-query@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/axobject-query/-/axobject-query-4.1.0.tgz#28768c76d0e3cff21bc62a9e2d0b6ac30042a1ee"
   integrity sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==
 
-babel-plugin-polyfill-corejs2@^0.4.10:
-  version "0.4.11"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.11.tgz"
-  integrity sha512-sMEJ27L0gRHShOh5G54uAAPaiCOygY/5ratXuiyb2G46FmlSpc9eFCzYVyDiPxfNbwzA7mYahmjQc5q+CZQ09Q==
+babel-plugin-polyfill-corejs2@^0.4.14:
+  version "0.4.14"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.14.tgz#8101b82b769c568835611542488d463395c2ef8f"
+  integrity sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==
   dependencies:
-    "@babel/compat-data" "^7.22.6"
-    "@babel/helper-define-polyfill-provider" "^0.6.2"
+    "@babel/compat-data" "^7.27.7"
+    "@babel/helper-define-polyfill-provider" "^0.6.5"
     semver "^6.3.1"
 
-babel-plugin-polyfill-corejs3@^0.10.6:
-  version "0.10.6"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.10.6.tgz"
-  integrity sha512-b37+KR2i/khY5sKmWNVQAnitvquQbNdWy6lJdsr0kmquCKEEUgMKK4SboVM3HtfnZilfjr4MMQ7vY58FVWDtIA==
+babel-plugin-polyfill-corejs3@^0.13.0:
+  version "0.13.0"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz#bb7f6aeef7addff17f7602a08a6d19a128c30164"
+  integrity sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.6.2"
-    core-js-compat "^3.38.0"
+    "@babel/helper-define-polyfill-provider" "^0.6.5"
+    core-js-compat "^3.43.0"
 
-babel-plugin-polyfill-regenerator@^0.6.1:
-  version "0.6.2"
-  resolved "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.2.tgz"
-  integrity sha512-2R25rQZWP63nGwaAswvDazbPXfrM3HwVoBXK6HcqeKrSrL/JqcC/rDcf95l4r7LXLyxDXc8uQDa064GubtCABg==
+babel-plugin-polyfill-regenerator@^0.6.5:
+  version "0.6.5"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.5.tgz#32752e38ab6f6767b92650347bf26a31b16ae8c5"
+  integrity sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.6.2"
+    "@babel/helper-define-polyfill-provider" "^0.6.5"
 
 bail@^1.0.0:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/bail/-/bail-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/bail/-/bail-1.0.5.tgz#b6fa133404a392cbc1f8c4bf63f5953351e7a776"
   integrity sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ==
 
 bail@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/bail/-/bail-2.0.2.tgz#d26f5cd8fe5d6f832a31517b9f7c356040ba6d5d"
   integrity sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==
 
 balanced-match@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 
+baseline-browser-mapping@^2.8.3:
+  version "2.8.9"
+  resolved "https://registry.yarnpkg.com/baseline-browser-mapping/-/baseline-browser-mapping-2.8.9.tgz#fd0b8543c4f172595131e94965335536b3101b75"
+  integrity sha512-hY/u2lxLrbecMEWSB0IpGzGyDyeoMFQhCvZd2jGFSE5I17Fh01sYUBPCJtkWERw7zrac9+cIghxm/ytJa2X8iA==
+
 bcp-47-match@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/bcp-47-match/-/bcp-47-match-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/bcp-47-match/-/bcp-47-match-2.0.3.tgz#603226f6e5d3914a581408be33b28a53144b09d0"
   integrity sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ==
 
 bcp-47-normalize@^2.0.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/bcp-47-normalize/-/bcp-47-normalize-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/bcp-47-normalize/-/bcp-47-normalize-2.3.0.tgz#00f7de9dfdd0f6901c048083be5ac60903bf4f7a"
   integrity sha512-8I/wfzqQvttUFz7HVJgIZ7+dj3vUaIyIxYXaTRP1YWoSDfzt6TUmxaKZeuXR62qBmYr+nvuWINFRl6pZ5DlN4Q==
   dependencies:
     bcp-47 "^2.0.0"
@@ -7036,7 +7511,7 @@ bcp-47-normalize@^2.0.0:
 
 bcp-47@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/bcp-47/-/bcp-47-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/bcp-47/-/bcp-47-2.1.0.tgz#7e80734c3338fe8320894981dccf4968c3092df6"
   integrity sha512-9IIS3UPrvIa1Ej+lVDdDwO7zLehjqsaByECw0bu2RRGP73jALm6FYbzI5gWbgHLvNdkvfXB5YrSbocZdOS0c0w==
   dependencies:
     is-alphabetical "^2.0.0"
@@ -7045,22 +7520,33 @@ bcp-47@^2.0.0:
 
 big-integer@^1.6.16:
   version "1.6.52"
-  resolved "https://registry.npmjs.org/big-integer/-/big-integer-1.6.52.tgz"
+  resolved "https://registry.yarnpkg.com/big-integer/-/big-integer-1.6.52.tgz#60a887f3047614a8e1bffe5d7173490a97dc8c85"
   integrity sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==
 
-binary-extensions@^2.0.0:
+bin-links@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/bin-links/-/bin-links-5.0.0.tgz#2b0605b62dd5e1ddab3b92a3c4e24221cae06cca"
+  integrity sha512-sdleLVfCjBtgO5cNjA2HVRvWBJAHs4zwenaCPMNJAJU0yNxpzj80IpjOIimkpkr+mhlA+how5poQtt53PygbHA==
+  dependencies:
+    cmd-shim "^7.0.0"
+    npm-normalize-package-bin "^4.0.0"
+    proc-log "^5.0.0"
+    read-cmd-shim "^5.0.0"
+    write-file-atomic "^6.0.0"
+
+binary-extensions@^2.0.0, binary-extensions@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz#f6e14a97858d327252200242d4ccfe522c445522"
   integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==
 
 bluebird@*:
   version "3.7.2"
-  resolved "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz"
+  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
   integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
 
 boolbase@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e"
   integrity sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==
 
 brace-expansion@2.0.2, brace-expansion@^1.1.7, brace-expansion@^2.0.1:
@@ -7072,14 +7558,14 @@ brace-expansion@2.0.2, brace-expansion@^1.1.7, brace-expansion@^2.0.1:
 
 braces@^3.0.3, braces@~3.0.2:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789"
   integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==
   dependencies:
     fill-range "^7.1.1"
 
 broadcast-channel@^3.4.1:
   version "3.7.0"
-  resolved "https://registry.npmjs.org/broadcast-channel/-/broadcast-channel-3.7.0.tgz"
+  resolved "https://registry.yarnpkg.com/broadcast-channel/-/broadcast-channel-3.7.0.tgz#2dfa5c7b4289547ac3f6705f9c00af8723889937"
   integrity sha512-cIAKJXAxGJceNZGTZSBzMxzyOn72cVgPnKx4dc6LRjQgbaJUQqhy5rzL3zbMxkMWsGKkv2hSFkPRMEXfoMZ2Mg==
   dependencies:
     "@babel/runtime" "^7.7.2"
@@ -7091,60 +7577,68 @@ broadcast-channel@^3.4.1:
     rimraf "3.0.2"
     unload "2.2.0"
 
-browserslist@^4.23.1, browserslist@^4.23.3:
-  version "4.24.0"
-  resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.24.0.tgz"
-  integrity sha512-Rmb62sR1Zpjql25eSanFGEhAxcFwfA1K0GuQcLoaJBAcENegrQut3hYdhXFF1obQfiDyqIW/cLM5HSJ/9k884A==
-  dependencies:
-    caniuse-lite "^1.0.30001663"
-    electron-to-chromium "^1.5.28"
-    node-releases "^2.0.18"
-    update-browserslist-db "^1.1.0"
-
-browserslist@^4.24.0:
-  version "4.25.3"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.25.3.tgz#9167c9cbb40473f15f75f85189290678b99b16c5"
-  integrity sha512-cDGv1kkDI4/0e5yON9yM5G/0A5u8sf5TnmdX5C9qHzI9PPu++sQ9zjm1k9NiOrf3riY4OkK0zSGqfvJyJsgCBQ==
+browserslist@^4.24.0, browserslist@^4.24.4, browserslist@^4.25.3:
+  version "4.26.2"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.26.2.tgz#7db3b3577ec97f1140a52db4936654911078cef3"
+  integrity sha512-ECFzp6uFOSB+dcZ5BK/IBaGWssbSYBHvuMeMt3MMFyhI0Z8SqGgEkBLARgpRH3hutIgPVsALcMwbDrJqPxQ65A==
   dependencies:
-    caniuse-lite "^1.0.30001735"
-    electron-to-chromium "^1.5.204"
-    node-releases "^2.0.19"
+    baseline-browser-mapping "^2.8.3"
+    caniuse-lite "^1.0.30001741"
+    electron-to-chromium "^1.5.218"
+    node-releases "^2.0.21"
     update-browserslist-db "^1.1.3"
 
 buffer-from@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
 busboy@1.6.0:
   version "1.6.0"
-  resolved "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/busboy/-/busboy-1.6.0.tgz#966ea36a9502e43cdb9146962523b92f531f6893"
   integrity sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==
   dependencies:
     streamsearch "^1.1.0"
 
-call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
+cacache@^19.0.0, cacache@^19.0.1:
+  version "19.0.1"
+  resolved "https://registry.yarnpkg.com/cacache/-/cacache-19.0.1.tgz#3370cc28a758434c85c2585008bd5bdcff17d6cd"
+  integrity sha512-hdsUxulXCi5STId78vRVYEtDAjq99ICAUktLTeTYsLoTE6Z8dS0c8pWNCxwdrk9YfJeobDZc2Y186hD/5ZQgFQ==
+  dependencies:
+    "@npmcli/fs" "^4.0.0"
+    fs-minipass "^3.0.0"
+    glob "^10.2.2"
+    lru-cache "^10.0.1"
+    minipass "^7.0.3"
+    minipass-collect "^2.0.1"
+    minipass-flush "^1.0.5"
+    minipass-pipeline "^1.2.4"
+    p-map "^7.0.2"
+    ssri "^12.0.0"
+    tar "^7.4.3"
+    unique-filename "^4.0.0"
+
+call-bind-apply-helpers@^1.0.0, call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz#4b5428c222be985d79c3d82657479dbe0b59b2d6"
   integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==
   dependencies:
     es-errors "^1.3.0"
     function-bind "^1.1.2"
 
-call-bind@^1.0.2, call-bind@^1.0.5, call-bind@^1.0.6, call-bind@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz"
-  integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==
+call-bind@^1.0.7, call-bind@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.8.tgz#0736a9660f537e3388826f440d5ec45f744eaa4c"
+  integrity sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==
   dependencies:
+    call-bind-apply-helpers "^1.0.0"
     es-define-property "^1.0.0"
-    es-errors "^1.3.0"
-    function-bind "^1.1.2"
     get-intrinsic "^1.2.4"
-    set-function-length "^1.2.1"
+    set-function-length "^1.2.2"
 
-call-bound@^1.0.2:
+call-bound@^1.0.2, call-bound@^1.0.3, call-bound@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/call-bound/-/call-bound-1.0.4.tgz#238de935d2a2a692928c538c7ccfa91067fd062a"
   integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==
   dependencies:
     call-bind-apply-helpers "^1.0.2"
@@ -7152,17 +7646,17 @@ call-bound@^1.0.2:
 
 call-me-maybe@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/call-me-maybe/-/call-me-maybe-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/call-me-maybe/-/call-me-maybe-1.0.2.tgz#03f964f19522ba643b1b0693acb9152fe2074baa"
   integrity sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ==
 
 callsites@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 
 camel-case@^4.1.2:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz#9728072a954f805228225a6deea6b38461e1bd5a"
   integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
   dependencies:
     pascal-case "^3.1.2"
@@ -7170,12 +7664,12 @@ camel-case@^4.1.2:
 
 camelcase-css@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase-css/-/camelcase-css-2.0.1.tgz#ee978f6947914cc30c6b44741b6ed1df7f043fd5"
   integrity sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==
 
 camelcase-keys@^6.2.2:
   version "6.2.2"
-  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-6.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0"
   integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==
   dependencies:
     camelcase "^5.3.1"
@@ -7184,27 +7678,27 @@ camelcase-keys@^6.2.2:
 
 camelcase@^5.3.1:
   version "5.3.1"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
   integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
 
 camelcase@^6.2.0:
   version "6.3.0"
-  resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
   integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
-caniuse-lite@^1.0.30001579, caniuse-lite@^1.0.30001646, caniuse-lite@^1.0.30001663, caniuse-lite@^1.0.30001735:
-  version "1.0.30001737"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001737.tgz#8292bb7591932ff09e9a765f12fdf5629a241ccc"
-  integrity sha512-BiloLiXtQNrY5UyF0+1nSJLXUENuhka2pzy2Fx5pGxqavdrxSCW4U6Pn/PoG3Efspi2frRbHpBV2XsrPE6EDlw==
+caniuse-lite@^1.0.30001579, caniuse-lite@^1.0.30001702, caniuse-lite@^1.0.30001741:
+  version "1.0.30001745"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001745.tgz#ab2a36e3b6ed5bfb268adc002c476aab6513f859"
+  integrity sha512-ywt6i8FzvdgrrrGbr1jZVObnVv6adj+0if2/omv9cmR2oiZs30zL4DIyaptKcbOrBdOIc74QTMoJvSE2QHh5UQ==
 
 ccount@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/ccount/-/ccount-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/ccount/-/ccount-1.1.0.tgz#246687debb6014735131be8abab2d93898f8d043"
   integrity sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg==
 
 ccount@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/ccount/-/ccount-2.0.1.tgz#17a3bf82302e0870d6da43a01311a8bc02a3ecf5"
   integrity sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==
 
 chalk@3.0.0:
@@ -7215,71 +7709,62 @@ chalk@3.0.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^2.4.2:
-  version "2.4.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz"
-  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
-  dependencies:
-    ansi-styles "^3.2.1"
-    escape-string-regexp "^1.0.5"
-    supports-color "^5.3.0"
-
 chalk@^4.0.0, chalk@^4.1.0:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
   dependencies:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@~5.3.0:
-  version "5.3.0"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz"
-  integrity sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==
+chalk@^5.4.1:
+  version "5.6.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.6.2.tgz#b1238b6e23ea337af71c7f8a295db5af0c158aea"
+  integrity sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==
 
 character-entities-html4@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities-html4/-/character-entities-html4-2.1.0.tgz#1f1adb940c971a4b22ba39ddca6b618dc6e56b2b"
   integrity sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==
 
 character-entities-legacy@^1.0.0:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz#94bc1845dce70a5bb9d2ecc748725661293d8fc1"
   integrity sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA==
 
 character-entities-legacy@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz#76bc83a90738901d7bc223a9e93759fdd560125b"
   integrity sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==
 
 character-entities@^1.0.0:
   version "1.2.4"
-  resolved "https://registry.npmjs.org/character-entities/-/character-entities-1.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities/-/character-entities-1.2.4.tgz#e12c3939b7eaf4e5b15e7ad4c5e28e1d48c5b16b"
   integrity sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw==
 
 character-entities@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/character-entities/-/character-entities-2.0.2.tgz#2d09c2e72cd9523076ccb21157dff66ad43fcc22"
   integrity sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==
 
 character-reference-invalid@^1.0.0:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz#083329cda0eae272ab3dbbf37e9a382c13af1560"
   integrity sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==
 
 character-reference-invalid@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz#85c66b041e43b47210faf401278abf808ac45cb9"
   integrity sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==
 
 charset@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/charset/-/charset-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/charset/-/charset-1.0.1.tgz#8d59546c355be61049a8fa9164747793319852bd"
   integrity sha512-6dVyOOYjpfFcL1Y4qChrAoQLRHvj2ziyhcm0QJlhOcAhykL/k1kTUPbeo+87MNRTRdk2OIIsIXbuF3x2wi5EXg==
 
-chokidar@^3.5.3:
+chokidar@^3.5.3, chokidar@^3.6.0:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b"
   integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
   dependencies:
     anymatch "~3.1.2"
@@ -7297,40 +7782,61 @@ chownr@^2.0.0:
   resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
   integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
 
+ci-info@^4.0.0, ci-info@^4.2.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-4.3.0.tgz#c39b1013f8fdbd28cd78e62318357d02da160cd7"
+  integrity sha512-l+2bNRMiQgcfILUi33labAZYIWlH1kWDp+ecNo5iisRKrbm0xcRyCww71/YU0Fkw0mAFpz9bJayXPjey6vkmaQ==
+
+cidr-regex@^4.1.1:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/cidr-regex/-/cidr-regex-4.1.3.tgz#df94af8ac16fc2e0791e2824693b957ff1ac4d3e"
+  integrity sha512-86M1y3ZeQvpZkZejQCcS+IaSWjlDUC+ORP0peScQ4uEUFCZ8bEQVz7NlJHqysoUb6w3zCjx4Mq/8/2RHhMwHYw==
+  dependencies:
+    ip-regex "^5.0.0"
+
 cjs-module-lexer@^1.2.2:
   version "1.4.3"
   resolved "https://registry.yarnpkg.com/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz#0f79731eb8cfe1ec72acd4066efac9d61991b00d"
   integrity sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==
 
+class-variance-authority@^0.7.0:
 class-variance-authority@^0.7.0:
   version "0.7.1"
-  resolved "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz"
+  resolved "https://registry.yarnpkg.com/class-variance-authority/-/class-variance-authority-0.7.1.tgz#4008a798a0e4553a781a57ac5177c9fb5d043787"
   integrity sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==
   dependencies:
     clsx "^2.1.1"
 
 classnames@^2.2.6:
   version "2.5.1"
-  resolved "https://registry.npmjs.org/classnames/-/classnames-2.5.1.tgz"
+  resolved "https://registry.yarnpkg.com/classnames/-/classnames-2.5.1.tgz#ba774c614be0f016da105c858e7159eae8e7687b"
   integrity sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow==
 
 clean-css@^5.0.0:
   version "5.3.3"
-  resolved "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/clean-css/-/clean-css-5.3.3.tgz#b330653cd3bd6b75009cc25c714cae7b93351ccd"
   integrity sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==
   dependencies:
     source-map "~0.6.0"
 
+cli-columns@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/cli-columns/-/cli-columns-4.0.0.tgz#9fe4d65975238d55218c41bd2ed296a7fa555646"
+  integrity sha512-XW2Vg+w+L9on9wtwKpyzluIPCWXjaBahI7mTcYjx+BVIYD9c3yqcv/yKC7CmdCZat4rq2yiE1UMSJC5ivKfMtQ==
+  dependencies:
+    string-width "^4.2.3"
+    strip-ansi "^6.0.1"
+
 cli-cursor@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-5.0.0.tgz#24a4831ecf5a6b01ddeb32fb71a4b2088b0dce38"
   integrity sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==
   dependencies:
     restore-cursor "^5.0.0"
 
 cli-truncate@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-4.0.0.tgz#6cc28a2924fee9e25ce91e973db56c7066e6172a"
   integrity sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==
   dependencies:
     slice-ansi "^5.0.0"
@@ -7338,19 +7844,19 @@ cli-truncate@^4.0.0:
 
 client-only@0.0.1:
   version "0.0.1"
-  resolved "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/client-only/-/client-only-0.0.1.tgz#38bba5d403c41ab150bff64a95c85013cf73bca1"
   integrity sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==
 
 clipanion@^3.2.1:
   version "3.2.1"
-  resolved "https://registry.npmjs.org/clipanion/-/clipanion-3.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/clipanion/-/clipanion-3.2.1.tgz#2887db4cb232e80ba57cf19347a4e3a1c4a74133"
   integrity sha512-dYFdjLb7y1ajfxQopN05mylEpK9ZX0sO1/RfMXdfmwjlIsPkbh4p7A682x++zFPLDCo1x3p82dtljHf5cW2LKA==
   dependencies:
     typanion "^3.8.0"
 
 cliui@^7.0.2:
   version "7.0.4"
-  resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
   integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
   dependencies:
     string-width "^4.2.0"
@@ -7359,7 +7865,7 @@ cliui@^7.0.2:
 
 cliui@^8.0.1:
   version "8.0.1"
-  resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa"
   integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==
   dependencies:
     string-width "^4.2.0"
@@ -7368,46 +7874,39 @@ cliui@^8.0.1:
 
 clsx@^1.1.1, clsx@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/clsx/-/clsx-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/clsx/-/clsx-1.2.1.tgz#0ddc4a20a549b59c93a4116bb26f5294ca17dc12"
   integrity sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==
 
 clsx@^2.0.0, clsx@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/clsx/-/clsx-2.1.1.tgz#eed397c9fd8bd882bfb18deab7102049a2f32999"
   integrity sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==
 
+cmd-shim@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/cmd-shim/-/cmd-shim-7.0.0.tgz#23bcbf69fff52172f7e7c02374e18fb215826d95"
+  integrity sha512-rtpaCbr164TPPh+zFdkWpCyZuKkjpAzODfaZCf/SVJZzJN+4bHQb/LP3Jzq5/+84um3XXY8r548XiWKSborwVw==
+
 collapse-white-space@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/collapse-white-space/-/collapse-white-space-2.1.0.tgz#640257174f9f42c740b40f3b55ee752924feefca"
   integrity sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==
 
-color-convert@^1.9.0:
-  version "1.9.3"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz"
-  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
-  dependencies:
-    color-name "1.1.3"
-
 color-convert@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
   integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
   dependencies:
     color-name "~1.1.4"
 
-color-name@1.1.3, color-name@^1.0.0:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz"
-  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
-
-color-name@~1.1.4:
+color-name@^1.0.0, color-name@~1.1.4:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
 color-string@^1.9.0:
   version "1.9.1"
-  resolved "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz"
+  resolved "https://registry.yarnpkg.com/color-string/-/color-string-1.9.1.tgz#4467f9146f036f855b764dfb5bf8582bf342c7a4"
   integrity sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==
   dependencies:
     color-name "^1.0.0"
@@ -7415,12 +7914,12 @@ color-string@^1.9.0:
 
 color2k@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/color2k/-/color2k-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/color2k/-/color2k-2.0.3.tgz#a771244f6b6285541c82aa65ff0a0c624046e533"
   integrity sha512-zW190nQTIoXcGCaU08DvVNFTmQhUpnJfVuAKfWqUQkflXKpaDdpaYoM0iluLS9lgJNHyBF58KKA2FBEwkD7wog==
 
 color@^4.2.3:
   version "4.2.3"
-  resolved "https://registry.npmjs.org/color/-/color-4.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/color/-/color-4.2.3.tgz#d781ecb5e57224ee43ea9627560107c0e0c6463a"
   integrity sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==
   dependencies:
     color-convert "^2.0.1"
@@ -7428,51 +7927,54 @@ color@^4.2.3:
 
 colorette@^2.0.20:
   version "2.0.20"
-  resolved "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a"
   integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==
 
 combined-stream@^1.0.8:
   version "1.0.8"
-  resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
   integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
   dependencies:
     delayed-stream "~1.0.0"
 
 comma-separated-tokens@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz#4e89c9458acb61bc8fef19f4529973b2392839ee"
   integrity sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==
 
+commander@^13.1.0:
+  version "13.1.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-13.1.0.tgz#776167db68c78f38dcce1f9b8d7b8b9a488abf46"
+  integrity sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==
+
 commander@^4.0.0:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068"
   integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==
 
 commander@^7.2.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7"
   integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
 
 commander@^8.3.0:
   version "8.3.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66"
   integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==
 
-commander@~12.1.0:
-  version "12.1.0"
-  resolved "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz"
-  integrity sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==
-
 comment-json@^4.2.3:
-  version "4.2.5"
-  resolved "https://registry.npmjs.org/comment-json/-/comment-json-4.2.5.tgz"
-  integrity sha512-bKw/r35jR3HGt5PEPm1ljsQQGyCrR8sFGNiN5L+ykDHdpO8Smxkrkla9Yi6NkQyUrb8V54PGhfMs6NrIwtxtdw==
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/comment-json/-/comment-json-4.3.0.tgz#74e1f35b4a6b76ac000d5cb8d02f950e44ff68ee"
+  integrity sha512-DczdmbvWLd09KATFWY0xcihOO45b32+5V34vZg1oelxqgjtGJotaLrrdFpJRLOdG6Wb031qcg4zOKgnQoBWbEw==
   dependencies:
     array-timsort "^1.0.3"
     core-util-is "^1.0.3"
     esprima "^4.0.1"
-    has-own-prop "^2.0.0"
-    repeat-string "^1.6.1"
+
+common-ancestor-path@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/common-ancestor-path/-/common-ancestor-path-1.0.1.tgz#4f7d2d1394d91b7abdf51871c62f71eadb0182a7"
+  integrity sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==
 
 commondir@^1.0.1:
   version "1.0.1"
@@ -7481,7 +7983,7 @@ commondir@^1.0.1:
 
 compare-func@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/compare-func/-/compare-func-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3"
   integrity sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==
   dependencies:
     array-ify "^1.0.0"
@@ -7489,12 +7991,12 @@ compare-func@^2.0.0:
 
 component-emitter@^1.2.0:
   version "1.3.1"
-  resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.1.tgz#ef1d5796f7d93f135ee6fb684340b26403c97d17"
   integrity sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==
 
 compute-gcd@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/compute-gcd/-/compute-gcd-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/compute-gcd/-/compute-gcd-1.2.1.tgz#34d639f3825625e1357ce81f0e456a6249d8c77f"
   integrity sha512-TwMbxBNz0l71+8Sc4czv13h4kEqnchV9igQZBi6QUaz09dnz13juGnnaWWJTRsP3brxOoxeB4SA2WELLw1hCtg==
   dependencies:
     validate.io-array "^1.0.3"
@@ -7503,7 +8005,7 @@ compute-gcd@^1.2.1:
 
 compute-lcm@^1.1.0:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/compute-lcm/-/compute-lcm-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/compute-lcm/-/compute-lcm-1.1.2.tgz#9107c66b9dca28cefb22b4ab4545caac4034af23"
   integrity sha512-OFNPdQAXnQhDSKioX8/XYT6sdUlXwpeMjfd6ApxMJfyZ4GxmLR1xvMERctlYhlHwIiz6CSpBc2+qYKjHGZw4TQ==
   dependencies:
     compute-gcd "^1.2.1"
@@ -7512,13 +8014,13 @@ compute-lcm@^1.1.0:
     validate.io-integer-array "^1.0.0"
 
 compute-scroll-into-view@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/compute-scroll-into-view/-/compute-scroll-into-view-3.1.0.tgz"
-  integrity sha512-rj8l8pD4bJ1nx+dAkMhV1xB5RuZEyVysfxJqB1pRchh1KVvwOv9b7CGB8ZfjTImVv2oF+sYMUkMZq6Na5Ftmbg==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/compute-scroll-into-view/-/compute-scroll-into-view-3.1.1.tgz#02c3386ec531fb6a9881967388e53e8564f3e9aa"
+  integrity sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw==
 
-contentlayer2@0.5.5, contentlayer2@^0.5.3:
+contentlayer2@0.5.5:
   version "0.5.5"
-  resolved "https://registry.npmjs.org/contentlayer2/-/contentlayer2-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/contentlayer2/-/contentlayer2-0.5.5.tgz#f818a1662862bc67b438b9657a59d7caeebb04de"
   integrity sha512-nz+pVYiY+k12G09Ty006xeIFB4ZgNQB8sZbzH6U2rvxcEOWGyPNZ/xbfuGGUu7I97DHcVgwxWh9zZUuL/4vsuQ==
   dependencies:
     "@contentlayer2/cli" "0.5.5"
@@ -7528,23 +8030,35 @@ contentlayer2@0.5.5, contentlayer2@^0.5.3:
     "@contentlayer2/source-remote-files" "0.5.5"
     "@contentlayer2/utils" "0.5.5"
 
+contentlayer2@^0.5.3:
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/contentlayer2/-/contentlayer2-0.5.8.tgz#876745ae5b3481da93813c5da3c0a3a05b4e08ec"
+  integrity sha512-GlyhZdJALMyTRuxquE2AQ47kELupZKz4BIEpZeN/NiNV+3MmE61LW1bF7gpCZ+cIrKkSaDNTKbeLvEtsefslqA==
+  dependencies:
+    "@contentlayer2/cli" "0.5.8"
+    "@contentlayer2/client" "0.5.8"
+    "@contentlayer2/core" "0.5.8"
+    "@contentlayer2/source-files" "0.5.8"
+    "@contentlayer2/source-remote-files" "0.5.8"
+    "@contentlayer2/utils" "0.5.8"
+
 conventional-changelog-angular@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/conventional-changelog-angular/-/conventional-changelog-angular-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-6.0.0.tgz#a9a9494c28b7165889144fd5b91573c4aa9ca541"
   integrity sha512-6qLgrBF4gueoC7AFVHu51nHL9pF9FRjXrH+ceVf7WmAfH3gs+gEYOkvxhjMPjZu57I4AGUGoNTY8V7Hrgf1uqg==
   dependencies:
     compare-func "^2.0.0"
 
 conventional-changelog-conventionalcommits@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-6.1.0.tgz#3bad05f4eea64e423d3d90fc50c17d2c8cf17652"
   integrity sha512-3cS3GEtR78zTfMzk0AizXKKIdN4OvSh7ibNz6/DPbhWWQu7LqE/8+/GqSodV+sywUR2gpJAdP/1JFf4XtN7Zpw==
   dependencies:
     compare-func "^2.0.0"
 
 conventional-commits-parser@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/conventional-commits-parser/-/conventional-commits-parser-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-4.0.0.tgz#02ae1178a381304839bce7cea9da5f1b549ae505"
   integrity sha512-WRv5j1FsVM5FISJkoYMR6tPk07fkKT0UodruX4je86V4owk451yjXAKzKAPOs9l7y59E2viHUS9eQ+dfUA9NSg==
   dependencies:
     JSONStream "^1.3.5"
@@ -7554,24 +8068,24 @@ conventional-commits-parser@^4.0.0:
 
 convert-source-map@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a"
   integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==
 
 cookiejar@^2.1.0:
   version "2.1.4"
-  resolved "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/cookiejar/-/cookiejar-2.1.4.tgz#ee669c1fea2cf42dc31585469d193fef0d65771b"
   integrity sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==
 
 copy-to-clipboard@^3.3.1:
   version "3.3.3"
-  resolved "https://registry.npmjs.org/copy-to-clipboard/-/copy-to-clipboard-3.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/copy-to-clipboard/-/copy-to-clipboard-3.3.3.tgz#55ac43a1db8ae639a4bd99511c148cdd1b83a1b0"
   integrity sha512-2KV8NhB5JqC3ky0r9PMCAZKbUHSwtEo4CwCs0KXgruG43gX5PMqDEBbVU4OUzw2MuAWUfsuFmWvEKG5QRfSnJA==
   dependencies:
     toggle-selection "^1.0.6"
 
 copyfiles@^2.4.1:
   version "2.4.1"
-  resolved "https://registry.npmjs.org/copyfiles/-/copyfiles-2.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/copyfiles/-/copyfiles-2.4.1.tgz#d2dcff60aaad1015f09d0b66e7f0f1c5cd3c5da5"
   integrity sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==
   dependencies:
     glob "^7.0.5"
@@ -7582,26 +8096,31 @@ copyfiles@^2.4.1:
     untildify "^4.0.0"
     yargs "^16.1.0"
 
-core-js-compat@^3.37.1, core-js-compat@^3.38.0:
-  version "3.38.1"
-  resolved "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.38.1.tgz"
-  integrity sha512-JRH6gfXxGmrzF3tZ57lFx97YARxCXPaMzPo6jELZhv88pBH5VXpQ+y0znKGlFnzuaihqhLbefxSJxWJMPtfDzw==
+core-js-compat@^3.43.0:
+  version "3.45.1"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.45.1.tgz#424f3f4af30bf676fd1b67a579465104f64e9c7a"
+  integrity sha512-tqTt5T4PzsMIZ430XGviK4vzYSoeNJ6CXODi6c/voxOT6IZqBht5/EKaSNnYiEjjRYxjVz7DQIsOsY0XNi8PIA==
   dependencies:
-    browserslist "^4.23.3"
+    browserslist "^4.25.3"
+
+core-js@^3.32.2:
+  version "3.45.1"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.45.1.tgz#5810e04a1b4e9bc5ddaa4dd12e702ff67300634d"
+  integrity sha512-L4NPsJlCfZsPeXukyzHFlg/i7IIVwHSItR0wg0FLNqYClJ4MQYTYLbC7EkjKYRLZF2iof2MUgN0EGy7MdQFChg==
 
 core-util-is@^1.0.3, core-util-is@~1.0.0:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
   integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
 
 cosmiconfig-typescript-loader@^4.0.0:
   version "4.4.0"
-  resolved "https://registry.npmjs.org/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-4.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-4.4.0.tgz#f3feae459ea090f131df5474ce4b1222912319f9"
   integrity sha512-BabizFdC3wBHhbI4kJh0VkQP9GkBfoHPydD0COMce1nJ1kJAB3F2TmJ/I7diULBKtmEWSwEbuN/KDtgnmUUVmw==
 
 cosmiconfig@^8.0.0, cosmiconfig@^8.1.3:
   version "8.3.6"
-  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-8.3.6.tgz#060a2b871d66dba6c8538ea1118ba1ac16f5fae3"
   integrity sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==
   dependencies:
     import-fresh "^3.3.0"
@@ -7611,26 +8130,26 @@ cosmiconfig@^8.0.0, cosmiconfig@^8.1.3:
 
 create-require@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
   integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
 
 cross-env@^7.0.3:
   version "7.0.3"
-  resolved "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/cross-env/-/cross-env-7.0.3.tgz#865264b29677dc015ba8418918965dd232fc54cf"
   integrity sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==
   dependencies:
     cross-spawn "^7.0.1"
 
 cross-fetch@^3.1.5:
-  version "3.1.8"
-  resolved "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.8.tgz"
-  integrity sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.2.0.tgz#34e9192f53bc757d6614304d9e5e6fb4edb782e3"
+  integrity sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==
   dependencies:
-    node-fetch "^2.6.12"
+    node-fetch "^2.7.0"
 
-cross-spawn@^7.0.0, cross-spawn@^7.0.1, cross-spawn@^7.0.2, cross-spawn@^7.0.3:
+cross-spawn@^7.0.1, cross-spawn@^7.0.2, cross-spawn@^7.0.3, cross-spawn@^7.0.6:
   version "7.0.6"
-  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.6.tgz#8a58fe78f00dcd70c370451759dfbfaf03e8ee9f"
   integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==
   dependencies:
     path-key "^3.1.0"
@@ -7639,15 +8158,15 @@ cross-spawn@^7.0.0, cross-spawn@^7.0.1, cross-spawn@^7.0.2, cross-spawn@^7.0.3:
 
 css-in-js-utils@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/css-in-js-utils/-/css-in-js-utils-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/css-in-js-utils/-/css-in-js-utils-3.1.0.tgz#640ae6a33646d401fc720c54fc61c42cd76ae2bb"
   integrity sha512-fJAcud6B3rRu+KHYk+Bwf+WFL2MDCJJ1XG9x137tJQ0xYxor7XziQtuGFbWNdqrvF4Tk26O3H73nfVqXt/fW1A==
   dependencies:
     hyphenate-style-name "^1.0.3"
 
 css-select@^5.1.0:
-  version "5.1.0"
-  resolved "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz"
-  integrity sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==
+  version "5.2.2"
+  resolved "https://registry.yarnpkg.com/css-select/-/css-select-5.2.2.tgz#01b6e8d163637bb2dd6c982ca4ed65863682786e"
+  integrity sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==
   dependencies:
     boolbase "^1.0.0"
     css-what "^6.1.0"
@@ -7657,17 +8176,17 @@ css-select@^5.1.0:
 
 css-selector-parser@^1.0.0:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-selector-parser/-/css-selector-parser-1.4.1.tgz#03f9cb8a81c3e5ab2c51684557d5aaf6d2569759"
   integrity sha512-HYPSb7y/Z7BNDCOrakL4raGO2zltZkbeXyAd6Tg9obzix6QhzxCotdBl6VT0Dv4vZfJGVz3WL/xaEI9Ly3ul0g==
 
 css-selector-parser@^3.0.0:
-  version "3.0.5"
-  resolved "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-3.0.5.tgz"
-  integrity sha512-3itoDFbKUNx1eKmVpYMFyqKX04Ww9osZ+dLgrk6GEv6KMVeXUhUnp4I5X+evw+u3ZxVU6RFXSSRxlTeMh8bA+g==
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/css-selector-parser/-/css-selector-parser-3.1.3.tgz#fb1ba303cfa00e0a7b7a49ede46c12e1b87a081f"
+  integrity sha512-gJMigczVZqYAk0hPVzx/M4Hm1D9QOtqkdQk9005TNzDIUGzo5cnHEDiKUT7jGPximL/oYb+LIitcHFQ4aKupxg==
 
 css-tree@^1.1.2:
   version "1.1.3"
-  resolved "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-1.1.3.tgz#eb4870fb6fd7707327ec95c2ff2ab09b5e8db91d"
   integrity sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==
   dependencies:
     mdn-data "2.0.14"
@@ -7675,7 +8194,7 @@ css-tree@^1.1.2:
 
 css-tree@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/css-tree/-/css-tree-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-2.3.1.tgz#10264ce1e5442e8572fc82fbe490644ff54b5c20"
   integrity sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==
   dependencies:
     mdn-data "2.0.30"
@@ -7683,71 +8202,72 @@ css-tree@^2.3.1:
 
 css-tree@~2.2.0:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/css-tree/-/css-tree-2.2.1.tgz#36115d382d60afd271e377f9c5f67d02bd48c032"
   integrity sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==
   dependencies:
     mdn-data "2.0.28"
     source-map-js "^1.0.1"
 
 css-what@^6.1.0:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz"
-  integrity sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/css-what/-/css-what-6.2.2.tgz#cdcc8f9b6977719fdfbd1de7aec24abf756b9dea"
+  integrity sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==
 
 cssesc@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee"
   integrity sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==
 
 csso@^5.0.5:
   version "5.0.5"
-  resolved "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/csso/-/csso-5.0.5.tgz#f9b7fe6cc6ac0b7d90781bb16d5e9874303e2ca6"
   integrity sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==
   dependencies:
     css-tree "~2.2.0"
 
+csstype@^3.0.2, csstype@^3.1.2:
 csstype@^3.0.2, csstype@^3.1.2:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.1.3.tgz#d80ff294d114fb0e6ac500fbf85b60137d7eff81"
   integrity sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==
 
 "d3-array@2 - 3", "d3-array@2.10.0 - 3", d3-array@^3.1.6:
   version "3.2.4"
-  resolved "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/d3-array/-/d3-array-3.2.4.tgz#15fec33b237f97ac5d7c986dc77da273a8ed0bb5"
   integrity sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==
   dependencies:
     internmap "1 - 2"
 
 "d3-color@1 - 3":
   version "3.1.0"
-  resolved "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-color/-/d3-color-3.1.0.tgz#395b2833dfac71507f12ac2f7af23bf819de24e2"
   integrity sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==
 
 d3-ease@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/d3-ease/-/d3-ease-3.0.1.tgz#9658ac38a2140d59d346160f1f6c30fda0bd12f4"
   integrity sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==
 
 "d3-format@1 - 3":
   version "3.1.0"
-  resolved "https://registry.npmjs.org/d3-format/-/d3-format-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-format/-/d3-format-3.1.0.tgz#9260e23a28ea5cb109e93b21a06e24e2ebd55641"
   integrity sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==
 
 "d3-interpolate@1.2.0 - 3", d3-interpolate@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/d3-interpolate/-/d3-interpolate-3.0.1.tgz#3c47aa5b32c5b3dfb56ef3fd4342078a632b400d"
   integrity sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==
   dependencies:
     d3-color "1 - 3"
 
 d3-path@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-path/-/d3-path-3.1.0.tgz#22df939032fb5a71ae8b1800d61ddb7851c42526"
   integrity sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==
 
 d3-scale@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/d3-scale/-/d3-scale-4.0.2.tgz#82b38e8e8ff7080764f8dcec77bd4be393689396"
   integrity sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==
   dependencies:
     d3-array "2.10.0 - 3"
@@ -7758,108 +8278,101 @@ d3-scale@^4.0.2:
 
 d3-shape@^3.1.0:
   version "3.2.0"
-  resolved "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-shape/-/d3-shape-3.2.0.tgz#a1a839cbd9ba45f28674c69d7f855bcf91dfc6a5"
   integrity sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==
   dependencies:
     d3-path "^3.1.0"
 
 "d3-time-format@2 - 4":
   version "4.1.0"
-  resolved "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-time-format/-/d3-time-format-4.1.0.tgz#7ab5257a5041d11ecb4fe70a5c7d16a195bb408a"
   integrity sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==
   dependencies:
     d3-time "1 - 3"
 
 "d3-time@1 - 3", "d3-time@2.1.1 - 3", d3-time@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/d3-time/-/d3-time-3.1.0.tgz#9310db56e992e3c0175e1ef385e545e48a9bb5c7"
   integrity sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==
   dependencies:
     d3-array "2 - 3"
 
 d3-timer@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/d3-timer/-/d3-timer-3.0.1.tgz#6284d2a2708285b1abb7e201eda4380af35e63b0"
   integrity sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==
 
 damerau-levenshtein@^1.0.8:
   version "1.0.8"
-  resolved "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz#b43d286ccbd36bc5b2f7ed41caf2d0aba1f8a6e7"
   integrity sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==
 
 dargs@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/dargs/-/dargs-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc"
   integrity sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==
 
-data-view-buffer@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.1.tgz"
-  integrity sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==
+data-view-buffer@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/data-view-buffer/-/data-view-buffer-1.0.2.tgz#211a03ba95ecaf7798a8c7198d79536211f88570"
+  integrity sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==
   dependencies:
-    call-bind "^1.0.6"
+    call-bound "^1.0.3"
     es-errors "^1.3.0"
-    is-data-view "^1.0.1"
+    is-data-view "^1.0.2"
 
-data-view-byte-length@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.1.tgz"
-  integrity sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==
+data-view-byte-length@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz#9e80f7ca52453ce3e93d25a35318767ea7704735"
+  integrity sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==
   dependencies:
-    call-bind "^1.0.7"
+    call-bound "^1.0.3"
     es-errors "^1.3.0"
-    is-data-view "^1.0.1"
+    is-data-view "^1.0.2"
 
-data-view-byte-offset@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz"
-  integrity sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==
+data-view-byte-offset@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz#068307f9b71ab76dbbe10291389e020856606191"
+  integrity sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==
   dependencies:
-    call-bind "^1.0.6"
+    call-bound "^1.0.2"
     es-errors "^1.3.0"
     is-data-view "^1.0.1"
 
 date-fns@^3.6.0:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/date-fns/-/date-fns-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-3.6.0.tgz#f20ca4fe94f8b754951b24240676e8618c0206bf"
   integrity sha512-fRHTG8g/Gif+kSh50gaGEdToemgfj74aRX3swtiouboip5JDLAyDE9F11nHMIcvOaXeOC6D7SpNhi7uFyB7Uww==
 
 debounce@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/debounce/-/debounce-1.2.1.tgz#38881d8f4166a5c5848020c11827b834bcb3e0a5"
   integrity sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==
 
 debug@2:
   version "2.6.9"
-  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
-debug@4:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.1.tgz#e5a8bc6cbc4c6cd3e64308b0693a3d4fa550189b"
-  integrity sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==
+debug@4, debug@^4.0.0, debug@^4.1.0, debug@^4.3.1, debug@^4.3.2, debug@^4.3.4, debug@^4.3.5, debug@^4.4.0, debug@^4.4.1:
+  version "4.4.3"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.3.tgz#c6ae432d9bd9662582fce08709b038c58e9e3d6a"
+  integrity sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==
   dependencies:
     ms "^2.1.3"
 
 debug@^3.1.0, debug@^3.2.6, debug@^3.2.7:
   version "3.2.7"
-  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
   integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
   dependencies:
     ms "^2.1.1"
 
-debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.4, debug@^4.3.5, debug@~4.3.6:
-  version "4.3.7"
-  resolved "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz"
-  integrity sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==
-  dependencies:
-    ms "^2.1.3"
-
 decamelize-keys@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8"
   integrity sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==
   dependencies:
     decamelize "^1.1.0"
@@ -7867,67 +8380,48 @@ decamelize-keys@^1.1.0:
 
 decamelize@^1.1.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
 
 decimal.js-light@^2.4.1:
   version "2.5.1"
-  resolved "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz"
+  resolved "https://registry.yarnpkg.com/decimal.js-light/-/decimal.js-light-2.5.1.tgz#134fd32508f19e208f4fb2f8dac0d2626a867934"
   integrity sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==
 
+decimal.js@^10.4.3:
+  version "10.6.0"
+  resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.6.0.tgz#e649a43e3ab953a72192ff5983865e509f37ed9a"
+  integrity sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==
+
 decode-named-character-reference@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz"
-  integrity sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/decode-named-character-reference/-/decode-named-character-reference-1.2.0.tgz#25c32ae6dd5e21889549d40f676030e9514cc0ed"
+  integrity sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q==
   dependencies:
     character-entities "^2.0.0"
 
-deep-equal@^2.0.5:
-  version "2.2.3"
-  resolved "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.3.tgz"
-  integrity sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==
-  dependencies:
-    array-buffer-byte-length "^1.0.0"
-    call-bind "^1.0.5"
-    es-get-iterator "^1.1.3"
-    get-intrinsic "^1.2.2"
-    is-arguments "^1.1.1"
-    is-array-buffer "^3.0.2"
-    is-date-object "^1.0.5"
-    is-regex "^1.1.4"
-    is-shared-array-buffer "^1.0.2"
-    isarray "^2.0.5"
-    object-is "^1.1.5"
-    object-keys "^1.1.1"
-    object.assign "^4.1.4"
-    regexp.prototype.flags "^1.5.1"
-    side-channel "^1.0.4"
-    which-boxed-primitive "^1.0.2"
-    which-collection "^1.0.1"
-    which-typed-array "^1.1.13"
-
 deep-is@^0.1.3:
   version "0.1.4"
-  resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
   integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
 
 deepmerge@4.3.1, deepmerge@^4.2.2, deepmerge@^4.3.1:
   version "4.3.1"
-  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
   integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
 
 define-data-property@^1.0.1, define-data-property@^1.1.4:
   version "1.1.4"
-  resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e"
   integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==
   dependencies:
     es-define-property "^1.0.0"
     es-errors "^1.3.0"
     gopd "^1.0.1"
 
-define-properties@^1.1.3, define-properties@^1.2.0, define-properties@^1.2.1:
+define-properties@^1.1.3, define-properties@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c"
   integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
   dependencies:
     define-data-property "^1.0.1"
@@ -7936,82 +8430,88 @@ define-properties@^1.1.3, define-properties@^1.2.0, define-properties@^1.2.1:
 
 delayed-stream@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
   integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
 
+dequal@^2.0.0:
 dequal@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/dequal/-/dequal-2.0.3.tgz#2644214f1997d39ed0ee0ece72335490a7ac67be"
   integrity sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==
 
 detect-node-es@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/detect-node-es/-/detect-node-es-1.1.0.tgz#163acdf643330caa0b4cd7c21e7ee7755d6fa493"
   integrity sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==
 
 detect-node@^2.0.4, detect-node@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
   integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
 
 devlop@^1.0.0, devlop@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/devlop/-/devlop-1.1.0.tgz#4db7c2ca4dc6e0e834c30be70c94bbc976dc7018"
   integrity sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==
   dependencies:
     dequal "^2.0.0"
 
 didyoumean@^1.2.2:
   version "1.2.2"
-  resolved "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037"
   integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
 
 diff@^4.0.1:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
+diff@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-5.2.0.tgz#26ded047cd1179b78b9537d5ef725503ce1ae531"
+  integrity sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==
+
 dir-glob@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
   integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
   dependencies:
     path-type "^4.0.0"
 
 direction@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/direction/-/direction-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/direction/-/direction-2.0.1.tgz#71800dd3c4fa102406502905d3866e65bdebb985"
   integrity sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA==
 
 dlv@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/dlv/-/dlv-1.1.3.tgz#5c198a8a11453596e751494d49874bc7732f2e79"
   integrity sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==
 
 doctrine@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
   integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
   dependencies:
     esutils "^2.0.2"
 
 doctrine@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
   integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
   dependencies:
     esutils "^2.0.2"
 
 dom-helpers@^3.3.1:
   version "3.4.0"
-  resolved "https://registry.npmjs.org/dom-helpers/-/dom-helpers-3.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/dom-helpers/-/dom-helpers-3.4.0.tgz#e9b369700f959f62ecde5a6babde4bccd9169af8"
   integrity sha512-LnuPJ+dwqKDIyotW1VzmOZ5TONUN7CwkCR5hrgawTUbkBGYdeoNLZo6nNfGkCrjtE1nXXaj7iMMpDa8/d9WoIA==
   dependencies:
     "@babel/runtime" "^7.1.2"
 
 dom-helpers@^5.0.1:
   version "5.2.1"
-  resolved "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/dom-helpers/-/dom-helpers-5.2.1.tgz#d9400536b2bf8225ad98fe052e029451ac40e902"
   integrity sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==
   dependencies:
     "@babel/runtime" "^7.8.7"
@@ -8019,12 +8519,12 @@ dom-helpers@^5.0.1:
 
 dom-mutator@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.npmjs.org/dom-mutator/-/dom-mutator-0.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/dom-mutator/-/dom-mutator-0.6.0.tgz#079d7a4b3e8981a562cd777548b99baab51d65c5"
   integrity sha512-iCt9o0aYfXMUkz/43ZOAUFQYotjGB+GNbYJiJdz4TgXkyToXbbRy5S6FbTp72lRBtfpUMwEc1KmpFEU4CZeoNg==
 
 dom-serializer@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-2.0.0.tgz#e41b802e1eedf9f6cae183ce5e622d789d7d8e53"
   integrity sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==
   dependencies:
     domelementtype "^2.3.0"
@@ -8033,27 +8533,27 @@ dom-serializer@^2.0.0:
 
 domelementtype@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.3.0.tgz#5c45e8e869952626331d7aab326d01daf65d589d"
   integrity sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==
 
 domhandler@^5.0.2, domhandler@^5.0.3:
   version "5.0.3"
-  resolved "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-5.0.3.tgz#cc385f7f751f1d1fc650c21374804254538c7d31"
   integrity sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==
   dependencies:
     domelementtype "^2.3.0"
 
 dompurify@*, dompurify@^3.2.6:
-  version "3.2.6"
-  resolved "https://registry.yarnpkg.com/dompurify/-/dompurify-3.2.6.tgz#ca040a6ad2b88e2a92dc45f38c79f84a714a1cad"
-  integrity sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ==
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/dompurify/-/dompurify-3.2.7.tgz#721d63913db5111dd6dfda8d3a748cfd7982d44a"
+  integrity sha512-WhL/YuveyGXJaerVlMYGWhvQswa7myDG17P7Vu65EWC05o8vfeNbvNf4d/BOvH99+ZW+LlQsc1GDKMa1vNK6dw==
   optionalDependencies:
     "@types/trusted-types" "^2.0.7"
 
 domutils@^3.0.1:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/domutils/-/domutils-3.1.0.tgz"
-  integrity sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/domutils/-/domutils-3.2.2.tgz#edbfe2b668b0c1d97c24baf0f1062b132221bc78"
+  integrity sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==
   dependencies:
     dom-serializer "^2.0.0"
     domelementtype "^2.3.0"
@@ -8061,7 +8561,7 @@ domutils@^3.0.1:
 
 dot-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
   integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
   dependencies:
     no-case "^3.0.4"
@@ -8069,7 +8569,7 @@ dot-case@^3.0.4:
 
 dot-prop@^5.1.0:
   version "5.3.0"
-  resolved "https://registry.npmjs.org/dot-prop/-/dot-prop-5.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88"
   integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==
   dependencies:
     is-obj "^2.0.0"
@@ -8081,12 +8581,12 @@ dotenv@^16.3.1:
 
 dotenv@^8.2.0:
   version "8.6.0"
-  resolved "https://registry.npmjs.org/dotenv/-/dotenv-8.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-8.6.0.tgz#061af664d19f7f4d8fc6e4ff9b584ce237adcb8b"
   integrity sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==
 
-dunder-proto@^1.0.1:
+dunder-proto@^1.0.0, dunder-proto@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/dunder-proto/-/dunder-proto-1.0.1.tgz#d7ae667e1dc83482f8b70fd0f6eefc50da30f58a"
   integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==
   dependencies:
     call-bind-apply-helpers "^1.0.1"
@@ -8095,178 +8595,182 @@ dunder-proto@^1.0.1:
 
 duplexer@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
   integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
 
 eastasianwidth@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
   integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
-electron-to-chromium@^1.5.204:
-  version "1.5.211"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.211.tgz#749317bf9cf894c06f67980940cf8074e5eb08ca"
-  integrity sha512-IGBvimJkotaLzFnwIVgW9/UD/AOJ2tByUmeOrtqBfACSbAw5b1G0XpvdaieKyc7ULmbwXVx+4e4Be8pOPBrYkw==
-
-electron-to-chromium@^1.5.28:
-  version "1.5.28"
-  resolved "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.28.tgz"
-  integrity sha512-VufdJl+rzaKZoYVUijN13QcXVF5dWPZANeFTLNy+OSpHdDL5ynXTF35+60RSBbaQYB1ae723lQXHCrf4pyLsMw==
+electron-to-chromium@^1.5.218:
+  version "1.5.227"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.227.tgz#c81b6af045b0d6098faed261f0bd611dc282d3a7"
+  integrity sha512-ITxuoPfJu3lsNWUi2lBM2PaBPYgH3uqmxut5vmBxgYvyI4AlJ6P3Cai1O76mOrkJCBzq0IxWg/NtqOrpu/0gKA==
 
 emoji-regex@^10.3.0:
-  version "10.4.0"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz"
-  integrity sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==
+  version "10.5.0"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-10.5.0.tgz#be23498b9e39db476226d8e81e467f39aca26b78"
+  integrity sha512-lb49vf1Xzfx080OKA0o6l8DQQpV+6Vg95zyCJX9VB/BqKYlhG7N4wgROUUHRA+ZPUefLnteQOad7z1kT2bV7bg==
 
 emoji-regex@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
 emoji-regex@^9.2.2:
   version "9.2.2"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
-enhanced-resolve@^5.15.0:
-  version "5.17.1"
-  resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz"
-  integrity sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==
+encoding@^0.1.13:
+  version "0.1.13"
+  resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.13.tgz#56574afdd791f54a8e9b2785c0582a2d26210fa9"
+  integrity sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==
   dependencies:
-    graceful-fs "^4.2.4"
-    tapable "^2.2.0"
+    iconv-lite "^0.6.2"
 
 entities@^4.2.0, entities@^4.4.0:
   version "4.5.0"
-  resolved "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48"
   integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==
 
+entities@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-6.0.1.tgz#c28c34a43379ca7f61d074130b2f5f7020a30694"
+  integrity sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==
+
+env-paths@^2.2.0:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2"
+  integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==
+
 environment@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/environment/-/environment-1.1.0.tgz#8e86c66b180f363c7ab311787e0259665f45a9f1"
   integrity sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==
 
+err-code@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/err-code/-/err-code-2.0.3.tgz#23c2f3b756ffdfc608d30e27c9a941024807e7f9"
+  integrity sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==
+
 error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
+  version "1.3.4"
+  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.4.tgz#b3a8d8bb6f92eecc1629e3e27d3c8607a8a32414"
+  integrity sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==
   dependencies:
     is-arrayish "^0.2.1"
 
 error-stack-parser@^2.0.6:
   version "2.1.4"
-  resolved "https://registry.npmjs.org/error-stack-parser/-/error-stack-parser-2.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/error-stack-parser/-/error-stack-parser-2.1.4.tgz#229cb01cdbfa84440bfa91876285b94680188286"
   integrity sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==
   dependencies:
     stackframe "^1.3.4"
 
-es-abstract@^1.17.5, es-abstract@^1.22.1, es-abstract@^1.22.3, es-abstract@^1.23.0, es-abstract@^1.23.1, es-abstract@^1.23.2, es-abstract@^1.23.3:
-  version "1.23.3"
-  resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.3.tgz"
-  integrity sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==
+es-abstract@^1.17.5, es-abstract@^1.23.2, es-abstract@^1.23.3, es-abstract@^1.23.5, es-abstract@^1.23.6, es-abstract@^1.23.9, es-abstract@^1.24.0:
+  version "1.24.0"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.24.0.tgz#c44732d2beb0acc1ed60df840869e3106e7af328"
+  integrity sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==
   dependencies:
-    array-buffer-byte-length "^1.0.1"
-    arraybuffer.prototype.slice "^1.0.3"
+    array-buffer-byte-length "^1.0.2"
+    arraybuffer.prototype.slice "^1.0.4"
     available-typed-arrays "^1.0.7"
-    call-bind "^1.0.7"
-    data-view-buffer "^1.0.1"
-    data-view-byte-length "^1.0.1"
-    data-view-byte-offset "^1.0.0"
-    es-define-property "^1.0.0"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    data-view-buffer "^1.0.2"
+    data-view-byte-length "^1.0.2"
+    data-view-byte-offset "^1.0.1"
+    es-define-property "^1.0.1"
     es-errors "^1.3.0"
-    es-object-atoms "^1.0.0"
-    es-set-tostringtag "^2.0.3"
-    es-to-primitive "^1.2.1"
-    function.prototype.name "^1.1.6"
-    get-intrinsic "^1.2.4"
-    get-symbol-description "^1.0.2"
-    globalthis "^1.0.3"
-    gopd "^1.0.1"
+    es-object-atoms "^1.1.1"
+    es-set-tostringtag "^2.1.0"
+    es-to-primitive "^1.3.0"
+    function.prototype.name "^1.1.8"
+    get-intrinsic "^1.3.0"
+    get-proto "^1.0.1"
+    get-symbol-description "^1.1.0"
+    globalthis "^1.0.4"
+    gopd "^1.2.0"
     has-property-descriptors "^1.0.2"
-    has-proto "^1.0.3"
-    has-symbols "^1.0.3"
+    has-proto "^1.2.0"
+    has-symbols "^1.1.0"
     hasown "^2.0.2"
-    internal-slot "^1.0.7"
-    is-array-buffer "^3.0.4"
+    internal-slot "^1.1.0"
+    is-array-buffer "^3.0.5"
     is-callable "^1.2.7"
-    is-data-view "^1.0.1"
+    is-data-view "^1.0.2"
     is-negative-zero "^2.0.3"
-    is-regex "^1.1.4"
-    is-shared-array-buffer "^1.0.3"
-    is-string "^1.0.7"
-    is-typed-array "^1.1.13"
-    is-weakref "^1.0.2"
-    object-inspect "^1.13.1"
+    is-regex "^1.2.1"
+    is-set "^2.0.3"
+    is-shared-array-buffer "^1.0.4"
+    is-string "^1.1.1"
+    is-typed-array "^1.1.15"
+    is-weakref "^1.1.1"
+    math-intrinsics "^1.1.0"
+    object-inspect "^1.13.4"
     object-keys "^1.1.1"
-    object.assign "^4.1.5"
-    regexp.prototype.flags "^1.5.2"
-    safe-array-concat "^1.1.2"
-    safe-regex-test "^1.0.3"
-    string.prototype.trim "^1.2.9"
-    string.prototype.trimend "^1.0.8"
+    object.assign "^4.1.7"
+    own-keys "^1.0.1"
+    regexp.prototype.flags "^1.5.4"
+    safe-array-concat "^1.1.3"
+    safe-push-apply "^1.0.0"
+    safe-regex-test "^1.1.0"
+    set-proto "^1.0.0"
+    stop-iteration-iterator "^1.1.0"
+    string.prototype.trim "^1.2.10"
+    string.prototype.trimend "^1.0.9"
     string.prototype.trimstart "^1.0.8"
-    typed-array-buffer "^1.0.2"
-    typed-array-byte-length "^1.0.1"
-    typed-array-byte-offset "^1.0.2"
-    typed-array-length "^1.0.6"
-    unbox-primitive "^1.0.2"
-    which-typed-array "^1.1.15"
+    typed-array-buffer "^1.0.3"
+    typed-array-byte-length "^1.0.3"
+    typed-array-byte-offset "^1.0.4"
+    typed-array-length "^1.0.7"
+    unbox-primitive "^1.1.0"
+    which-typed-array "^1.1.19"
 
 es-define-property@^1.0.0, es-define-property@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.1.tgz#983eb2f9a6724e9303f61addf011c72e09e0b0fa"
   integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==
 
-es-errors@^1.2.1, es-errors@^1.3.0:
+es-errors@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f"
   integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==
 
-es-get-iterator@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz"
-  integrity sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.3"
-    has-symbols "^1.0.3"
-    is-arguments "^1.1.1"
-    is-map "^2.0.2"
-    is-set "^2.0.2"
-    is-string "^1.0.7"
-    isarray "^2.0.5"
-    stop-iteration-iterator "^1.0.0"
-
-es-iterator-helpers@^1.0.19:
-  version "1.0.19"
-  resolved "https://registry.npmjs.org/es-iterator-helpers/-/es-iterator-helpers-1.0.19.tgz"
-  integrity sha512-zoMwbCcH5hwUkKJkT8kDIBZSz9I6mVG//+lDCinLCGov4+r7NIy0ld8o03M0cJxl2spVf6ESYVS6/gpIfq1FFw==
+es-iterator-helpers@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/es-iterator-helpers/-/es-iterator-helpers-1.2.1.tgz#d1dd0f58129054c0ad922e6a9a1e65eef435fe75"
+  integrity sha512-uDn+FE1yrDzyC0pCo961B2IHbdM8y/ACZsKD4dG6WqrjV53BADjwa7D+1aom2rsNVfLyDgU/eigvlJGJ08OQ4w==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
     define-properties "^1.2.1"
-    es-abstract "^1.23.3"
+    es-abstract "^1.23.6"
     es-errors "^1.3.0"
     es-set-tostringtag "^2.0.3"
     function-bind "^1.1.2"
-    get-intrinsic "^1.2.4"
-    globalthis "^1.0.3"
+    get-intrinsic "^1.2.6"
+    globalthis "^1.0.4"
+    gopd "^1.2.0"
     has-property-descriptors "^1.0.2"
-    has-proto "^1.0.3"
-    has-symbols "^1.0.3"
-    internal-slot "^1.0.7"
-    iterator.prototype "^1.1.2"
-    safe-array-concat "^1.1.2"
+    has-proto "^1.2.0"
+    has-symbols "^1.1.0"
+    internal-slot "^1.1.0"
+    iterator.prototype "^1.1.4"
+    safe-array-concat "^1.1.3"
 
 es-object-atoms@^1.0.0, es-object-atoms@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz#1c4f2c4837327597ce69d2ca190a7fdd172338c1"
   integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==
   dependencies:
     es-errors "^1.3.0"
 
 es-set-tostringtag@^2.0.3, es-set-tostringtag@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz#f31dbbe0c183b00a6d26eb6325c810c0fd18bd4d"
   integrity sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==
   dependencies:
     es-errors "^1.3.0"
@@ -8274,76 +8778,92 @@ es-set-tostringtag@^2.0.3, es-set-tostringtag@^2.1.0:
     has-tostringtag "^1.0.2"
     hasown "^2.0.2"
 
-es-shim-unscopables@^1.0.0, es-shim-unscopables@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz"
-  integrity sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==
+es-shim-unscopables@^1.0.2, es-shim-unscopables@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz#438df35520dac5d105f3943d927549ea3b00f4b5"
+  integrity sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==
   dependencies:
-    hasown "^2.0.0"
+    hasown "^2.0.2"
 
-es-to-primitive@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz"
-  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
+es-to-primitive@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.3.0.tgz#96c89c82cc49fd8794a24835ba3e1ff87f214e18"
+  integrity sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==
+  dependencies:
+    is-callable "^1.2.7"
+    is-date-object "^1.0.5"
+    is-symbol "^1.0.4"
+
+esast-util-from-estree@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz#8d1cfb51ad534d2f159dc250e604f3478a79f1ad"
+  integrity sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==
+  dependencies:
+    "@types/estree-jsx" "^1.0.0"
+    devlop "^1.0.0"
+    estree-util-visit "^2.0.0"
+    unist-util-position-from-estree "^2.0.0"
+
+esast-util-from-js@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz#5147bec34cc9da44accf52f87f239a40ac3e8225"
+  integrity sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==
   dependencies:
-    is-callable "^1.1.4"
-    is-date-object "^1.0.1"
-    is-symbol "^1.0.2"
+    "@types/estree-jsx" "^1.0.0"
+    acorn "^8.0.0"
+    esast-util-from-estree "^2.0.0"
+    vfile-message "^4.0.0"
 
 esbuild@>=0.17:
-  version "0.25.0"
-  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.25.0.tgz"
-  integrity sha512-BXq5mqc8ltbaN34cDqWuYKyNhX8D/Z0J1xdtdQ8UcIIIyJyz+ZMKUt58tF3SrZ85jcfN/PZYhjR5uDQAYNVbuw==
+  version "0.25.10"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.25.10.tgz#37f5aa5cd14500f141be121c01b096ca83ac34a9"
+  integrity sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==
   optionalDependencies:
-    "@esbuild/aix-ppc64" "0.25.0"
-    "@esbuild/android-arm" "0.25.0"
-    "@esbuild/android-arm64" "0.25.0"
-    "@esbuild/android-x64" "0.25.0"
-    "@esbuild/darwin-arm64" "0.25.0"
-    "@esbuild/darwin-x64" "0.25.0"
-    "@esbuild/freebsd-arm64" "0.25.0"
-    "@esbuild/freebsd-x64" "0.25.0"
-    "@esbuild/linux-arm" "0.25.0"
-    "@esbuild/linux-arm64" "0.25.0"
-    "@esbuild/linux-ia32" "0.25.0"
-    "@esbuild/linux-loong64" "0.25.0"
-    "@esbuild/linux-mips64el" "0.25.0"
-    "@esbuild/linux-ppc64" "0.25.0"
-    "@esbuild/linux-riscv64" "0.25.0"
-    "@esbuild/linux-s390x" "0.25.0"
-    "@esbuild/linux-x64" "0.25.0"
-    "@esbuild/netbsd-arm64" "0.25.0"
-    "@esbuild/netbsd-x64" "0.25.0"
-    "@esbuild/openbsd-arm64" "0.25.0"
-    "@esbuild/openbsd-x64" "0.25.0"
-    "@esbuild/sunos-x64" "0.25.0"
-    "@esbuild/win32-arm64" "0.25.0"
-    "@esbuild/win32-ia32" "0.25.0"
-    "@esbuild/win32-x64" "0.25.0"
-
-escalade@^3.1.1, escalade@^3.1.2, escalade@^3.2.0:
+    "@esbuild/aix-ppc64" "0.25.10"
+    "@esbuild/android-arm" "0.25.10"
+    "@esbuild/android-arm64" "0.25.10"
+    "@esbuild/android-x64" "0.25.10"
+    "@esbuild/darwin-arm64" "0.25.10"
+    "@esbuild/darwin-x64" "0.25.10"
+    "@esbuild/freebsd-arm64" "0.25.10"
+    "@esbuild/freebsd-x64" "0.25.10"
+    "@esbuild/linux-arm" "0.25.10"
+    "@esbuild/linux-arm64" "0.25.10"
+    "@esbuild/linux-ia32" "0.25.10"
+    "@esbuild/linux-loong64" "0.25.10"
+    "@esbuild/linux-mips64el" "0.25.10"
+    "@esbuild/linux-ppc64" "0.25.10"
+    "@esbuild/linux-riscv64" "0.25.10"
+    "@esbuild/linux-s390x" "0.25.10"
+    "@esbuild/linux-x64" "0.25.10"
+    "@esbuild/netbsd-arm64" "0.25.10"
+    "@esbuild/netbsd-x64" "0.25.10"
+    "@esbuild/openbsd-arm64" "0.25.10"
+    "@esbuild/openbsd-x64" "0.25.10"
+    "@esbuild/openharmony-arm64" "0.25.10"
+    "@esbuild/sunos-x64" "0.25.10"
+    "@esbuild/win32-arm64" "0.25.10"
+    "@esbuild/win32-ia32" "0.25.10"
+    "@esbuild/win32-x64" "0.25.10"
+
+escalade@^3.1.1, escalade@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5"
   integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==
 
-escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
-  integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
-
 escape-string-regexp@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
 escape-string-regexp@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz#4683126b500b61762f2dbebace1806e8be31b1c8"
   integrity sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==
 
 eslint-config-next@14.2.3:
   version "14.2.3"
-  resolved "https://registry.npmjs.org/eslint-config-next/-/eslint-config-next-14.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/eslint-config-next/-/eslint-config-next-14.2.3.tgz#2fb0f7c4eccda530a4b5054438162b2303786d4f"
   integrity sha512-ZkNztm3Q7hjqvB1rRlOX8P9E/cXRL9ajRcs8jufEtwMfTVYRqnmtnaSu57QqHyBlovMuiB8LEzfLBkh5RYV6Fg==
   dependencies:
     "@next/eslint-plugin-next" "14.2.3"
@@ -8357,13 +8877,13 @@ eslint-config-next@14.2.3:
     eslint-plugin-react-hooks "^4.5.0 || 5.0.0-canary-7118f5dd7-20230705"
 
 eslint-config-prettier@^8.8.0:
-  version "8.10.0"
-  resolved "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-8.10.0.tgz"
-  integrity sha512-SM8AMJdeQqRYT9O9zguiruQZaN7+z+E4eAP9oiLNGKMtomwaB1E9dcgUD6ZAn/eQAb52USbvezbiljfZUhbJcg==
+  version "8.10.2"
+  resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.10.2.tgz#0642e53625ebc62c31c24726b0f050df6bd97a2e"
+  integrity sha512-/IGJ6+Dka158JnP5n5YFMOszjDWrXggGz1LaK/guZq9vZTmniaKlHcsscvkAhn9y4U+BU3JuUdYvtAMcv30y4A==
 
 eslint-import-resolver-node@^0.3.6, eslint-import-resolver-node@^0.3.9:
   version "0.3.9"
-  resolved "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz"
+  resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz#d4eaac52b8a2e7c3cd1903eb00f7e053356118ac"
   integrity sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==
   dependencies:
     debug "^3.2.7"
@@ -8371,56 +8891,56 @@ eslint-import-resolver-node@^0.3.6, eslint-import-resolver-node@^0.3.9:
     resolve "^1.22.4"
 
 eslint-import-resolver-typescript@^3.5.2:
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.6.3.tgz"
-  integrity sha512-ud9aw4szY9cCT1EWWdGv1L1XR6hh2PaRWif0j2QjQ0pgTY/69iw+W0Z4qZv5wHahOl8isEr+k/JnyAqNQkLkIA==
+  version "3.10.1"
+  resolved "https://registry.yarnpkg.com/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.10.1.tgz#23dac32efa86a88e2b8232eb244ac499ad636db2"
+  integrity sha512-A1rHYb06zjMGAxdLSkN2fXPBwuSaQ0iO5M/hdyS0Ajj1VBaRp0sPD3dn1FhME3c/JluGFbwSxyCfqdSbtQLAHQ==
   dependencies:
     "@nolyfill/is-core-module" "1.0.39"
-    debug "^4.3.5"
-    enhanced-resolve "^5.15.0"
-    eslint-module-utils "^2.8.1"
-    fast-glob "^3.3.2"
-    get-tsconfig "^4.7.5"
-    is-bun-module "^1.0.2"
-    is-glob "^4.0.3"
-
-eslint-module-utils@^2.8.1, eslint-module-utils@^2.9.0:
-  version "2.11.1"
-  resolved "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.11.1.tgz"
-  integrity sha512-EwcbfLOhwVMAfatfqLecR2yv3dE5+kQ8kx+Rrt0DvDXEVwW86KQ/xbMDQhtp5l42VXukD5SOF8mQQHbaNtO0CQ==
+    debug "^4.4.0"
+    get-tsconfig "^4.10.0"
+    is-bun-module "^2.0.0"
+    stable-hash "^0.0.5"
+    tinyglobby "^0.2.13"
+    unrs-resolver "^1.6.2"
+
+eslint-module-utils@^2.12.1:
+  version "2.12.1"
+  resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz#f76d3220bfb83c057651359295ab5854eaad75ff"
+  integrity sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==
   dependencies:
     debug "^3.2.7"
 
 eslint-plugin-import@^2.28.1:
-  version "2.30.0"
-  resolved "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.30.0.tgz"
-  integrity sha512-/mHNE9jINJfiD2EKkg1BKyPyUk4zdnT54YgbOgfjSakWT5oyX/qQLVNTkehyfpcMxZXMy1zyonZ2v7hZTX43Yw==
+  version "2.32.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz#602b55faa6e4caeaa5e970c198b5c00a37708980"
+  integrity sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==
   dependencies:
     "@rtsao/scc" "^1.1.0"
-    array-includes "^3.1.8"
-    array.prototype.findlastindex "^1.2.5"
-    array.prototype.flat "^1.3.2"
-    array.prototype.flatmap "^1.3.2"
+    array-includes "^3.1.9"
+    array.prototype.findlastindex "^1.2.6"
+    array.prototype.flat "^1.3.3"
+    array.prototype.flatmap "^1.3.3"
     debug "^3.2.7"
     doctrine "^2.1.0"
     eslint-import-resolver-node "^0.3.9"
-    eslint-module-utils "^2.9.0"
+    eslint-module-utils "^2.12.1"
     hasown "^2.0.2"
-    is-core-module "^2.15.1"
+    is-core-module "^2.16.1"
     is-glob "^4.0.3"
     minimatch "^3.1.2"
     object.fromentries "^2.0.8"
     object.groupby "^1.0.3"
-    object.values "^1.2.0"
+    object.values "^1.2.1"
     semver "^6.3.1"
+    string.prototype.trimend "^1.0.9"
     tsconfig-paths "^3.15.0"
 
 eslint-plugin-jsx-a11y@^6.7.1:
-  version "6.10.0"
-  resolved "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.10.0.tgz"
-  integrity sha512-ySOHvXX8eSN6zz8Bywacm7CvGNhUtdjvqfQDVe6020TUK34Cywkw7m0KsCCk1Qtm9G1FayfTN1/7mMYnYO2Bhg==
+  version "6.10.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.10.2.tgz#d2812bb23bf1ab4665f1718ea442e8372e638483"
+  integrity sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==
   dependencies:
-    aria-query "~5.1.3"
+    aria-query "^5.3.2"
     array-includes "^3.1.8"
     array.prototype.flatmap "^1.3.2"
     ast-types-flow "^0.0.8"
@@ -8428,68 +8948,67 @@ eslint-plugin-jsx-a11y@^6.7.1:
     axobject-query "^4.1.0"
     damerau-levenshtein "^1.0.8"
     emoji-regex "^9.2.2"
-    es-iterator-helpers "^1.0.19"
     hasown "^2.0.2"
     jsx-ast-utils "^3.3.5"
     language-tags "^1.0.9"
     minimatch "^3.1.2"
     object.fromentries "^2.0.8"
     safe-regex-test "^1.0.3"
-    string.prototype.includes "^2.0.0"
+    string.prototype.includes "^2.0.1"
 
 eslint-plugin-prettier@^5.0.0:
-  version "5.2.1"
-  resolved "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.1.tgz"
-  integrity sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==
+  version "5.5.4"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.4.tgz#9d61c4ea11de5af704d4edf108c82ccfa7f2e61c"
+  integrity sha512-swNtI95SToIz05YINMA6Ox5R057IMAmWZ26GqPxusAp1TZzj+IdY9tXNWWD3vkF/wEqydCONcwjTFpxybBqZsg==
   dependencies:
     prettier-linter-helpers "^1.0.0"
-    synckit "^0.9.1"
+    synckit "^0.11.7"
 
 "eslint-plugin-react-hooks@^4.5.0 || 5.0.0-canary-7118f5dd7-20230705":
-  version "4.6.2"
-  resolved "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz"
-  integrity sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==
+  version "5.0.0-canary-7118f5dd7-20230705"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.0.0-canary-7118f5dd7-20230705.tgz#4d55c50e186f1a2b0636433d2b0b2f592ddbccfd"
+  integrity sha512-AZYbMo/NW9chdL7vk6HQzQhT+PvTAEVqWk9ziruUoW2kAOcN5qNyelv70e0F1VNQAbvutOC9oc+xfWycI9FxDw==
 
 eslint-plugin-react@^7.33.2:
-  version "7.36.1"
-  resolved "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.36.1.tgz"
-  integrity sha512-/qwbqNXZoq+VP30s1d4Nc1C5GTxjJQjk4Jzs4Wq2qzxFM7dSmuG2UkIjg2USMLh3A/aVcUNrK7v0J5U1XEGGwA==
+  version "7.37.5"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react/-/eslint-plugin-react-7.37.5.tgz#2975511472bdda1b272b34d779335c9b0e877065"
+  integrity sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==
   dependencies:
     array-includes "^3.1.8"
     array.prototype.findlast "^1.2.5"
-    array.prototype.flatmap "^1.3.2"
+    array.prototype.flatmap "^1.3.3"
     array.prototype.tosorted "^1.1.4"
     doctrine "^2.1.0"
-    es-iterator-helpers "^1.0.19"
+    es-iterator-helpers "^1.2.1"
     estraverse "^5.3.0"
     hasown "^2.0.2"
     jsx-ast-utils "^2.4.1 || ^3.0.0"
     minimatch "^3.1.2"
-    object.entries "^1.1.8"
+    object.entries "^1.1.9"
     object.fromentries "^2.0.8"
-    object.values "^1.2.0"
+    object.values "^1.2.1"
     prop-types "^15.8.1"
     resolve "^2.0.0-next.5"
     semver "^6.3.1"
-    string.prototype.matchall "^4.0.11"
+    string.prototype.matchall "^4.0.12"
     string.prototype.repeat "^1.0.0"
 
 eslint-scope@^7.2.2:
   version "7.2.2"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f"
   integrity sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^5.2.0"
 
-eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3:
+eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3:
   version "3.4.3"
-  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800"
   integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==
 
 eslint@^8.45.0:
   version "8.57.1"
-  resolved "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.57.1.tgz#7df109654aba7e3bbe5c8eae533c5e461d3c6ca9"
   integrity sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==
   dependencies:
     "@eslint-community/eslint-utils" "^4.2.0"
@@ -8533,7 +9052,7 @@ eslint@^8.45.0:
 
 espree@^9.6.0, espree@^9.6.1:
   version "9.6.1"
-  resolved "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f"
   integrity sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==
   dependencies:
     acorn "^8.9.0"
@@ -8542,38 +9061,38 @@ espree@^9.6.0, espree@^9.6.1:
 
 esprima@^4.0.0, esprima@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
 esquery@^1.4.2:
   version "1.6.0"
-  resolved "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.6.0.tgz#91419234f804d852a82dceec3e16cdc22cf9dae7"
   integrity sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==
   dependencies:
     estraverse "^5.1.0"
 
 esrecurse@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
   integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
   dependencies:
     estraverse "^5.2.0"
 
 estraverse@^5.1.0, estraverse@^5.2.0, estraverse@^5.3.0:
   version "5.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
   integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
 
 estree-util-attach-comments@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz#344bde6a64c8a31d15231e5ee9e297566a691c2d"
   integrity sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==
   dependencies:
     "@types/estree" "^1.0.0"
 
 estree-util-build-jsx@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz#b6d0bced1dcc4f06f25cf0ceda2b2dcaf98168f1"
   integrity sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -8583,12 +9102,20 @@ estree-util-build-jsx@^3.0.0:
 
 estree-util-is-identifier-name@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz#0b5ef4c4ff13508b34dcd01ecfa945f61fce5dbd"
   integrity sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==
 
+estree-util-scope@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/estree-util-scope/-/estree-util-scope-1.0.0.tgz#9cbdfc77f5cb51e3d9ed4ad9c4adbff22d43e585"
+  integrity sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==
+  dependencies:
+    "@types/estree" "^1.0.0"
+    devlop "^1.0.0"
+
 estree-util-to-js@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz#10a6fb924814e6abb62becf0d2bc4dea51d04f17"
   integrity sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -8597,14 +9124,14 @@ estree-util-to-js@^2.0.0:
 
 estree-util-value-to-estree@^3.0.0:
   version "3.4.0"
-  resolved "https://registry.npmjs.org/estree-util-value-to-estree/-/estree-util-value-to-estree-3.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-value-to-estree/-/estree-util-value-to-estree-3.4.0.tgz#827122e40c3a756d3c4cf5d5d296fa06026a1a4f"
   integrity sha512-Zlp+gxis+gCfK12d3Srl2PdX2ybsEA8ZYy6vQGVQTNNYLEGRQQ56XB64bjemN8kxIKXP1nC9ip4Z+ILy9LGzvQ==
   dependencies:
     "@types/estree" "^1.0.0"
 
 estree-util-visit@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/estree-util-visit/-/estree-util-visit-2.0.0.tgz#13a9a9f40ff50ed0c022f831ddf4b58d05446feb"
   integrity sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -8617,29 +9144,29 @@ estree-walker@^2.0.2:
 
 estree-walker@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-3.0.3.tgz#67c3e549ec402a487b4fc193d1953a524752340d"
   integrity sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==
   dependencies:
     "@types/estree" "^1.0.0"
 
 esutils@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 eventemitter3@^4.0.1:
   version "4.0.7"
-  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
 eventemitter3@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-5.0.1.tgz#53f5ffd0a492ac800721bb42c66b841de96423c4"
   integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==
 
 execa@^5.0.0:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
   integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
   dependencies:
     cross-spawn "^7.0.3"
@@ -8652,9 +9179,9 @@ execa@^5.0.0:
     signal-exit "^3.0.3"
     strip-final-newline "^2.0.0"
 
-execa@~8.0.1:
+execa@^8.0.1:
   version "8.0.1"
-  resolved "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-8.0.1.tgz#51f6a5943b580f963c3ca9c6321796db8cc39b8c"
   integrity sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==
   dependencies:
     cross-spawn "^7.0.3"
@@ -8667,132 +9194,142 @@ execa@~8.0.1:
     signal-exit "^4.1.0"
     strip-final-newline "^3.0.0"
 
+exponential-backoff@^3.1.1:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/exponential-backoff/-/exponential-backoff-3.1.2.tgz#a8f26adb96bf78e8cd8ad1037928d5e5c0679d91"
+  integrity sha512-8QxYTVXUkuy7fIIoitQkPwGonB8F3Zj8eEO8Sqg9Zv/bkI7RJAzowee4gr81Hak/dUTpA2Z7VfQgoijjPNlUZA==
+
 extend-shallow@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
   integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==
   dependencies:
     is-extendable "^0.1.0"
 
 extend@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
 fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
-  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
 fast-diff@^1.1.2:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.3.0.tgz#ece407fa550a64d638536cd727e129c61616e0f0"
   integrity sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==
 
 fast-equals@^2.0.3:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/fast-equals/-/fast-equals-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/fast-equals/-/fast-equals-2.0.4.tgz#3add9410585e2d7364c2deeb6a707beadb24b927"
   integrity sha512-caj/ZmjHljPrZtbzJ3kfH5ia/k4mTJe/qSiXAGzxZWRZgsgDV0cvNaQULqUX8t0/JVlzzEdYOwCN5DmzTxoD4w==
 
 fast-equals@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/fast-equals/-/fast-equals-5.0.1.tgz"
-  integrity sha512-WF1Wi8PwwSY7/6Kx0vKXtw8RwuSGoM1bvDaJbu7MxDlR1vovZjIAKrnzyrThgAjm6JDTu0fVgWXDlMGspodfoQ==
+  version "5.3.2"
+  resolved "https://registry.yarnpkg.com/fast-equals/-/fast-equals-5.3.2.tgz#75a9c7b1c2f627851349a2db94327d79b774ce83"
+  integrity sha512-6rxyATwPCkaFIL3JLqw8qXqMpIZ942pTX/tbQFkRsDGblS8tNGtlUauA/+mt6RUfqn/4MoEr+WDkYoIQbibWuQ==
 
-fast-glob@^3.2.12, fast-glob@^3.2.9, fast-glob@^3.3.0, fast-glob@^3.3.2:
-  version "3.3.2"
-  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz"
-  integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==
+fast-glob@^3.2.12, fast-glob@^3.2.9, fast-glob@^3.3.2:
+  version "3.3.3"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.3.tgz#d06d585ce8dba90a16b0505c543c3ccfb3aeb818"
+  integrity sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==
   dependencies:
     "@nodelib/fs.stat" "^2.0.2"
     "@nodelib/fs.walk" "^1.2.3"
     glob-parent "^5.1.2"
     merge2 "^1.3.0"
-    micromatch "^4.0.4"
+    micromatch "^4.0.8"
 
 fast-json-stable-stringify@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
 
 fast-levenshtein@^2.0.6:
   version "2.0.6"
-  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
   integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
 
 fast-shallow-equal@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/fast-shallow-equal/-/fast-shallow-equal-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/fast-shallow-equal/-/fast-shallow-equal-1.0.0.tgz#d4dcaf6472440dcefa6f88b98e3251e27f25628b"
   integrity sha512-HPtaa38cPgWvaCFmRNhlc6NG7pv6NUHqjPgVAkWGoB9mQMwYB27/K0CvOM5Czy+qpT3e8XJ6Q4aPAnzpNpzNaw==
 
 fast-uri@^3.0.1:
-  version "3.0.6"
-  resolved "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz"
-  integrity sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/fast-uri/-/fast-uri-3.1.0.tgz#66eecff6c764c0df9b762e62ca7edcfb53b4edfa"
+  integrity sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==
+
+fastest-levenshtein@^1.0.16:
+  version "1.0.16"
+  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5"
+  integrity sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==
 
 fastest-stable-stringify@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/fastest-stable-stringify/-/fastest-stable-stringify-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/fastest-stable-stringify/-/fastest-stable-stringify-2.0.2.tgz#3757a6774f6ec8de40c4e86ec28ea02417214c76"
   integrity sha512-bijHueCGd0LqqNK9b5oCMHc0MluJAx0cwqASgbWMvkO01lCYgIhacVRLcaDz3QnyYIRNJRDwMb41VuT6pHJ91Q==
 
 fastestsmallesttextencoderdecoder@^1.0.22:
   version "1.0.22"
-  resolved "https://registry.npmjs.org/fastestsmallesttextencoderdecoder/-/fastestsmallesttextencoderdecoder-1.0.22.tgz"
+  resolved "https://registry.yarnpkg.com/fastestsmallesttextencoderdecoder/-/fastestsmallesttextencoderdecoder-1.0.22.tgz#59b47e7b965f45258629cc6c127bf783281c5e93"
   integrity sha512-Pb8d48e+oIuY4MaM64Cd7OW1gt4nxCHs7/ddPPZ/Ic3sg8yVGM7O9wDvZ7us6ScaUupzM+pfBolwtYhN1IxBIw==
 
 fastq@^1.6.0:
-  version "1.17.1"
-  resolved "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz"
-  integrity sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==
+  version "1.19.1"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.19.1.tgz#d50eaba803c8846a883c16492821ebcd2cda55f5"
+  integrity sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==
   dependencies:
     reusify "^1.0.4"
 
 fault@^1.0.0:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/fault/-/fault-1.0.4.tgz#eafcfc0a6d214fc94601e170df29954a4f842f13"
   integrity sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==
   dependencies:
     format "^0.2.0"
 
 fault@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/fault/-/fault-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/fault/-/fault-2.0.1.tgz#d47ca9f37ca26e4bd38374a7c500b5a384755b6c"
   integrity sha512-WtySTkS4OKev5JtpHXnib4Gxiurzh5NCGvWrFaZ34m6JehfTUhKZvn9njTfw48t6JumVQOmrKqpmGcdwxnhqBQ==
   dependencies:
     format "^0.2.0"
 
-fdir@^6.2.0:
+fdir@^6.2.0, fdir@^6.5.0:
   version "6.5.0"
   resolved "https://registry.yarnpkg.com/fdir/-/fdir-6.5.0.tgz#ed2ab967a331ade62f18d077dae192684d50d350"
   integrity sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==
 
 file-entry-cache@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
   integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
   dependencies:
     flat-cache "^3.0.4"
 
 file-saver@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.npmjs.org/file-saver/-/file-saver-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/file-saver/-/file-saver-2.0.5.tgz#d61cfe2ce059f414d899e9dd6d4107ee25670c38"
   integrity sha512-P9bmyZ3h/PRG+Nzga+rbdI4OEpNDzAVyy74uVO9ATgzLK6VtAsYybF/+TOCvrc0MO793d6+42lLyZTw7/ArVzA==
 
 file-type@3.9.0:
   version "3.9.0"
-  resolved "https://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-3.9.0.tgz#257a078384d1db8087bc449d107d52a52672b9e9"
   integrity sha512-RLoqTXE8/vPmMuTI88DAzhMYC99I8BWv7zYP4A1puo5HIjEJ5EX48ighy4ZyKMG9EDXxBgW6e++cn7d1xuFghA==
 
 fill-range@^7.1.1:
   version "7.1.1"
-  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292"
   integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==
   dependencies:
     to-regex-range "^5.0.1"
 
 find-up@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
   integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
   dependencies:
     locate-path "^5.0.0"
@@ -8800,7 +9337,7 @@ find-up@^4.1.0:
 
 find-up@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
   integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
   dependencies:
     locate-path "^6.0.0"
@@ -8808,7 +9345,7 @@ find-up@^5.0.0:
 
 flat-cache@^3.0.4:
   version "3.2.0"
-  resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.2.0.tgz#2c0c2d5040c99b1632771a9d105725c0115363ee"
   integrity sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==
   dependencies:
     flatted "^3.2.9"
@@ -8817,39 +9354,40 @@ flat-cache@^3.0.4:
 
 flat@^5.0.2:
   version "5.0.2"
-  resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
   integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
 
 flatted@^3.2.9:
-  version "3.3.1"
-  resolved "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz"
-  integrity sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==
+  version "3.3.3"
+  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.3.3.tgz#67c8fad95454a7c7abebf74bb78ee74a44023358"
+  integrity sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==
 
 fnv-plus@^1.3.1:
   version "1.3.1"
-  resolved "https://registry.npmjs.org/fnv-plus/-/fnv-plus-1.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/fnv-plus/-/fnv-plus-1.3.1.tgz#c34cb4572565434acb08ba257e4044ce2b006d67"
   integrity sha512-Gz1EvfOneuFfk4yG458dJ3TLJ7gV19q3OM/vVvvHf7eT02Hm1DleB4edsia6ahbKgAYxO9gvyQ1ioWZR+a00Yw==
 
-for-each@^0.3.3:
-  version "0.3.3"
-  resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz"
-  integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==
+for-each@^0.3.3, for-each@^0.3.5:
+  version "0.3.5"
+  resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.5.tgz#d650688027826920feeb0af747ee7b9421a41d47"
+  integrity sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==
   dependencies:
-    is-callable "^1.1.3"
+    is-callable "^1.2.7"
 
 foreach@^2.0.4:
   version "2.0.6"
-  resolved "https://registry.npmjs.org/foreach/-/foreach-2.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.6.tgz#87bcc8a1a0e74000ff2bf9802110708cfb02eb6e"
   integrity sha512-k6GAGDyqLe9JaebCsFCoudPPWfihKu8pylYXRlqP1J7ms39iPoTtk2fviNglIeQEwdh0bQeKJ01ZPyuyQvKzwg==
 
 foreground-child@^3.1.0:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz"
-  integrity sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/foreground-child/-/foreground-child-3.3.1.tgz#32e8e9ed1b68a3497befb9ac2b6adf92a638576f"
+  integrity sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==
   dependencies:
-    cross-spawn "^7.0.0"
+    cross-spawn "^7.0.6"
     signal-exit "^4.0.1"
 
+form-data@4.0.4, form-data@^2.3.1:
 form-data@4.0.4, form-data@^2.3.1:
   version "4.0.4"
   resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.4.tgz#784cdcce0669a9d68e94d11ac4eea98088edd2c4"
@@ -8863,12 +9401,13 @@ form-data@4.0.4, form-data@^2.3.1:
 
 format@^0.2.0:
   version "0.2.2"
-  resolved "https://registry.npmjs.org/format/-/format-0.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/format/-/format-0.2.2.tgz#d6170107e9efdc4ed30c9dc39016df942b5cb58b"
   integrity sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==
 
+formdata-node@^4.4.1:
 formdata-node@^4.4.1:
   version "4.4.1"
-  resolved "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/formdata-node/-/formdata-node-4.4.1.tgz#23f6a5cb9cb55315912cbec4ff7b0f59bbd191e2"
   integrity sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==
   dependencies:
     node-domexception "1.0.0"
@@ -8876,7 +9415,7 @@ formdata-node@^4.4.1:
 
 formidable@^1.1.1:
   version "1.2.6"
-  resolved "https://registry.npmjs.org/formidable/-/formidable-1.2.6.tgz"
+  resolved "https://registry.yarnpkg.com/formidable/-/formidable-1.2.6.tgz#d2a51d60162bbc9b4a055d8457a7c75315d1a168"
   integrity sha512-KcpbcpuLNOwrEjnbpMC0gS+X8ciDoZE1kkqzat4a8vrprf+s9pKNQ/QIwWfbfs4ltgmFl3MD177SNTkve3BwGQ==
 
 forwarded-parse@2.1.2:
@@ -8886,7 +9425,7 @@ forwarded-parse@2.1.2:
 
 fraction.js@^4.3.7:
   version "4.3.7"
-  resolved "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz"
+  resolved "https://registry.yarnpkg.com/fraction.js/-/fraction.js-4.3.7.tgz#06ca0085157e42fda7f9e726e79fefc4068840f7"
   integrity sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==
 
 framer-motion@^11.13.5:
@@ -8899,9 +9438,9 @@ framer-motion@^11.13.5:
     tslib "^2.4.0"
 
 fs-extra@^11.0.0:
-  version "11.3.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz"
-  integrity sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==
+  version "11.3.2"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.3.2.tgz#c838aeddc6f4a8c74dd15f85e11fe5511bfe02a4"
+  integrity sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==
   dependencies:
     graceful-fs "^4.2.0"
     jsonfile "^6.0.1"
@@ -8914,59 +9453,68 @@ fs-minipass@^2.0.0:
   dependencies:
     minipass "^3.0.0"
 
+fs-minipass@^3.0.0, fs-minipass@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-3.0.3.tgz#79a85981c4dc120065e96f62086bf6f9dc26cc54"
+  integrity sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==
+  dependencies:
+    minipass "^7.0.3"
+
 fs.realpath@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
   integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
 
 fsevents@~2.3.2:
   version "2.3.3"
-  resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
   integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
 
 function-bind@^1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c"
   integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
 
-function.prototype.name@^1.1.6:
-  version "1.1.6"
-  resolved "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.6.tgz"
-  integrity sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==
+function.prototype.name@^1.1.6, function.prototype.name@^1.1.8:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.8.tgz#e68e1df7b259a5c949eeef95cdbde53edffabb78"
+  integrity sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==
   dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.2.0"
-    es-abstract "^1.22.1"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    define-properties "^1.2.1"
     functions-have-names "^1.2.3"
+    hasown "^2.0.2"
+    is-callable "^1.2.7"
 
 functions-have-names@^1.2.3:
   version "1.2.3"
-  resolved "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834"
   integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==
 
 fuse.js@^6.6.2:
   version "6.6.2"
-  resolved "https://registry.npmjs.org/fuse.js/-/fuse.js-6.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/fuse.js/-/fuse.js-6.6.2.tgz#fe463fed4b98c0226ac3da2856a415576dc9a111"
   integrity sha512-cJaJkxCCxC8qIIcPBF9yGxY0W/tVZS3uEISDxhYIdtk8OL93pe+6Zj7LjCqVV4dzbqcriOZ+kQ/NE4RXZHsIGA==
 
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
-  resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz"
+  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
 get-caller-file@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
-get-east-asian-width@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz"
-  integrity sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==
+get-east-asian-width@^1.0.0, get-east-asian-width@^1.3.1:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/get-east-asian-width/-/get-east-asian-width-1.4.0.tgz#9bc4caa131702b4b61729cb7e42735bc550c9ee6"
+  integrity sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==
 
-get-intrinsic@^1.1.3, get-intrinsic@^1.2.1, get-intrinsic@^1.2.2, get-intrinsic@^1.2.3, get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6, get-intrinsic@^1.3.0:
+get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6, get-intrinsic@^1.2.7, get-intrinsic@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz#743f0e3b6964a93a5491ed1bffaae054d7f98d01"
   integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==
   dependencies:
     call-bind-apply-helpers "^1.0.2"
@@ -8982,17 +9530,17 @@ get-intrinsic@^1.1.3, get-intrinsic@^1.2.1, get-intrinsic@^1.2.2, get-intrinsic@
 
 get-nonce@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/get-nonce/-/get-nonce-1.0.1.tgz#fdf3f0278073820d2ce9426c18f07481b1e0cdf3"
   integrity sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==
 
 get-own-enumerable-property-symbols@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz#b5fde77f22cbe35f390b4e089922c50bce6ef664"
   integrity sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==
 
-get-proto@^1.0.1:
+get-proto@^1.0.0, get-proto@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/get-proto/-/get-proto-1.0.1.tgz#150b3f2743869ef3e851ec0c49d15b1d14d00ee1"
   integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==
   dependencies:
     dunder-proto "^1.0.1"
@@ -9000,40 +9548,40 @@ get-proto@^1.0.1:
 
 get-stream@^6.0.0:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
   integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
 get-stream@^8.0.1:
   version "8.0.1"
-  resolved "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-8.0.1.tgz#def9dfd71742cd7754a7761ed43749a27d02eca2"
   integrity sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==
 
-get-symbol-description@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.2.tgz"
-  integrity sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==
+get-symbol-description@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.1.0.tgz#7bdd54e0befe8ffc9f3b4e203220d9f1e881b6ee"
+  integrity sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==
   dependencies:
-    call-bind "^1.0.5"
+    call-bound "^1.0.3"
     es-errors "^1.3.0"
-    get-intrinsic "^1.2.4"
+    get-intrinsic "^1.2.6"
 
-get-tsconfig@^4.7.5:
-  version "4.8.1"
-  resolved "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.8.1.tgz"
-  integrity sha512-k9PN+cFBmaLWtVz29SkUoqU5O0slLuHJXt/2P+tMVFT+phsSGXGkp9t3rQIqdz0e+06EHNGs3oM6ZX1s2zHxRg==
+get-tsconfig@^4.10.0:
+  version "4.10.1"
+  resolved "https://registry.yarnpkg.com/get-tsconfig/-/get-tsconfig-4.10.1.tgz#d34c1c01f47d65a606c37aa7a177bc3e56ab4b2e"
+  integrity sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==
   dependencies:
     resolve-pkg-maps "^1.0.0"
 
-giscus@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/giscus/-/giscus-1.5.0.tgz"
-  integrity sha512-t3LL0qbSO3JXq3uyQeKpF5CegstGfKX/0gI6eDe1cmnI7D56R7j52yLdzw4pdKrg3VnufwCgCM3FDz7G1Qr6lg==
+giscus@^1.6.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/giscus/-/giscus-1.6.0.tgz#96c592e01829707b3a0ba72c2636c07a28b5c19d"
+  integrity sha512-Zrsi8r4t1LVW950keaWcsURuZUQwUaMKjvJgTCY125vkW6OiEBkatE7ScJDbpqKHdZwb///7FVC21SE3iFK3PQ==
   dependencies:
-    lit "^3.1.2"
+    lit "^3.2.1"
 
 git-raw-commits@^2.0.11:
   version "2.0.11"
-  resolved "https://registry.npmjs.org/git-raw-commits/-/git-raw-commits-2.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-2.0.11.tgz#bc3576638071d18655e1cc60d7f524920008d723"
   integrity sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==
   dependencies:
     dargs "^7.0.0"
@@ -9044,31 +9592,36 @@ git-raw-commits@^2.0.11:
 
 github-slugger@^1.3.0:
   version "1.5.0"
-  resolved "https://registry.npmjs.org/github-slugger/-/github-slugger-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/github-slugger/-/github-slugger-1.5.0.tgz#17891bbc73232051474d68bd867a34625c955f7d"
   integrity sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw==
 
 github-slugger@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/github-slugger/-/github-slugger-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/github-slugger/-/github-slugger-2.0.0.tgz#52cf2f9279a21eb6c59dd385b410f0c0adda8f1a"
   integrity sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==
 
 glob-parent@^5.1.2, glob-parent@~5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
 glob-parent@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
   integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
   dependencies:
     is-glob "^4.0.3"
 
-glob@10.3.10, glob@^10.3.10:
+glob-to-regex.js@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/glob-to-regex.js/-/glob-to-regex.js-1.0.1.tgz#f71cc9cb8441471a9318626160bc8a35e1306b21"
+  integrity sha512-CG/iEvgQqfzoVsMUbxSJcwbG2JwyZ3naEqPkeltwl0BSS8Bp83k3xlGms+0QdWFUAwV+uvo80wNswKF6FWEkKg==
+
+glob@10.3.10:
   version "10.3.10"
-  resolved "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-10.3.10.tgz#0351ebb809fd187fe421ab96af83d3a70715df4b"
   integrity sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==
   dependencies:
     foreground-child "^3.1.0"
@@ -9077,9 +9630,21 @@ glob@10.3.10, glob@^10.3.10:
     minipass "^5.0.0 || ^6.0.2 || ^7.0.0"
     path-scurry "^1.10.1"
 
+glob@^10.2.2, glob@^10.3.10, glob@^10.4.5:
+  version "10.4.5"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-10.4.5.tgz#f4d9f0b90ffdbab09c9d77f5f29b4262517b0956"
+  integrity sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==
+  dependencies:
+    foreground-child "^3.1.0"
+    jackspeak "^3.1.2"
+    minimatch "^9.0.4"
+    minipass "^7.1.2"
+    package-json-from-dist "^1.0.0"
+    path-scurry "^1.11.1"
+
 glob@^7.0.5, glob@^7.1.3:
   version "7.2.3"
-  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
   integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
   dependencies:
     fs.realpath "^1.0.0"
@@ -9101,26 +9666,21 @@ glob@^9.3.2:
 
 global-dirs@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.npmjs.org/global-dirs/-/global-dirs-0.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-0.1.1.tgz#b319c0dd4607f353f3be9cca4c72fc148c49f445"
   integrity sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg==
   dependencies:
     ini "^1.3.4"
 
-globals@^11.1.0:
-  version "11.12.0"
-  resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz"
-  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
-
 globals@^13.19.0:
   version "13.24.0"
-  resolved "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-13.24.0.tgz#8432a19d78ce0c1e833949c36adb345400bb1171"
   integrity sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==
   dependencies:
     type-fest "^0.20.2"
 
-globalthis@^1.0.3:
+globalthis@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.4.tgz#7430ed3a975d97bfb59bcce41f5cabbafa651236"
   integrity sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==
   dependencies:
     define-properties "^1.2.1"
@@ -9128,7 +9688,7 @@ globalthis@^1.0.3:
 
 globby@^11.1.0:
   version "11.1.0"
-  resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
   integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
   dependencies:
     array-union "^2.1.0"
@@ -9140,22 +9700,22 @@ globby@^11.1.0:
 
 gopd@^1.0.1, gopd@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.2.0.tgz#89f56b8217bdbc8802bd299df6d7f1081d7e51a1"
   integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==
 
-graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.11, graceful-fs@^4.2.4:
+graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.11, graceful-fs@^4.2.6:
   version "4.2.11"
-  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
   integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
 
 graphemer@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6"
   integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==
 
 gray-matter@^4.0.2, gray-matter@^4.0.3:
   version "4.0.3"
-  resolved "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/gray-matter/-/gray-matter-4.0.3.tgz#e893c064825de73ea1f5f7d88c7a9f7274288798"
   integrity sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==
   dependencies:
     js-yaml "^3.13.1"
@@ -9165,75 +9725,67 @@ gray-matter@^4.0.2, gray-matter@^4.0.3:
 
 gzip-size@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/gzip-size/-/gzip-size-6.0.0.tgz#065367fd50c239c0671cbcbad5be3e2eeb10e462"
   integrity sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==
   dependencies:
     duplexer "^0.1.2"
 
 hard-rejection@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
   integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
 
-has-bigints@^1.0.1, has-bigints@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz"
-  integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
-
-has-flag@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz"
-  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
+has-bigints@^1.0.2:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.1.0.tgz#28607e965ac967e03cd2a2c70a2636a1edad49fe"
+  integrity sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==
 
 has-flag@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
-has-own-prop@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/has-own-prop/-/has-own-prop-2.0.0.tgz"
-  integrity sha512-Pq0h+hvsVm6dDEa8x82GnLSYHOzNDt7f0ddFa3FqcQlgzEiptPqL+XrOJNavjOzSYiYWIrgeVYYgGlLmnxwilQ==
-
 has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854"
   integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==
   dependencies:
     es-define-property "^1.0.0"
 
-has-proto@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz"
-  integrity sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==
+has-proto@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.2.0.tgz#5de5a6eabd95fdffd9818b43055e8065e39fe9d5"
+  integrity sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==
+  dependencies:
+    dunder-proto "^1.0.0"
 
-has-symbols@^1.0.2, has-symbols@^1.0.3, has-symbols@^1.1.0:
+has-symbols@^1.0.3, has-symbols@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.1.0.tgz#fc9c6a783a084951d0b971fe1018de813707a338"
   integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==
 
-has-tostringtag@^1.0.0, has-tostringtag@^1.0.2:
+has-tostringtag@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz#2cdc42d40bef2e5b4eeab7c01a73c54ce7ab5abc"
   integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==
   dependencies:
     has-symbols "^1.0.3"
 
 hash-wasm@^4.11.0:
-  version "4.11.0"
-  resolved "https://registry.npmjs.org/hash-wasm/-/hash-wasm-4.11.0.tgz"
-  integrity sha512-HVusNXlVqHe0fzIzdQOGolnFN6mX/fqcrSAOcTBXdvzrXVHwTz11vXeKRmkR5gTuwVpvHZEIyKoePDvuAR+XwQ==
+  version "4.12.0"
+  resolved "https://registry.yarnpkg.com/hash-wasm/-/hash-wasm-4.12.0.tgz#f9f1a9f9121e027a9acbf6db5d59452ace1ef9bb"
+  integrity sha512-+/2B2rYLb48I/evdOIhP+K/DD2ca2fgBjp6O+GBEnCDk2e4rpeXIK8GvIyRPjTezgmWn9gmKwkQjjx6BtqDHVQ==
 
-hasown@^2.0.0, hasown@^2.0.2:
+hasown@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003"
   integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==
   dependencies:
     function-bind "^1.1.2"
 
 hast-to-hyperscript@^10.0.1:
   version "10.0.3"
-  resolved "https://registry.npmjs.org/hast-to-hyperscript/-/hast-to-hyperscript-10.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/hast-to-hyperscript/-/hast-to-hyperscript-10.0.3.tgz#808133a8a2167976cd0024255adeced27ef7e7da"
   integrity sha512-NuBoUStp4fRwmvlfbidlEiRSTk0gSHm+97q4Xn9CJ10HO+Py7nlTuDi6RhM1qLOureukGrCXLG7AAxaGqqyslQ==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -9245,24 +9797,24 @@ hast-to-hyperscript@^10.0.1:
 
 hast-util-embedded@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-embedded/-/hast-util-embedded-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-embedded/-/hast-util-embedded-3.0.0.tgz#be4477780fbbe079cdba22982e357a0de4ba853e"
   integrity sha512-naH8sld4Pe2ep03qqULEtvYr7EjrLK2QHY8KJR6RJkTUjPGObe1vnx585uzem2hGra+s1q08DZZpfgDVYRbaXA==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
 
 hast-util-from-dom@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.0.tgz"
-  integrity sha512-d6235voAp/XR3Hh5uy7aGLbM3S4KamdW0WEgOaU1YoewnuYw4HXb5eRtv9g65m/RFGEfUY1Mw4UqCc5Y8L4Stg==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz#c3c92fbd8d4e1c1625edeb3a773952b9e4ad64a8"
+  integrity sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==
   dependencies:
     "@types/hast" "^3.0.0"
-    hastscript "^8.0.0"
+    hastscript "^9.0.0"
     web-namespaces "^2.0.0"
 
 hast-util-from-html-isomorphic@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz#b31baee386a899a2472326a3c5692f29f86d1d3c"
   integrity sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -9272,7 +9824,7 @@ hast-util-from-html-isomorphic@^2.0.0:
 
 hast-util-from-html@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz#485c74785358beb80c4ba6346299311ac4c49c82"
   integrity sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -9284,7 +9836,7 @@ hast-util-from-html@^2.0.0:
 
 hast-util-from-parse5@^7.0.0:
   version "7.1.2"
-  resolved "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz#aecfef73e3ceafdfa4550716443e4eb7b02e22b0"
   integrity sha512-Nz7FfPBuljzsN3tCQ4kCBKqdNhQE2l0Tn+X1ubgKBPRoiDIu1mL08Cfw4k7q71+Duyaw7DXDN+VTAp4Vh3oCOw==
   dependencies:
     "@types/hast" "^2.0.0"
@@ -9296,87 +9848,87 @@ hast-util-from-parse5@^7.0.0:
     web-namespaces "^2.0.0"
 
 hast-util-from-parse5@^8.0.0:
-  version "8.0.1"
-  resolved "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.1.tgz"
-  integrity sha512-Er/Iixbc7IEa7r/XLtuG52zoqn/b3Xng/w6aZQ0xGVxzhw5xUFxcRqdPzP6yFi/4HBYRaifaI5fQ1RH8n0ZeOQ==
+  version "8.0.3"
+  resolved "https://registry.yarnpkg.com/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz#830a35022fff28c3fea3697a98c2f4cc6b835a2e"
+  integrity sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/unist" "^3.0.0"
     devlop "^1.0.0"
-    hastscript "^8.0.0"
-    property-information "^6.0.0"
+    hastscript "^9.0.0"
+    property-information "^7.0.0"
     vfile "^6.0.0"
     vfile-location "^5.0.0"
     web-namespaces "^2.0.0"
 
 hast-util-from-string@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-from-string/-/hast-util-from-string-3.0.0.tgz"
-  integrity sha512-wHZ8oXSUZGq9noJocMeBOBFVd0YWmSbkVQDcwPHuMqrWxwN8iv20UnYKrWbPZfeHIYkvW34hIik6lQofJzjjaw==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-from-string/-/hast-util-from-string-3.0.1.tgz#18bbfbd22468eb804c60c78d2c5bf1da67458240"
+  integrity sha512-EpOi8Ux+QiJEUhv69d0xtGlA/7o6V1Yr4jqy6hq0s71mgl9sJsdruRrCo9UMVLMg+VwBVB4dnut/qsOsem5WWA==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-has-property@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-has-property/-/hast-util-has-property-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-has-property/-/hast-util-has-property-3.0.0.tgz#4e595e3cddb8ce530ea92f6fc4111a818d8e7f93"
   integrity sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-heading-rank@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-heading-rank/-/hast-util-heading-rank-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-heading-rank/-/hast-util-heading-rank-3.0.0.tgz#2d5c6f2807a7af5c45f74e623498dd6054d2aba8"
   integrity sha512-EJKb8oMUXVHcWZTDepnr+WNbfnXKFNf9duMesmr4S8SXTJBJ9M4Yok08pu9vxdJwdlGRhVumk9mEhkEvKGifwA==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-is-conditional-comment@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-conditional-comment/-/hast-util-is-conditional-comment-3.0.0.tgz"
-  integrity sha512-eugTiSl0bGgjAkXLfN6QUzfGlWPTcRC+xhVlwHNxthSxyUfwlTf/0AHDQRJImZ6UyHs+WdGf3s5BCuwAilK6cQ==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-is-conditional-comment/-/hast-util-is-conditional-comment-3.0.1.tgz#322a405743ddde7dacdc16bfb2333c65e9e2e80a"
+  integrity sha512-RWpXL//CiEWwOh4OeAvr2fFeoBbX/sAnPnaYN9x4Nv6O4VPdFf/3Dq64mIybctblVA498SgVjfNc0/mN9S4IQw==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-is-css-link@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-css-link/-/hast-util-is-css-link-3.0.0.tgz"
-  integrity sha512-oIbAccKOPhRXicPj7yqg8+qF6+KRBZk6GYoH8I/q38XVwHremzMIAmGhb+NSNgxxBKTJfSE7dgFI3r+ZaAhBmA==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-is-css-link/-/hast-util-is-css-link-3.0.1.tgz#7d3bf8a1f498f35012af1a0ec5568dce39bc8172"
+  integrity sha512-jyR6Ns8ypYH3nnJhvGehHTpSJdymxjKrg5PgDMClNH61JpWxXm9FLMvnk2CtWN5nulm6IeIrRgbVCsye+UPIBg==
   dependencies:
     "@types/hast" "^3.0.0"
     collapse-white-space "^2.0.0"
 
 hast-util-is-css-style@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-css-style/-/hast-util-is-css-style-3.0.0.tgz"
-  integrity sha512-LImaVMS/6I9PKZwtcW1TztZzOt1gXjLq1Ry7p3XAhbNhfUdxOXUEknPxOJPB6RfgFl0e4d0fYW8zfeQOBd1aTA==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-is-css-style/-/hast-util-is-css-style-3.0.1.tgz#9d337fdd623671bdd39374bd4859adaf1e9fc13b"
+  integrity sha512-5dlGKMoyB2+HY4hAB9pEkzlrH1tfnlHdkw6q1pkzLv2RI01w2ofyhJICzcYbW3NOrTUy4/0qrNvCPsVyHQlB2w==
   dependencies:
     "@types/hast" "^3.0.0"
     collapse-white-space "^2.0.0"
 
 hast-util-is-element@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz#6e31a6532c217e5b533848c7e52c9d9369ca0932"
   integrity sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-is-event-handler@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-event-handler/-/hast-util-is-event-handler-3.0.0.tgz"
-  integrity sha512-+5ABNfBqcE3cqIfkCT7CB+/WAoXBgwu0zT/3ndlx+CDQHs9SaKsMGgHz3rPaCkOlEAZW9y8wpfxaxdiz8QF9tg==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-is-event-handler/-/hast-util-is-event-handler-3.0.1.tgz#1d262a6574c441ecd40d394e92e854f8c76b0da0"
+  integrity sha512-Xu8jmmojIJ45sSE4c39kZXrW96O/J/wFCxZmg+C7/A/Av6kxwtTPRMBe9TGNJEtRRSch3v1H6iZe7C2hkGe8oQ==
 
 hast-util-is-javascript@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-is-javascript/-/hast-util-is-javascript-3.0.0.tgz"
-  integrity sha512-bY4Foa/zDN71rEaFhicgFo2IcbFSb8oUMqQEN08HpUurBcqGUsiTG5Bgy1WsWG9vUGEATjqBgbFXiVV2lpDaLQ==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-is-javascript/-/hast-util-is-javascript-3.0.1.tgz#f71de43a249f63bc19c4c0b4511803319f96eff8"
+  integrity sha512-z4KmilPwiFev1QP9dl++aZDvN1y9LLKgWiZ5oyOG23ybNz+F3Y4tIoWzG+RiQfns/+y3iq7H7p2ebwaY2fFLSQ==
   dependencies:
     "@types/hast" "^3.0.0"
     collapse-white-space "^2.0.0"
 
 hast-util-minify-whitespace@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/hast-util-minify-whitespace/-/hast-util-minify-whitespace-1.0.0.tgz"
-  integrity sha512-gD1m4YJSIk62ij32TlhFNqsC3dOQvpA4QAhyZOZFAT4u8LfEfB6N+F0V9oXQGBWXoqrs0h9wQRKa8RCeo8j61g==
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-minify-whitespace/-/hast-util-minify-whitespace-1.0.1.tgz#7588fd1a53f48f1d30406b81959dffc3650daf55"
+  integrity sha512-L96fPOVpnclQE0xzdWb/D12VT5FabA7SnZOUMtL1DbXmYiHJMXZvFkIZfiMmTCNJHUeO2K9UYNXoVyfz+QHuOw==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-embedded "^3.0.0"
@@ -9386,21 +9938,21 @@ hast-util-minify-whitespace@^1.0.0:
 
 hast-util-parse-selector@^3.0.0:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-parse-selector/-/hast-util-parse-selector-3.1.1.tgz#25ab00ae9e75cbc62cf7a901f68a247eade659e2"
   integrity sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA==
   dependencies:
     "@types/hast" "^2.0.0"
 
 hast-util-parse-selector@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz#352879fa86e25616036037dd8931fb5f34cb4a27"
   integrity sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-raw@7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-raw/-/hast-util-raw-7.0.0.tgz#77eb87580792a5769010b522ba2d75ba7e1a6c71"
   integrity sha512-3UKuYgaqakZrY916JfQzqSk8xZGyxpj9zwfPB3MctXLDorPdyqk1QZGZoCEqU2LMIEzVXBZukAQs7aAH9TJPIw==
   dependencies:
     "@types/hast" "^2.0.0"
@@ -9418,15 +9970,15 @@ hast-util-raw@7.0.0:
 
 hast-util-sanitize@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-sanitize/-/hast-util-sanitize-4.1.0.tgz#d90f8521f5083547095c5c63a7e03150303e0286"
   integrity sha512-Hd9tU0ltknMGRDv+d6Ro/4XKzBqQnP/EZrpiTbpFYfXv/uOhWeKc+2uajcbEvAEH98VZd7eII2PiXm13RihnLw==
   dependencies:
     "@types/hast" "^2.0.0"
 
 hast-util-select@^6.0.0:
-  version "6.0.2"
-  resolved "https://registry.npmjs.org/hast-util-select/-/hast-util-select-6.0.2.tgz"
-  integrity sha512-hT/SD/d/Meu+iobvgkffo1QecV8WeKWxwsNMzcTJsKw1cKTQKSR/7ArJeURLNJF9HDjp9nVoORyNNJxrvBye8Q==
+  version "6.0.4"
+  resolved "https://registry.yarnpkg.com/hast-util-select/-/hast-util-select-6.0.4.tgz#1d8f69657a57441d0ce0ade35887874d3e65a303"
+  integrity sha512-RqGS1ZgI0MwxLaKLDxjprynNzINEkRHY2i8ln4DDjgv9ZhcYVIHN9rlpiYsqtFwrgpYU361SyWDQcGNIBVu3lw==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/unist" "^3.0.0"
@@ -9438,17 +9990,16 @@ hast-util-select@^6.0.0:
     hast-util-has-property "^3.0.0"
     hast-util-to-string "^3.0.0"
     hast-util-whitespace "^3.0.0"
-    not "^0.1.0"
     nth-check "^2.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
     unist-util-visit "^5.0.0"
     zwitch "^2.0.0"
 
 hast-util-to-estree@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.0.tgz"
-  integrity sha512-lfX5g6hqVh9kjS/B9E2gSkvHH4SZNiQFiqWS0x9fENzEl+8W12RqdRxX6d/Cwxi30tPQs3bIO+aolQJNp1bIyw==
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz#e654c1c9374645135695cc0ab9f70b8fcaf733d7"
+  integrity sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/estree-jsx" "^1.0.0"
@@ -9461,16 +10012,16 @@ hast-util-to-estree@^3.0.0:
     mdast-util-mdx-expression "^2.0.0"
     mdast-util-mdx-jsx "^3.0.0"
     mdast-util-mdxjs-esm "^2.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
-    style-to-object "^0.4.0"
+    style-to-js "^1.0.0"
     unist-util-position "^5.0.0"
     zwitch "^2.0.0"
 
 hast-util-to-html@^9.0.0:
-  version "9.0.3"
-  resolved "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.3.tgz"
-  integrity sha512-M17uBDzMJ9RPCqLMO92gNNUDuBSq10a25SDBI08iCCxmorf4Yy6sYHK57n9WAbRAAaU+DuR4W6GN9K4DFZesYg==
+  version "9.0.5"
+  resolved "https://registry.yarnpkg.com/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz#ccc673a55bb8e85775b08ac28380f72d47167005"
+  integrity sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/unist" "^3.0.0"
@@ -9479,15 +10030,15 @@ hast-util-to-html@^9.0.0:
     hast-util-whitespace "^3.0.0"
     html-void-elements "^3.0.0"
     mdast-util-to-hast "^13.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
     stringify-entities "^4.0.0"
     zwitch "^2.0.4"
 
 hast-util-to-jsx-runtime@^2.0.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.0.tgz"
-  integrity sha512-H/y0+IWPdsLLS738P8tDnrQ8Z+dj12zQQ6WC11TIM21C8WFVoIxcqWXf2H3hiTVZjF1AWqoimGwrTWecWrnmRQ==
+  version "2.3.6"
+  resolved "https://registry.yarnpkg.com/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz#ff31897aae59f62232e21594eac7ef6b63333e98"
+  integrity sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==
   dependencies:
     "@types/estree" "^1.0.0"
     "@types/hast" "^3.0.0"
@@ -9499,15 +10050,15 @@ hast-util-to-jsx-runtime@^2.0.0:
     mdast-util-mdx-expression "^2.0.0"
     mdast-util-mdx-jsx "^3.0.0"
     mdast-util-mdxjs-esm "^2.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
-    style-to-object "^1.0.0"
+    style-to-js "^1.0.0"
     unist-util-position "^5.0.0"
     vfile-message "^4.0.0"
 
 hast-util-to-parse5@^7.0.0:
   version "7.1.0"
-  resolved "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-7.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-to-parse5/-/hast-util-to-parse5-7.1.0.tgz#c49391bf8f151973e0c9adcd116b561e8daf29f3"
   integrity sha512-YNRgAJkH2Jky5ySkIqFXTQiaqcAtJyVE+D5lkN6CdtOqrnkLfGYYrEcKuHOJZlp+MwjSwuD3fZuawI+sic/RBw==
   dependencies:
     "@types/hast" "^2.0.0"
@@ -9518,27 +10069,27 @@ hast-util-to-parse5@^7.0.0:
     zwitch "^2.0.0"
 
 hast-util-to-string@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-to-string/-/hast-util-to-string-3.0.0.tgz"
-  integrity sha512-OGkAxX1Ua3cbcW6EJ5pT/tslVb90uViVkcJ4ZZIMW/R33DX/AkcJcRrPebPwJkHYwlDHXz4aIwvAAaAdtrACFA==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/hast-util-to-string/-/hast-util-to-string-3.0.1.tgz#a4f15e682849326dd211c97129c94b0c3e76527c"
+  integrity sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hast-util-whitespace@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-2.0.1.tgz#0ec64e257e6fc216c7d14c8a1b74d27d650b4557"
   integrity sha512-nAxA0v8+vXSBDt3AnRUNjyRIQ0rD+ntpbAp4LnPkumc5M9yUbSMa4XDU9Q6etY4f1Wp4bNgvc1yjiZtsTTrSng==
 
 hast-util-whitespace@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz#7778ed9d3c92dd9e8c5c8f648a49c21fc51cb621"
   integrity sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==
   dependencies:
     "@types/hast" "^3.0.0"
 
 hastscript@^7.0.0, hastscript@^7.0.2:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/hastscript/-/hastscript-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-7.2.0.tgz#0eafb7afb153d047077fa2a833dc9b7ec604d10b"
   integrity sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw==
   dependencies:
     "@types/hast" "^2.0.0"
@@ -9547,20 +10098,20 @@ hastscript@^7.0.0, hastscript@^7.0.2:
     property-information "^6.0.0"
     space-separated-tokens "^2.0.0"
 
-hastscript@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/hastscript/-/hastscript-8.0.0.tgz"
-  integrity sha512-dMOtzCEd3ABUeSIISmrETiKuyydk1w0pa+gE/uormcTpSYuaNJPbX1NU3JLyscSLjwAQM8bWMhhIlnCqnRvDTw==
+hastscript@^9.0.0:
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/hastscript/-/hastscript-9.0.1.tgz#dbc84bef6051d40084342c229c451cd9dc567dff"
+  integrity sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==
   dependencies:
     "@types/hast" "^3.0.0"
     comma-separated-tokens "^2.0.0"
     hast-util-parse-selector "^4.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
 
 history@^4.9.0:
   version "4.10.1"
-  resolved "https://registry.npmjs.org/history/-/history-4.10.1.tgz"
+  resolved "https://registry.yarnpkg.com/history/-/history-4.10.1.tgz#33371a65e3a83b267434e2b3f3b1b4c58aad4cf3"
   integrity sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==
   dependencies:
     "@babel/runtime" "^7.1.2"
@@ -9580,56 +10131,76 @@ hogan.js@^3.0.2:
 
 hoist-non-react-statics@^3.1.0, hoist-non-react-statics@^3.3.2:
   version "3.3.2"
-  resolved "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz#ece0acaf71d62c2969c2ec59feff42a4b1a85b45"
   integrity sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==
   dependencies:
     react-is "^16.7.0"
 
 hosted-git-info@^2.1.4:
   version "2.8.9"
-  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz"
+  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
   integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==
 
 hosted-git-info@^4.0.1:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
   integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
   dependencies:
     lru-cache "^6.0.0"
 
+hosted-git-info@^8.0.0, hosted-git-info@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-8.1.0.tgz#153cd84c03c6721481e16a5709eb74b1a0ab2ed0"
+  integrity sha512-Rw/B2DNQaPBICNXEm8balFz9a6WpZrkCGpcWFpy7nCj+NyhSdqXipmfvtmWt9xGfp0wZnBxB+iVpLmQMYt47Tw==
+  dependencies:
+    lru-cache "^10.0.1"
+
 htm@^3.0.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/htm/-/htm-3.1.1.tgz#49266582be0dc66ed2235d5ea892307cc0c24b78"
   integrity sha512-983Vyg8NwUE7JkZ6NmOqpCZ+sh1bKv2iYTlUkzlWmA5JD2acKoxd4KVxbMmxX/85mtfdnDmTFoNKcg5DGAvxNQ==
 
 html-enumerated-attributes@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/html-enumerated-attributes/-/html-enumerated-attributes-1.1.0.tgz"
-  integrity sha512-XJMYQYY3rze+lUxVb3ufucdjyvbPEr6ZRx96K1Z3IjOdoNj4qRqnmn69XZuTL+DHGewHjgZW0vWezx5aJsV80g==
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/html-enumerated-attributes/-/html-enumerated-attributes-1.1.1.tgz#924cad2668ad27e6c66f99b8aea30d77d9cfed5b"
+  integrity sha512-fxfswuADQ6N6RmCUYoCEIw09Zbk/h8GJSJsbiQ3Uw3mkQegJ5b7Eu5Tpxl2xDUq9meWmivHe0GFieG2qHl2j4A==
 
 html-escaper@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
 html-url-attributes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.0.tgz"
-  integrity sha512-/sXbVCWayk6GDVg3ctOX6nxaVj7So40FcFAnWlWGNAB1LpYKcV5Cd10APjPjW80O7zYW2MsjBV4zZ7IZO5fVow==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/html-url-attributes/-/html-url-attributes-3.0.1.tgz#83b052cd5e437071b756cd74ae70f708870c2d87"
+  integrity sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==
 
 html-void-elements@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-2.0.1.tgz#29459b8b05c200b6c5ee98743c41b979d577549f"
   integrity sha512-0quDb7s97CfemeJAnW9wC0hw78MtW7NU3hqtCD75g2vFlDLt36llsYD7uB7SUzojLMP24N5IatXf7ylGXiGG9A==
 
 html-void-elements@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/html-void-elements/-/html-void-elements-3.0.0.tgz#fc9dbd84af9e747249034d4d62602def6517f1d7"
   integrity sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==
 
+http-cache-semantics@^4.1.1:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz#205f4db64f8562b76a4ff9235aa5279839a09dd5"
+  integrity sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==
+
+http-proxy-agent@^7.0.0:
+  version "7.0.2"
+  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz#9a8b1f246866c028509486585f62b8f2c18c270e"
+  integrity sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==
+  dependencies:
+    agent-base "^7.1.0"
+    debug "^4.3.4"
+
 http-reasons@0.1.0:
   version "0.1.0"
-  resolved "https://registry.npmjs.org/http-reasons/-/http-reasons-0.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/http-reasons/-/http-reasons-0.1.0.tgz#a953ca670078669dde142ce899401b9d6e85d3b4"
   integrity sha512-P6kYh0lKZ+y29T2Gqz+RlC9WBLhKe8kDmcJ+A+611jFfxdPsbMRQ5aNmFRM3lENqFkK+HTTL+tlQviAiv0AbLQ==
 
 https-proxy-agent@^5.0.0:
@@ -9640,9 +10211,17 @@ https-proxy-agent@^5.0.0:
     agent-base "6"
     debug "4"
 
+https-proxy-agent@^7.0.1:
+  version "7.0.6"
+  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz#da8dfeac7da130b05c2ba4b59c9b6cd66611a6b9"
+  integrity sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==
+  dependencies:
+    agent-base "^7.1.2"
+    debug "4"
+
 httpsnippet-lite@^3.0.5:
   version "3.0.5"
-  resolved "https://registry.npmjs.org/httpsnippet-lite/-/httpsnippet-lite-3.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/httpsnippet-lite/-/httpsnippet-lite-3.0.5.tgz#af937fa37d3f34e333a1f68e64f906c0fe48c992"
   integrity sha512-So4qTXY5iFj5XtFDwyz2PicUu+8NWrI8e8h+ZeZoVtMNcFQp4FFIntBHUE+JPUG6QQU8o1VHCy+X4ETRDwt9CA==
   dependencies:
     "@types/har-format" "^1.2.10"
@@ -9651,78 +10230,77 @@ httpsnippet-lite@^3.0.5:
 
 human-signals@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
   integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
 
 human-signals@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-5.0.0.tgz#42665a284f9ae0dade3ba41ebc37eb4b852f3a28"
   integrity sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==
 
 husky@^9.0.0:
-  version "9.1.6"
-  resolved "https://registry.npmjs.org/husky/-/husky-9.1.6.tgz"
-  integrity sha512-sqbjZKK7kf44hfdE94EoX8MZNk0n7HeW37O4YrVGCF4wzgQjp+akPAkfUK5LZ6KuR/6sqeAVuXHji+RzQgOn5A==
+  version "9.1.7"
+  resolved "https://registry.yarnpkg.com/husky/-/husky-9.1.7.tgz#d46a38035d101b46a70456a850ff4201344c0b2d"
+  integrity sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==
 
 hyperdyperid@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/hyperdyperid/-/hyperdyperid-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/hyperdyperid/-/hyperdyperid-1.2.0.tgz#59668d323ada92228d2a869d3e474d5a33b69e6b"
   integrity sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==
 
 hyphenate-style-name@^1.0.3:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/hyphenate-style-name/-/hyphenate-style-name-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/hyphenate-style-name/-/hyphenate-style-name-1.1.0.tgz#1797bf50369588b47b72ca6d5e65374607cf4436"
   integrity sha512-WDC/ui2VVRrz3jOVi+XtjqkDjiVjTtFaAGiW37k6b+ohyQ5wYDOGkvCZa8+H0nx3gyvv0+BST9xuOgIyGQ00gw==
 
-iconv-lite@0.6.3:
+iconv-lite@0.6.3, iconv-lite@^0.6.2:
   version "0.6.3"
-  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501"
   integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==
   dependencies:
     safer-buffer ">= 2.1.2 < 3.0.0"
 
 iconv-lite@^0.4.4:
   version "0.4.24"
-  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
+ignore-walk@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-7.0.0.tgz#8350e475cf4375969c12eb49618b3fd9cca6704f"
+  integrity sha512-T4gbf83A4NH95zvhVYZc+qWocBBGlpzUXLPGurJggw/WIOwicfXJChLDP/iBZnN5WqROSu5Bm3hhle4z8a8YGQ==
+  dependencies:
+    minimatch "^9.0.0"
+
 ignore@^5.2.0, ignore@^5.2.4:
   version "5.3.2"
-  resolved "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.3.2.tgz#3cd40e729f3643fd87cb04e50bf0eb722bc596f5"
   integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==
 
 imagescript@^1.2.16:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/imagescript/-/imagescript-1.3.0.tgz"
-  integrity sha512-lCYzQrWzdnA68K03oMj/BUlBJrVBnslzDOgGFymAp49NmdGEJxGeN7sHh5mCva0nQkq+kkKSuru2zLf1m04+3A==
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/imagescript/-/imagescript-1.3.1.tgz#cc59e0e2f34018c4be3625cb519e37099344521c"
+  integrity sha512-ue/zxSyEzj7je8Nlt2vjY9GEa2BbScFSRZJq7OTVDZFp0r57fyuxrlsF8qWgxTP+kP8WklTw4by/ZEYVX5S13w==
 
 immediate@~3.0.5:
   version "3.0.6"
   resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
   integrity sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==
 
-import-fresh@^3.0.0:
+import-fresh@^3.0.0, import-fresh@^3.2.1, import-fresh@^3.3.0:
   version "3.3.1"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.1.tgz#9cecb56503c0ada1f2741dbbd6546e4b13b57ccf"
   integrity sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==
   dependencies:
     parent-module "^1.0.0"
     resolve-from "^4.0.0"
 
-import-fresh@^3.2.1, import-fresh@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
 import-in-the-middle@^1.14.2, import-in-the-middle@^1.8.1:
-  version "1.14.2"
-  resolved "https://registry.yarnpkg.com/import-in-the-middle/-/import-in-the-middle-1.14.2.tgz#283661625a88ff7c0462bd2984f77715c3bc967c"
-  integrity sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==
+  version "1.14.4"
+  resolved "https://registry.yarnpkg.com/import-in-the-middle/-/import-in-the-middle-1.14.4.tgz#5350cf8eba46e3b51cd3e507f5fe36a8faeb3684"
+  integrity sha512-eWjxh735SJLFJJDs5X82JQ2405OdJeAHDBnaoFCfdr5GVc7AWc9xU7KbrF+3Xd5F2ccP1aQFKtY+65X6EfKZ7A==
   dependencies:
     acorn "^8.14.0"
     acorn-import-attributes "^1.9.5"
@@ -9731,22 +10309,22 @@ import-in-the-middle@^1.14.2, import-in-the-middle@^1.8.1:
 
 imurmurhash@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
   integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
 
 indent-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
   integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
 
 inflection@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/inflection/-/inflection-3.0.0.tgz"
-  integrity sha512-1zEJU1l19SgJlmwqsEyFTbScw/tkMHFenUo//Y0i+XEP83gDFdMvPizAD/WGcE+l1ku12PcTVHQhO6g5E0UCMw==
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/inflection/-/inflection-3.0.2.tgz#2f591c3dad053e3fac65a03bf6431b675d829601"
+  integrity sha512-+Bg3+kg+J6JUWn8J6bzFmOWkTQ6L/NHfDRSYU+EVvuKHDxUDHAXgqixHfVlzuBQaPOTac8hn43aPhMNk6rMe3g==
 
 inflight@^1.0.4:
   version "1.0.6"
-  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
   integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
   dependencies:
     once "^1.3.0"
@@ -9754,31 +10332,59 @@ inflight@^1.0.4:
 
 inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.1, inherits@~2.0.3:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
 ini@^1.3.4:
   version "1.3.8"
-  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
+ini@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/ini/-/ini-5.0.0.tgz#a7a4615339843d9a8ccc2d85c9d81cf93ffbc638"
+  integrity sha512-+N0ngpO3e7cRUWOJAS7qw0IZIVc6XPrW4MlFBdD066F2L4k1L6ker3hLqSq7iXxU5tgS4WGkIUElWn5vogAEnw==
+
+init-package-json@^7.0.2:
+  version "7.0.2"
+  resolved "https://registry.yarnpkg.com/init-package-json/-/init-package-json-7.0.2.tgz#62d7fa76d880a7773a7be51981a2b09006d2516f"
+  integrity sha512-Qg6nAQulaOQZjvaSzVLtYRqZmuqOi7gTknqqgdhZy7LV5oO+ppvHWq15tZYzGyxJLTH5BxRTqTa+cPDx2pSD9Q==
+  dependencies:
+    "@npmcli/package-json" "^6.0.0"
+    npm-package-arg "^12.0.0"
+    promzard "^2.0.0"
+    read "^4.0.0"
+    semver "^7.3.5"
+    validate-npm-package-license "^3.0.4"
+    validate-npm-package-name "^6.0.0"
+
 inline-style-parser@0.1.1:
   version "0.1.1"
-  resolved "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.1.1.tgz#ec8a3b429274e9c0a1f1c4ffa9453a7fef72cea1"
   integrity sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==
 
 inline-style-parser@0.2.4:
   version "0.2.4"
-  resolved "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/inline-style-parser/-/inline-style-parser-0.2.4.tgz#f4af5fe72e612839fcd453d989a586566d695f22"
   integrity sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==
 
 inline-style-prefixer@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/inline-style-prefixer/-/inline-style-prefixer-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/inline-style-prefixer/-/inline-style-prefixer-7.0.1.tgz#9310f3cfa2c6f3901d1480f373981c02691781e8"
   integrity sha512-lhYo5qNTQp3EvSSp3sRvXMbVQTLrvGV6DycRMJ5dm2BLMiJ30wpXKdDdgX+GmJZ5uQMucwRKHamXSst3Sj/Giw==
   dependencies:
     css-in-js-utils "^3.1.0"
 
+input-otp@1.4.1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/input-otp/-/input-otp-1.4.1.tgz#bc22e68b14b1667219d54adf74243e37ea79cf84"
+  integrity sha512-+yvpmKYKHi9jIGngxagY9oWiiblPB7+nEO75F2l2o4vs+6vpPZZmUl4tBNYuTCvQjhvEIbdNeJu70bhfYP2nbw==
+
+install@^0.13.0:
+  version "0.13.0"
+  resolved "https://registry.yarnpkg.com/install/-/install-0.13.0.tgz#6af6e9da9dd0987de2ab420f78e60d9c17260776"
+  integrity sha512-zDml/jzr2PKU9I8J/xyZBQn8rPCAY//UOYNmR01XwNwyfhEWObo2SWfSl1+0tm1u6PhxLwDnfsT/6jB7OUxqFA==
+
 instantsearch-ui-components@0.11.2:
   version "0.11.2"
   resolved "https://registry.yarnpkg.com/instantsearch-ui-components/-/instantsearch-ui-components-0.11.2.tgz#428c7d424326671183b9b2c2ca6c6f3b59d741b2"
@@ -9804,43 +10410,53 @@ instantsearch.js@4.80.0:
     qs "^6.5.1 < 6.10"
     search-insights "^2.17.2"
 
-internal-slot@^1.0.4, internal-slot@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.7.tgz"
-  integrity sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==
+internal-slot@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.1.0.tgz#1eac91762947d2f7056bc838d93e13b2e9604961"
+  integrity sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==
   dependencies:
     es-errors "^1.3.0"
-    hasown "^2.0.0"
-    side-channel "^1.0.4"
+    hasown "^2.0.2"
+    side-channel "^1.1.0"
 
 "internmap@1 - 2":
   version "2.0.3"
-  resolved "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/internmap/-/internmap-2.0.3.tgz#6685f23755e43c524e251d29cbc97248e3061009"
   integrity sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==
 
 intl-messageformat@^10.1.0:
-  version "10.5.14"
-  resolved "https://registry.npmjs.org/intl-messageformat/-/intl-messageformat-10.5.14.tgz"
-  integrity sha512-IjC6sI0X7YRjjyVH9aUgdftcmZK7WXdHeil4KwbjDnRWjnVitKpAx3rr6t6di1joFp5188VqKcobOPA6mCLG/w==
+  version "10.7.16"
+  resolved "https://registry.yarnpkg.com/intl-messageformat/-/intl-messageformat-10.7.16.tgz#d909f9f9f4ab857fbe681d559b958dd4dd9f665a"
+  integrity sha512-UmdmHUmp5CIKKjSoE10la5yfU+AYJAaiYLsodbjL4lji83JNvgOQUjGaGhGrpFCb0Uh7sl7qfP1IyILa8Z40ug==
   dependencies:
-    "@formatjs/ecma402-abstract" "2.0.0"
-    "@formatjs/fast-memoize" "2.2.0"
-    "@formatjs/icu-messageformat-parser" "2.7.8"
-    tslib "^2.4.0"
+    "@formatjs/ecma402-abstract" "2.3.4"
+    "@formatjs/fast-memoize" "2.2.7"
+    "@formatjs/icu-messageformat-parser" "2.11.2"
+    tslib "^2.8.0"
+
+ip-address@^10.0.1:
+  version "10.0.1"
+  resolved "https://registry.yarnpkg.com/ip-address/-/ip-address-10.0.1.tgz#a8180b783ce7788777d796286d61bce4276818ed"
+  integrity sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==
+
+ip-regex@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-5.0.0.tgz#cd313b2ae9c80c07bd3851e12bf4fa4dc5480632"
+  integrity sha512-fOCG6lhoKKakwv+C6KdsOnGvgXnmgfmp0myi3bcNwj3qfwPAxRKWEuFhvEFF7ceYIz6+1jRZ+yguLFAmUNPEfw==
 
 is-alphabetical@^1.0.0:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphabetical/-/is-alphabetical-1.0.4.tgz#9e7d6b94916be22153745d184c298cbf986a686d"
   integrity sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==
 
 is-alphabetical@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphabetical/-/is-alphabetical-2.0.1.tgz#01072053ea7c1036df3c7d19a6daaec7f19e789b"
   integrity sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==
 
 is-alphanumerical@^1.0.0:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz#7eb9a2431f855f6b1ef1a78e326df515696c4dbf"
   integrity sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==
   dependencies:
     is-alphabetical "^1.0.0"
@@ -9848,235 +10464,247 @@ is-alphanumerical@^1.0.0:
 
 is-alphanumerical@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz#7c03fbe96e3e931113e57f964b0a368cc2dfd875"
   integrity sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==
   dependencies:
     is-alphabetical "^2.0.0"
     is-decimal "^2.0.0"
 
-is-arguments@^1.0.4, is-arguments@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz"
-  integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==
+is-arguments@^1.0.4:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.2.0.tgz#ad58c6aecf563b78ef2bf04df540da8f5d7d8e1b"
+  integrity sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==
   dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.2"
+    has-tostringtag "^1.0.2"
 
-is-array-buffer@^3.0.2, is-array-buffer@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz"
-  integrity sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==
+is-array-buffer@^3.0.4, is-array-buffer@^3.0.5:
+  version "3.0.5"
+  resolved "https://registry.yarnpkg.com/is-array-buffer/-/is-array-buffer-3.0.5.tgz#65742e1e687bd2cc666253068fd8707fe4d44280"
+  integrity sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==
   dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.2.1"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
+    get-intrinsic "^1.2.6"
 
 is-arrayish@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
 
 is-arrayish@^0.3.1:
-  version "0.3.2"
-  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz"
-  integrity sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==
+  version "0.3.4"
+  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.3.4.tgz#1ee5553818511915685d33bb13d31bf854e5059d"
+  integrity sha512-m6UrgzFVUYawGBh1dUsWR5M2Clqic9RVXC/9f8ceNlv2IcO9j9J/z8UoCLPqtsPBFNzEpfR3xftohbfqDx8EQA==
 
 is-async-function@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/is-async-function/-/is-async-function-2.0.0.tgz"
-  integrity sha512-Y1JXKrfykRJGdlDwdKlLpLyMIiWqWvuSd17TvZk68PLAOGOoF4Xyav1z0Xhoi+gCYjZVeC5SI+hYFOfvXmGRCA==
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/is-async-function/-/is-async-function-2.1.1.tgz#3e69018c8e04e73b738793d020bfe884b9fd3523"
+  integrity sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==
   dependencies:
-    has-tostringtag "^1.0.0"
+    async-function "^1.0.0"
+    call-bound "^1.0.3"
+    get-proto "^1.0.1"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
 
-is-bigint@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz"
-  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
+is-bigint@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.1.0.tgz#dda7a3445df57a42583db4228682eba7c4170672"
+  integrity sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==
   dependencies:
-    has-bigints "^1.0.1"
+    has-bigints "^1.0.2"
 
 is-binary-path@~2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
   integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
   dependencies:
     binary-extensions "^2.0.0"
 
-is-boolean-object@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz"
-  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
+is-boolean-object@^1.2.1:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.2.2.tgz#7067f47709809a393c71ff5bb3e135d8a9215d9e"
+  integrity sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==
   dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
 
 is-buffer@^2.0.0:
   version "2.0.5"
-  resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-2.0.5.tgz#ebc252e400d22ff8d77fa09888821a24a658c191"
   integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==
 
-is-bun-module@^1.0.2:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/is-bun-module/-/is-bun-module-1.2.1.tgz"
-  integrity sha512-AmidtEM6D6NmUiLOvvU7+IePxjEjOzra2h0pSrsfSAcXwl/83zLLXDByafUJy9k/rKK0pvXMLdwKwGHlX2Ke6Q==
+is-bun-module@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-bun-module/-/is-bun-module-2.0.0.tgz#4d7859a87c0fcac950c95e666730e745eae8bddd"
+  integrity sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ==
   dependencies:
-    semver "^7.6.3"
+    semver "^7.7.1"
 
-is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7:
+is-callable@^1.2.7:
   version "1.2.7"
-  resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.7.tgz#3bc2a85ea742d9e36205dcacdd72ca1fdc51b055"
   integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
 
-is-core-module@^2.13.0, is-core-module@^2.15.1:
-  version "2.15.1"
-  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz"
-  integrity sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==
+is-cidr@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/is-cidr/-/is-cidr-5.1.1.tgz#83ec462922c2b9209bc64794c4e3b2a890d23994"
+  integrity sha512-AwzRMjtJNTPOgm7xuYZ71715z99t+4yRnSnSzgK5err5+heYi4zMuvmpUadaJ28+KCXCQo8CjUrKQZRWSPmqTQ==
   dependencies:
-    hasown "^2.0.2"
+    cidr-regex "^4.1.1"
 
-is-core-module@^2.16.0, is-core-module@^2.5.0:
+is-core-module@^2.13.0, is-core-module@^2.16.0, is-core-module@^2.16.1, is-core-module@^2.5.0:
   version "2.16.1"
-  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.16.1.tgz#2a98801a849f43e2add644fbb6bc6229b19a4ef4"
   integrity sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==
   dependencies:
     hasown "^2.0.2"
 
-is-data-view@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.1.tgz"
-  integrity sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==
+is-data-view@^1.0.1, is-data-view@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-data-view/-/is-data-view-1.0.2.tgz#bae0a41b9688986c2188dda6657e56b8f9e63b8e"
+  integrity sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==
   dependencies:
+    call-bound "^1.0.2"
+    get-intrinsic "^1.2.6"
     is-typed-array "^1.1.13"
 
-is-date-object@^1.0.1, is-date-object@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz"
-  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
+is-date-object@^1.0.5, is-date-object@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.1.0.tgz#ad85541996fc7aa8b2729701d27b7319f95d82f7"
+  integrity sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==
   dependencies:
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.2"
+    has-tostringtag "^1.0.2"
 
 is-decimal@^1.0.0:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/is-decimal/-/is-decimal-1.0.4.tgz#65a3a5958a1c5b63a706e1b333d7cd9f630d3fa5"
   integrity sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==
 
 is-decimal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-decimal/-/is-decimal-2.0.1.tgz#9469d2dc190d0214fd87d78b78caecc0cc14eef7"
   integrity sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==
 
 is-extendable@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
   integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==
 
 is-extglob@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
   integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
 
-is-finalizationregistry@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.0.2.tgz"
-  integrity sha512-0by5vtUJs8iFQb5TYUHHPudOR+qXYIMKtiUzvLIZITZUjknFmziyBJuLhVRc+Ds0dREFlskDNJKYIdIzu/9pfw==
+is-finalizationregistry@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz#eefdcdc6c94ddd0674d9c85887bf93f944a97c90"
+  integrity sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==
   dependencies:
-    call-bind "^1.0.2"
+    call-bound "^1.0.3"
 
 is-fullwidth-code-point@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
 is-fullwidth-code-point@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz#fae3167c729e7463f8461ce512b080a49268aa88"
   integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==
 
 is-fullwidth-code-point@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.0.0.tgz"
-  integrity sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz#046b2a6d4f6b156b2233d3207d4b5a9783999b98"
+  integrity sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==
   dependencies:
-    get-east-asian-width "^1.0.0"
+    get-east-asian-width "^1.3.1"
 
 is-generator-function@^1.0.10, is-generator-function@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz"
-  integrity sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.1.0.tgz#bf3eeda931201394f57b5dba2800f91a238309ca"
+  integrity sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==
   dependencies:
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.3"
+    get-proto "^1.0.0"
+    has-tostringtag "^1.0.2"
+    safe-regex-test "^1.1.0"
 
 is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
   version "4.0.3"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
   integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
   dependencies:
     is-extglob "^2.1.1"
 
 is-hexadecimal@^1.0.0:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz#cc35c97588da4bd49a8eedd6bc4082d44dcb23a7"
   integrity sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==
 
 is-hexadecimal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz#86b5bf668fca307498d319dfc03289d781a90027"
   integrity sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==
 
-is-map@^2.0.2, is-map@^2.0.3:
+is-map@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-map/-/is-map-2.0.3.tgz#ede96b7fe1e270b3c4465e3a465658764926d62e"
   integrity sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==
 
 is-negative-zero@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.3.tgz#ced903a027aca6381b777a5743069d7376a49747"
   integrity sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==
 
-is-number-object@^1.0.4:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz"
-  integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
+is-number-object@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.1.1.tgz#144b21e95a1bc148205dcc2814a9134ec41b2541"
+  integrity sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==
   dependencies:
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
 
 is-number@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
 is-obj@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
   integrity sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==
 
 is-obj@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
   integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
 
 is-path-inside@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
   integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
 
 is-plain-obj@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
   integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==
 
 is-plain-obj@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
   integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
 
 is-plain-obj@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-4.1.0.tgz#d65025edec3657ce032fd7db63c97883eaed71f0"
   integrity sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==
 
 is-plain-object@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344"
   integrity sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==
 
 is-reference@1.2.1:
@@ -10086,299 +10714,312 @@ is-reference@1.2.1:
   dependencies:
     "@types/estree" "*"
 
-is-reference@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/is-reference/-/is-reference-3.0.2.tgz"
-  integrity sha512-v3rht/LgVcsdZa3O2Nqs+NMowLOxeOm7Ay9+/ARQ2F+qEoANRcqrjAZKGN0v8ymUetZGgkp26LTnGT7H0Qo9Pg==
-  dependencies:
-    "@types/estree" "*"
-
-is-regex@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz"
-  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
+is-regex@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.2.1.tgz#76d70a3ed10ef9be48eb577887d74205bf0cad22"
+  integrity sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==
   dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.2"
+    gopd "^1.2.0"
+    has-tostringtag "^1.0.2"
+    hasown "^2.0.2"
 
 is-regexp@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069"
   integrity sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==
 
-is-set@^2.0.2, is-set@^2.0.3:
+is-set@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/is-set/-/is-set-2.0.3.tgz#8ab209ea424608141372ded6e0cb200ef1d9d01d"
   integrity sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==
 
-is-shared-array-buffer@^1.0.2, is-shared-array-buffer@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz"
-  integrity sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==
+is-shared-array-buffer@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz#9b67844bd9b7f246ba0708c3a93e34269c774f6f"
+  integrity sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==
   dependencies:
-    call-bind "^1.0.7"
+    call-bound "^1.0.3"
 
 is-stream@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
 is-stream@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-3.0.0.tgz#e6bfd7aa6bef69f4f472ce9bb681e3e57b4319ac"
   integrity sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==
 
-is-string@^1.0.5, is-string@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz"
-  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
+is-string@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.1.1.tgz#92ea3f3d5c5b6e039ca8677e5ac8d07ea773cbb9"
+  integrity sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==
   dependencies:
-    has-tostringtag "^1.0.0"
+    call-bound "^1.0.3"
+    has-tostringtag "^1.0.2"
 
-is-symbol@^1.0.2, is-symbol@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz"
-  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
+is-symbol@^1.0.4, is-symbol@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.1.1.tgz#f47761279f532e2b05a7024a7506dbbedacd0634"
+  integrity sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==
   dependencies:
-    has-symbols "^1.0.2"
+    call-bound "^1.0.2"
+    has-symbols "^1.1.0"
+    safe-regex-test "^1.1.0"
 
 is-text-path@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/is-text-path/-/is-text-path-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
   integrity sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w==
   dependencies:
     text-extensions "^1.0.0"
 
-is-typed-array@^1.1.13, is-typed-array@^1.1.3:
-  version "1.1.13"
-  resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz"
-  integrity sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==
+is-typed-array@^1.1.13, is-typed-array@^1.1.14, is-typed-array@^1.1.15, is-typed-array@^1.1.3:
+  version "1.1.15"
+  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.15.tgz#4bfb4a45b61cee83a5a46fba778e4e8d59c0ce0b"
+  integrity sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==
   dependencies:
-    which-typed-array "^1.1.14"
+    which-typed-array "^1.1.16"
 
 is-weakmap@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/is-weakmap/-/is-weakmap-2.0.2.tgz#bf72615d649dfe5f699079c54b83e47d1ae19cfd"
   integrity sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==
 
-is-weakref@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz"
-  integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
+is-weakref@^1.0.2, is-weakref@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.1.1.tgz#eea430182be8d64174bd96bffbc46f21bf3f9293"
+  integrity sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==
   dependencies:
-    call-bind "^1.0.2"
+    call-bound "^1.0.3"
 
 is-weakset@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.3.tgz"
-  integrity sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/is-weakset/-/is-weakset-2.0.4.tgz#c9f5deb0bc1906c6d6f1027f284ddf459249daca"
+  integrity sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==
   dependencies:
-    call-bind "^1.0.7"
-    get-intrinsic "^1.2.4"
+    call-bound "^1.0.3"
+    get-intrinsic "^1.2.6"
 
 isarray@0.0.1:
   version "0.0.1"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
   integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
 
 isarray@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.5.tgz#8af1e4c1221244cc62459faf38940d4e644a5723"
   integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==
 
 isarray@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
   integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
 
 isexe@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
   integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
 
+isexe@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-3.1.1.tgz#4a407e2bd78ddfb14bea0c27c6f7072dde775f0d"
+  integrity sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==
+
 isomorphic-fetch@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/isomorphic-fetch/-/isomorphic-fetch-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/isomorphic-fetch/-/isomorphic-fetch-3.0.0.tgz#0267b005049046d2421207215d45d6a262b8b8b4"
   integrity sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==
   dependencies:
     node-fetch "^2.6.1"
     whatwg-fetch "^3.4.1"
 
-iterator.prototype@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.2.tgz"
-  integrity sha512-DR33HMMr8EzwuRL8Y9D3u2BMj8+RqSE850jfGu59kS7tbmPLzGkZmVSfyCFSDxuZiEY6Rzt3T2NA/qU+NwVj1w==
+iterator.prototype@^1.1.4:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/iterator.prototype/-/iterator.prototype-1.1.5.tgz#12c959a29de32de0aa3bbbb801f4d777066dae39"
+  integrity sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==
   dependencies:
-    define-properties "^1.2.1"
-    get-intrinsic "^1.2.1"
-    has-symbols "^1.0.3"
-    reflect.getprototypeof "^1.0.4"
-    set-function-name "^2.0.1"
+    define-data-property "^1.1.4"
+    es-object-atoms "^1.0.0"
+    get-intrinsic "^1.2.6"
+    get-proto "^1.0.0"
+    has-symbols "^1.1.0"
+    set-function-name "^2.0.2"
 
 jackspeak@^2.3.5:
   version "2.3.6"
-  resolved "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.6.tgz"
+  resolved "https://registry.yarnpkg.com/jackspeak/-/jackspeak-2.3.6.tgz#647ecc472238aee4b06ac0e461acc21a8c505ca8"
   integrity sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==
   dependencies:
     "@isaacs/cliui" "^8.0.2"
   optionalDependencies:
     "@pkgjs/parseargs" "^0.11.0"
 
-jiti@^1.21.0:
-  version "1.21.6"
-  resolved "https://registry.npmjs.org/jiti/-/jiti-1.21.6.tgz"
-  integrity sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==
+jackspeak@^3.1.2:
+  version "3.4.3"
+  resolved "https://registry.yarnpkg.com/jackspeak/-/jackspeak-3.4.3.tgz#8833a9d89ab4acde6188942bd1c53b6390ed5a8a"
+  integrity sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==
+  dependencies:
+    "@isaacs/cliui" "^8.0.2"
+  optionalDependencies:
+    "@pkgjs/parseargs" "^0.11.0"
+
+jiti@^1.21.6:
+  version "1.21.7"
+  resolved "https://registry.yarnpkg.com/jiti/-/jiti-1.21.7.tgz#9dd81043424a3d28458b193d965f0d18a2300ba9"
+  integrity sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==
 
 jotai@1.3.9:
   version "1.3.9"
-  resolved "https://registry.npmjs.org/jotai/-/jotai-1.3.9.tgz"
+  resolved "https://registry.yarnpkg.com/jotai/-/jotai-1.3.9.tgz#d65a7069b949a3a74f9e069d3e3f06f99be02817"
   integrity sha512-b6DvH9gf+7TfjaboCO54g+C0yhaakIaUBtjLf0dk1p15FWCzNw/93sezdXy9cCaZ8qcEdMLJcjBwQlORmIq29g==
 
 jotai@^1.4.5:
   version "1.13.1"
-  resolved "https://registry.npmjs.org/jotai/-/jotai-1.13.1.tgz"
+  resolved "https://registry.yarnpkg.com/jotai/-/jotai-1.13.1.tgz#20cc46454cbb39096b12fddfa635b873b3668236"
   integrity sha512-RUmH1S4vLsG3V6fbGlKzGJnLrDcC/HNb5gH2AeA9DzuJknoVxSGvvg8OBB7lke+gDc4oXmdVsaKn/xDUhWZ0vw==
 
 js-cookie@^2.2.1:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/js-cookie/-/js-cookie-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/js-cookie/-/js-cookie-2.2.1.tgz#69e106dc5d5806894562902aa5baec3744e9b2b8"
   integrity sha512-HvdH2LzI/EAZcUwA8+0nKNtWHqS+ZmijLA30RwZA0bo7ToCckjK5MkGhjED9KoRcXO6BaGI3I9UIzSA1FKFPOQ==
 
 js-cookie@^3.0.5:
   version "3.0.5"
-  resolved "https://registry.npmjs.org/js-cookie/-/js-cookie-3.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/js-cookie/-/js-cookie-3.0.5.tgz#0b7e2fd0c01552c58ba86e0841f94dc2557dcdbc"
   integrity sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==
 
 js-sha3@0.8.0:
   version "0.8.0"
-  resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz"
+  resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840"
   integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==
 
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
 js-yaml@4.1.0, js-yaml@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
   integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
   dependencies:
     argparse "^2.0.1"
 
 js-yaml@^3.13.1:
   version "3.14.1"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
   dependencies:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
 jsbi@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/jsbi/-/jsbi-4.3.0.tgz"
-  integrity sha512-SnZNcinB4RIcnEyZqFPdGPVgrg2AcnykiBy0sHVJQKHYeaLUvi3Exj+iaPpLnFVkDPZIV4U0yvgC9/R4uEAZ9g==
-
-jsesc@^2.5.1:
-  version "2.5.2"
-  resolved "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz"
-  integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/jsbi/-/jsbi-4.3.2.tgz#8a4d05d4e09907d73042135b6aa55a6d161ee955"
+  integrity sha512-9fqMSQbhJykSeii05nxKl4m6Eqn2P6rOlYiS+C5Dr/HPIU/7yZxu5qzbs40tgaFORiw2Amd0mirjxatXYMkIew==
 
-jsesc@^3.0.2:
+jsesc@^3.0.2, jsesc@~3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.1.0.tgz#74d335a234f67ed19907fdadfac7ccf9d409825d"
   integrity sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==
 
-jsesc@~0.5.0:
-  version "0.5.0"
-  resolved "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz"
-  integrity sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==
-
 json-buffer@3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13"
   integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
 
 json-parse-even-better-errors@^2.3.0:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
   integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
 
+json-parse-even-better-errors@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-4.0.0.tgz#d3f67bd5925e81d3e31aa466acc821c8375cec43"
+  integrity sha512-lR4MXjGNgkJc7tkQ97kb2nuEMnNCyU//XYVH0MKTGcXEiSudQ5MKGKen3C5QubYy0vmq+JGitUg92uuywGEwIA==
+
 json-pointer@^0.6.1:
   version "0.6.2"
-  resolved "https://registry.npmjs.org/json-pointer/-/json-pointer-0.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/json-pointer/-/json-pointer-0.6.2.tgz#f97bd7550be5e9ea901f8c9264c9d436a22a93cd"
   integrity sha512-vLWcKbOaXlO+jvRy4qNd+TI1QUPZzfJj1tpJ3vAXDych5XJf93ftpUKe5pKCrzyIIwgBJcOcCVRUfqQP25afBw==
   dependencies:
     foreach "^2.0.4"
 
 json-promise@1.1.x:
   version "1.1.8"
-  resolved "https://registry.npmjs.org/json-promise/-/json-promise-1.1.8.tgz"
+  resolved "https://registry.yarnpkg.com/json-promise/-/json-promise-1.1.8.tgz#7b74120422d16ddb449aa3170403fc69ad416402"
   integrity sha512-rz31P/7VfYnjQFrF60zpPTT0egMPlc8ZvIQHWs4ZtNZNnAXRmXo6oS+6eyWr5sEMG03OVhklNrTXxiIRYzoUgQ==
   dependencies:
     bluebird "*"
 
 json-schema-compare@^0.2.2:
   version "0.2.2"
-  resolved "https://registry.npmjs.org/json-schema-compare/-/json-schema-compare-0.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema-compare/-/json-schema-compare-0.2.2.tgz#dd601508335a90c7f4cfadb6b2e397225c908e56"
   integrity sha512-c4WYmDKyJXhs7WWvAWm3uIYnfyWFoIp+JEoX34rctVvEkMYCPGhXtvmFFXiffBbxfZsvQ0RNnV5H7GvDF5HCqQ==
   dependencies:
     lodash "^4.17.4"
 
 json-schema-traverse@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
 json-schema-traverse@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
   integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
 
 json-schema@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5"
   integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
 
 json-stable-stringify-without-jsonify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
   integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
 
+json-stringify-nice@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/json-stringify-nice/-/json-stringify-nice-1.1.4.tgz#2c937962b80181d3f317dd39aa323e14f5a60a67"
+  integrity sha512-5Z5RFW63yxReJ7vANgW6eZFGWaQvnPE3WNmZoOJrSkGju2etKA2L5rrOa1sm877TVTFt57A80BH1bArcmlLfPw==
+
 json5@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.2.tgz#63d98d60f21b313b77c4d6da18bfa69d80e1d593"
   integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==
   dependencies:
     minimist "^1.2.0"
 
 json5@^2.2.3:
   version "2.2.3"
-  resolved "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
   integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
 
 jsonc-parser@~2.2.1:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-2.2.1.tgz#db73cd59d78cce28723199466b2a03d1be1df2bc"
   integrity sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w==
 
 jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.2.0.tgz#7c265bd1b65de6977478300087c99f1c84383f62"
+  integrity sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==
   dependencies:
     universalify "^2.0.0"
   optionalDependencies:
     graceful-fs "^4.1.6"
 
-jsonparse@^1.2.0:
+jsonparse@^1.2.0, jsonparse@^1.3.1:
   version "1.3.1"
-  resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
   integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
 
 "jsx-ast-utils@^2.4.1 || ^3.0.0", jsx-ast-utils@^3.3.5:
   version "3.3.5"
-  resolved "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz"
+  resolved "https://registry.yarnpkg.com/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz#4766bd05a8e2a11af222becd19e15575e52a853a"
   integrity sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==
   dependencies:
     array-includes "^3.1.6"
@@ -10386,16 +11027,26 @@ jsonparse@^1.2.0:
     object.assign "^4.1.4"
     object.values "^1.1.6"
 
+just-diff-apply@^5.2.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/just-diff-apply/-/just-diff-apply-5.5.0.tgz#771c2ca9fa69f3d2b54e7c3f5c1dfcbcc47f9f0f"
+  integrity sha512-OYTthRfSh55WOItVqwpefPtNt2VdKsq5AnAK6apdtR6yCH8pr0CmSr710J0Mf+WdQy7K/OzMy7K2MgAfdQURDw==
+
+just-diff@^6.0.0:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/just-diff/-/just-diff-6.0.2.tgz#03b65908543ac0521caf6d8eb85035f7d27ea285"
+  integrity sha512-S59eriX5u3/QhMNq3v/gm8Kd0w8OS6Tz2FS1NG4blv+z0MuQcBRJyFWjdovM0Rad4/P4aUPFtnkNjMjyMlMSYA==
+
 katex@^0.16.0:
-  version "0.16.21"
-  resolved "https://registry.npmjs.org/katex/-/katex-0.16.21.tgz"
-  integrity sha512-XvqR7FgOHtWupfMiigNzmh+MgUVmDGU2kXZm899ZkPfcuoPuFxyHmXsgATDpFZDAXCI8tvinaVcDo8PIIJSo4A==
+  version "0.16.22"
+  resolved "https://registry.yarnpkg.com/katex/-/katex-0.16.22.tgz#d2b3d66464b1e6d69e6463b28a86ced5a02c5ccd"
+  integrity sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==
   dependencies:
     commander "^8.3.0"
 
 kbar@0.1.0-beta.45:
   version "0.1.0-beta.45"
-  resolved "https://registry.npmjs.org/kbar/-/kbar-0.1.0-beta.45.tgz"
+  resolved "https://registry.yarnpkg.com/kbar/-/kbar-0.1.0-beta.45.tgz#6b0871f2860a7fe21ad4db5df2389cf3b73d344a"
   integrity sha512-kXvjthqPLoWZXlxLJPrFKioskNdQv1O3Ukg5mqq2ExK3Ix1qvYT3W/ACDRIv/e/CHxPWZoTriB4oFbQ6UCSX5g==
   dependencies:
     "@radix-ui/react-portal" "^1.0.1"
@@ -10406,36 +11057,147 @@ kbar@0.1.0-beta.45:
 
 keyv@^4.5.3:
   version "4.5.4"
-  resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.5.4.tgz#a879a99e29452f942439f2a405e3af8b31d4de93"
   integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==
   dependencies:
     json-buffer "3.0.1"
 
 kind-of@^6.0.0, kind-of@^6.0.2, kind-of@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
 language-subtag-registry@^0.3.20:
   version "0.3.23"
-  resolved "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz"
+  resolved "https://registry.yarnpkg.com/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz#23529e04d9e3b74679d70142df3fd2eb6ec572e7"
   integrity sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==
 
 language-tags@^1.0.9:
   version "1.0.9"
-  resolved "https://registry.npmjs.org/language-tags/-/language-tags-1.0.9.tgz"
+  resolved "https://registry.yarnpkg.com/language-tags/-/language-tags-1.0.9.tgz#1ffdcd0ec0fafb4b1be7f8b11f306ad0f9c08777"
   integrity sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==
   dependencies:
     language-subtag-registry "^0.3.20"
 
 levn@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
   integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
   dependencies:
     prelude-ls "^1.2.1"
     type-check "~0.4.0"
 
+libnpmaccess@^9.0.0:
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmaccess/-/libnpmaccess-9.0.0.tgz#47ac12dcd358c2c2f2c9ecb0f081a65ef2cc68bc"
+  integrity sha512-mTCFoxyevNgXRrvgdOhghKJnCWByBc9yp7zX4u9RBsmZjwOYdUDEBfL5DdgD1/8gahsYnauqIWFbq0iK6tO6CQ==
+  dependencies:
+    npm-package-arg "^12.0.0"
+    npm-registry-fetch "^18.0.1"
+
+libnpmdiff@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/libnpmdiff/-/libnpmdiff-7.0.1.tgz#187c6c596b8a7a518f69667b763437b74f0df9a3"
+  integrity sha512-CPcLUr23hLwiil/nAlnMQ/eWSTXPPaX+Qe31di8JvcV2ELbbBueucZHBaXlXruUch6zIlSY6c7JCGNAqKN7yaQ==
+  dependencies:
+    "@npmcli/arborist" "^8.0.1"
+    "@npmcli/installed-package-contents" "^3.0.0"
+    binary-extensions "^2.3.0"
+    diff "^5.1.0"
+    minimatch "^9.0.4"
+    npm-package-arg "^12.0.0"
+    pacote "^19.0.0"
+    tar "^6.2.1"
+
+libnpmexec@^9.0.1:
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/libnpmexec/-/libnpmexec-9.0.1.tgz#a2d0473ec92615f4b187c9e60712220290ec359e"
+  integrity sha512-+SI/x9p0KUkgJdW9L0nDNqtjsFRY3yA5kQKdtGYNMXX4iP/MXQjuXF8MaUAweuV6Awm8plxqn8xCPs2TelZEUg==
+  dependencies:
+    "@npmcli/arborist" "^8.0.1"
+    "@npmcli/run-script" "^9.0.1"
+    ci-info "^4.0.0"
+    npm-package-arg "^12.0.0"
+    pacote "^19.0.0"
+    proc-log "^5.0.0"
+    read "^4.0.0"
+    read-package-json-fast "^4.0.0"
+    semver "^7.3.7"
+    walk-up-path "^3.0.1"
+
+libnpmfund@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/libnpmfund/-/libnpmfund-6.0.1.tgz#49488cf48ccbf2a5d6c90cd292608ab219aece53"
+  integrity sha512-UBbHY9yhhZVffbBpFJq+TsR2KhhEqpQ2mpsIJa6pt0PPQaZ2zgOjvGUYEjURYIGwg2wL1vfQFPeAtmN5w6i3Gg==
+  dependencies:
+    "@npmcli/arborist" "^8.0.1"
+
+libnpmhook@^11.0.0:
+  version "11.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmhook/-/libnpmhook-11.0.0.tgz#b8caf6fe31666d7b18cbf61ce8b722dca1600943"
+  integrity sha512-Xc18rD9NFbRwZbYCQ+UCF5imPsiHSyuQA8RaCA2KmOUo8q4kmBX4JjGWzmZnxZCT8s6vwzmY1BvHNqBGdg9oBQ==
+  dependencies:
+    aproba "^2.0.0"
+    npm-registry-fetch "^18.0.1"
+
+libnpmorg@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmorg/-/libnpmorg-7.0.0.tgz#055dfdba32ac5e8757dd4b264f805b64cbd6980b"
+  integrity sha512-DcTodX31gDEiFrlIHurBQiBlBO6Var2KCqMVCk+HqZhfQXqUfhKGmFOp0UHr6HR1lkTVM0MzXOOYtUObk0r6Dg==
+  dependencies:
+    aproba "^2.0.0"
+    npm-registry-fetch "^18.0.1"
+
+libnpmpack@^8.0.1:
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/libnpmpack/-/libnpmpack-8.0.1.tgz#36db2d8cda841775f3c80187cb332686feab40f2"
+  integrity sha512-E53w3QcldAXg5cG9NpXZcsgNiLw5AEtu7ufGJk6+dxudD0/U5Y6vHIws+CJiI76I9rAidXasKmmS2mwiYDncBw==
+  dependencies:
+    "@npmcli/arborist" "^8.0.1"
+    "@npmcli/run-script" "^9.0.1"
+    npm-package-arg "^12.0.0"
+    pacote "^19.0.0"
+
+libnpmpublish@^10.0.1:
+  version "10.0.1"
+  resolved "https://registry.yarnpkg.com/libnpmpublish/-/libnpmpublish-10.0.1.tgz#7a284565be164c2f8605225213316a0c1d0a9827"
+  integrity sha512-xNa1DQs9a8dZetNRV0ky686MNzv1MTqB3szgOlRR3Fr24x1gWRu7aB9OpLZsml0YekmtppgHBkyZ+8QZlzmEyw==
+  dependencies:
+    ci-info "^4.0.0"
+    normalize-package-data "^7.0.0"
+    npm-package-arg "^12.0.0"
+    npm-registry-fetch "^18.0.1"
+    proc-log "^5.0.0"
+    semver "^7.3.7"
+    sigstore "^3.0.0"
+    ssri "^12.0.0"
+
+libnpmsearch@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmsearch/-/libnpmsearch-8.0.0.tgz#ce2e28ad05a152c736d5ae86356aedd5a52406a5"
+  integrity sha512-W8FWB78RS3Nkl1gPSHOlF024qQvcoU/e3m9BGDuBfVZGfL4MJ91GXXb04w3zJCGOW9dRQUyWVEqupFjCrgltDg==
+  dependencies:
+    npm-registry-fetch "^18.0.1"
+
+libnpmteam@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmteam/-/libnpmteam-7.0.0.tgz#e8f40c4bc543b720da2cdd4385e2fafcd06c92c0"
+  integrity sha512-PKLOoVukN34qyJjgEm5DEOnDwZkeVMUHRx8NhcKDiCNJGPl7G/pF1cfBw8yicMwRlHaHkld1FdujOzKzy4AlwA==
+  dependencies:
+    aproba "^2.0.0"
+    npm-registry-fetch "^18.0.1"
+
+libnpmversion@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/libnpmversion/-/libnpmversion-7.0.0.tgz#b264a07662b31b78822ba870171088eca6466f38"
+  integrity sha512-0xle91R6F8r/Q/4tHOnyKko+ZSquEXNdxwRdKCPv4kC1cOVBMFXRsKKrVtRKtXcFn362U8ZlJefk4Apu00424g==
+  dependencies:
+    "@npmcli/git" "^6.0.1"
+    "@npmcli/run-script" "^9.0.1"
+    json-parse-even-better-errors "^4.0.0"
+    proc-log "^5.0.0"
+    semver "^7.3.7"
+
 lie@3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/lie/-/lie-3.1.1.tgz#9a436b2cc7746ca59de7a41fa469b3efb76bd87e"
@@ -10443,46 +11205,41 @@ lie@3.1.1:
   dependencies:
     immediate "~3.0.5"
 
-lilconfig@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz"
-  integrity sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==
-
-lilconfig@^3.0.0, lilconfig@~3.1.2:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.2.tgz"
-  integrity sha512-eop+wDAvpItUys0FWkHIKeC9ybYrTGbU41U5K7+bttZZeohvnY7M9dZ5kB21GNWiFT2q1OoPTvncPCgSOVO5ow==
+lilconfig@^3.0.0, lilconfig@^3.1.3:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-3.1.3.tgz#a1bcfd6257f9585bf5ae14ceeebb7b559025e4c4"
+  integrity sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==
 
 lines-and-columns@^1.1.6:
   version "1.2.4"
-  resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
+  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
   integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
 
 lint-staged@^15.2.10:
-  version "15.2.10"
-  resolved "https://registry.npmjs.org/lint-staged/-/lint-staged-15.2.10.tgz"
-  integrity sha512-5dY5t743e1byO19P9I4b3x8HJwalIznL5E1FWYnU6OWw33KxNBSLAc6Cy7F2PsFEO8FKnLwjwm5hx7aMF0jzZg==
-  dependencies:
-    chalk "~5.3.0"
-    commander "~12.1.0"
-    debug "~4.3.6"
-    execa "~8.0.1"
-    lilconfig "~3.1.2"
-    listr2 "~8.2.4"
-    micromatch "~4.0.8"
-    pidtree "~0.6.0"
-    string-argv "~0.3.2"
-    yaml "~2.5.0"
+  version "15.5.2"
+  resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-15.5.2.tgz#beff028fd0681f7db26ffbb67050a21ed4d059a3"
+  integrity sha512-YUSOLq9VeRNAo/CTaVmhGDKG+LBtA8KF1X4K5+ykMSwWST1vDxJRB2kv2COgLb1fvpCo+A/y9A0G0znNVmdx4w==
+  dependencies:
+    chalk "^5.4.1"
+    commander "^13.1.0"
+    debug "^4.4.0"
+    execa "^8.0.1"
+    lilconfig "^3.1.3"
+    listr2 "^8.2.5"
+    micromatch "^4.0.8"
+    pidtree "^0.6.0"
+    string-argv "^0.3.2"
+    yaml "^2.7.0"
 
 liquid-json@0.3.1:
   version "0.3.1"
-  resolved "https://registry.npmjs.org/liquid-json/-/liquid-json-0.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/liquid-json/-/liquid-json-0.3.1.tgz#9155a18136d8a6b2615e5f16f9a2448ab6b50eea"
   integrity sha512-wUayTU8MS827Dam6MxgD72Ui+KOSF+u/eIqpatOtjnvgJ0+mnDq33uC2M7J0tPK+upe/DpUAuK4JUU89iBoNKQ==
 
-listr2@~8.2.4:
-  version "8.2.5"
-  resolved "https://registry.npmjs.org/listr2/-/listr2-8.2.5.tgz"
-  integrity sha512-iyAZCeyD+c1gPyE9qpFu8af0Y+MRtmKOncdGoA2S5EY8iFq99dmmvkNnHiWo+pj0s7yH7l3KPIgee77tKpXPWQ==
+listr2@^8.2.5:
+  version "8.3.3"
+  resolved "https://registry.yarnpkg.com/listr2/-/listr2-8.3.3.tgz#815fc8f738260ff220981bf9e866b3e11e8121bf"
+  integrity sha512-LWzX2KsqcB1wqQ4AHgYb4RsDXauQiqhjLk+6hjbaeHG4zpjjVAB6wC/gz6X0l+Du1cN3pUB5ZlrvTbhGSNnUQQ==
   dependencies:
     cli-truncate "^4.0.0"
     colorette "^2.0.20"
@@ -10491,30 +11248,30 @@ listr2@~8.2.4:
     rfdc "^1.4.1"
     wrap-ansi "^9.0.0"
 
-lit-element@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/lit-element/-/lit-element-4.1.0.tgz"
-  integrity sha512-gSejRUQJuMQjV2Z59KAS/D4iElUhwKpIyJvZ9w+DIagIQjfJnhR20h2Q5ddpzXGS+fF0tMZ/xEYGMnKmaI/iww==
+lit-element@^4.2.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/lit-element/-/lit-element-4.2.1.tgz#0a3782f36eaa545862fe07f84abcb14b2903a042"
+  integrity sha512-WGAWRGzirAgyphK2urmYOV72tlvnxw7YfyLDgQ+OZnM9vQQBQnumQ7jUJe6unEzwGU3ahFOjuz1iz1jjrpCPuw==
   dependencies:
-    "@lit-labs/ssr-dom-shim" "^1.2.0"
-    "@lit/reactive-element" "^2.0.4"
-    lit-html "^3.2.0"
+    "@lit-labs/ssr-dom-shim" "^1.4.0"
+    "@lit/reactive-element" "^2.1.0"
+    lit-html "^3.3.0"
 
-lit-html@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/lit-html/-/lit-html-3.2.0.tgz"
-  integrity sha512-pwT/HwoxqI9FggTrYVarkBKFN9MlTUpLrDHubTmW4SrkL3kkqW5gxwbxMMUnbbRHBC0WTZnYHcjDSCM559VyfA==
+lit-html@^3.3.0:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/lit-html/-/lit-html-3.3.1.tgz#f0a7e4b9ea0a1d034eb28a4bf2d1b0a0096253e3"
+  integrity sha512-S9hbyDu/vs1qNrithiNyeyv64c9yqiW9l+DBgI18fL+MTvOtWoFR0FWiyq1TxaYef5wNlpEmzlXoBlZEO+WjoA==
   dependencies:
     "@types/trusted-types" "^2.0.2"
 
-lit@^3.1.2:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/lit/-/lit-3.2.0.tgz"
-  integrity sha512-s6tI33Lf6VpDu7u4YqsSX78D28bYQulM+VAzsGch4fx2H0eLZnJsUBsPWmGYSGoKDNbjtRv02rio1o+UdPVwvw==
+lit@^3.2.1:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/lit/-/lit-3.3.1.tgz#9dc79be626bc9a3b824de98b107dd662cabdeda6"
+  integrity sha512-Ksr/8L3PTapbdXJCk+EJVB78jDodUMaP54gD24W186zGRARvwrsPfS60wae/SSCTCNZVPd1chXqio1qHQmu4NA==
   dependencies:
-    "@lit/reactive-element" "^2.0.4"
-    lit-element "^4.1.0"
-    lit-html "^3.2.0"
+    "@lit/reactive-element" "^2.1.0"
+    lit-element "^4.2.0"
+    lit-html "^3.3.0"
 
 localforage@^1.8.1:
   version "1.10.0"
@@ -10525,106 +11282,86 @@ localforage@^1.8.1:
 
 locate-path@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
   integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
   dependencies:
     p-locate "^4.1.0"
 
 locate-path@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
   integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
   dependencies:
     p-locate "^5.0.0"
 
 lodash.camelcase@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
   integrity sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==
 
-lodash.castarray@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz"
-  integrity sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==
-
 lodash.debounce@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
   integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==
 
-lodash.foreach@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.foreach/-/lodash.foreach-4.5.0.tgz"
-  integrity sha512-aEXTF4d+m05rVOAUG3z4vZZ4xVexLKZGF0lIxuHZ1Hplpk/3B6Z1+/ICICYRLm7c41Z2xiejbkCkJoTlypoXhQ==
-
 lodash.get@^4.4.2:
   version "4.4.2"
-  resolved "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
   integrity sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==
 
 lodash.isfunction@^3.0.9:
   version "3.0.9"
-  resolved "https://registry.npmjs.org/lodash.isfunction/-/lodash.isfunction-3.0.9.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.isfunction/-/lodash.isfunction-3.0.9.tgz#06de25df4db327ac931981d1bdb067e5af68d051"
   integrity sha512-AirXNj15uRIMMPihnkInB4i3NHeb4iBtNg9WRWuK2o31S+ePwwNmDPaTL3o7dTJ+VXNZim7rFs4rxN4YU1oUJw==
 
 lodash.isplainobject@^4.0.6:
   version "4.0.6"
-  resolved "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb"
   integrity sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==
 
 lodash.kebabcase@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz#8489b1cb0d29ff88195cceca448ff6d6cc295c36"
   integrity sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==
 
-lodash.mapkeys@^4.6.0:
-  version "4.6.0"
-  resolved "https://registry.npmjs.org/lodash.mapkeys/-/lodash.mapkeys-4.6.0.tgz"
-  integrity sha512-0Al+hxpYvONWtg+ZqHpa/GaVzxuN3V7Xeo2p+bY06EaK/n+Y9R7nBePPN2o1LxmL0TWQSwP8LYZ008/hc9JzhA==
-
 lodash.merge@^4.6.2:
   version "4.6.2"
-  resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
   integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
 
 lodash.mergewith@^4.6.2:
   version "4.6.2"
-  resolved "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz#617121f89ac55f59047c7aec1ccd6654c6590f55"
   integrity sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==
 
-lodash.omit@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.omit/-/lodash.omit-4.5.0.tgz"
-  integrity sha512-XeqSp49hNGmlkj2EJlfrQFIzQ6lXdNro9sddtQzcJY8QaoC2GO0DT7xaIokHeyM+mIT0mPMlPvkYzg2xCuHdZg==
-
 lodash.snakecase@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz#39d714a35357147837aefd64b5dcbb16becd8f8d"
   integrity sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==
 
 lodash.startcase@^4.4.0:
   version "4.4.0"
-  resolved "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.startcase/-/lodash.startcase-4.4.0.tgz#9436e34ed26093ed7ffae1936144350915d9add8"
   integrity sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==
 
 lodash.uniq@^4.5.0:
   version "4.5.0"
-  resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
   integrity sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==
 
 lodash.upperfirst@^4.3.1:
   version "4.3.1"
-  resolved "https://registry.npmjs.org/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz#1365edf431480481ef0d1c68957a5ed99d49f7ce"
   integrity sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==
 
 lodash@4.17.21, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21, lodash@^4.17.4:
   version "4.17.21"
-  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 
 log-update@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/log-update/-/log-update-6.1.0.tgz#1a04ff38166f94647ae1af562f4bd6a15b1b7cd4"
   integrity sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==
   dependencies:
     ansi-escapes "^7.0.0"
@@ -10634,56 +11371,56 @@ log-update@^6.1.0:
     wrap-ansi "^9.0.0"
 
 long@^5.0.0:
-  version "5.2.3"
-  resolved "https://registry.npmjs.org/long/-/long-5.2.3.tgz"
-  integrity sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==
+  version "5.3.2"
+  resolved "https://registry.yarnpkg.com/long/-/long-5.3.2.tgz#1d84463095999262d7d7b7f8bfd4a8cc55167f83"
+  integrity sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==
 
 longest-streak@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/longest-streak/-/longest-streak-2.0.4.tgz#b8599957da5b5dab64dee3fe316fa774597d90e4"
   integrity sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg==
 
 longest-streak@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/longest-streak/-/longest-streak-3.1.0.tgz#62fa67cd958742a1574af9f39866364102d90cd4"
   integrity sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==
 
 loose-envify@^1.1.0, loose-envify@^1.2.0, loose-envify@^1.3.1, loose-envify@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
   integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
 lower-case@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
   integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
   dependencies:
     tslib "^2.0.3"
 
-lru-cache@^10.2.0:
+lru-cache@^10.0.1, lru-cache@^10.2.0, lru-cache@^10.2.2:
   version "10.4.3"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-10.4.3.tgz#410fc8a17b70e598013df257c2446b7f3383f119"
   integrity sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==
 
 lru-cache@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
   integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
   dependencies:
     yallist "^3.0.2"
 
 lru-cache@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
   integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
   dependencies:
     yallist "^4.0.0"
 
 lucide-react@^0.445.0:
   version "0.445.0"
-  resolved "https://registry.npmjs.org/lucide-react/-/lucide-react-0.445.0.tgz"
+  resolved "https://registry.yarnpkg.com/lucide-react/-/lucide-react-0.445.0.tgz#35c42341e98fbf0475b2a6cf74fd25ef7cbfcd62"
   integrity sha512-YrLf3aAHvmd4dZ8ot+mMdNFrFpJD7YRwQ2pUcBhgqbmxtrMP4xDzIorcj+8y+6kpuXBF4JB0NOCTUWIYetJjgA==
 
 lucide-react@^0.468.0:
@@ -10693,7 +11430,7 @@ lucide-react@^0.468.0:
 
 magic-error@0.0.1:
   version "0.0.1"
-  resolved "https://registry.npmjs.org/magic-error/-/magic-error-0.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/magic-error/-/magic-error-0.0.1.tgz#95ebe658ca4a86f1aebda390cab6ea50d41bfa2a"
   integrity sha512-1+N1ET8cbC5bfLQZcRojClzgK2gbUt9keTMr9OJeuXnQKWsfwRRRICuMA3HKaCIXFEgKzxivuMGCNKD7cdU5pg==
 
 magic-string@0.30.8:
@@ -10704,60 +11441,77 @@ magic-string@0.30.8:
     "@jridgewell/sourcemap-codec" "^1.4.15"
 
 magic-string@^0.30.3:
-  version "0.30.18"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.18.tgz#905bfbbc6aa5692703a93db26a9edcaa0007d2bb"
-  integrity sha512-yi8swmWbO17qHhwIBNeeZxTceJMeBvWJaId6dyvTSOwTipqeHhMhOrz6513r1sOKnpvQ7zkhlG8tPrpilwTxHQ==
+  version "0.30.19"
+  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.19.tgz#cebe9f104e565602e5d2098c5f2e79a77cc86da9"
+  integrity sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==
   dependencies:
     "@jridgewell/sourcemap-codec" "^1.5.5"
 
 make-error@^1.1.1:
   version "1.3.6"
-  resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz"
+  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
 
+make-fetch-happen@^14.0.0, make-fetch-happen@^14.0.2, make-fetch-happen@^14.0.3:
+  version "14.0.3"
+  resolved "https://registry.yarnpkg.com/make-fetch-happen/-/make-fetch-happen-14.0.3.tgz#d74c3ecb0028f08ab604011e0bc6baed483fcdcd"
+  integrity sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ==
+  dependencies:
+    "@npmcli/agent" "^3.0.0"
+    cacache "^19.0.1"
+    http-cache-semantics "^4.1.1"
+    minipass "^7.0.2"
+    minipass-fetch "^4.0.0"
+    minipass-flush "^1.0.5"
+    minipass-pipeline "^1.2.4"
+    negotiator "^1.0.0"
+    proc-log "^5.0.0"
+    promise-retry "^2.0.1"
+    ssri "^12.0.0"
+
 map-obj@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
   integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==
 
 map-obj@^4.0.0:
   version "4.3.0"
-  resolved "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
   integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
 
 markdown-extensions@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/markdown-extensions/-/markdown-extensions-2.0.0.tgz#34bebc83e9938cae16e0e017e4a9814a8330d3c4"
   integrity sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==
 
 markdown-table@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/markdown-table/-/markdown-table-2.0.0.tgz#194a90ced26d31fe753d8b9434430214c011865b"
   integrity sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A==
   dependencies:
     repeat-string "^1.0.0"
 
 markdown-table@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.3.tgz"
-  integrity sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/markdown-table/-/markdown-table-3.0.4.tgz#fe44d6d410ff9d6f2ea1797a3f60aa4d2b631c2a"
+  integrity sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==
 
 match-sorter@^6.0.2:
-  version "6.3.4"
-  resolved "https://registry.npmjs.org/match-sorter/-/match-sorter-6.3.4.tgz"
-  integrity sha512-jfZW7cWS5y/1xswZo8VBOdudUiSd9nifYRWphc9M5D/ee4w4AoXLgBEdRbgVaxbMuagBPeUC5y2Hi8DO6o9aDg==
+  version "6.4.0"
+  resolved "https://registry.yarnpkg.com/match-sorter/-/match-sorter-6.4.0.tgz#ae9c166cb3c9efd337690b3160c0e28cb8377c13"
+  integrity sha512-d4664ahzdL1QTTvmK1iI0JsrxWeJ6gn33qkYtnPg3mcn+naBLtXSgSPOe+X2vUgtgGwaAk3eiaj7gwKjjMAq+Q==
   dependencies:
     "@babel/runtime" "^7.23.8"
     remove-accents "0.5.0"
 
 math-intrinsics@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz#a0dd74be81e2aa5c2f27e65ce283605ee4e2b7f9"
   integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==
 
 mdast-util-definitions@^5.0.0:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-definitions/-/mdast-util-definitions-5.1.2.tgz#9910abb60ac5d7115d6819b57ae0bcef07a3f7a7"
   integrity sha512-8SVPMuHqlPME/z3gqVwWY4zVXn8lqKv/pAhC57FuJ40ImXyBpmO5ukh98zB2v7Blql2FiHjHv9LVztSIqjY+MA==
   dependencies:
     "@types/mdast" "^3.0.0"
@@ -10766,7 +11520,7 @@ mdast-util-definitions@^5.0.0:
 
 mdast-util-find-and-replace@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-find-and-replace/-/mdast-util-find-and-replace-1.1.1.tgz#b7db1e873f96f66588c321f1363069abf607d1b5"
   integrity sha512-9cKl33Y21lyckGzpSmEQnIDjEfeeWelN5s1kUW1LwdB0Fkuq2u+4GdqcGEygYxJE8GVqCl0741bYXHgamfWAZA==
   dependencies:
     escape-string-regexp "^4.0.0"
@@ -10774,9 +11528,9 @@ mdast-util-find-and-replace@^1.1.0:
     unist-util-visit-parents "^3.0.0"
 
 mdast-util-find-and-replace@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.1.tgz"
-  integrity sha512-SG21kZHGC3XRTSUhtofZkBzZTJNM5ecCi0SK2IMKmSXR8vO3peL+kb1O0z7Zl83jKtutG4k5Wv/W7V3/YHvzPA==
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz#70a3174c894e14df722abf43bc250cbae44b11df"
+  integrity sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==
   dependencies:
     "@types/mdast" "^4.0.0"
     escape-string-regexp "^5.0.0"
@@ -10785,7 +11539,7 @@ mdast-util-find-and-replace@^3.0.0:
 
 mdast-util-from-markdown@^0.8.0:
   version "0.8.5"
-  resolved "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-0.8.5.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-from-markdown/-/mdast-util-from-markdown-0.8.5.tgz#d1ef2ca42bc377ecb0463a987910dae89bd9a28c"
   integrity sha512-2hkTXtYYnr+NubD/g6KGBS/0mFmBcifAsI0yIWRiRo0PjVs6SSOSOdtzbp6kSGnShDN6G5aWZpKQ2lWRy27mWQ==
   dependencies:
     "@types/mdast" "^3.0.0"
@@ -10795,9 +11549,9 @@ mdast-util-from-markdown@^0.8.0:
     unist-util-stringify-position "^2.0.0"
 
 mdast-util-from-markdown@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.1.tgz"
-  integrity sha512-aJEUyzZ6TzlsX2s5B4Of7lN7EQtAxvtradMMglCQDyaTFgse6CmtmdJ15ElnVRlCg1vpNyVtbem0PWzlNieZsA==
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz#4850390ca7cf17413a9b9a0fbefcd1bc0eb4160a"
+  integrity sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==
   dependencies:
     "@types/mdast" "^4.0.0"
     "@types/unist" "^3.0.0"
@@ -10814,14 +11568,14 @@ mdast-util-from-markdown@^2.0.0:
 
 mdast-util-frontmatter@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-frontmatter/-/mdast-util-frontmatter-0.2.0.tgz#8bd5cd55e236c03e204a036f7372ebe9e6748240"
   integrity sha512-FHKL4w4S5fdt1KjJCwB0178WJ0evnyyQr5kXTM3wrOVpytD0hrkvd+AOOjU9Td8onOejCkmZ+HQRT3CZ3coHHQ==
   dependencies:
     micromark-extension-frontmatter "^0.2.0"
 
 mdast-util-frontmatter@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-frontmatter/-/mdast-util-frontmatter-2.0.1.tgz#f5f929eb1eb36c8a7737475c7eb438261f964ee8"
   integrity sha512-LRqI9+wdgC25P0URIJY9vwocIzCcksduHQ9OF2joxQoyTNVduwLAFUzjoopuRJbJAReaKrNQKAZKL3uCMugWJA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -10833,7 +11587,7 @@ mdast-util-frontmatter@^2.0.0:
 
 mdast-util-gfm-autolink-literal@^0.1.0:
   version "0.1.3"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-0.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-0.1.3.tgz#9c4ff399c5ddd2ece40bd3b13e5447d84e385fb7"
   integrity sha512-GjmLjWrXg1wqMIO9+ZsRik/s7PLwTaeCHVB7vRxUwLntZc8mzmTsLVr6HW1yLokcnhfURsn5zmSVdi3/xWWu1A==
   dependencies:
     ccount "^1.0.0"
@@ -10842,7 +11596,7 @@ mdast-util-gfm-autolink-literal@^0.1.0:
 
 mdast-util-gfm-autolink-literal@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz#abd557630337bd30a6d5a4bd8252e1c2dc0875d5"
   integrity sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -10852,9 +11606,9 @@ mdast-util-gfm-autolink-literal@^2.0.0:
     micromark-util-character "^2.0.0"
 
 mdast-util-gfm-footnote@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.0.0.tgz"
-  integrity sha512-5jOT2boTSVkMnQ7LTrd6n/18kqwjmuYqo7JUPe+tRCY6O7dAuTFMtTPauYYrMPpox9hlN0uOx/FL8XvEfG9/mQ==
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz#7778e9d9ca3df7238cc2bd3fa2b1bf6a65b19403"
+  integrity sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==
   dependencies:
     "@types/mdast" "^4.0.0"
     devlop "^1.1.0"
@@ -10864,14 +11618,14 @@ mdast-util-gfm-footnote@^2.0.0:
 
 mdast-util-gfm-strikethrough@^0.2.0:
   version "0.2.3"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-0.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-0.2.3.tgz#45eea337b7fff0755a291844fbea79996c322890"
   integrity sha512-5OQLXpt6qdbttcDG/UxYY7Yjj3e8P7X16LzvpX8pIQPYJ/C2Z1qFGMmcw+1PZMUM3Z8wt8NRfYTvCni93mgsgA==
   dependencies:
     mdast-util-to-markdown "^0.6.0"
 
 mdast-util-gfm-strikethrough@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz#d44ef9e8ed283ac8c1165ab0d0dfd058c2764c16"
   integrity sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -10880,7 +11634,7 @@ mdast-util-gfm-strikethrough@^2.0.0:
 
 mdast-util-gfm-table@^0.1.0:
   version "0.1.6"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-0.1.6.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-table/-/mdast-util-gfm-table-0.1.6.tgz#af05aeadc8e5ee004eeddfb324b2ad8c029b6ecf"
   integrity sha512-j4yDxQ66AJSBwGkbpFEp9uG/LS1tZV3P33fN1gkyRB2LoRL+RR3f76m0HPHaby6F4Z5xr9Fv1URmATlRRUIpRQ==
   dependencies:
     markdown-table "^2.0.0"
@@ -10888,7 +11642,7 @@ mdast-util-gfm-table@^0.1.0:
 
 mdast-util-gfm-table@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz#7a435fb6223a72b0862b33afbd712b6dae878d38"
   integrity sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -10899,14 +11653,14 @@ mdast-util-gfm-table@^2.0.0:
 
 mdast-util-gfm-task-list-item@^0.1.0:
   version "0.1.6"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-0.1.6.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-0.1.6.tgz#70c885e6b9f543ddd7e6b41f9703ee55b084af10"
   integrity sha512-/d51FFIfPsSmCIRNp7E6pozM9z1GYPIkSy1urQ8s/o4TC22BZ7DqfHFWiqBD23bc7J3vV1Fc9O4QIHBlfuit8A==
   dependencies:
     mdast-util-to-markdown "~0.6.0"
 
 mdast-util-gfm-task-list-item@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz#e68095d2f8a4303ef24094ab642e1047b991a936"
   integrity sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -10916,7 +11670,7 @@ mdast-util-gfm-task-list-item@^2.0.0:
 
 mdast-util-gfm@^0.1.0:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm/-/mdast-util-gfm-0.1.2.tgz#8ecddafe57d266540f6881f5c57ff19725bd351c"
   integrity sha512-NNkhDx/qYcuOWB7xHUGWZYVXvjPFFd6afg6/e2g+SV4r9q5XUcCbV4Wfa3DLYIiD+xAEZc6K4MGaE/m0KDcPwQ==
   dependencies:
     mdast-util-gfm-autolink-literal "^0.1.0"
@@ -10926,9 +11680,9 @@ mdast-util-gfm@^0.1.0:
     mdast-util-to-markdown "^0.6.1"
 
 mdast-util-gfm@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.0.0.tgz"
-  integrity sha512-dgQEX5Amaq+DuUqf26jJqSK9qgixgd6rYDHAv4aTBuA92cTknZlKpPfa86Z/s8Dj8xsAQpFfBmPUHWJBWqS4Bw==
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz#2cdf63b92c2a331406b0fb0db4c077c1b0331751"
+  integrity sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==
   dependencies:
     mdast-util-from-markdown "^2.0.0"
     mdast-util-gfm-autolink-literal "^2.0.0"
@@ -10940,7 +11694,7 @@ mdast-util-gfm@^3.0.0:
 
 mdast-util-math@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-math/-/mdast-util-math-3.0.0.tgz#8d79dd3baf8ab8ac781f62b8853768190b9a00b0"
   integrity sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -10953,7 +11707,7 @@ mdast-util-math@^3.0.0:
 
 mdast-util-mdx-expression@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz#43f0abac9adc756e2086f63822a38c8d3c3a5096"
   integrity sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -10964,9 +11718,9 @@ mdast-util-mdx-expression@^2.0.0:
     mdast-util-to-markdown "^2.0.0"
 
 mdast-util-mdx-jsx@^3.0.0:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz"
-  integrity sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz#fd04c67a2a7499efb905a8a5c578dddc9fdada0d"
+  integrity sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
     "@types/hast" "^3.0.0"
@@ -10983,7 +11737,7 @@ mdast-util-mdx-jsx@^3.0.0:
 
 mdast-util-mdx@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz#792f9cf0361b46bee1fdf1ef36beac424a099c41"
   integrity sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==
   dependencies:
     mdast-util-from-markdown "^2.0.0"
@@ -10994,7 +11748,7 @@ mdast-util-mdx@^3.0.0:
 
 mdast-util-mdxjs-esm@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz#019cfbe757ad62dd557db35a695e7314bcc9fa97"
   integrity sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==
   dependencies:
     "@types/estree-jsx" "^1.0.0"
@@ -11006,7 +11760,7 @@ mdast-util-mdxjs-esm@^2.0.0:
 
 mdast-util-phrasing@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz#7cc0a8dec30eaf04b7b1a9661a92adb3382aa6e3"
   integrity sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -11014,7 +11768,7 @@ mdast-util-phrasing@^4.0.0:
 
 mdast-util-to-hast@^11.1.1:
   version "11.3.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-11.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-11.3.0.tgz#ea9220617a710e80aa5cc3ac7cc9d4bb0440ae7a"
   integrity sha512-4o3Cli3hXPmm1LhB+6rqhfsIUBjnKFlIUZvudaermXB+4/KONdd/W4saWWkC+LBLbPMqhFSSTSRgafHsT5fVJw==
   dependencies:
     "@types/hast" "^2.0.0"
@@ -11029,7 +11783,7 @@ mdast-util-to-hast@^11.1.1:
 
 mdast-util-to-hast@^13.0.0:
   version "13.2.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz#5ca58e5b921cc0a3ded1bc02eed79a4fe4fe41f4"
   integrity sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -11044,7 +11798,7 @@ mdast-util-to-hast@^13.0.0:
 
 mdast-util-to-markdown@^0.6.0, mdast-util-to-markdown@^0.6.1, mdast-util-to-markdown@~0.6.0:
   version "0.6.5"
-  resolved "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-0.6.5.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-markdown/-/mdast-util-to-markdown-0.6.5.tgz#b33f67ca820d69e6cc527a93d4039249b504bebe"
   integrity sha512-XeV9sDE7ZlOQvs45C9UKMtfTcctcaj/pGwH8YLbMHoMOXNNCn2LsqVQOqrF1+/NU8lKDAqozme9SCXWyo9oAcQ==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -11055,61 +11809,62 @@ mdast-util-to-markdown@^0.6.0, mdast-util-to-markdown@^0.6.1, mdast-util-to-mark
     zwitch "^1.0.0"
 
 mdast-util-to-markdown@^2.0.0, mdast-util-to-markdown@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.0.tgz"
-  integrity sha512-SR2VnIEdVNCJbP6y7kVTJgPLifdr8WEU440fQec7qHoHOUz/oJ2jmNRqdDQ3rbiStOXb2mCDGTuwsK5OPUgYlQ==
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz#f910ffe60897f04bb4b7e7ee434486f76288361b"
+  integrity sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==
   dependencies:
     "@types/mdast" "^4.0.0"
     "@types/unist" "^3.0.0"
     longest-streak "^3.0.0"
     mdast-util-phrasing "^4.0.0"
     mdast-util-to-string "^4.0.0"
+    micromark-util-classify-character "^2.0.0"
     micromark-util-decode-string "^2.0.0"
     unist-util-visit "^5.0.0"
     zwitch "^2.0.0"
 
 mdast-util-to-string@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-2.0.0.tgz#b8cfe6a713e1091cb5b728fc48885a4767f8b97b"
   integrity sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w==
 
 mdast-util-to-string@^3.1.0:
   version "3.2.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-3.2.0.tgz#66f7bb6324756741c5f47a53557f0cbf16b6f789"
   integrity sha512-V4Zn/ncyN1QNSqSBxTrMOLpjr+IKdHl2v3KVLoWmDPscP4r9GcCi71gjgvUV1SFSKh92AjAG4peFuBl2/YgCJg==
   dependencies:
     "@types/mdast" "^3.0.0"
 
 mdast-util-to-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz#7a5121475556a04e7eddeb67b264aae79d312814"
   integrity sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==
   dependencies:
     "@types/mdast" "^4.0.0"
 
 mdn-data@2.0.14:
   version "2.0.14"
-  resolved "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.14.tgz#7113fc4281917d63ce29b43446f701e68c25ba50"
   integrity sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==
 
 mdn-data@2.0.28:
   version "2.0.28"
-  resolved "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.28.tgz#5ec48e7bef120654539069e1ae4ddc81ca490eba"
   integrity sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==
 
 mdn-data@2.0.30:
   version "2.0.30"
-  resolved "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz"
+  resolved "https://registry.yarnpkg.com/mdn-data/-/mdn-data-2.0.30.tgz#ce4df6f80af6cfbe218ecd5c552ba13c4dfa08cc"
   integrity sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==
 
 mdurl@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e"
   integrity sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==
 
 mdx-bundler@^10.1.1:
   version "10.1.1"
-  resolved "https://registry.npmjs.org/mdx-bundler/-/mdx-bundler-10.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/mdx-bundler/-/mdx-bundler-10.1.1.tgz#72f012ac525a3de97302fe97ccc696a944f5dcb9"
   integrity sha512-87FtxC7miUPznwqEaAlJARinHJ6Qin9kDuG2E2BCCNEOszr62kHpqivI/IF/CmwObVSpvApVFFxN1ftM/Gykvw==
   dependencies:
     "@babel/runtime" "^7.23.2"
@@ -11124,22 +11879,24 @@ mdx-bundler@^10.1.1:
 
 media-typer@0.3.0:
   version "0.3.0"
-  resolved "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
   integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==
 
 memfs@^4.8.2:
-  version "4.12.0"
-  resolved "https://registry.npmjs.org/memfs/-/memfs-4.12.0.tgz"
-  integrity sha512-74wDsex5tQDSClVkeK1vtxqYCAgCoXxx+K4NSHzgU/muYVYByFqa+0RnrPO9NM6naWm1+G9JmZ0p6QHhXmeYfA==
-  dependencies:
-    "@jsonjoy.com/json-pack" "^1.0.3"
-    "@jsonjoy.com/util" "^1.3.0"
-    tree-dump "^1.0.1"
+  version "4.47.0"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-4.47.0.tgz#410291da6dcce89a0d6c9cab23b135231a5ed44c"
+  integrity sha512-Xey8IZA57tfotV/TN4d6BmccQuhFP+CqRiI7TTNdipZdZBzF2WnzUcH//Cudw6X4zJiUbo/LTuU/HPA/iC/pNg==
+  dependencies:
+    "@jsonjoy.com/json-pack" "^1.11.0"
+    "@jsonjoy.com/util" "^1.9.0"
+    glob-to-regex.js "^1.0.1"
+    thingies "^2.5.0"
+    tree-dump "^1.0.3"
     tslib "^2.0.0"
 
 meow@^8.0.0, meow@^8.1.2:
   version "8.1.2"
-  resolved "https://registry.npmjs.org/meow/-/meow-8.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/meow/-/meow-8.1.2.tgz#bcbe45bda0ee1729d350c03cffc8395a36c4e897"
   integrity sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==
   dependencies:
     "@types/minimist" "^1.2.0"
@@ -11156,23 +11913,23 @@ meow@^8.0.0, meow@^8.1.2:
 
 merge-stream@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
   integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
 
 merge2@^1.3.0, merge2@^1.4.1:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
 methods@^1.1.1:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
   integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==
 
 micromark-core-commonmark@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.1.tgz"
-  integrity sha512-CUQyKr1e///ZODyD1U3xit6zXwy1a8q2a1S1HKtIlmgvurrEpaw/Y9y6KSIbF8P59cn/NjzHyO+Q2fAyYLQrAA==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz#c691630e485021a68cf28dbc2b2ca27ebf678cd4"
+  integrity sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==
   dependencies:
     decode-named-character-reference "^1.0.0"
     devlop "^1.0.0"
@@ -11193,14 +11950,14 @@ micromark-core-commonmark@^2.0.0:
 
 micromark-extension-frontmatter@^0.2.0:
   version "0.2.2"
-  resolved "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-0.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-frontmatter/-/micromark-extension-frontmatter-0.2.2.tgz#61b8e92e9213e1d3c13f5a59e7862f5ca98dfa53"
   integrity sha512-q6nPLFCMTLtfsctAuS0Xh4vaolxSFUWUWR6PZSrXXiRy+SANGllpcqdXFv2z07l0Xz/6Hl40hK0ffNCJPH2n1A==
   dependencies:
     fault "^1.0.0"
 
 micromark-extension-frontmatter@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-frontmatter/-/micromark-extension-frontmatter-2.0.0.tgz#651c52ffa5d7a8eeed687c513cd869885882d67a"
   integrity sha512-C4AkuM3dA58cgZha7zVnuVxBhDsbttIMiytjgsM2XbHAB2faRVaHRle40558FBN+DJcrLNCoqG5mlrpdU4cRtg==
   dependencies:
     fault "^2.0.0"
@@ -11210,7 +11967,7 @@ micromark-extension-frontmatter@^2.0.0:
 
 micromark-extension-gfm-autolink-literal@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz#6286aee9686c4462c1e3552a9d505feddceeb935"
   integrity sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==
   dependencies:
     micromark-util-character "^2.0.0"
@@ -11220,14 +11977,14 @@ micromark-extension-gfm-autolink-literal@^2.0.0:
 
 micromark-extension-gfm-autolink-literal@~0.5.0:
   version "0.5.7"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-0.5.7.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-0.5.7.tgz#53866c1f0c7ef940ae7ca1f72c6faef8fed9f204"
   integrity sha512-ePiDGH0/lhcngCe8FtH4ARFoxKTUelMp4L7Gg2pujYD5CSMb9PbblnyL+AAMud/SNMyusbS2XDSiPIRcQoNFAw==
   dependencies:
     micromark "~2.11.3"
 
 micromark-extension-gfm-footnote@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz#4dab56d4e398b9853f6fe4efac4fc9361f3e0750"
   integrity sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==
   dependencies:
     devlop "^1.0.0"
@@ -11241,7 +11998,7 @@ micromark-extension-gfm-footnote@^2.0.0:
 
 micromark-extension-gfm-strikethrough@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz#86106df8b3a692b5f6a92280d3879be6be46d923"
   integrity sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==
   dependencies:
     devlop "^1.0.0"
@@ -11253,15 +12010,15 @@ micromark-extension-gfm-strikethrough@^2.0.0:
 
 micromark-extension-gfm-strikethrough@~0.6.5:
   version "0.6.5"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-0.6.5.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-0.6.5.tgz#96cb83356ff87bf31670eefb7ad7bba73e6514d1"
   integrity sha512-PpOKlgokpQRwUesRwWEp+fHjGGkZEejj83k9gU5iXCbDG+XBA92BqnRKYJdfqfkrRcZRgGuPuXb7DaK/DmxOhw==
   dependencies:
     micromark "~2.11.0"
 
 micromark-extension-gfm-table@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.0.tgz"
-  integrity sha512-Ub2ncQv+fwD70/l4ou27b4YzfNaCJOvyX4HxXU15m7mpYY+rjuWzsLIPZHJL253Z643RpbcP1oeIJlQ/SKW67g==
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz#fac70bcbf51fe65f5f44033118d39be8a9b5940b"
+  integrity sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==
   dependencies:
     devlop "^1.0.0"
     micromark-factory-space "^2.0.0"
@@ -11271,26 +12028,26 @@ micromark-extension-gfm-table@^2.0.0:
 
 micromark-extension-gfm-table@~0.4.0:
   version "0.4.3"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-0.4.3.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-table/-/micromark-extension-gfm-table-0.4.3.tgz#4d49f1ce0ca84996c853880b9446698947f1802b"
   integrity sha512-hVGvESPq0fk6ALWtomcwmgLvH8ZSVpcPjzi0AjPclB9FsVRgMtGZkUcpE0zgjOCFAznKepF4z3hX8z6e3HODdA==
   dependencies:
     micromark "~2.11.0"
 
 micromark-extension-gfm-tagfilter@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz#f26d8a7807b5985fba13cf61465b58ca5ff7dc57"
   integrity sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-extension-gfm-tagfilter@~0.3.0:
   version "0.3.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-0.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-0.3.0.tgz#d9f26a65adee984c9ccdd7e182220493562841ad"
   integrity sha512-9GU0xBatryXifL//FJH+tAZ6i240xQuFrSL7mYi8f4oZSbc+NvXjkrHemeYP0+L4ZUT+Ptz3b95zhUZnMtoi/Q==
 
 micromark-extension-gfm-task-list-item@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz#bcc34d805639829990ec175c3eea12bb5b781f2c"
   integrity sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==
   dependencies:
     devlop "^1.0.0"
@@ -11301,14 +12058,14 @@ micromark-extension-gfm-task-list-item@^2.0.0:
 
 micromark-extension-gfm-task-list-item@~0.3.0:
   version "0.3.3"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-0.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-0.3.3.tgz#d90c755f2533ed55a718129cee11257f136283b8"
   integrity sha512-0zvM5iSLKrc/NQl84pZSjGo66aTGd57C1idmlWmE87lkMcXrTxg1uXa/nXomxJytoje9trP0NDLvw4bZ/Z/XCQ==
   dependencies:
     micromark "~2.11.0"
 
 micromark-extension-gfm@^0.3.0:
   version "0.3.3"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-0.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm/-/micromark-extension-gfm-0.3.3.tgz#36d1a4c089ca8bdfd978c9bd2bf1a0cb24e2acfe"
   integrity sha512-oVN4zv5/tAIA+l3GbMi7lWeYpJ14oQyJ3uEim20ktYFAcfX1x3LNlFGGlmrZHt7u9YlKExmyJdDGaTt6cMSR/A==
   dependencies:
     micromark "~2.11.0"
@@ -11320,7 +12077,7 @@ micromark-extension-gfm@^0.3.0:
 
 micromark-extension-gfm@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz#3e13376ab95dd7a5cfd0e29560dfe999657b3c5b"
   integrity sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==
   dependencies:
     micromark-extension-gfm-autolink-literal "^2.0.0"
@@ -11334,7 +12091,7 @@ micromark-extension-gfm@^3.0.0:
 
 micromark-extension-math@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz#c42ee3b1dd5a9a03584e83dd8f08e3de510212c1"
   integrity sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==
   dependencies:
     "@types/katex" "^0.16.0"
@@ -11346,9 +12103,9 @@ micromark-extension-math@^3.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdx-expression@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.0.tgz"
-  integrity sha512-sI0nwhUDz97xyzqJAbHQhp5TfaxEvZZZ2JDqUo+7NvyIYG6BZ5CPPqj2ogUoPJlmXHBnyZUzISg9+oUmU6tUjQ==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz#43d058d999532fb3041195a3c3c05c46fa84543b"
+  integrity sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==
   dependencies:
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
@@ -11360,11 +12117,10 @@ micromark-extension-mdx-expression@^3.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdx-jsx@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.1.tgz"
-  integrity sha512-vNuFb9czP8QCtAQcEJn0UJQJZA8Dk6DXKBqx+bg/w0WGuSxDxNr7hErW89tHUY31dUW4NqEOWwmEUNhjTFmHkg==
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.2.tgz#ffc98bdb649798902fa9fc5689f67f9c1c902044"
+  integrity sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==
   dependencies:
-    "@types/acorn" "^4.0.0"
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
     estree-util-is-identifier-name "^3.0.0"
@@ -11378,14 +12134,14 @@ micromark-extension-mdx-jsx@^3.0.0:
 
 micromark-extension-mdx-md@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz#1d252881ea35d74698423ab44917e1f5b197b92d"
   integrity sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-extension-mdxjs-esm@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz#de21b2b045fd2059bd00d36746081de38390d54a"
   integrity sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==
   dependencies:
     "@types/estree" "^1.0.0"
@@ -11400,7 +12156,7 @@ micromark-extension-mdxjs-esm@^3.0.0:
 
 micromark-extension-mdxjs@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz#b5a2e0ed449288f3f6f6c544358159557549de18"
   integrity sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==
   dependencies:
     acorn "^8.0.0"
@@ -11413,18 +12169,18 @@ micromark-extension-mdxjs@^3.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-factory-destination@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.0.tgz"
-  integrity sha512-j9DGrQLm/Uhl2tCzcbLhy5kXsgkHUrjJHg4fFAeoMRwJmJerT9aw4FEhIbZStWN8A3qMwOp1uzHr4UL8AInxtA==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz#8fef8e0f7081f0474fbdd92deb50c990a0264639"
+  integrity sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==
   dependencies:
     micromark-util-character "^2.0.0"
     micromark-util-symbol "^2.0.0"
     micromark-util-types "^2.0.0"
 
 micromark-factory-label@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.0.tgz"
-  integrity sha512-RR3i96ohZGde//4WSe/dJsxOX6vxIg9TimLAS3i4EhBAFx8Sm5SmqVfR8E87DPSR31nEAjZfbt91OMZWcNgdZw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz#5267efa97f1e5254efc7f20b459a38cb21058ba1"
+  integrity sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==
   dependencies:
     devlop "^1.0.0"
     micromark-util-character "^2.0.0"
@@ -11432,9 +12188,9 @@ micromark-factory-label@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-factory-mdx-expression@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.2.tgz"
-  integrity sha512-5E5I2pFzJyg2CtemqAbcyCktpHXuJbABnsb32wX2U8IQKhhVFBqkcZR5LRm1WVoFqa4kTueZK4abep7wdo9nrw==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz#bb09988610589c07d1c1e4425285895041b3dfa9"
+  integrity sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==
   dependencies:
     "@types/estree" "^1.0.0"
     devlop "^1.0.0"
@@ -11447,17 +12203,17 @@ micromark-factory-mdx-expression@^2.0.0:
     vfile-message "^4.0.0"
 
 micromark-factory-space@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.0.tgz"
-  integrity sha512-TKr+LIDX2pkBJXFLzpyPyljzYK3MtmllMUMODTQJIUfDGncESaqB90db9IAUcz4AZAJFdd8U9zOp9ty1458rxg==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz#36d0212e962b2b3121f8525fc7a3c7c029f334fc"
+  integrity sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==
   dependencies:
     micromark-util-character "^2.0.0"
     micromark-util-types "^2.0.0"
 
 micromark-factory-title@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.0.tgz"
-  integrity sha512-jY8CSxmpWLOxS+t8W+FG3Xigc0RDQA9bKMY/EwILvsesiRniiVMejYTE4wumNc2f4UbAa4WsHqe3J1QS1sli+A==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz#237e4aa5d58a95863f01032d9ee9b090f1de6e94"
+  integrity sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==
   dependencies:
     micromark-factory-space "^2.0.0"
     micromark-util-character "^2.0.0"
@@ -11465,9 +12221,9 @@ micromark-factory-title@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-factory-whitespace@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.0.tgz"
-  integrity sha512-28kbwaBjc5yAI1XadbdPYHX/eDnqaUFVikLwrO7FDnKG7lpgxnvk/XGRhX/PN0mOZ+dBSZ+LgunHS+6tYQAzhA==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz#06b26b2983c4d27bfcc657b33e25134d4868b0b1"
+  integrity sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==
   dependencies:
     micromark-factory-space "^2.0.0"
     micromark-util-character "^2.0.0"
@@ -11475,48 +12231,48 @@ micromark-factory-whitespace@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-util-character@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.0.tgz"
-  integrity sha512-KvOVV+X1yLBfs9dCBSopq/+G1PcgT3lAK07mC4BzXi5E7ahzMAF8oIupDDJ6mievI6F+lAATkbQQlQixJfT3aQ==
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-character/-/micromark-util-character-2.1.1.tgz#2f987831a40d4c510ac261e89852c4e9703ccda6"
+  integrity sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==
   dependencies:
     micromark-util-symbol "^2.0.0"
     micromark-util-types "^2.0.0"
 
 micromark-util-chunked@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.0.tgz"
-  integrity sha512-anK8SWmNphkXdaKgz5hJvGa7l00qmcaUQoMYsBwDlSKFKjc6gjGXPDw3FNL3Nbwq5L8gE+RCbGqTw49FK5Qyvg==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz#47fbcd93471a3fccab86cff03847fc3552db1051"
+  integrity sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-classify-character@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.0.tgz"
-  integrity sha512-S0ze2R9GH+fu41FA7pbSqNWObo/kzwf8rN/+IGlW/4tC6oACOs8B++bh+i9bVyNnwCcuksbFwsBme5OCKXCwIw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz#d399faf9c45ca14c8b4be98b1ea481bced87b629"
+  integrity sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==
   dependencies:
     micromark-util-character "^2.0.0"
     micromark-util-symbol "^2.0.0"
     micromark-util-types "^2.0.0"
 
 micromark-util-combine-extensions@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.0.tgz"
-  integrity sha512-vZZio48k7ON0fVS3CUgFatWHoKbbLTK/rT7pzpJ4Bjp5JjkZeasRfrS9wsBdDJK2cJLHMckXZdzPSSr1B8a4oQ==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz#2a0f490ab08bff5cc2fd5eec6dd0ca04f89b30a9"
+  integrity sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==
   dependencies:
     micromark-util-chunked "^2.0.0"
     micromark-util-types "^2.0.0"
 
 micromark-util-decode-numeric-character-reference@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.1.tgz"
-  integrity sha512-bmkNc7z8Wn6kgjZmVHOX3SowGmVdhYS7yBpMnuMnPzDq/6xwVA604DuOXMZTO1lvq01g+Adfa0pE2UKGlxL1XQ==
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz#fcf15b660979388e6f118cdb6bf7d79d73d26fe5"
+  integrity sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-decode-string@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.0.tgz"
-  integrity sha512-r4Sc6leeUTn3P6gk20aFMj2ntPwn6qpDZqWvYmAG6NgvFTIlj4WtrAudLi65qYoaGdXYViXYw2pkmn7QnIFasA==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz#6cb99582e5d271e84efca8e61a807994d7161eb2"
+  integrity sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==
   dependencies:
     decode-named-character-reference "^1.0.0"
     micromark-util-character "^2.0.0"
@@ -11524,16 +12280,15 @@ micromark-util-decode-string@^2.0.0:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-encode@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.0.tgz"
-  integrity sha512-pS+ROfCXAGLWCOc8egcBvT0kf27GoWMqtdarNfDcjb6YLuV5cM3ioG45Ys2qOVqeqSbjaKg72vU+Wby3eddPsA==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz#0d51d1c095551cfaac368326963cf55f15f540b8"
+  integrity sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==
 
 micromark-util-events-to-acorn@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.2.tgz"
-  integrity sha512-Fk+xmBrOv9QZnEDguL9OI9/NQQp6Hz4FuQ4YmCb/5V7+9eAh1s6AYSvL20kHkD67YIg7EpE54TiSlcsf3vyZgA==
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz#e7a8a6b55a47e5a06c720d5a1c4abae8c37c98f3"
+  integrity sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==
   dependencies:
-    "@types/acorn" "^4.0.0"
     "@types/estree" "^1.0.0"
     "@types/unist" "^3.0.0"
     devlop "^1.0.0"
@@ -11543,37 +12298,37 @@ micromark-util-events-to-acorn@^2.0.0:
     vfile-message "^4.0.0"
 
 micromark-util-html-tag-name@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.0.tgz"
-  integrity sha512-xNn4Pqkj2puRhKdKTm8t1YHC/BAjx6CEwRFXntTaRf/x16aqka6ouVoutm+QdkISTlT7e2zU7U4ZdlDLJd2Mcw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz#e40403096481986b41c106627f98f72d4d10b825"
+  integrity sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==
 
 micromark-util-normalize-identifier@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.0.tgz"
-  integrity sha512-2xhYT0sfo85FMrUPtHcPo2rrp1lwbDEEzpx7jiH2xXJLqBuy4H0GgXk5ToU8IEwoROtXuL8ND0ttVa4rNqYK3w==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz#c30d77b2e832acf6526f8bf1aa47bc9c9438c16d"
+  integrity sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==
   dependencies:
     micromark-util-symbol "^2.0.0"
 
 micromark-util-resolve-all@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.0.tgz"
-  integrity sha512-6KU6qO7DZ7GJkaCgwBNtplXCvGkJToU86ybBAUdavvgsCiG8lSSvYxr9MhwmQ+udpzywHsl4RpGJsYWG1pDOcA==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz#e1a2d62cdd237230a2ae11839027b19381e31e8b"
+  integrity sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==
   dependencies:
     micromark-util-types "^2.0.0"
 
 micromark-util-sanitize-uri@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.0.tgz"
-  integrity sha512-WhYv5UEcZrbAtlsnPuChHUAsu/iBPOVaEVsntLBIdpibO0ddy8OzavZz3iL2xVvBZOpolujSliP65Kq0/7KIYw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz#ab89789b818a58752b73d6b55238621b7faa8fd7"
+  integrity sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==
   dependencies:
     micromark-util-character "^2.0.0"
     micromark-util-encode "^2.0.0"
     micromark-util-symbol "^2.0.0"
 
 micromark-util-subtokenize@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.1.tgz"
-  integrity sha512-jZNtiFl/1aY73yS3UGQkutD0UbhTt68qnRpw2Pifmz5wV9h8gOVsN70v+Lq/f1rKaU/W8pxRe8y8Q9FX1AOe1Q==
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz#d8ade5ba0f3197a1cf6a2999fbbfe6357a1a19ee"
+  integrity sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==
   dependencies:
     devlop "^1.0.0"
     micromark-util-chunked "^2.0.0"
@@ -11581,27 +12336,27 @@ micromark-util-subtokenize@^2.0.0:
     micromark-util-types "^2.0.0"
 
 micromark-util-symbol@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.0.tgz"
-  integrity sha512-8JZt9ElZ5kyTnO94muPxIGS8oyElRJaiJO8EzV6ZSyGQ1Is8xwl4Q45qU5UOg+bGH4AikWziz0iN4sFLWs8PGw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz#e5da494e8eb2b071a0d08fb34f6cefec6c0a19b8"
+  integrity sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==
 
 micromark-util-types@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.0.tgz"
-  integrity sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w==
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/micromark-util-types/-/micromark-util-types-2.0.2.tgz#f00225f5f5a0ebc3254f96c36b6605c4b393908e"
+  integrity sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==
 
 micromark@^2.11.3, micromark@~2.11.0, micromark@~2.11.3:
   version "2.11.4"
-  resolved "https://registry.npmjs.org/micromark/-/micromark-2.11.4.tgz"
+  resolved "https://registry.yarnpkg.com/micromark/-/micromark-2.11.4.tgz#d13436138eea826383e822449c9a5c50ee44665a"
   integrity sha512-+WoovN/ppKolQOFIAajxi7Lu9kInbPxFuTBVEavFcL8eAfVstoc5MocPmqBeAdBOJV00uaVjegzH4+MA0DN/uA==
   dependencies:
     debug "^4.0.0"
     parse-entities "^2.0.0"
 
 micromark@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/micromark/-/micromark-4.0.0.tgz"
-  integrity sha512-o/sd0nMof8kYff+TqcDx3VSrgBTcZpSvYcAHIfHhv5VAuNmisCxjhx6YmxS8PFEpb9z5WKWKPdzf0jM23ro3RQ==
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/micromark/-/micromark-4.0.2.tgz#91395a3e1884a198e62116e33c9c568e39936fdb"
+  integrity sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==
   dependencies:
     "@types/debug" "^4.0.0"
     debug "^4.0.0"
@@ -11621,9 +12376,9 @@ micromark@^4.0.0:
     micromark-util-symbol "^2.0.0"
     micromark-util-types "^2.0.0"
 
-micromatch@^4.0.4, micromatch@^4.0.5, micromatch@~4.0.8:
+micromatch@^4.0.5, micromatch@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.8.tgz#d66fa18f3a47076789320b9b1af32bd86d9fa202"
   integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==
   dependencies:
     braces "^3.0.3"
@@ -11631,68 +12386,68 @@ micromatch@^4.0.4, micromatch@^4.0.5, micromatch@~4.0.8:
 
 microseconds@0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/microseconds/-/microseconds-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/microseconds/-/microseconds-0.2.0.tgz#233b25f50c62a65d861f978a4a4f8ec18797dc39"
   integrity sha512-n7DHHMjR1avBbSpsTBj6fmMGh2AGrifVV4e+WYc3Q9lO+xnSZ3NyhcBND3vzzatt05LFhoKFRxrIyklmLlUtyA==
 
 mime-db@1.52.0:
   version "1.52.0"
-  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
 mime-format@2.0.1:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/mime-format/-/mime-format-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mime-format/-/mime-format-2.0.1.tgz#1274876d58bc803332427a515f5f7036e07b9413"
   integrity sha512-XxU3ngPbEnrYnNbIX+lYSaYg0M01v6p2ntd2YaFksTu0vayaw5OJvbdRyWs07EYRlLED5qadUZ+xo+XhOvFhwg==
   dependencies:
     charset "^1.0.0"
 
 mime-types@2.1.35, mime-types@^2.1.12, mime-types@~2.1.24:
   version "2.1.35"
-  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
   integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
   dependencies:
     mime-db "1.52.0"
 
 mime@^1.4.1:
   version "1.6.0"
-  resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
 mimic-fn@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
   integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
 
 mimic-fn@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-4.0.0.tgz#60a90550d5cb0b239cca65d893b1a53b29871ecc"
   integrity sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==
 
 mimic-function@^5.0.0:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-function/-/mimic-function-5.0.1.tgz#acbe2b3349f99b9deaca7fb70e48b83e94e67076"
   integrity sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==
 
 min-indent@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
   integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
 
 mini-svg-data-uri@^1.2.3:
   version "1.4.4"
-  resolved "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz"
+  resolved "https://registry.yarnpkg.com/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz#8ab0aabcdf8c29ad5693ca595af19dd2ead09939"
   integrity sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==
 
-minimatch@9.0.3, minimatch@^9.0.1:
+minimatch@9.0.3:
   version "9.0.3"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.3.tgz#a6e00c3de44c3a542bfaae70abfc22420a6da825"
   integrity sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==
   dependencies:
     brace-expansion "^2.0.1"
 
 minimatch@^3.0.3, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
   version "3.1.2"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
   integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
   dependencies:
     brace-expansion "^1.1.7"
@@ -11704,7 +12459,7 @@ minimatch@^8.0.2:
   dependencies:
     brace-expansion "^2.0.1"
 
-minimatch@^9.0.0:
+minimatch@^9.0.0, minimatch@^9.0.1, minimatch@^9.0.4, minimatch@^9.0.5:
   version "9.0.5"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.5.tgz#d74f9dd6b57d83d8e98cfb82133b03978bc929e5"
   integrity sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==
@@ -11713,18 +12468,62 @@ minimatch@^9.0.0:
 
 minimist-options@4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
   integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==
   dependencies:
     arrify "^1.0.1"
     is-plain-obj "^1.1.0"
     kind-of "^6.0.3"
 
-minimist@1.2.6, minimist@^1.2.0, minimist@^1.2.6:
+minimist@1.2.6:
   version "1.2.6"
-  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44"
   integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==
 
+minimist@^1.2.0, minimist@^1.2.6:
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
+  integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
+
+minipass-collect@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/minipass-collect/-/minipass-collect-2.0.1.tgz#1621bc77e12258a12c60d34e2276ec5c20680863"
+  integrity sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==
+  dependencies:
+    minipass "^7.0.3"
+
+minipass-fetch@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/minipass-fetch/-/minipass-fetch-4.0.1.tgz#f2d717d5a418ad0b1a7274f9b913515d3e78f9e5"
+  integrity sha512-j7U11C5HXigVuutxebFadoYBbd7VSdZWggSe64NVdvWNBqGAiXPL2QVCehjmw7lY1oF9gOllYbORh+hiNgfPgQ==
+  dependencies:
+    minipass "^7.0.3"
+    minipass-sized "^1.0.3"
+    minizlib "^3.0.1"
+  optionalDependencies:
+    encoding "^0.1.13"
+
+minipass-flush@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/minipass-flush/-/minipass-flush-1.0.5.tgz#82e7135d7e89a50ffe64610a787953c4c4cbb373"
+  integrity sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==
+  dependencies:
+    minipass "^3.0.0"
+
+minipass-pipeline@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz#68472f79711c084657c067c5c6ad93cddea8214c"
+  integrity sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==
+  dependencies:
+    minipass "^3.0.0"
+
+minipass-sized@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/minipass-sized/-/minipass-sized-1.0.3.tgz#70ee5a7c5052070afacfbc22977ea79def353b70"
+  integrity sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==
+  dependencies:
+    minipass "^3.0.0"
+
 minipass@^3.0.0:
   version "3.3.6"
   resolved "https://registry.yarnpkg.com/minipass/-/minipass-3.3.6.tgz#7bba384db3a1520d18c9c0e5251c3444e95dd94a"
@@ -11742,9 +12541,9 @@ minipass@^5.0.0:
   resolved "https://registry.yarnpkg.com/minipass/-/minipass-5.0.0.tgz#3e9788ffb90b694a5d0ec94479a45b5d8738133d"
   integrity sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==
 
-"minipass@^5.0.0 || ^6.0.2 || ^7.0.0":
+"minipass@^5.0.0 || ^6.0.2 || ^7.0.0", minipass@^7.0.2, minipass@^7.0.3, minipass@^7.1.1, minipass@^7.1.2:
   version "7.1.2"
-  resolved "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/minipass/-/minipass-7.1.2.tgz#93a9626ce5e5e66bd4db86849e7515e92340a707"
   integrity sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==
 
 minizlib@^2.1.1:
@@ -11755,6 +12554,13 @@ minizlib@^2.1.1:
     minipass "^3.0.0"
     yallist "^4.0.0"
 
+minizlib@^3.0.1:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-3.1.0.tgz#6ad76c3a8f10227c9b51d1c9ac8e30b27f5a251c"
+  integrity sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==
+  dependencies:
+    minipass "^7.1.2"
+
 mkdirp@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.3.0.tgz#1bbf5ab1ba827af23575143490426455f481fe1e"
@@ -11762,7 +12568,7 @@ mkdirp@0.3.0:
 
 mkdirp@0.5.x:
   version "0.5.6"
-  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
   integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
   dependencies:
     minimist "^1.2.6"
@@ -11790,23 +12596,28 @@ motion-utils@^11.18.1:
   integrity sha512-49Kt+HKjtbJKLtgO/LKj9Ld+6vw9BjH5d9sc40R/kVyH8GLAXgT42M2NnuPcJNuA3s9ZfZBUcwIgpmZWGEE+hA==
 
 mrmime@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz"
-  integrity sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-2.0.1.tgz#bc3e87f7987853a54c9850eeb1f1078cd44adddc"
+  integrity sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==
 
 ms@2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
   integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
 
-ms@^2.1.1, ms@^2.1.3:
+ms@2.1.3, ms@^2.1.1, ms@^2.1.2, ms@^2.1.3:
   version "2.1.3"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
+mute-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-2.0.0.tgz#a5446fc0c512b71c83c44d908d5c7b7b4c493b2b"
+  integrity sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==
+
 mz@^2.7.0:
   version "2.7.0"
-  resolved "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz"
+  resolved "https://registry.yarnpkg.com/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32"
   integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==
   dependencies:
     any-promise "^1.0.0"
@@ -11815,7 +12626,7 @@ mz@^2.7.0:
 
 nano-css@^5.6.2:
   version "5.6.2"
-  resolved "https://registry.npmjs.org/nano-css/-/nano-css-5.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/nano-css/-/nano-css-5.6.2.tgz#584884ddd7547278f6d6915b6805069742679a32"
   integrity sha512-+6bHaC8dSDGALM1HJjOHVXpuastdu2xFoZlC77Jh4cg+33Zcgm+Gxd+1xsnpZK14eyHObSp82+ll5y3SX75liw==
   dependencies:
     "@jridgewell/sourcemap-codec" "^1.4.15"
@@ -11834,56 +12645,81 @@ nano-memoize@^1.2.1:
 
 nano-time@1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/nano-time/-/nano-time-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/nano-time/-/nano-time-1.0.0.tgz#b0554f69ad89e22d0907f7a12b0993a5d96137ef"
   integrity sha512-flnngywOoQ0lLQOTRNexn2gGSNuM9bKj9RZAWSzhQ+UJYaAFG9bac4DW9VHjUAzrOaIcajHybCTHe/bkvozQqA==
   dependencies:
     big-integer "^1.6.16"
 
-nanoid@^3.1.32, nanoid@^3.3.6, nanoid@^3.3.7:
-  version "3.3.8"
-  resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz"
-  integrity sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==
-
-nanoid@^3.3.11:
+nanoid@^3.1.32, nanoid@^3.3.11, nanoid@^3.3.6:
   version "3.3.11"
   resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.11.tgz#4f4f112cefbe303202f2199838128936266d185b"
   integrity sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==
 
+napi-postinstall@^0.3.0:
+  version "0.3.3"
+  resolved "https://registry.yarnpkg.com/napi-postinstall/-/napi-postinstall-0.3.3.tgz#93d045c6b576803ead126711d3093995198c6eb9"
+  integrity sha512-uTp172LLXSxuSYHv/kou+f6KW3SMppU9ivthaVTXian9sOt3XM/zHYHpRZiLgQoxeWfYUnslNWQHF1+G71xcow==
+
 native-promise-only@0.8.1:
   version "0.8.1"
-  resolved "https://registry.npmjs.org/native-promise-only/-/native-promise-only-0.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/native-promise-only/-/native-promise-only-0.8.1.tgz#20a318c30cb45f71fe7adfbf7b21c99c1472ef11"
   integrity sha512-zkVhZUA3y8mbz652WrL5x0fB0ehrBkulWT3TomAQ9iDtyXZvzKeEA6GPxAItBYeNYl5yngKRX612qHOhvMkDeg==
 
 natural-compare@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
 
 needle@^2.5.2:
   version "2.9.1"
-  resolved "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz"
+  resolved "https://registry.yarnpkg.com/needle/-/needle-2.9.1.tgz#22d1dffbe3490c2b83e301f7709b6736cd8f2684"
   integrity sha512-6R9fqJ5Zcmf+uYaFgdIHmLwNldn5HbK8L5ybn7Uz+ylX/rnOsSp1AHcvQSrCaFN+qNM1wpymHqD7mVasEOlHGQ==
   dependencies:
     debug "^3.2.6"
     iconv-lite "^0.4.4"
     sax "^1.2.4"
 
-next-contentlayer2@0.5.5, next-contentlayer2@^0.5.3:
+negotiator@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-1.0.0.tgz#b6c91bb47172d69f93cfd7c357bbb529019b5f6a"
+  integrity sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==
+
+next-contentlayer2@0.5.5:
   version "0.5.5"
-  resolved "https://registry.npmjs.org/next-contentlayer2/-/next-contentlayer2-0.5.5.tgz"
+  resolved "https://registry.yarnpkg.com/next-contentlayer2/-/next-contentlayer2-0.5.5.tgz#61a6016815f91560e35bcea3df94f769d7ddb164"
   integrity sha512-ADaDVELWndW8I53nGNUPhePdimB+kTBCKl9dmm0AqKiD0fF7ZCt+dpCRqNbyl/7bFDfEXhKDdo8tCdbCc//UXg==
   dependencies:
     "@contentlayer2/core" "0.5.5"
     "@contentlayer2/utils" "0.5.5"
 
+next-contentlayer2@^0.5.3:
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/next-contentlayer2/-/next-contentlayer2-0.5.8.tgz#ddfff75cdaa0eaf8f8cc01f84f5ffd5dddfde6db"
+  integrity sha512-3Xh8quPCFmg/QGa4qTnOwSsT3oNYCtmm+Ii0UlbOHxX59gHYVX9M5mTzkdUKiKC1aJfiGIPPGQXhKNfc6qvWZg==
+  dependencies:
+    "@contentlayer2/core" "0.5.8"
+    "@contentlayer2/utils" "0.5.8"
+
 next-image-zoom@^1.1.7:
   version "1.1.7"
-  resolved "https://registry.npmjs.org/next-image-zoom/-/next-image-zoom-1.1.7.tgz"
+  resolved "https://registry.yarnpkg.com/next-image-zoom/-/next-image-zoom-1.1.7.tgz#5a4e9f0f32b3b2e49b7c153f30a0ddf301607b10"
   integrity sha512-dSXA/c7z6SZQQvwoCP+JK9s0A5Nx1ZtGwIM7p/j7dP2gsLhdkwrTlShkQw+SvXDKgU5iVB2XoUKS+DFBGm49og==
 
+next-mdx-remote@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/next-mdx-remote/-/next-mdx-remote-5.0.0.tgz#028a2cf5cf7f814d988d7ab11a401bed0f31b4ee"
+  integrity sha512-RNNbqRpK9/dcIFZs/esQhuLA8jANqlH694yqoDBK8hkVdJUndzzGmnPHa2nyi90N4Z9VmzuSWNRpr5ItT3M7xQ==
+  dependencies:
+    "@babel/code-frame" "^7.23.5"
+    "@mdx-js/mdx" "^3.0.1"
+    "@mdx-js/react" "^3.0.1"
+    unist-util-remove "^3.1.0"
+    vfile "^6.0.1"
+    vfile-matter "^5.0.0"
+
 next-themes@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.npmjs.org/next-themes/-/next-themes-0.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/next-themes/-/next-themes-0.3.0.tgz#b4d2a866137a67d42564b07f3a3e720e2ff3871a"
   integrity sha512-/QHIrsYpd6Kfk7xakK4svpDI5mmXP0gfvCoJdGpZQ2TOrQZmsW0QxjaiLn8wbIKjtm4BTSqLoix4lxYYOnLJ/w==
 
 next@14.2.32:
@@ -11911,7 +12747,7 @@ next@14.2.32:
 
 no-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
   integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
   dependencies:
     lower-case "^2.0.2"
@@ -11919,34 +12755,45 @@ no-case@^3.0.4:
 
 node-abort-controller@^3.0.1:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/node-abort-controller/-/node-abort-controller-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/node-abort-controller/-/node-abort-controller-3.1.1.tgz#a94377e964a9a37ac3976d848cb5c765833b8548"
   integrity sha512-AGK2yQKIjRuqnc6VkX2Xj5d+QW8xZ87pa1UK6yA6ouUyuxfHuMP6umE5QK7UmTeOAymo+Zx1Fxiuw9rVx8taHQ==
 
 node-domexception@1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/node-domexception/-/node-domexception-1.0.0.tgz#6888db46a1f71c0b76b3f7555016b63fe64766e5"
   integrity sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==
 
-node-fetch@^2.6.1, node-fetch@^2.6.12, node-fetch@^2.6.7:
+node-fetch@^2.6.1, node-fetch@^2.6.7, node-fetch@^2.7.0:
   version "2.7.0"
-  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz"
+  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d"
   integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==
   dependencies:
     whatwg-url "^5.0.0"
 
-node-releases@^2.0.18:
-  version "2.0.18"
-  resolved "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz"
-  integrity sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==
-
-node-releases@^2.0.19:
-  version "2.0.19"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.19.tgz#9e445a52950951ec4d177d843af370b411caf314"
-  integrity sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==
+node-gyp@^11.0.0, node-gyp@^11.2.0:
+  version "11.4.2"
+  resolved "https://registry.yarnpkg.com/node-gyp/-/node-gyp-11.4.2.tgz#bb74cc6a80a0cc301811c8efd755fac39efc7cd0"
+  integrity sha512-3gD+6zsrLQH7DyYOUIutaauuXrcyxeTPyQuZQCQoNPZMHMMS5m4y0xclNpvYzoK3VNzuyxT6eF4mkIL4WSZ1eQ==
+  dependencies:
+    env-paths "^2.2.0"
+    exponential-backoff "^3.1.1"
+    graceful-fs "^4.2.6"
+    make-fetch-happen "^14.0.3"
+    nopt "^8.0.0"
+    proc-log "^5.0.0"
+    semver "^7.3.5"
+    tar "^7.4.3"
+    tinyglobby "^0.2.12"
+    which "^5.0.0"
+
+node-releases@^2.0.21:
+  version "2.0.21"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.21.tgz#f59b018bc0048044be2d4c4c04e4c8b18160894c"
+  integrity sha512-5b0pgg78U3hwXkCM8Z9b2FJdPZlr9Psr9V2gQPESdGHqbntyFJKFW4r5TeWGFzafGY3hzs1JC62VEQMbl1JFkw==
 
 noms@0.0.0:
   version "0.0.0"
-  resolved "https://registry.npmjs.org/noms/-/noms-0.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/noms/-/noms-0.0.0.tgz#da8ebd9f3af9d6760919b27d9cdc8092a7332859"
   integrity sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow==
   dependencies:
     inherits "^2.0.1"
@@ -11959,9 +12806,16 @@ nopt@1.0.10:
   dependencies:
     abbrev "1"
 
+nopt@^8.0.0, nopt@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/nopt/-/nopt-8.1.0.tgz#b11d38caf0f8643ce885818518064127f602eae3"
+  integrity sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A==
+  dependencies:
+    abbrev "^3.0.0"
+
 normalize-package-data@^2.5.0:
   version "2.5.0"
-  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
   integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
   dependencies:
     hosted-git-info "^2.1.4"
@@ -11971,7 +12825,7 @@ normalize-package-data@^2.5.0:
 
 normalize-package-data@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
   integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
   dependencies:
     hosted-git-info "^4.0.1"
@@ -11979,97 +12833,243 @@ normalize-package-data@^3.0.0:
     semver "^7.3.4"
     validate-npm-package-license "^3.0.1"
 
+normalize-package-data@^7.0.0:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-7.0.1.tgz#84d2971bd8be97b23f0ce06f9e401840be8eaa3e"
+  integrity sha512-linxNAT6M0ebEYZOx2tO6vBEFsVgnPpv+AVjk0wJHfaUIbq31Jm3T6vvZaarnOeWDh8ShnwXuaAyM7WT3RzErA==
+  dependencies:
+    hosted-git-info "^8.0.0"
+    semver "^7.3.5"
+    validate-npm-package-license "^3.0.4"
+
 normalize-path@^3.0.0, normalize-path@~3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
 normalize-range@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/normalize-range/-/normalize-range-0.1.2.tgz#2d10c06bdfd312ea9777695a4d28439456b75942"
   integrity sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==
 
-not@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.npmjs.org/not/-/not-0.1.0.tgz"
-  integrity sha512-5PDmaAsVfnWUgTUbJ3ERwn7u79Z0dYxN9ErxCpVJJqe2RK0PJ3z+iFUxuqjwtlDDegXvtWoxD/3Fzxox7tFGWA==
+npm-audit-report@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/npm-audit-report/-/npm-audit-report-6.0.0.tgz#0262e5e2b674fabf0ea47e900fc7384b83de0fbb"
+  integrity sha512-Ag6Y1irw/+CdSLqEEAn69T8JBgBThj5mw0vuFIKeP7hATYuQuS5jkMjK6xmVB8pr7U4g5Audbun0lHhBDMIBRA==
+
+npm-bundled@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-4.0.0.tgz#f5b983f053fe7c61566cf07241fab2d4e9d513d3"
+  integrity sha512-IxaQZDMsqfQ2Lz37VvyyEtKLe8FsRZuysmedy/N06TU1RyVppYKXrO4xIhR0F+7ubIBox6Q7nir6fQI3ej39iA==
+  dependencies:
+    npm-normalize-package-bin "^4.0.0"
+
+npm-install-checks@^7.1.0, npm-install-checks@^7.1.1:
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/npm-install-checks/-/npm-install-checks-7.1.2.tgz#e338d333930ee18e0fb0be6bd8b67af98be3d2fa"
+  integrity sha512-z9HJBCYw9Zr8BqXcllKIs5nI+QggAImbBdHphOzVYrz2CB4iQ6FzWyKmlqDZua+51nAu7FcemlbTc9VgQN5XDQ==
+  dependencies:
+    semver "^7.1.1"
+
+npm-normalize-package-bin@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/npm-normalize-package-bin/-/npm-normalize-package-bin-4.0.0.tgz#df79e70cd0a113b77c02d1fe243c96b8e618acb1"
+  integrity sha512-TZKxPvItzai9kN9H/TkmCtx/ZN/hvr3vUycjlfmH0ootY9yFBzNOpiXAdIn1Iteqsvk4lQn6B5PTrt+n6h8k/w==
+
+npm-package-arg@^12.0.0, npm-package-arg@^12.0.2:
+  version "12.0.2"
+  resolved "https://registry.yarnpkg.com/npm-package-arg/-/npm-package-arg-12.0.2.tgz#3b1e04ebe651cc45028e298664e8c15ce9c0ca40"
+  integrity sha512-f1NpFjNI9O4VbKMOlA5QoBq/vSQPORHcTZ2feJpFkTHJ9eQkdlmZEKSjcAhxTGInC7RlEyScT9ui67NaOsjFWA==
+  dependencies:
+    hosted-git-info "^8.0.0"
+    proc-log "^5.0.0"
+    semver "^7.3.5"
+    validate-npm-package-name "^6.0.0"
+
+npm-packlist@^9.0.0:
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-9.0.0.tgz#8e9b061bab940de639dd93d65adc95c34412c7d0"
+  integrity sha512-8qSayfmHJQTx3nJWYbbUmflpyarbLMBc6LCAjYsiGtXxDB68HaZpb8re6zeaLGxZzDuMdhsg70jryJe+RrItVQ==
+  dependencies:
+    ignore-walk "^7.0.0"
+
+npm-pick-manifest@^10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/npm-pick-manifest/-/npm-pick-manifest-10.0.0.tgz#6cc120c6473ceea56dfead500f00735b2b892851"
+  integrity sha512-r4fFa4FqYY8xaM7fHecQ9Z2nE9hgNfJR+EmoKv0+chvzWkBcORX3r0FpTByP+CbOVJDladMXnPQGVN8PBLGuTQ==
+  dependencies:
+    npm-install-checks "^7.1.0"
+    npm-normalize-package-bin "^4.0.0"
+    npm-package-arg "^12.0.0"
+    semver "^7.3.5"
+
+npm-profile@^11.0.1:
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/npm-profile/-/npm-profile-11.0.1.tgz#6ffac43f3d186316d37e80986d84aef2470269a2"
+  integrity sha512-HP5Cw9WHwFS9vb4fxVlkNAQBUhVL5BmW6rAR+/JWkpwqcFJid7TihKUdYDWqHl0NDfLd0mpucheGySqo8ysyfw==
+  dependencies:
+    npm-registry-fetch "^18.0.0"
+    proc-log "^5.0.0"
+
+npm-registry-fetch@^18.0.0, npm-registry-fetch@^18.0.1, npm-registry-fetch@^18.0.2:
+  version "18.0.2"
+  resolved "https://registry.yarnpkg.com/npm-registry-fetch/-/npm-registry-fetch-18.0.2.tgz#340432f56b5a8b1af068df91aae0435d2de646b5"
+  integrity sha512-LeVMZBBVy+oQb5R6FDV9OlJCcWDU+al10oKpe+nsvcHnG24Z3uM3SvJYKfGJlfGjVU8v9liejCrUR/M5HO5NEQ==
+  dependencies:
+    "@npmcli/redact" "^3.0.0"
+    jsonparse "^1.3.1"
+    make-fetch-happen "^14.0.0"
+    minipass "^7.0.2"
+    minipass-fetch "^4.0.0"
+    minizlib "^3.0.1"
+    npm-package-arg "^12.0.0"
+    proc-log "^5.0.0"
 
 npm-run-path@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
   integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
   dependencies:
     path-key "^3.0.0"
 
 npm-run-path@^5.1.0:
   version "5.3.0"
-  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-5.3.0.tgz#e23353d0ebb9317f174e93417e4a4d82d0249e9f"
   integrity sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==
   dependencies:
     path-key "^4.0.0"
 
+npm-user-validate@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/npm-user-validate/-/npm-user-validate-3.0.0.tgz#9b1410796bf1f1d78297a8096328c55d3083f233"
+  integrity sha512-9xi0RdSmJ4mPYTC393VJPz1Sp8LyCx9cUnm/L9Qcb3cFO8gjT4mN20P9FAsea8qDHdQ7LtcN8VLh2UT47SdKCw==
+
+npm@^10.1.0:
+  version "10.9.3"
+  resolved "https://registry.yarnpkg.com/npm/-/npm-10.9.3.tgz#e803ef2166aa96eda9b795a9acee1877c8b4e6f2"
+  integrity sha512-6Eh1u5Q+kIVXeA8e7l2c/HpnFFcwrkt37xDMujD5be1gloWa9p6j3Fsv3mByXXmqJHy+2cElRMML8opNT7xIJQ==
+  dependencies:
+    "@isaacs/string-locale-compare" "^1.1.0"
+    "@npmcli/arborist" "^8.0.1"
+    "@npmcli/config" "^9.0.0"
+    "@npmcli/fs" "^4.0.0"
+    "@npmcli/map-workspaces" "^4.0.2"
+    "@npmcli/package-json" "^6.2.0"
+    "@npmcli/promise-spawn" "^8.0.2"
+    "@npmcli/redact" "^3.2.2"
+    "@npmcli/run-script" "^9.1.0"
+    "@sigstore/tuf" "^3.1.1"
+    abbrev "^3.0.1"
+    archy "~1.0.0"
+    cacache "^19.0.1"
+    chalk "^5.4.1"
+    ci-info "^4.2.0"
+    cli-columns "^4.0.0"
+    fastest-levenshtein "^1.0.16"
+    fs-minipass "^3.0.3"
+    glob "^10.4.5"
+    graceful-fs "^4.2.11"
+    hosted-git-info "^8.1.0"
+    ini "^5.0.0"
+    init-package-json "^7.0.2"
+    is-cidr "^5.1.1"
+    json-parse-even-better-errors "^4.0.0"
+    libnpmaccess "^9.0.0"
+    libnpmdiff "^7.0.1"
+    libnpmexec "^9.0.1"
+    libnpmfund "^6.0.1"
+    libnpmhook "^11.0.0"
+    libnpmorg "^7.0.0"
+    libnpmpack "^8.0.1"
+    libnpmpublish "^10.0.1"
+    libnpmsearch "^8.0.0"
+    libnpmteam "^7.0.0"
+    libnpmversion "^7.0.0"
+    make-fetch-happen "^14.0.3"
+    minimatch "^9.0.5"
+    minipass "^7.1.1"
+    minipass-pipeline "^1.2.4"
+    ms "^2.1.2"
+    node-gyp "^11.2.0"
+    nopt "^8.1.0"
+    normalize-package-data "^7.0.0"
+    npm-audit-report "^6.0.0"
+    npm-install-checks "^7.1.1"
+    npm-package-arg "^12.0.2"
+    npm-pick-manifest "^10.0.0"
+    npm-profile "^11.0.1"
+    npm-registry-fetch "^18.0.2"
+    npm-user-validate "^3.0.0"
+    p-map "^7.0.3"
+    pacote "^19.0.1"
+    parse-conflict-json "^4.0.0"
+    proc-log "^5.0.0"
+    qrcode-terminal "^0.12.0"
+    read "^4.1.0"
+    semver "^7.7.2"
+    spdx-expression-parse "^4.0.0"
+    ssri "^12.0.0"
+    supports-color "^9.4.0"
+    tar "^6.2.1"
+    text-table "~0.2.0"
+    tiny-relative-date "^1.3.0"
+    treeverse "^3.0.0"
+    validate-npm-package-name "^6.0.1"
+    which "^5.0.0"
+    write-file-atomic "^6.0.0"
+
 nth-check@^2.0.0, nth-check@^2.0.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.1.1.tgz#c9eab428effce36cd6b92c924bdb000ef1f1ed1d"
   integrity sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==
   dependencies:
     boolbase "^1.0.0"
 
 object-assign@^4.0.1, object-assign@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
 
 object-hash@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/object-hash/-/object-hash-3.0.0.tgz#73f97f753e7baffc0e2cc9d6e079079744ac82e9"
   integrity sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==
 
-object-inspect@^1.13.1:
-  version "1.13.2"
-  resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz"
-  integrity sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==
-
-object-inspect@^1.13.3:
+object-inspect@^1.13.3, object-inspect@^1.13.4:
   version "1.13.4"
-  resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.4.tgz#8375265e21bc20d0fa582c22e1b13485d6e00213"
   integrity sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==
 
-object-is@^1.1.5:
-  version "1.1.6"
-  resolved "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz"
-  integrity sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==
-  dependencies:
-    call-bind "^1.0.7"
-    define-properties "^1.2.1"
-
 object-keys@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
-object.assign@^4.1.4, object.assign@^4.1.5:
-  version "4.1.5"
-  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz"
-  integrity sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==
+object.assign@^4.1.4, object.assign@^4.1.7:
+  version "4.1.7"
+  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.7.tgz#8c14ca1a424c6a561b0bb2a22f66f5049a945d3d"
+  integrity sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==
   dependencies:
-    call-bind "^1.0.5"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
     define-properties "^1.2.1"
-    has-symbols "^1.0.3"
+    es-object-atoms "^1.0.0"
+    has-symbols "^1.1.0"
     object-keys "^1.1.1"
 
-object.entries@^1.1.8:
-  version "1.1.8"
-  resolved "https://registry.npmjs.org/object.entries/-/object.entries-1.1.8.tgz"
-  integrity sha512-cmopxi8VwRIAw/fkijJohSfpef5PdN0pMQJN6VC/ZKvn0LIknWD8KtgY6KlQdEc4tIjcQ3HxSMmnvtzIscdaYQ==
+object.entries@^1.1.9:
+  version "1.1.9"
+  resolved "https://registry.yarnpkg.com/object.entries/-/object.entries-1.1.9.tgz#e4770a6a1444afb61bd39f984018b5bede25f8b3"
+  integrity sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
     define-properties "^1.2.1"
-    es-object-atoms "^1.0.0"
+    es-object-atoms "^1.1.1"
 
 object.fromentries@^2.0.8:
   version "2.0.8"
-  resolved "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/object.fromentries/-/object.fromentries-2.0.8.tgz#f7195d8a9b97bd95cbc1999ea939ecd1a2b00c65"
   integrity sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==
   dependencies:
     call-bind "^1.0.7"
@@ -12079,75 +13079,76 @@ object.fromentries@^2.0.8:
 
 object.groupby@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/object.groupby/-/object.groupby-1.0.3.tgz#9b125c36238129f6f7b61954a1e7176148d5002e"
   integrity sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==
   dependencies:
     call-bind "^1.0.7"
     define-properties "^1.2.1"
     es-abstract "^1.23.2"
 
-object.values@^1.1.6, object.values@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/object.values/-/object.values-1.2.0.tgz"
-  integrity sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==
+object.values@^1.1.6, object.values@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.2.1.tgz#deed520a50809ff7f75a7cfd4bc64c7a038c6216"
+  integrity sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
     define-properties "^1.2.1"
     es-object-atoms "^1.0.0"
 
 oblivious-set@1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/oblivious-set/-/oblivious-set-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/oblivious-set/-/oblivious-set-1.0.0.tgz#c8316f2c2fb6ff7b11b6158db3234c49f733c566"
   integrity sha512-z+pI07qxo4c2CulUHCDf9lcqDlMSo72N/4rLUpRXf6fu+q8vjt8y0xS+Tlf8NTJDdTXHbdeO1n3MlbctwEoXZw==
 
 once@^1.3.0:
   version "1.4.0"
-  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
   integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
   dependencies:
     wrappy "1"
 
 onetime@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
   integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
   dependencies:
     mimic-fn "^2.1.0"
 
 onetime@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-6.0.0.tgz#7c24c18ed1fd2e9bca4bd26806a33613c77d34b4"
   integrity sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==
   dependencies:
     mimic-fn "^4.0.0"
 
 onetime@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-7.0.0.tgz#9f16c92d8c9ef5120e3acd9dd9957cceecc1ab60"
   integrity sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==
   dependencies:
     mimic-function "^5.0.0"
 
 oo-ascii-tree@^1.94.0:
-  version "1.103.1"
-  resolved "https://registry.npmjs.org/oo-ascii-tree/-/oo-ascii-tree-1.103.1.tgz"
-  integrity sha512-X0nmbb8xUUi637JXzCxY/K4AtO/I0fB5b7iiGaHJHu8IXBWV8TnQ4xqa0Igb/NoAg3OP2uXNhSeiTsErETOA/g==
+  version "1.114.1"
+  resolved "https://registry.yarnpkg.com/oo-ascii-tree/-/oo-ascii-tree-1.114.1.tgz#41c2f8c7c66d668a284653e64b6815be919551a8"
+  integrity sha512-+xac1eA8pc16YTNQ3Joxfw1+C3kySirXJmZvKvbtvw2m16CQXpBjETp19EPIvXH6b4dthokP4NbVHm75btcGIQ==
 
 openapi3-ts@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/openapi3-ts/-/openapi3-ts-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/openapi3-ts/-/openapi3-ts-2.0.2.tgz#a200dd838bf24c9086c8eedcfeb380b7eb31e82a"
   integrity sha512-TxhYBMoqx9frXyOgnRHufjQfPXomTIHYKhSKJ6jHfj13kS8OEIhvmE8CTuQyKtjjWttAjX5DPxM1vmalEpo8Qw==
   dependencies:
     yaml "^1.10.2"
 
 opener@^1.5.2:
   version "1.5.2"
-  resolved "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz"
+  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
 optionator@^0.9.3:
   version "0.9.4"
-  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.4.tgz#7ea1c1a5d91d764fb282139c88fe11e182a3a734"
   integrity sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==
   dependencies:
     deep-is "^0.1.3"
@@ -12157,49 +13158,123 @@ optionator@^0.9.3:
     type-check "^0.4.0"
     word-wrap "^1.2.5"
 
+own-keys@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/own-keys/-/own-keys-1.0.1.tgz#e4006910a2bf913585289676eebd6f390cf51358"
+  integrity sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==
+  dependencies:
+    get-intrinsic "^1.2.6"
+    object-keys "^1.1.1"
+    safe-push-apply "^1.0.0"
+
 p-limit@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
   integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
   dependencies:
     p-try "^2.0.0"
 
 p-limit@^3.0.2:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
   integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
   dependencies:
     yocto-queue "^0.1.0"
 
 p-locate@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
   integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
   dependencies:
     p-limit "^2.2.0"
 
 p-locate@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
   integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
   dependencies:
     p-limit "^3.0.2"
 
+p-map@^7.0.2, p-map@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/p-map/-/p-map-7.0.3.tgz#7ac210a2d36f81ec28b736134810f7ba4418cdb6"
+  integrity sha512-VkndIv2fIB99swvQoA65bm+fsmt6UNdGeIB0oxBs+WhAhdh08QA04JXpI7rbB9r08/nkbysKoya9rtDERYOYMA==
+
 p-try@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
 
+package-json-from-dist@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz#4f1471a010827a86f94cfd9b0727e36d267de505"
+  integrity sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==
+
+pacote@^19.0.0, pacote@^19.0.1:
+  version "19.0.1"
+  resolved "https://registry.yarnpkg.com/pacote/-/pacote-19.0.1.tgz#66d22dbd274ed8a7c30029d70eb8030f5151e6fc"
+  integrity sha512-zIpxWAsr/BvhrkSruspG8aqCQUUrWtpwx0GjiRZQhEM/pZXrigA32ElN3vTcCPUDOFmHr6SFxwYrvVUs5NTEUg==
+  dependencies:
+    "@npmcli/git" "^6.0.0"
+    "@npmcli/installed-package-contents" "^3.0.0"
+    "@npmcli/package-json" "^6.0.0"
+    "@npmcli/promise-spawn" "^8.0.0"
+    "@npmcli/run-script" "^9.0.0"
+    cacache "^19.0.0"
+    fs-minipass "^3.0.0"
+    minipass "^7.0.2"
+    npm-package-arg "^12.0.0"
+    npm-packlist "^9.0.0"
+    npm-pick-manifest "^10.0.0"
+    npm-registry-fetch "^18.0.0"
+    proc-log "^5.0.0"
+    promise-retry "^2.0.1"
+    sigstore "^3.0.0"
+    ssri "^12.0.0"
+    tar "^6.1.11"
+
+pacote@^20.0.0:
+  version "20.0.0"
+  resolved "https://registry.yarnpkg.com/pacote/-/pacote-20.0.0.tgz#c974373d8e0859d00e8f9158574350f8c1b168e5"
+  integrity sha512-pRjC5UFwZCgx9kUFDVM9YEahv4guZ1nSLqwmWiLUnDbGsjs+U5w7z6Uc8HNR1a6x8qnu5y9xtGE6D1uAuYz+0A==
+  dependencies:
+    "@npmcli/git" "^6.0.0"
+    "@npmcli/installed-package-contents" "^3.0.0"
+    "@npmcli/package-json" "^6.0.0"
+    "@npmcli/promise-spawn" "^8.0.0"
+    "@npmcli/run-script" "^9.0.0"
+    cacache "^19.0.0"
+    fs-minipass "^3.0.0"
+    minipass "^7.0.2"
+    npm-package-arg "^12.0.0"
+    npm-packlist "^9.0.0"
+    npm-pick-manifest "^10.0.0"
+    npm-registry-fetch "^18.0.0"
+    proc-log "^5.0.0"
+    promise-retry "^2.0.1"
+    sigstore "^3.0.0"
+    ssri "^12.0.0"
+    tar "^6.1.11"
+
 parent-module@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
   integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
   dependencies:
     callsites "^3.0.0"
 
+parse-conflict-json@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/parse-conflict-json/-/parse-conflict-json-4.0.0.tgz#996b1edfc0c727583b56c7644dbb3258fc9e9e4b"
+  integrity sha512-37CN2VtcuvKgHUs8+0b1uJeEsbGn61GRHz469C94P5xiOoqpDYJYwjg4RY9Vmz39WyZAVkR5++nbJwLMIgOCnQ==
+  dependencies:
+    json-parse-even-better-errors "^4.0.0"
+    just-diff "^6.0.0"
+    just-diff-apply "^5.2.0"
+
 parse-entities@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/parse-entities/-/parse-entities-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse-entities/-/parse-entities-2.0.0.tgz#53c6eb5b9314a1f4ec99fa0fdf7ce01ecda0cbe8"
   integrity sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ==
   dependencies:
     character-entities "^1.0.0"
@@ -12210,12 +13285,11 @@ parse-entities@^2.0.0:
     is-hexadecimal "^1.0.0"
 
 parse-entities@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.1.tgz"
-  integrity sha512-SWzvYcSJh4d/SGLIOQfZ/CoNv6BTlI6YEQ7Nj82oDVnRpwe/Z/F1EMx42x3JAOwGBlCjeCH0BRJQbQ/opHL17w==
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/parse-entities/-/parse-entities-4.0.2.tgz#61d46f5ed28e4ee62e9ddc43d6b010188443f159"
+  integrity sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==
   dependencies:
     "@types/unist" "^2.0.0"
-    character-entities "^2.0.0"
     character-entities-legacy "^3.0.0"
     character-reference-invalid "^2.0.0"
     decode-named-character-reference "^1.0.0"
@@ -12225,7 +13299,7 @@ parse-entities@^4.0.0:
 
 parse-json@^5.0.0, parse-json@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
   integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -12235,24 +13309,24 @@ parse-json@^5.0.0, parse-json@^5.2.0:
 
 parse-numeric-range@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/parse-numeric-range/-/parse-numeric-range-1.3.0.tgz#7c63b61190d61e4d53a1197f0c83c47bb670ffa3"
   integrity sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ==
 
 parse5@^6.0.0:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-6.0.1.tgz#e1a1c085c569b3dc08321184f19a39cc27f7c30b"
   integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==
 
 parse5@^7.0.0:
-  version "7.1.2"
-  resolved "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz"
-  integrity sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==
+  version "7.3.0"
+  resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.3.0.tgz#d7e224fa72399c7a175099f45fc2ad024b05ec05"
+  integrity sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==
   dependencies:
-    entities "^4.4.0"
+    entities "^6.0.0"
 
 pascal-case@^3.1.2:
   version "3.1.2"
-  resolved "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
   integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
   dependencies:
     no-case "^3.0.4"
@@ -12260,30 +13334,30 @@ pascal-case@^3.1.2:
 
 path-exists@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
   integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
 
 path-is-absolute@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
   integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
 
 path-key@^3.0.0, path-key@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
 path-key@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-4.0.0.tgz#295588dc3aee64154f877adb9d780b81c554bf18"
   integrity sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==
 
 path-parse@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
 
-path-scurry@^1.10.1, path-scurry@^1.6.1:
+path-scurry@^1.10.1, path-scurry@^1.11.1, path-scurry@^1.6.1:
   version "1.11.1"
   resolved "https://registry.yarnpkg.com/path-scurry/-/path-scurry-1.11.1.tgz#7960a668888594a0720b12a911d1a742ab9f11d2"
   integrity sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==
@@ -12293,25 +13367,16 @@ path-scurry@^1.10.1, path-scurry@^1.6.1:
 
 path-to-regexp@^1.7.0:
   version "1.9.0"
-  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-1.9.0.tgz#5dc0753acbf8521ca2e0f137b4578b917b10cf24"
   integrity sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==
   dependencies:
     isarray "0.0.1"
 
 path-type@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
-periscopic@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/periscopic/-/periscopic-3.1.0.tgz"
-  integrity sha512-vKiQ8RRtkl9P+r/+oefh25C3fhybptkHKCZSPlcXiJux2tJF55GnEj3BVn4A5gKfq9NWWXXrxkHBwVPUfH0opw==
-  dependencies:
-    "@types/estree" "^1.0.0"
-    estree-walker "^3.0.0"
-    is-reference "^3.0.0"
-
 pg-int8@1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/pg-int8/-/pg-int8-1.0.1.tgz#943bd463bf5b71b4170115f80f8efc9a0c0eb78c"
@@ -12333,44 +13398,39 @@ pg-types@^2.2.0:
     postgres-date "~1.0.4"
     postgres-interval "^1.1.0"
 
-picocolors@^1.0.0, picocolors@^1.0.1, picocolors@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz"
-  integrity sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==
-
-picocolors@^1.1.1:
+picocolors@^1.0.0, picocolors@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b"
   integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==
 
 picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
-picomatch@^4.0.2:
+picomatch@^4.0.2, picomatch@^4.0.3:
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.3.tgz#796c76136d1eead715db1e7bad785dedd695a042"
   integrity sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==
 
-pidtree@~0.6.0:
+pidtree@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.npmjs.org/pidtree/-/pidtree-0.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/pidtree/-/pidtree-0.6.0.tgz#90ad7b6d42d5841e69e0a2419ef38f8883aa057c"
   integrity sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==
 
 pify@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
   integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
 
 pirates@^4.0.1:
-  version "4.0.6"
-  resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz"
-  integrity sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.7.tgz#643b4a18c4257c8a65104b73f3049ce9a0a15e22"
+  integrity sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==
 
 pliny@0.4.1:
   version "0.4.1"
-  resolved "https://registry.npmjs.org/pliny/-/pliny-0.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/pliny/-/pliny-0.4.1.tgz#47b49e666b5fdadcfad886be3c5392943a79b4cf"
   integrity sha512-VF6OapxBSUhRhVCj6jSoK2HNC7aJsfp6xDq5n4oQTFFQ1d0LHXVdVev2PznNzLuXkc/s3L1DooN8qWKRi4bpRw==
   dependencies:
     "@docsearch/react" "^3.6.2"
@@ -12389,19 +13449,19 @@ pliny@0.4.1:
 
 polished@^4.1.3:
   version "4.3.1"
-  resolved "https://registry.npmjs.org/polished/-/polished-4.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/polished/-/polished-4.3.1.tgz#5a00ae32715609f83d89f6f31d0f0261c6170548"
   integrity sha512-OBatVyC/N7SCW/FaDHrSd+vn0o5cS855TOmYi4OkdWUMSJCET/xip//ch8xGUvtr3i44X9LVyWwQlRMTN3pwSA==
   dependencies:
     "@babel/runtime" "^7.17.8"
 
 possible-typed-array-names@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz"
-  integrity sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz#93e3582bc0e5426586d9d07b79ee40fc841de4ae"
+  integrity sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==
 
 postcss-import@^15.1.0:
   version "15.1.0"
-  resolved "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-import/-/postcss-import-15.1.0.tgz#41c64ed8cc0e23735a9698b3249ffdbf704adc70"
   integrity sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==
   dependencies:
     postcss-value-parser "^4.0.0"
@@ -12409,67 +13469,66 @@ postcss-import@^15.1.0:
     resolve "^1.1.7"
 
 postcss-js@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz"
-  integrity sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-js/-/postcss-js-4.1.0.tgz#003b63c6edde948766e40f3daf7e997ae43a5ce6"
+  integrity sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==
   dependencies:
     camelcase-css "^2.0.1"
 
-postcss-load-config@^4.0.1:
+postcss-load-config@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-load-config/-/postcss-load-config-4.0.2.tgz#7159dcf626118d33e299f485d6afe4aff7c4a3e3"
   integrity sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==
   dependencies:
     lilconfig "^3.0.0"
     yaml "^2.3.4"
 
-postcss-nested@^6.0.1:
+postcss-nested@^6.2.0:
   version "6.2.0"
-  resolved "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-nested/-/postcss-nested-6.2.0.tgz#4c2d22ab5f20b9cb61e2c5c5915950784d068131"
   integrity sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==
   dependencies:
     postcss-selector-parser "^6.1.1"
 
 postcss-selector-parser@6.0.10:
   version "6.0.10"
-  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz#79b61e2c0d1bfc2602d549e11d0876256f8df88d"
   integrity sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==
   dependencies:
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
-postcss-selector-parser@^6.0.11, postcss-selector-parser@^6.1.1:
+postcss-selector-parser@^6.1.1, postcss-selector-parser@^6.1.2:
   version "6.1.2"
-  resolved "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz#27ecb41fb0e3b6ba7a1ec84fff347f734c7929de"
   integrity sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==
   dependencies:
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
+postcss-selector-parser@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz#4d6af97eba65d73bc4d84bcb343e865d7dd16262"
+  integrity sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==
+  dependencies:
+    cssesc "^3.0.0"
+    util-deprecate "^1.0.2"
+
 postcss-value-parser@^4.0.0, postcss-value-parser@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514"
   integrity sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==
 
 postcss@8.4.31:
   version "8.4.31"
-  resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.31.tgz#92b451050a9f914da6755af352bdc0192508656d"
   integrity sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==
   dependencies:
     nanoid "^3.3.6"
     picocolors "^1.0.0"
     source-map-js "^1.0.2"
 
-postcss@^8.4.23:
-  version "8.4.47"
-  resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.47.tgz"
-  integrity sha512-56rxCq7G/XfB4EkXq9Egn5GCqugWvDFjafDOThIdMBsI15iqPqR5r15TfSr1YPYeEI19YeaXMCbY6u88Y76GLQ==
-  dependencies:
-    nanoid "^3.3.7"
-    picocolors "^1.1.0"
-    source-map-js "^1.2.1"
-
-postcss@^8.5.0:
+postcss@^8.4.47, postcss@^8.5.0:
   version "8.5.6"
   resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.6.tgz#2825006615a619b4f62a9e7426cc120b349a8f3c"
   integrity sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==
@@ -12502,7 +13561,7 @@ postgres-interval@^1.1.0:
 
 postman-collection@^4.1.3:
   version "4.5.0"
-  resolved "https://registry.npmjs.org/postman-collection/-/postman-collection-4.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/postman-collection/-/postman-collection-4.5.0.tgz#cc485d67f2177d6f4c5c5f4bc75c257efd23f221"
   integrity sha512-152JSW9pdbaoJihwjc7Q8lc3nPg/PC9lPTHdMk7SHnHhu/GBJB7b2yb9zG7Qua578+3PxkQ/HYBuXpDSvsf7GQ==
   dependencies:
     "@faker-js/faker" "5.5.3"
@@ -12519,7 +13578,7 @@ postman-collection@^4.1.3:
 
 postman-url-encoder@3.0.5:
   version "3.0.5"
-  resolved "https://registry.npmjs.org/postman-url-encoder/-/postman-url-encoder-3.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/postman-url-encoder/-/postman-url-encoder-3.0.5.tgz#af2efee3bb7644e2b059d8a78bc8070fae0467a5"
   integrity sha512-jOrdVvzUXBC7C+9gkIkpDJ3HIxOHTIqjpQ4C1EMt1ZGeMvSEpbFCKq23DEfgsj46vMnDgyQf+1ZLp2Wm+bKSsA==
   dependencies:
     punycode "^2.1.1"
@@ -12531,63 +13590,98 @@ preact@^10.10.0:
 
 prelude-ls@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
 prettier-linter-helpers@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b"
   integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==
   dependencies:
     fast-diff "^1.1.2"
 
 prettier-plugin-tailwindcss@^0.5.11:
   version "0.5.14"
-  resolved "https://registry.npmjs.org/prettier-plugin-tailwindcss/-/prettier-plugin-tailwindcss-0.5.14.tgz"
+  resolved "https://registry.yarnpkg.com/prettier-plugin-tailwindcss/-/prettier-plugin-tailwindcss-0.5.14.tgz#4482eed357d5e22eac259541c70aca5a4c7b9d5c"
   integrity sha512-Puaz+wPUAhFp8Lo9HuciYKM2Y2XExESjeT+9NQoVFXZsPPnc9VYss2SpxdQ6vbatmt8/4+SN0oe0I1cPDABg9Q==
 
 prettier@^3.0.0:
-  version "3.3.3"
-  resolved "https://registry.npmjs.org/prettier/-/prettier-3.3.3.tgz"
-  integrity sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==
+  version "3.6.2"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.6.2.tgz#ccda02a1003ebbb2bfda6f83a074978f608b9393"
+  integrity sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==
 
 pretty-data@0.40.x:
   version "0.40.0"
-  resolved "https://registry.npmjs.org/pretty-data/-/pretty-data-0.40.0.tgz"
+  resolved "https://registry.yarnpkg.com/pretty-data/-/pretty-data-0.40.0.tgz#572aa8ea23467467ab94b6b5266a6fd9c8fddd72"
   integrity sha512-YFLnEdDEDnkt/GEhet5CYZHCvALw6+Elyb/tp8kQG03ZSIuzeaDWpZYndCXwgqu4NAjh1PI534dhDS1mHarRnQ==
 
 prism-react-renderer@^1.2.1:
   version "1.3.5"
-  resolved "https://registry.npmjs.org/prism-react-renderer/-/prism-react-renderer-1.3.5.tgz"
+  resolved "https://registry.yarnpkg.com/prism-react-renderer/-/prism-react-renderer-1.3.5.tgz#786bb69aa6f73c32ba1ee813fbe17a0115435085"
   integrity sha512-IJ+MSwBWKG+SM3b2SUfdrhC+gu01QkV2KmRQgREThBfSQRoufqRfxfHUxpG1WcaFjP+kojcFyO9Qqtpgt3qLCg==
 
 prismjs@^1.23.0:
   version "1.30.0"
-  resolved "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz"
+  resolved "https://registry.yarnpkg.com/prismjs/-/prismjs-1.30.0.tgz#d9709969d9d4e16403f6f348c63553b19f0975a9"
   integrity sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==
 
 probe-image-size@^7.2.3:
   version "7.2.3"
-  resolved "https://registry.npmjs.org/probe-image-size/-/probe-image-size-7.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/probe-image-size/-/probe-image-size-7.2.3.tgz#d49c64be540ec8edea538f6f585f65a9b3ab4309"
   integrity sha512-HubhG4Rb2UH8YtV4ba0Vp5bQ7L78RTONYu/ujmCu5nBI8wGv24s4E9xSKBi0N1MowRpxk76pFCpJtW0KPzOK0w==
   dependencies:
     lodash.merge "^4.6.2"
     needle "^2.5.2"
     stream-parser "~0.3.1"
 
+proc-log@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/proc-log/-/proc-log-5.0.0.tgz#e6c93cf37aef33f835c53485f314f50ea906a9d8"
+  integrity sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ==
+
 process-nextick-args@~2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
+proggy@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/proggy/-/proggy-3.0.0.tgz#874e91fed27fe00a511758e83216a6b65148bd6c"
+  integrity sha512-QE8RApCM3IaRRxVzxrjbgNMpQEX6Wu0p0KBeoSiSEw5/bsGwZHsshF4LCxH2jp/r6BU+bqA3LrMDEYNfJnpD8Q==
+
 progress@^2.0.3:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
   integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
 
+promise-all-reject-late@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/promise-all-reject-late/-/promise-all-reject-late-1.0.1.tgz#f8ebf13483e5ca91ad809ccc2fcf25f26f8643c2"
+  integrity sha512-vuf0Lf0lOxyQREH7GDIOUMLS7kz+gs8i6B+Yi8dC68a2sychGrHTJYghMBD6k7eUcH0H5P73EckCA48xijWqXw==
+
+promise-call-limit@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/promise-call-limit/-/promise-call-limit-3.0.2.tgz#524b7f4b97729ff70417d93d24f46f0265efa4f9"
+  integrity sha512-mRPQO2T1QQVw11E7+UdCJu7S61eJVWknzml9sC1heAdj1jxl0fWMBypIt9ZOcLFf8FkG995ZD7RnVk7HH72fZw==
+
+promise-retry@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/promise-retry/-/promise-retry-2.0.1.tgz#ff747a13620ab57ba688f5fc67855410c370da22"
+  integrity sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==
+  dependencies:
+    err-code "^2.0.2"
+    retry "^0.12.0"
+
+promzard@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/promzard/-/promzard-2.0.0.tgz#03ad0e4db706544dfdd4f459281f13484fc10c49"
+  integrity sha512-Ncd0vyS2eXGOjchIRg6PVCYKetJYrW1BSbbIo+bKdig61TB6nH2RQNF2uP+qMpsI73L/jURLWojcw8JNIKZ3gg==
+  dependencies:
+    read "^4.0.0"
+
 prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.1:
   version "15.8.1"
-  resolved "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5"
   integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
   dependencies:
     loose-envify "^1.4.0"
@@ -12596,13 +13690,18 @@ prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.1:
 
 property-information@^6.0.0:
   version "6.5.0"
-  resolved "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/property-information/-/property-information-6.5.0.tgz#6212fbb52ba757e92ef4fb9d657563b933b7ffec"
   integrity sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==
 
-protobufjs@^7.2.5, protobufjs@^7.3.0:
-  version "7.4.0"
-  resolved "https://registry.npmjs.org/protobufjs/-/protobufjs-7.4.0.tgz"
-  integrity sha512-mRUWCc3KUU4w1jU8sGxICXH/gNS94DvI1gxqDvBzhj1JpcsimQkYiOJfwsPUykUI5ZaspFbSgmBLER8IrQ3tqw==
+property-information@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/property-information/-/property-information-7.1.0.tgz#b622e8646e02b580205415586b40804d3e8bfd5d"
+  integrity sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==
+
+protobufjs@^7.3.0, protobufjs@^7.5.3:
+  version "7.5.4"
+  resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-7.5.4.tgz#885d31fe9c4b37f25d1bb600da30b1c5b37d286a"
+  integrity sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==
   dependencies:
     "@protobufjs/aspromise" "^1.1.2"
     "@protobufjs/base64" "^1.1.2"
@@ -12619,28 +13718,26 @@ protobufjs@^7.2.5, protobufjs@^7.3.0:
 
 proxy-from-env@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
   integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
 
 punycode@^2.1.0, punycode@^2.1.1:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5"
   integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==
 
-qs@^6.14.0:
+qrcode-terminal@^0.12.0:
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/qrcode-terminal/-/qrcode-terminal-0.12.0.tgz#bb5b699ef7f9f0505092a3748be4464fe71b5819"
+  integrity sha512-EXtzRZmC+YGmGlDFbXKxQiMZNwCLEO6BANKXG4iCtSIM0yqc/pappSx3RIKr4r0uh5JsBckOXeKrB3Iz7mdQpQ==
+
+qs@^6.14.0, qs@^6.5.1:
   version "6.14.0"
-  resolved "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.14.0.tgz#c63fa40680d2c5c941412a0e899c89af60c0a930"
   integrity sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==
   dependencies:
     side-channel "^1.1.0"
 
-qs@^6.5.1:
-  version "6.13.0"
-  resolved "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz"
-  integrity sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==
-  dependencies:
-    side-channel "^1.0.6"
-
 "qs@^6.5.1 < 6.10":
   version "6.9.7"
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.7.tgz#4610846871485e1e048f44ae3b94033f0e675afe"
@@ -12648,17 +13745,17 @@ qs@^6.5.1:
 
 queue-microtask@^1.2.2:
   version "1.2.3"
-  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
 quick-lru@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
   integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==
 
 react-dom@18.3.1:
   version "18.3.1"
-  resolved "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-18.3.1.tgz#c2265d79511b57d479b3dd3fdfa51536494c5cb4"
   integrity sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==
   dependencies:
     loose-envify "^1.1.0"
@@ -12666,17 +13763,17 @@ react-dom@18.3.1:
 
 react-fast-compare@^3.2.0:
   version "3.2.2"
-  resolved "https://registry.npmjs.org/react-fast-compare/-/react-fast-compare-3.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/react-fast-compare/-/react-fast-compare-3.2.2.tgz#929a97a532304ce9fee4bcae44234f1ce2c21d49"
   integrity sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==
 
 react-ga4@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/react-ga4/-/react-ga4-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/react-ga4/-/react-ga4-2.1.0.tgz#56601f59d95c08466ebd6edfbf8dede55c4678f9"
   integrity sha512-ZKS7PGNFqqMd3PJ6+C2Jtz/o1iU9ggiy8Y8nUeksgVuvNISbmrQtJiZNvC/TjDsqD0QlU5Wkgs7i+w9+OjHhhQ==
 
 react-icons@^5.5.0:
   version "5.5.0"
-  resolved "https://registry.npmjs.org/react-icons/-/react-icons-5.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/react-icons/-/react-icons-5.5.0.tgz#8aa25d3543ff84231685d3331164c00299cdfaf2"
   integrity sha512-MEFcXdkP3dLo8uumGI5xN3lDFNsRtrjbOEKDLD7yv76v4wpnEq2Lt2qeHaQOr34I/wPN3s3+N08WkQ+CW37Xiw==
 
 react-instantsearch-core@7.16.3:
@@ -12701,25 +13798,26 @@ react-instantsearch@^7.16.3:
 
 react-is@^16.13.1, react-is@^16.6.0, react-is@^16.7.0:
   version "16.13.1"
-  resolved "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
 react-is@^18.3.1:
   version "18.3.1"
-  resolved "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.3.1.tgz#e83557dc12eae63a99e003a46388b1dcbb44db7e"
   integrity sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==
 
 react-lite-yt-embed@^1.2.7:
   version "1.2.7"
-  resolved "https://registry.npmjs.org/react-lite-yt-embed/-/react-lite-yt-embed-1.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/react-lite-yt-embed/-/react-lite-yt-embed-1.2.7.tgz#720d90ae225989ef558b974613d4bdebfd33ac8b"
   integrity sha512-c660Rp089OJnhIKHq6BzI/2XiExveJAYBVZBj0q26A1Pl2uqlXeLHW/WruGjszQdRHxiJquo2o7hVTvJ5OongA==
 
 react-markdown@^9.0.1:
-  version "9.0.3"
-  resolved "https://registry.npmjs.org/react-markdown/-/react-markdown-9.0.3.tgz"
-  integrity sha512-Yk7Z94dbgYTOrdk41Z74GoKA7rThnsbbqBTRYuxoe08qvfQ9tJVhmAKw6BJS/ZORG7kTy/s1QvYzSuaoBA1qfw==
+  version "9.1.0"
+  resolved "https://registry.yarnpkg.com/react-markdown/-/react-markdown-9.1.0.tgz#606bd74c6af131ba382a7c1282ff506708ed2e26"
+  integrity sha512-xaijuJB0kzGiUdG7nc2MOMDUDBWPyGAjZtUrow9XxUeua8IqeP+VlIfAZ3bphpcLTnSZXz6z9jcVC/TCwbfgdw==
   dependencies:
     "@types/hast" "^3.0.0"
+    "@types/mdast" "^4.0.0"
     devlop "^1.0.0"
     hast-util-to-jsx-runtime "^2.0.0"
     html-url-attributes "^3.0.0"
@@ -12731,25 +13829,29 @@ react-markdown@^9.0.1:
     vfile "^6.0.0"
 
 react-medium-image-zoom@^5.2.3:
-  version "5.2.10"
-  resolved "https://registry.npmjs.org/react-medium-image-zoom/-/react-medium-image-zoom-5.2.10.tgz"
-  integrity sha512-JBYf4u0zsocezIDtrjwStD+8sX+c8XuLsdz+HxPbojRj0sCicua0XOQKysuPetoFyX+YgStfj+vEtZ+699O/pg==
+  version "5.4.0"
+  resolved "https://registry.yarnpkg.com/react-medium-image-zoom/-/react-medium-image-zoom-5.4.0.tgz#b89c74a4f631289e8a7a21af26614c58fff0ea81"
+  integrity sha512-BsE+EnFVQzFIlyuuQrZ9iTwyKpKkqdFZV1ImEQN573QPqGrIUuNni7aF+sZwDcxlsuOMayCr6oO/PZR/yJnbRg==
 
 react-multi-carousel@^2.8.5:
-  version "2.8.5"
-  resolved "https://registry.npmjs.org/react-multi-carousel/-/react-multi-carousel-2.8.5.tgz"
-  integrity sha512-C5DAvJkfzR2JK9YixZ3oyF9x6R4LW6nzTpIXrl9Oujxi4uqP9SzVVCjl+JLM3tSdqdjAx/oWZK3dTVBSR73Q+w==
+  version "2.8.6"
+  resolved "https://registry.yarnpkg.com/react-multi-carousel/-/react-multi-carousel-2.8.6.tgz#a7b8027a0e871bfcf06efce96d1deab3a41e1b2c"
+  integrity sha512-sAX5I9Xec3MR9FxLgZYcYqNnY8M8zJxRRwRipMPtuh4BGvcvoptJfX8Z6nRn0ROMkqVO72iAmb83GlqmSW4Gqw==
+  dependencies:
+    core-js "^3.32.2"
+    install "^0.13.0"
+    npm "^10.1.0"
 
 react-overflow-list@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.npmjs.org/react-overflow-list/-/react-overflow-list-0.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/react-overflow-list/-/react-overflow-list-0.5.0.tgz#49ef8c34b619f2aead70b48dbf5d57b18d6a13aa"
   integrity sha512-+UegukgQ10E4ll3txz4DJyrnCgZ3eDVuv5dvR8ziyG5FfgCDZcUKeKhIgbU90oyqQa21aH4oLOoGKt0TiYJRmg==
   dependencies:
     react-use "^17.3.1"
 
 react-query@^3.34.19:
   version "3.39.3"
-  resolved "https://registry.npmjs.org/react-query/-/react-query-3.39.3.tgz"
+  resolved "https://registry.yarnpkg.com/react-query/-/react-query-3.39.3.tgz#4cea7127c6c26bdea2de5fb63e51044330b03f35"
   integrity sha512-nLfLz7GiohKTJDuT4us4X3h/8unOh+00MLb2yJoGTPjxKs2bc1iDhkNx2bd5MKklXnOD3NrVZ+J2UXujA5In4g==
   dependencies:
     "@babel/runtime" "^7.5.5"
@@ -12758,15 +13860,15 @@ react-query@^3.34.19:
 
 react-remove-scroll-bar@^2.3.7:
   version "2.3.8"
-  resolved "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz#99c20f908ee467b385b68a3469b4a3e750012223"
   integrity sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==
   dependencies:
     react-style-singleton "^2.2.2"
     tslib "^2.0.0"
 
-react-remove-scroll@^2.5.6, react-remove-scroll@^2.6.3:
+react-remove-scroll@^2.6.3:
   version "2.7.1"
-  resolved "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.1.tgz"
+  resolved "https://registry.yarnpkg.com/react-remove-scroll/-/react-remove-scroll-2.7.1.tgz#d2101d414f6d81d7d3bf033f3c1cb4785789f753"
   integrity sha512-HpMh8+oahmIdOuS5aFKKY6Pyog+FNaZV/XyJOq7b4YFwsFHe5yYfdbIalI4k3vU2nSDql7YskmUseHsRrJqIPA==
   dependencies:
     react-remove-scroll-bar "^2.3.7"
@@ -12777,7 +13879,7 @@ react-remove-scroll@^2.5.6, react-remove-scroll@^2.6.3:
 
 react-router-dom@^5.2.0:
   version "5.3.4"
-  resolved "https://registry.npmjs.org/react-router-dom/-/react-router-dom-5.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/react-router-dom/-/react-router-dom-5.3.4.tgz#2ed62ffd88cae6db134445f4a0c0ae8b91d2e5e6"
   integrity sha512-m4EqFMHv/Ih4kpcBCONHbkT68KoAeHN4p3lAGoNryfHi0dMy0kCzEZakiKRsvg5wHZ/JLrLW8o8KomWiz/qbYQ==
   dependencies:
     "@babel/runtime" "^7.12.13"
@@ -12790,14 +13892,14 @@ react-router-dom@^5.2.0:
 
 react-router-hash-link@^2.1.0:
   version "2.4.3"
-  resolved "https://registry.npmjs.org/react-router-hash-link/-/react-router-hash-link-2.4.3.tgz"
+  resolved "https://registry.yarnpkg.com/react-router-hash-link/-/react-router-hash-link-2.4.3.tgz#570824d53d6c35ce94d73a46c8e98673a127bf08"
   integrity sha512-NU7GWc265m92xh/aYD79Vr1W+zAIXDWp3L2YZOYP4rCqPnJ6LI6vh3+rKgkidtYijozHclaEQTAHaAaMWPVI4A==
   dependencies:
     prop-types "^15.7.2"
 
 react-router@5.3.4:
   version "5.3.4"
-  resolved "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/react-router/-/react-router-5.3.4.tgz#8ca252d70fcc37841e31473c7a151cf777887bb5"
   integrity sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==
   dependencies:
     "@babel/runtime" "^7.12.13"
@@ -12810,10 +13912,10 @@ react-router@5.3.4:
     tiny-invariant "^1.0.2"
     tiny-warning "^1.0.0"
 
-react-smooth@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/react-smooth/-/react-smooth-4.0.1.tgz"
-  integrity sha512-OE4hm7XqR0jNOq3Qmk9mFLyd6p2+j6bvbPJ7qlB7+oo0eNcL2l7WQzG6MBnT3EXY6xzkLMUBec3AfewJdA0J8w==
+react-smooth@^4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/react-smooth/-/react-smooth-4.0.4.tgz#a5875f8bb61963ca61b819cedc569dc2453894b4"
+  integrity sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==
   dependencies:
     fast-equals "^5.0.1"
     prop-types "^15.8.1"
@@ -12821,16 +13923,16 @@ react-smooth@^4.0.0:
 
 react-style-singleton@^2.2.2, react-style-singleton@^2.2.3:
   version "2.2.3"
-  resolved "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/react-style-singleton/-/react-style-singleton-2.2.3.tgz#4265608be69a4d70cfe3047f2c6c88b2c3ace388"
   integrity sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==
   dependencies:
     get-nonce "^1.0.0"
     tslib "^2.0.0"
 
 react-textarea-autosize@^8.5.3:
-  version "8.5.7"
-  resolved "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.5.7.tgz"
-  integrity sha512-2MqJ3p0Jh69yt9ktFIaZmORHXw4c4bxSIhCeWiFwmJ9EYKgLmuNII3e9c9b2UO+ijl4StnpZdqpxNIhTdHvqtQ==
+  version "8.5.9"
+  resolved "https://registry.yarnpkg.com/react-textarea-autosize/-/react-textarea-autosize-8.5.9.tgz#ab8627b09aa04d8a2f45d5b5cd94c84d1d4a8893"
+  integrity sha512-U1DGlIQN5AwgjTyOEnI1oCcMuEr1pv1qOtklB2l4nyMGbHzWrI0eFsYK0zos2YWqAolJyG0IWJaqWmWj5ETh0A==
   dependencies:
     "@babel/runtime" "^7.20.13"
     use-composed-ref "^1.3.0"
@@ -12838,7 +13940,7 @@ react-textarea-autosize@^8.5.3:
 
 react-transition-group@^4.4.5:
   version "4.4.5"
-  resolved "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz"
+  resolved "https://registry.yarnpkg.com/react-transition-group/-/react-transition-group-4.4.5.tgz#e53d4e3f3344da8521489fbef8f2581d42becdd1"
   integrity sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==
   dependencies:
     "@babel/runtime" "^7.5.5"
@@ -12848,13 +13950,13 @@ react-transition-group@^4.4.5:
 
 react-universal-interface@^0.6.2:
   version "0.6.2"
-  resolved "https://registry.npmjs.org/react-universal-interface/-/react-universal-interface-0.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/react-universal-interface/-/react-universal-interface-0.6.2.tgz#5e8d438a01729a4dbbcbeeceb0b86be146fe2b3b"
   integrity sha512-dg8yXdcQmvgR13RIlZbTRQOoUrDciFVoSBZILwjE2LFISxZZ8loVJKAkuzswl5js8BHda79bIb2b84ehU8IjXw==
 
 react-use@^17.3.1:
-  version "17.5.1"
-  resolved "https://registry.npmjs.org/react-use/-/react-use-17.5.1.tgz"
-  integrity sha512-LG/uPEVRflLWMwi3j/sZqR00nF6JGqTTDblkXK2nzXsIvij06hXl1V/MZIlwj1OKIQUtlh1l9jK8gLsRyCQxMg==
+  version "17.6.0"
+  resolved "https://registry.yarnpkg.com/react-use/-/react-use-17.6.0.tgz#2101a3a79dc965a25866b21f5d6de4b128488a14"
+  integrity sha512-OmedEScUMKFfzn1Ir8dBxiLLSOzhKe/dPZwVxcujweSj45aNM7BEGPb9BEVIgVEqEXx6f3/TsXzwIktNgUR02g==
   dependencies:
     "@types/js-cookie" "^2.2.6"
     "@xobotyi/scrollbar-width" "^1.9.5"
@@ -12873,28 +13975,41 @@ react-use@^17.3.1:
 
 react-virtual@^2.8.2:
   version "2.10.4"
-  resolved "https://registry.npmjs.org/react-virtual/-/react-virtual-2.10.4.tgz"
+  resolved "https://registry.yarnpkg.com/react-virtual/-/react-virtual-2.10.4.tgz#08712f0acd79d7d6f7c4726f05651a13b24d8704"
   integrity sha512-Ir6+oPQZTVHfa6+JL9M7cvMILstFZH/H3jqeYeKI4MSUX+rIruVwFC6nGVXw9wqAw8L0Kg2KvfXxI85OvYQdpQ==
   dependencies:
     "@reach/observe-rect" "^1.1.0"
 
 react@^18.3.1:
   version "18.3.1"
-  resolved "https://registry.npmjs.org/react/-/react-18.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/react/-/react-18.3.1.tgz#49ab892009c53933625bd16b2533fc754cab2891"
   integrity sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==
   dependencies:
     loose-envify "^1.1.0"
 
 read-cache@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/read-cache/-/read-cache-1.0.0.tgz#e664ef31161166c9751cdbe8dbcf86b5fb58f774"
   integrity sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==
   dependencies:
     pify "^2.3.0"
 
+read-cmd-shim@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/read-cmd-shim/-/read-cmd-shim-5.0.0.tgz#6e5450492187a0749f6c80dcbef0debc1117acca"
+  integrity sha512-SEbJV7tohp3DAAILbEMPXavBjAnMN0tVnh4+9G8ihV4Pq3HYF9h8QNez9zkJ1ILkv9G2BjdzwctznGZXgu/HGw==
+
+read-package-json-fast@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/read-package-json-fast/-/read-package-json-fast-4.0.0.tgz#8ccbc05740bb9f58264f400acc0b4b4eee8d1b39"
+  integrity sha512-qpt8EwugBWDw2cgE2W+/3oxC+KTez2uSVR8JU9Q36TXPAGCaozfQUs59v4j4GFpWTaw0i6hAZSvOmu1J0uOEUg==
+  dependencies:
+    json-parse-even-better-errors "^4.0.0"
+    npm-normalize-package-bin "^4.0.0"
+
 read-pkg-up@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
   integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
   dependencies:
     find-up "^4.1.0"
@@ -12903,7 +14018,7 @@ read-pkg-up@^7.0.1:
 
 read-pkg@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
   integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==
   dependencies:
     "@types/normalize-package-data" "^2.4.0"
@@ -12911,9 +14026,16 @@ read-pkg@^5.2.0:
     parse-json "^5.0.0"
     type-fest "^0.6.0"
 
+read@^4.0.0, read@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/read/-/read-4.1.0.tgz#d97c2556b009b47b16b5bb82311d477cc7503548"
+  integrity sha512-uRfX6K+f+R8OOrYScaM3ixPY4erg69f8DN6pgTvMcA9iRc8iDhwrA4m3Yu8YYKsXJgVvum+m8PkRboZwwuLzYA==
+  dependencies:
+    mute-stream "^2.0.0"
+
 readable-stream@3, readable-stream@^3.0.0:
   version "3.6.2"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967"
   integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
   dependencies:
     inherits "^2.0.3"
@@ -12922,7 +14044,7 @@ readable-stream@3, readable-stream@^3.0.0:
 
 readable-stream@^2.0.5, readable-stream@~2.3.6:
   version "2.3.8"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.8.tgz#91125e8042bba1b9887f49345f6277027ce8be9b"
   integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
   dependencies:
     core-util-is "~1.0.0"
@@ -12935,7 +14057,7 @@ readable-stream@^2.0.5, readable-stream@~2.3.6:
 
 readable-stream@~1.0.31:
   version "1.0.34"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.34.tgz#125820e34bc842d2f2aaafafe4c2916ee32c157c"
   integrity sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==
   dependencies:
     core-util-is "~1.0.0"
@@ -12945,124 +14067,160 @@ readable-stream@~1.0.31:
 
 readdirp@~3.6.0:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
   integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
   dependencies:
     picomatch "^2.2.1"
 
 reading-time@1.5.0:
   version "1.5.0"
-  resolved "https://registry.npmjs.org/reading-time/-/reading-time-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/reading-time/-/reading-time-1.5.0.tgz#d2a7f1b6057cb2e169beaf87113cc3411b5bc5bb"
   integrity sha512-onYyVhBNr4CmAxFsKS7bz+uTLRakypIe4R+5A824vBSkQy/hB3fZepoVEf8OVAxzLvK+H/jm9TzpI3ETSm64Kg==
 
 recharts-scale@^0.4.4:
   version "0.4.5"
-  resolved "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.4.5.tgz"
+  resolved "https://registry.yarnpkg.com/recharts-scale/-/recharts-scale-0.4.5.tgz#0969271f14e732e642fcc5bd4ab270d6e87dd1d9"
   integrity sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==
   dependencies:
     decimal.js-light "^2.4.1"
 
 recharts@^2.13.0:
-  version "2.13.0"
-  resolved "https://registry.npmjs.org/recharts/-/recharts-2.13.0.tgz"
-  integrity sha512-sbfxjWQ+oLWSZEWmvbq/DFVdeRLqqA6d0CDjKx2PkxVVdoXo16jvENCE+u/x7HxOO+/fwx//nYRwb8p8X6s/lQ==
+  version "2.15.4"
+  resolved "https://registry.yarnpkg.com/recharts/-/recharts-2.15.4.tgz#0ed3e66c0843bcf2d9f9a172caf97b1d05127a5f"
+  integrity sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==
   dependencies:
     clsx "^2.0.0"
     eventemitter3 "^4.0.1"
     lodash "^4.17.21"
     react-is "^18.3.1"
-    react-smooth "^4.0.0"
+    react-smooth "^4.0.4"
     recharts-scale "^0.4.4"
     tiny-invariant "^1.3.1"
     victory-vendor "^36.6.8"
 
+recma-build-jsx@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz#c02f29e047e103d2fab2054954e1761b8ea253c4"
+  integrity sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==
+  dependencies:
+    "@types/estree" "^1.0.0"
+    estree-util-build-jsx "^3.0.0"
+    vfile "^6.0.0"
+
+recma-jsx@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/recma-jsx/-/recma-jsx-1.0.1.tgz#58e718f45e2102ed0bf2fa994f05b70d76801a1a"
+  integrity sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==
+  dependencies:
+    acorn-jsx "^5.0.0"
+    estree-util-to-js "^2.0.0"
+    recma-parse "^1.0.0"
+    recma-stringify "^1.0.0"
+    unified "^11.0.0"
+
+recma-parse@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/recma-parse/-/recma-parse-1.0.0.tgz#c351e161bb0ab47d86b92a98a9d891f9b6814b52"
+  integrity sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==
+  dependencies:
+    "@types/estree" "^1.0.0"
+    esast-util-from-js "^2.0.0"
+    unified "^11.0.0"
+    vfile "^6.0.0"
+
+recma-stringify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/recma-stringify/-/recma-stringify-1.0.0.tgz#54632030631e0c7546136ff9ef8fde8e7b44f130"
+  integrity sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==
+  dependencies:
+    "@types/estree" "^1.0.0"
+    estree-util-to-js "^2.0.0"
+    unified "^11.0.0"
+    vfile "^6.0.0"
+
 redent@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
   integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
   dependencies:
     indent-string "^4.0.0"
     strip-indent "^3.0.0"
 
-reflect.getprototypeof@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.6.tgz"
-  integrity sha512-fmfw4XgoDke3kdI6h4xcUz1dG8uaiv5q9gcEwLS4Pnth2kxT+GZ7YehS1JTMGBQmtV7Y4GFGbs2re2NqhdozUg==
+reflect.getprototypeof@^1.0.6, reflect.getprototypeof@^1.0.9:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz#c629219e78a3316d8b604c765ef68996964e7bf9"
+  integrity sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
     define-properties "^1.2.1"
-    es-abstract "^1.23.1"
+    es-abstract "^1.23.9"
     es-errors "^1.3.0"
-    get-intrinsic "^1.2.4"
-    globalthis "^1.0.3"
-    which-builtin-type "^1.1.3"
+    es-object-atoms "^1.0.0"
+    get-intrinsic "^1.2.7"
+    get-proto "^1.0.1"
+    which-builtin-type "^1.2.1"
 
 refractor@^4.8.0:
-  version "4.8.1"
-  resolved "https://registry.npmjs.org/refractor/-/refractor-4.8.1.tgz"
-  integrity sha512-/fk5sI0iTgFYlmVGYVew90AoYnNMP6pooClx/XKqyeeCQXrL0Kvgn8V0VEht5ccdljbzzF1i3Q213gcntkRExg==
+  version "4.9.0"
+  resolved "https://registry.yarnpkg.com/refractor/-/refractor-4.9.0.tgz#2e1c7af0157230cdd2f9086660912eadc5f68323"
+  integrity sha512-nEG1SPXFoGGx+dcjftjv8cAjEusIh6ED1xhf5DG3C0x/k+rmZ2duKnc3QLpt6qeHv5fPb8uwN3VWN2BT7fr3Og==
   dependencies:
     "@types/hast" "^2.0.0"
     "@types/prismjs" "^1.0.0"
     hastscript "^7.0.0"
     parse-entities "^4.0.0"
 
-regenerate-unicode-properties@^10.1.0:
-  version "10.2.0"
-  resolved "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz"
-  integrity sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==
+regenerate-unicode-properties@^10.2.2:
+  version "10.2.2"
+  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz#aa113812ba899b630658c7623466be71e1f86f66"
+  integrity sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==
   dependencies:
     regenerate "^1.4.2"
 
 regenerate@^1.4.2:
   version "1.4.2"
-  resolved "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz"
+  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
-regenerator-runtime@^0.14.0:
-  version "0.14.1"
-  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz"
-  integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==
-
-regenerator-transform@^0.15.2:
-  version "0.15.2"
-  resolved "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz"
-  integrity sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==
-  dependencies:
-    "@babel/runtime" "^7.8.4"
-
-regexp.prototype.flags@^1.5.1, regexp.prototype.flags@^1.5.2:
-  version "1.5.2"
-  resolved "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz"
-  integrity sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==
+regexp.prototype.flags@^1.5.3, regexp.prototype.flags@^1.5.4:
+  version "1.5.4"
+  resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz#1ad6c62d44a259007e55b3970e00f746efbcaa19"
+  integrity sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==
   dependencies:
-    call-bind "^1.0.6"
+    call-bind "^1.0.8"
     define-properties "^1.2.1"
     es-errors "^1.3.0"
-    set-function-name "^2.0.1"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
+    set-function-name "^2.0.2"
 
-regexpu-core@^5.3.1:
-  version "5.3.2"
-  resolved "https://registry.npmjs.org/regexpu-core/-/regexpu-core-5.3.2.tgz"
-  integrity sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==
+regexpu-core@^6.2.0:
+  version "6.4.0"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-6.4.0.tgz#3580ce0c4faedef599eccb146612436b62a176e5"
+  integrity sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==
   dependencies:
-    "@babel/regjsgen" "^0.8.0"
     regenerate "^1.4.2"
-    regenerate-unicode-properties "^10.1.0"
-    regjsparser "^0.9.1"
+    regenerate-unicode-properties "^10.2.2"
+    regjsgen "^0.8.0"
+    regjsparser "^0.13.0"
     unicode-match-property-ecmascript "^2.0.0"
-    unicode-match-property-value-ecmascript "^2.1.0"
+    unicode-match-property-value-ecmascript "^2.2.1"
+
+regjsgen@^0.8.0:
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.8.0.tgz#df23ff26e0c5b300a6470cad160a9d090c3a37ab"
+  integrity sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==
 
-regjsparser@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.9.1.tgz"
-  integrity sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==
+regjsparser@^0.13.0:
+  version "0.13.0"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.13.0.tgz#01f8351335cf7898d43686bc74d2dd71c847ecc0"
+  integrity sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==
   dependencies:
-    jsesc "~0.5.0"
+    jsesc "~3.1.0"
 
 rehype-autolink-headings@^7.1.0:
   version "7.1.0"
-  resolved "https://registry.npmjs.org/rehype-autolink-headings/-/rehype-autolink-headings-7.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/rehype-autolink-headings/-/rehype-autolink-headings-7.1.0.tgz#531087e155d9df053944923efd47d99728f3b196"
   integrity sha512-rItO/pSdvnvsP4QRB1pmPiNHUskikqtPojZKJPPPAVx9Hj8i8TwMBhofrrAYRhYOOBZH9tgmG5lPqDLuIWPWmw==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -13073,9 +14231,9 @@ rehype-autolink-headings@^7.1.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-attribute-whitespace@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-attribute-whitespace/-/rehype-minify-attribute-whitespace-4.0.0.tgz"
-  integrity sha512-F1MjgAY1wjD5cHhPrWBW8zDoD8YboJuYBj9wDOClibvbuAE34NmoWiEV2ortAwilzwuZFodJaxK6VaDp8uW6zA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-attribute-whitespace/-/rehype-minify-attribute-whitespace-4.0.1.tgz#16c029749abcd42c67353aaa7a0fa5496f7eb239"
+  integrity sha512-QAfUrcZ6KCfpYonDbiWKTRpnVu9DYxFlvXMWWZe4BQbojwjjUbGIg1zoqyInJiJHAdYYyTHN5yJV2THa3opIng==
   dependencies:
     "@types/hast" "^3.0.0"
     collapse-white-space "^2.0.0"
@@ -13084,9 +14242,9 @@ rehype-minify-attribute-whitespace@^4.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-css-style@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-css-style/-/rehype-minify-css-style-4.0.0.tgz"
-  integrity sha512-xGG89O5KaHN0V9eT1bVZd3aIaNwSpaYPD44VW0Mv5BQ3UBqL7xnkU6VVLn8G1P2zV3nqjznh+2jZ1hBsxnVHdg==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-css-style/-/rehype-minify-css-style-4.0.1.tgz#825a8691dbb8644425cd8a01ab59c573d635f405"
+  integrity sha512-vIYlkQx0vvstzUk7XKc//i5HOklD7N84jaRq22XzOqxgf8bpGF9Jl90V4T+OUepX110UMEltv1rHl57lpAQjjg==
   dependencies:
     "@types/hast" "^3.0.0"
     clean-css "^5.0.0"
@@ -13096,21 +14254,21 @@ rehype-minify-css-style@^4.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-enumerated-attribute@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-enumerated-attribute/-/rehype-minify-enumerated-attribute-5.0.0.tgz"
-  integrity sha512-z8hprxjuxlbnj8GvJmHgzUXeyti+qoTzlYCjPaDAHapPuw4drDu33m8bfQEPB1k9maOdcF274PAcODuBZ2iXFg==
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/rehype-minify-enumerated-attribute/-/rehype-minify-enumerated-attribute-5.0.2.tgz#92aff3dc99d1f5d8bbac6ae42196636c79e5a538"
+  integrity sha512-B4laV6OHZAtXnvfNQw17q9a2TIzSCLM5gGc0Hv8Cn2Zun7Ri0hz5wKRULy0yelAyBZfTMbjM/euR2kHAmQHITw==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-select "^6.0.0"
     html-enumerated-attributes "^1.0.0"
-    property-information "^6.0.0"
+    property-information "^7.0.0"
     space-separated-tokens "^2.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-event-handler@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-event-handler/-/rehype-minify-event-handler-4.0.0.tgz"
-  integrity sha512-kWg3WUipExzU7dOIszrUVJ61lA66blccwyW1GixL0fvWkWUeHW9RKW6jF1c8e3kiWcg91YpLtpgjujDK3bf9mg==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-event-handler/-/rehype-minify-event-handler-4.0.1.tgz#b78dbe4c49d5d5fddc5d0b7cbc2651d723de3dc1"
+  integrity sha512-zDO5GyQqPKP68mGV4lGeCDoVii9eAt4DgqOiyfYIapHA/8YTQHCjJAevrNuBd3+xPg2e9jsH4KE8SpRjjAKfLg==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-event-handler "^3.0.0"
@@ -13118,9 +14276,9 @@ rehype-minify-event-handler@^4.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-javascript-script@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-javascript-script/-/rehype-minify-javascript-script-5.0.0.tgz"
-  integrity sha512-DkU4tJt4vGt9Rnz1yW4ttbEypIHBkHT/LLNH+9bwDA5RYN88Fsdq3m42TVCAJNfqXUAiwIIuJzipMAMtlD+mEw==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-javascript-script/-/rehype-minify-javascript-script-5.0.1.tgz#adb684db720cbf5bc0da85e6c9bd2c4097a3d10a"
+  integrity sha512-7kzo/4hJz/6zIdPune/TyaFfA8IEawN3WmEZpw1Sa/iGu0nXwFI07nH45efYdYg/PD8EGNzJfuGqHGzfq0ewhA==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-from-string "^3.0.0"
@@ -13130,9 +14288,9 @@ rehype-minify-javascript-script@^5.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-javascript-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-javascript-url/-/rehype-minify-javascript-url-5.0.0.tgz"
-  integrity sha512-LFvs0V/UlO3TbtKqbUwlGr5kfgZcQ9ogTJ6BnOPv2ZAYAmGmRwOahT2mbNasMD19IfHyYrrp9bOn5ZkQkHck2Q==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-javascript-url/-/rehype-minify-javascript-url-5.0.1.tgz#5b9bf512829b19bff039c6a38a232e7752809a9a"
+  integrity sha512-sBaN58Vj/a303tnKVv0fKKJoN9TxpZhw1Jt1k1rQoIxs3SCCjDpIc+VGp4RcqBY4K2F7i1gjbAKYQ1H/7mjUTQ==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
@@ -13141,9 +14299,9 @@ rehype-minify-javascript-url@^5.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-json-script@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-json-script/-/rehype-minify-json-script-4.0.0.tgz"
-  integrity sha512-0NfiNC4aXRThGVxqsQN2vhEeDZeLfOcuyBEh1qw14JtxTiH0nZFKNLzLuY9Jfg8w5AlYkR6NEAwUV4gkTjm8pw==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-json-script/-/rehype-minify-json-script-4.0.1.tgz#2639246e18acd96289ef68e42cdbfa18a28ce634"
+  integrity sha512-r4+mqLZvhICFTPGxNykw2uOejnCy0wHtnAZSFHZbOCq5fF0+fr9892o6fdwT7phcXCrLPeZXORRZr48mTyhEBQ==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-from-string "^3.0.0"
@@ -13151,71 +14309,71 @@ rehype-minify-json-script@^4.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-minify-language@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-language/-/rehype-minify-language-3.0.0.tgz"
-  integrity sha512-IbRgWo9NXffkneQi9GNNs4OrZxtja6RN2rSIyDO7vwYRs8zqBNDknTQfzPo/IyU28SBco4k8dDR3J+Hv7cUCMw==
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-language/-/rehype-minify-language-3.0.1.tgz#885dad1ea5d1bb7e5202e648f27ee00f5876b7a8"
+  integrity sha512-601rocoA1MntPZZsWmPUkNN76nisKbG2JGv8OsacWs8tnpHoE8Ozurm9kp7ddvFjTbYy8xtgJB72s2yPEFhbzg==
   dependencies:
     "@types/hast" "^3.0.0"
     bcp-47-normalize "^2.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-media-attribute@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-media-attribute/-/rehype-minify-media-attribute-4.0.0.tgz"
-  integrity sha512-2JACl0xNs1TUPA6YXDMppDvtugrXMaOyv51caXVeW/PFYflZoUsnuKqjuJEQkPEFVikUVlfB05RCnbS/0JD6RA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-media-attribute/-/rehype-minify-media-attribute-4.0.1.tgz#791e2084785f6a415408a6456d4ccc4cfbf5625b"
+  integrity sha512-J6W+RceuJ07PQcHUTBfFEgxw5buGvwY901PQMGSQJBoWkfe7vJhXSPwZJ5EdIeAMbh0vYpc80k//FNfFUhqKXg==
   dependencies:
     "@types/hast" "^3.0.0"
     clean-css "^5.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-meta-color@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-meta-color/-/rehype-minify-meta-color-4.0.0.tgz"
-  integrity sha512-lkDFBWl6P4SNE90jj31uWEa09laGIi+5HhHgoPglJA+lLjhODqtZIA67IpnBaQIRPd9eV4BmWxFk6qrORgYTlw==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-meta-color/-/rehype-minify-meta-color-4.0.1.tgz#77bda0f34dcaa724ef227b61867dd4296bdc16ee"
+  integrity sha512-oWpcdB+fZQNZBvVLSF8Jo7/D+s8y7okJQCJNOu73WF2asXuR5Iz5zmFChujhqTVl4X3Io2yZ9NryJ+2QK/butQ==
   dependencies:
     "@types/hast" "^3.0.0"
     clean-css "^5.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-meta-content@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-meta-content/-/rehype-minify-meta-content-4.0.0.tgz"
-  integrity sha512-kunksmrtjGEYTfWx+nyX/b4y736KEE41uKoFApfFxjvPYX0b9II7G7E4Nji2f1v44+OHQgMfgluJcGrOKVvbcQ==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-meta-content/-/rehype-minify-meta-content-4.0.1.tgz#3ddf18d96256e2bd4748f99ade4b7a5668209d79"
+  integrity sha512-81/0V5HIgaSkgzlhi8P9lXh8JkoQ8gZzda+xAIGgK0zRFu9EUYfbzJp/y5pUsV7zZaSWDgr0WhMSs4zyUnRLQA==
   dependencies:
     "@types/hast" "^3.0.0"
     comma-separated-tokens "^2.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-style-attribute@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-minify-style-attribute/-/rehype-minify-style-attribute-4.0.0.tgz"
-  integrity sha512-hljVab2ikSUFC8O2JFKCvTPj1TdZcxHdnyCcpy2EzQw6JFGiQnUwVrCVgd2kMiKNmeanliwxLOZqaUiGPG58/w==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-minify-style-attribute/-/rehype-minify-style-attribute-4.0.1.tgz#7a2074e550441a86d8d3abebb336b6b6b03a4896"
+  integrity sha512-J2efUDe9A4AIwCi04HRHnqf2+mZoADZAmnwBmfJKMAjoci1d8nGgTyAhw1uq6XHXzG0wDa3i54o5xoS+4lc5xw==
   dependencies:
     "@types/hast" "^3.0.0"
     clean-css "^5.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-minify-whitespace@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/rehype-minify-whitespace/-/rehype-minify-whitespace-6.0.1.tgz"
-  integrity sha512-3oJZ3O8ukn6cNJ8elg8dU/tMCH4CDk7elE9x5G+dKL1qQYXeVnsDkSz17sAiUKIoDOXUUkOyC/VMNGEHbPmCew==
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/rehype-minify-whitespace/-/rehype-minify-whitespace-6.0.2.tgz#7dd234ce0775656ce6b6b0aad0a6093de29b2278"
+  integrity sha512-Zk0pyQ06A3Lyxhe9vGtOtzz3Z0+qZ5+7icZ/PL/2x1SHPbKao5oB/g/rlc6BCTajqBb33JcOe71Ye1oFsuYbnw==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-minify-whitespace "^1.0.0"
 
 rehype-normalize-attribute-value-case@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-normalize-attribute-value-case/-/rehype-normalize-attribute-value-case-4.0.0.tgz"
-  integrity sha512-H/AOFCgbAv9TNJkDmtxQIlVhfK8wzLBAaAcAG34IKprbsa/88tDujuFZpT6PyWqrJyJLzdy7TTlccsbZmGDXfg==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-normalize-attribute-value-case/-/rehype-normalize-attribute-value-case-4.0.1.tgz#5b6b1691018e0a5a4252433050504bc0596c6a2f"
+  integrity sha512-sdsfY4DgVWO3K9lJHdIQHg+ErgSGxpFJX0lIOo0tpChQ+iaJHMITHWCGofLor1NjcxLZeeMTfJ5Aif85kLhL3g==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-parse@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.npmjs.org/rehype-parse/-/rehype-parse-9.0.0.tgz"
-  integrity sha512-WG7nfvmWWkCR++KEkZevZb/uw41E8TsH4DsY9UxsTbIXCVGbAs4S+r8FrQ+OtH5EEQAs+5UxKC42VinkmpA1Yw==
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-parse/-/rehype-parse-9.0.1.tgz#9993bda129acc64c417a9d3654a7be38b2a94c20"
+  integrity sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-from-html "^2.0.0"
@@ -13223,7 +14381,7 @@ rehype-parse@^9.0.0:
 
 rehype-preset-minify@7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/rehype-preset-minify/-/rehype-preset-minify-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/rehype-preset-minify/-/rehype-preset-minify-7.0.0.tgz#bf04a1d05707cc76a2f669b2398efac25d6e85b9"
   integrity sha512-bZ/k4Th7I3n2+6qOM7fMysvfGWNrSeJ6ACStZpdAnZMIHx50onj4l+fMBfI8oZEOxQXZUINw7L20Hxg/Qr6N4g==
   dependencies:
     rehype-minify-attribute-whitespace "^4.0.0"
@@ -13252,9 +14410,9 @@ rehype-preset-minify@7.0.0:
     unified "^11.0.0"
 
 rehype-prism-plus@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/rehype-prism-plus/-/rehype-prism-plus-2.0.0.tgz"
-  integrity sha512-FeM/9V2N7EvDZVdR2dqhAzlw5YI49m9Tgn7ZrYJeYHIahM6gcXpH0K1y2gNnKanZCydOMluJvX2cB9z3lhY8XQ==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-prism-plus/-/rehype-prism-plus-2.0.1.tgz#5acc4c1940f90d9170cc0e9055de240b2da899c9"
+  integrity sha512-Wglct0OW12tksTUseAPyWPo3srjBOY7xKlql/DPKi7HbsdZTyaLCAoO58QBKSczFQxElTsQlOY3JDOFzB/K++Q==
   dependencies:
     hast-util-to-string "^3.0.0"
     parse-numeric-range "^1.3.0"
@@ -13263,28 +14421,37 @@ rehype-prism-plus@^2.0.0:
     unist-util-filter "^5.0.0"
     unist-util-visit "^5.0.0"
 
+rehype-recma@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/rehype-recma/-/rehype-recma-1.0.0.tgz#d68ef6344d05916bd96e25400c6261775411aa76"
+  integrity sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==
+  dependencies:
+    "@types/estree" "^1.0.0"
+    "@types/hast" "^3.0.0"
+    hast-util-to-estree "^3.0.0"
+
 rehype-remove-comments@^6.0.0:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/rehype-remove-comments/-/rehype-remove-comments-6.1.0.tgz"
-  integrity sha512-zpdAJTGdbauyEpv0Bn2FaT3vP2fJWNsVR/OvOO3nyNGJqUFUXS0/GBk3IGvUoOyICnP2jcRUH+3xUoh/bXWh1A==
+  version "6.1.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-comments/-/rehype-remove-comments-6.1.1.tgz#353f3c5e7f00f384f5c1648b271bffe4f396a61d"
+  integrity sha512-O3OAvqpV8IUJf6+Q4s5nqaKQqrgeXdU/+0fjUHMO0KAB4SwkMdN34NJQC9hexwvjYE00tX/xB8GvnVJI8Cdf6g==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-conditional-comment "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-remove-duplicate-attribute-values@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-duplicate-attribute-values/-/rehype-remove-duplicate-attribute-values-4.0.0.tgz"
-  integrity sha512-CqmvAT2za09yNwnySiervSXa3UGcVfwJcjv3d/GCsDR29r+ll+uBuerOuQAOTiJNxxB/LUBeF9qA+np71H3dmw==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-duplicate-attribute-values/-/rehype-remove-duplicate-attribute-values-4.0.1.tgz#c09eee94b7940bf1833d9169cf488681a07cdc04"
+  integrity sha512-CwSTYj6Oxs/CzfMvzwJeTyqKegiYMr1L8y4PUlbAicnZm0Ex1DzDKlTmW8ik6jDOL4SzA6+f4PRkt6t4bJBM9Q==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-remove-empty-attribute@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-empty-attribute/-/rehype-remove-empty-attribute-4.0.0.tgz"
-  integrity sha512-8rDGJQEcLDnUkBbnFYBhEc5jkBsS95JpvUeIWYCPUQzsJqGDqx0QbxjKyQlopc/x02Xh6x766agL5skc05k+Gg==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-empty-attribute/-/rehype-remove-empty-attribute-4.0.1.tgz#bed6a6a42f8140869aadc36fa883e3a30f43d123"
+  integrity sha512-DumltSgLRNKSecLa9+amnr72Qn70D9mwnm/1Y1FcSiyXLcfrbXaM9bvTwpGGIhDPdyUp1khEDGxx1MnD2PPV2Q==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
@@ -13292,36 +14459,36 @@ rehype-remove-empty-attribute@^4.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-remove-external-script-content@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-external-script-content/-/rehype-remove-external-script-content-4.0.0.tgz"
-  integrity sha512-4K3goNZE1hZE6C2kdjZbxbF+AI/8I4y1zI4msuTwgKETjJX6xvSfDHzySL7zkhgV2xNPxBnW2EAnmZnLqIJqnA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-external-script-content/-/rehype-remove-external-script-content-4.0.1.tgz#2864e953739ef9a39ae35520cc1dd80afc92c124"
+  integrity sha512-wt+ONr0EY97RUMcI7J+oUuyuTu8AbMGIxApNdfaYi+/zYQfqre0LEvMuuaCSG6hRbmo22nr0a2FeKNmo6bYfNw==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-javascript "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-remove-meta-http-equiv@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-meta-http-equiv/-/rehype-remove-meta-http-equiv-4.0.0.tgz"
-  integrity sha512-1hKKLo/BWSYxaqwPcGIJSkBU7dpscjRjgeKFC6GS5aIwZGzS10k0AdbXlD/0RT6AdOFVrkSugLRc/2aX82VJfg==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-meta-http-equiv/-/rehype-remove-meta-http-equiv-4.0.1.tgz#2b5bef9e31d0116387439541b6c04b277e333760"
+  integrity sha512-BtnEEEjxFzj8ywdvY5iBoOWINFUPFHa73hdFRA/1niho82KeB7jZCbetDNX4nE4B16aooSuPUiKtM3J1WnDhiA==
   dependencies:
     "@types/hast" "^3.0.0"
     space-separated-tokens "^2.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-remove-script-type-javascript@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-script-type-javascript/-/rehype-remove-script-type-javascript-4.0.0.tgz"
-  integrity sha512-bmaikMcvmHuOSY+G950A5Z/2uZ/N9MQJgbJeKUWH5rTil145EUVwzMkO6gal3PBt0wHeDKezZum6Xrng+o9ptA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-script-type-javascript/-/rehype-remove-script-type-javascript-4.0.1.tgz#71faf0298a2efa5b3170138c0c79c26c72935993"
+  integrity sha512-YtFejlGvyZE1tbpGav6RThBuVcfLMV9IAG8CDf8wXENIu3qJyegyC+HFz80MZPxw3mQKsZHAOHYE3G4LoOcGzg==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-javascript "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-remove-style-type-css@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/rehype-remove-style-type-css/-/rehype-remove-style-type-css-4.0.0.tgz"
-  integrity sha512-IvyLC4AS7nPJ0Kzeuc6F2zdiC/HhROGcSlBYGGcY8YPYZ00ZHoBmnnIWW9qpjAlA3Q6STKOm29EyMHB56nBqWA==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-remove-style-type-css/-/rehype-remove-style-type-css-4.0.1.tgz#e8e19f562b8d8f46172db46960a72ff49f4f1954"
+  integrity sha512-vMTQu+QjkzpzftOGzr6tmk/tA9V/JsfYlPz1APjrsjWl4el5ySJjKKjZiSVmxKUZDO6cDNVZQm+2ldODyoN4wg==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-css-link "^3.0.0"
@@ -13330,7 +14497,7 @@ rehype-remove-style-type-css@^4.0.0:
 
 rehype-slug@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/rehype-slug/-/rehype-slug-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/rehype-slug/-/rehype-slug-6.0.0.tgz#1d21cf7fc8a83ef874d873c15e6adaee6344eaf1"
   integrity sha512-lWyvf/jwu+oS5+hL5eClVd3hNdmwM1kAC0BUvEGD19pajQMIzcNUd/k9GsfQ+FfECvX+JE+e9/btsKH0EjJT6A==
   dependencies:
     "@types/hast" "^3.0.0"
@@ -13340,26 +14507,26 @@ rehype-slug@^6.0.0:
     unist-util-visit "^5.0.0"
 
 rehype-sort-attribute-values@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/rehype-sort-attribute-values/-/rehype-sort-attribute-values-5.0.0.tgz"
-  integrity sha512-dQdHdCIRnpiU+BkrLSqH+aM4lWJyLqGzv49KvH4gHj+JxYwNqvGhoTXckS3AJu4V9ZutwsTcawP0pC7PhwX0tQ==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-sort-attribute-values/-/rehype-sort-attribute-values-5.0.1.tgz#0c77507d178c5788d4899409f42220040877476f"
+  integrity sha512-lU3ABJO5frbUgV132YS6SL7EISf//irIm9KFMaeu5ixHfgWf6jhe+09Uf/Ef8pOYUJWKOaQJDRJGCXs6cNsdsQ==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-is-element "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-sort-attributes@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/rehype-sort-attributes/-/rehype-sort-attributes-5.0.0.tgz"
-  integrity sha512-6tJUH4xHFcdO85CZRwAcEtHNCzjZ9V9S0VZLgo1pzbN04qy8jiVCZ3oAxDmBVG3Rth5b1xFTDet5WG/UYZeJLQ==
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-sort-attributes/-/rehype-sort-attributes-5.0.1.tgz#750daa9aa57c30b8e571c2c8a8a30e47f9d6d2cd"
+  integrity sha512-Bxo+AKUIELcnnAZwJDt5zUDDRpt4uzhfz9d0PVGhcxYWsbFj5Cv35xuWxu5r1LeYNFNhgGqsr9Q2QiIOM/Qctg==
   dependencies:
     "@types/hast" "^3.0.0"
     unist-util-visit "^5.0.0"
 
 rehype-stringify@^10.0.0:
-  version "10.0.0"
-  resolved "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-10.0.0.tgz"
-  integrity sha512-1TX1i048LooI9QoecrXy7nGFFbFSufxVRAfc6Y9YMRAi56l+oB0zP51mLSV312uRuvVLPV1opSlJmslozR1XHQ==
+  version "10.0.1"
+  resolved "https://registry.yarnpkg.com/rehype-stringify/-/rehype-stringify-10.0.1.tgz#2ec1ebc56c6aba07905d3b4470bdf0f684f30b75"
+  integrity sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA==
   dependencies:
     "@types/hast" "^3.0.0"
     hast-util-to-html "^9.0.0"
@@ -13367,7 +14534,7 @@ rehype-stringify@^10.0.0:
 
 remark-frontmatter@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-frontmatter/-/remark-frontmatter-3.0.0.tgz#ca5d996361765c859bd944505f377d6b186a6ec6"
   integrity sha512-mSuDd3svCHs+2PyO29h7iijIZx4plX0fheacJcAoYAASfgzgVIcXGYSq9GFyYocFLftQs8IOmmkgtOovs6d4oA==
   dependencies:
     mdast-util-frontmatter "^0.2.0"
@@ -13375,7 +14542,7 @@ remark-frontmatter@^3.0.0:
 
 remark-frontmatter@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-frontmatter/-/remark-frontmatter-5.0.0.tgz#b68d61552a421ec412c76f4f66c344627dc187a2"
   integrity sha512-XTFYvNASMe5iPN0719nPrdItC9aU0ssC4v14mH1BCi1u0n1gAocqcujWUrByftZTbLhRtiKRyjYTSIOcr69UVQ==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13385,15 +14552,16 @@ remark-frontmatter@^5.0.0:
 
 remark-gfm@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/remark-gfm/-/remark-gfm-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-gfm/-/remark-gfm-1.0.0.tgz#9213643001be3f277da6256464d56fd28c3b3c0d"
   integrity sha512-KfexHJCiqvrdBZVbQ6RopMZGwaXz6wFJEfByIuEwGf0arvITHjiKKZ1dpXujjH9KZdm1//XJQwgfnJ3lmXaDPA==
   dependencies:
     mdast-util-gfm "^0.1.0"
     micromark-extension-gfm "^0.3.0"
 
+remark-gfm@^4.0.0:
 remark-gfm@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/remark-gfm/-/remark-gfm-4.0.1.tgz#33227b2a74397670d357bf05c098eaf8513f0d6b"
   integrity sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13405,7 +14573,7 @@ remark-gfm@^4.0.0:
 
 remark-math@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-math/-/remark-math-6.0.0.tgz#0acdf74675f1c195fea6efffa78582f7ed7fc0d7"
   integrity sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13415,7 +14583,7 @@ remark-math@^6.0.0:
 
 remark-mdx-frontmatter@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/remark-mdx-frontmatter/-/remark-mdx-frontmatter-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-mdx-frontmatter/-/remark-mdx-frontmatter-4.0.0.tgz#1d0287103ac73c5d493d2fad19dd805e69db55ca"
   integrity sha512-PZzAiDGOEfv1Ua7exQ8S5kKxkD8CDaSb4nM+1Mprs6u8dyvQifakh+kCj6NovfGXW+bTvrhjaR3srzjS2qJHKg==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13426,16 +14594,16 @@ remark-mdx-frontmatter@^4.0.0:
     yaml "^2.0.0"
 
 remark-mdx@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz"
-  integrity sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/remark-mdx/-/remark-mdx-3.1.1.tgz#047f97038bc7ec387aebb4b0a4fe23779999d845"
+  integrity sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==
   dependencies:
     mdast-util-mdx "^3.0.0"
     micromark-extension-mdxjs "^3.0.0"
 
 remark-parse@^11.0.0:
   version "11.0.0"
-  resolved "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-parse/-/remark-parse-11.0.0.tgz#aa60743fcb37ebf6b069204eb4da304e40db45a1"
   integrity sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13445,15 +14613,15 @@ remark-parse@^11.0.0:
 
 remark-parse@^9.0.0:
   version "9.0.0"
-  resolved "https://registry.npmjs.org/remark-parse/-/remark-parse-9.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-parse/-/remark-parse-9.0.0.tgz#4d20a299665880e4f4af5d90b7c7b8a935853640"
   integrity sha512-geKatMwSzEXKHuzBNU1z676sGcDcFoChMK38TgdHJNAYfFtsfHDQG7MoJAjs6sgYMqyLduCYWDIWZIxiPeafEw==
   dependencies:
     mdast-util-from-markdown "^0.8.0"
 
 remark-rehype@^11.0.0, remark-rehype@^11.1.0:
-  version "11.1.1"
-  resolved "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.1.tgz"
-  integrity sha512-g/osARvjkBXb6Wo0XvAeXQohVta8i84ACbenPpoSsxTOQH/Ae0/RGP4WZgnMH5pMLpsj4FG7OHmcIcXxpza8eQ==
+  version "11.1.2"
+  resolved "https://registry.yarnpkg.com/remark-rehype/-/remark-rehype-11.1.2.tgz#2addaadda80ca9bd9aa0da763e74d16327683b37"
+  integrity sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==
   dependencies:
     "@types/hast" "^3.0.0"
     "@types/mdast" "^4.0.0"
@@ -13463,7 +14631,7 @@ remark-rehype@^11.0.0, remark-rehype@^11.1.0:
 
 remark-stringify@^11.0.0:
   version "11.0.0"
-  resolved "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/remark-stringify/-/remark-stringify-11.0.0.tgz#4c5b01dd711c269df1aaae11743eb7e2e7636fd3"
   integrity sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13472,14 +14640,14 @@ remark-stringify@^11.0.0:
 
 remark-stringify@^9.0.1:
   version "9.0.1"
-  resolved "https://registry.npmjs.org/remark-stringify/-/remark-stringify-9.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/remark-stringify/-/remark-stringify-9.0.1.tgz#576d06e910548b0a7191a71f27b33f1218862894"
   integrity sha512-mWmNg3ZtESvZS8fv5PTvaPckdL4iNlCHTt8/e/8oN08nArHRHjNZMKzA/YW3+p7/lYqIw4nx1XsjCBo/AxNChg==
   dependencies:
     mdast-util-to-markdown "^0.6.0"
 
 remark@^15.0.0:
   version "15.0.1"
-  resolved "https://registry.npmjs.org/remark/-/remark-15.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/remark/-/remark-15.0.1.tgz#ac7e7563260513b66426bc47f850e7aa5862c37c"
   integrity sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==
   dependencies:
     "@types/mdast" "^4.0.0"
@@ -13489,22 +14657,22 @@ remark@^15.0.0:
 
 remove-accents@0.5.0:
   version "0.5.0"
-  resolved "https://registry.npmjs.org/remove-accents/-/remove-accents-0.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/remove-accents/-/remove-accents-0.5.0.tgz#77991f37ba212afba162e375b627631315bed687"
   integrity sha512-8g3/Otx1eJaVD12e31UbJj1YzdtVvzH85HV7t+9MJYk/u3XmkOUJ5Ys9wQrf9PCPK8+xn4ymzqYCiZl6QWKn+A==
 
-repeat-string@^1.0.0, repeat-string@^1.6.1:
+repeat-string@^1.0.0:
   version "1.6.1"
-  resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
   integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==
 
 require-directory@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
 
 require-from-string@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
   integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
 
 require-in-the-middle@^7.1.1:
@@ -13518,37 +14686,37 @@ require-in-the-middle@^7.1.1:
 
 resize-observer-polyfill@^1.5.1:
   version "1.5.1"
-  resolved "https://registry.npmjs.org/resize-observer-polyfill/-/resize-observer-polyfill-1.5.1.tgz"
+  resolved "https://registry.yarnpkg.com/resize-observer-polyfill/-/resize-observer-polyfill-1.5.1.tgz#0e9020dd3d21024458d4ebd27e23e40269810464"
   integrity sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg==
 
 resolve-from@5.0.0, resolve-from@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
   integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
 
 resolve-from@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
 resolve-global@1.0.0, resolve-global@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/resolve-global/-/resolve-global-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-global/-/resolve-global-1.0.0.tgz#a2a79df4af2ca3f49bf77ef9ddacd322dad19255"
   integrity sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==
   dependencies:
     global-dirs "^0.1.1"
 
 resolve-pathname@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/resolve-pathname/-/resolve-pathname-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-pathname/-/resolve-pathname-3.0.0.tgz#99d02224d3cf263689becbb393bc560313025dcd"
   integrity sha512-C7rARubxI8bXFNB/hqcp/4iUeIXJhJZvFPFPiSPRnhU5UPxzMFIl+2E6yY6c4k9giDJAhtV+enfA+G89N6Csng==
 
 resolve-pkg-maps@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz#616b3dc2c57056b5588c31cdf4b3d64db133720f"
   integrity sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==
 
-resolve@1.22.8, resolve@^1.1.7, resolve@^1.14.2, resolve@^1.19.0, resolve@^1.22.2, resolve@^1.22.4:
+resolve@1.22.8:
   version "1.22.8"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.8.tgz#b6c87a9f2aa06dfab52e3d70ac8cde321fa5a48d"
   integrity sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==
@@ -13557,7 +14725,7 @@ resolve@1.22.8, resolve@^1.1.7, resolve@^1.14.2, resolve@^1.19.0, resolve@^1.22.
     path-parse "^1.0.7"
     supports-preserve-symlinks-flag "^1.0.0"
 
-resolve@^1.10.0, resolve@^1.22.8:
+resolve@^1.1.7, resolve@^1.10.0, resolve@^1.19.0, resolve@^1.22.10, resolve@^1.22.4, resolve@^1.22.8:
   version "1.22.10"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.10.tgz#b663e83ffb09bbf2386944736baae803029b8b39"
   integrity sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==
@@ -13568,7 +14736,7 @@ resolve@^1.10.0, resolve@^1.22.8:
 
 resolve@^2.0.0-next.5:
   version "2.0.0-next.5"
-  resolved "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.5.tgz"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-2.0.0-next.5.tgz#6b0ec3107e671e52b68cd068ef327173b90dc03c"
   integrity sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==
   dependencies:
     is-core-module "^2.13.0"
@@ -13577,131 +14745,147 @@ resolve@^2.0.0-next.5:
 
 restore-cursor@^5.0.0:
   version "5.1.0"
-  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-5.1.0.tgz#0766d95699efacb14150993f55baf0953ea1ebe7"
   integrity sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==
   dependencies:
     onetime "^7.0.0"
     signal-exit "^4.1.0"
 
+retry@^0.12.0:
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b"
+  integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==
+
 reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.1.0.tgz#0fe13b9522e1473f51b558ee796e08f11f9b489f"
+  integrity sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==
 
 rfdc@^1.4.1:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.4.1.tgz#778f76c4fb731d93414e8f925fbecf64cce7f6ca"
   integrity sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==
 
 rimraf@3.0.2, rimraf@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
   dependencies:
     glob "^7.1.3"
 
 rollup@^4.35.0:
-  version "4.49.0"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.49.0.tgz#9751ad9d06a47a4496c3c5c238b27b1422c8b0eb"
-  integrity sha512-3IVq0cGJ6H7fKXXEdVt+RcYvRCt8beYY9K1760wGQwSAHZcS9eot1zDG5axUbcp/kWRi5zKIIDX8MoKv/TzvZA==
+  version "4.52.3"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.52.3.tgz#cc5c28d772b022ce48b235a97b347ccd9d88c1a3"
+  integrity sha512-RIDh866U8agLgiIcdpB+COKnlCreHJLfIhWC3LVflku5YHfpnsIKigRZeFfMfCc4dVcqNVfQQ5gO/afOck064A==
   dependencies:
     "@types/estree" "1.0.8"
   optionalDependencies:
-    "@rollup/rollup-android-arm-eabi" "4.49.0"
-    "@rollup/rollup-android-arm64" "4.49.0"
-    "@rollup/rollup-darwin-arm64" "4.49.0"
-    "@rollup/rollup-darwin-x64" "4.49.0"
-    "@rollup/rollup-freebsd-arm64" "4.49.0"
-    "@rollup/rollup-freebsd-x64" "4.49.0"
-    "@rollup/rollup-linux-arm-gnueabihf" "4.49.0"
-    "@rollup/rollup-linux-arm-musleabihf" "4.49.0"
-    "@rollup/rollup-linux-arm64-gnu" "4.49.0"
-    "@rollup/rollup-linux-arm64-musl" "4.49.0"
-    "@rollup/rollup-linux-loongarch64-gnu" "4.49.0"
-    "@rollup/rollup-linux-ppc64-gnu" "4.49.0"
-    "@rollup/rollup-linux-riscv64-gnu" "4.49.0"
-    "@rollup/rollup-linux-riscv64-musl" "4.49.0"
-    "@rollup/rollup-linux-s390x-gnu" "4.49.0"
-    "@rollup/rollup-linux-x64-gnu" "4.49.0"
-    "@rollup/rollup-linux-x64-musl" "4.49.0"
-    "@rollup/rollup-win32-arm64-msvc" "4.49.0"
-    "@rollup/rollup-win32-ia32-msvc" "4.49.0"
-    "@rollup/rollup-win32-x64-msvc" "4.49.0"
+    "@rollup/rollup-android-arm-eabi" "4.52.3"
+    "@rollup/rollup-android-arm64" "4.52.3"
+    "@rollup/rollup-darwin-arm64" "4.52.3"
+    "@rollup/rollup-darwin-x64" "4.52.3"
+    "@rollup/rollup-freebsd-arm64" "4.52.3"
+    "@rollup/rollup-freebsd-x64" "4.52.3"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.52.3"
+    "@rollup/rollup-linux-arm-musleabihf" "4.52.3"
+    "@rollup/rollup-linux-arm64-gnu" "4.52.3"
+    "@rollup/rollup-linux-arm64-musl" "4.52.3"
+    "@rollup/rollup-linux-loong64-gnu" "4.52.3"
+    "@rollup/rollup-linux-ppc64-gnu" "4.52.3"
+    "@rollup/rollup-linux-riscv64-gnu" "4.52.3"
+    "@rollup/rollup-linux-riscv64-musl" "4.52.3"
+    "@rollup/rollup-linux-s390x-gnu" "4.52.3"
+    "@rollup/rollup-linux-x64-gnu" "4.52.3"
+    "@rollup/rollup-linux-x64-musl" "4.52.3"
+    "@rollup/rollup-openharmony-arm64" "4.52.3"
+    "@rollup/rollup-win32-arm64-msvc" "4.52.3"
+    "@rollup/rollup-win32-ia32-msvc" "4.52.3"
+    "@rollup/rollup-win32-x64-gnu" "4.52.3"
+    "@rollup/rollup-win32-x64-msvc" "4.52.3"
     fsevents "~2.3.2"
 
 rtl-css-js@^1.16.1:
   version "1.16.1"
-  resolved "https://registry.npmjs.org/rtl-css-js/-/rtl-css-js-1.16.1.tgz"
+  resolved "https://registry.yarnpkg.com/rtl-css-js/-/rtl-css-js-1.16.1.tgz#4b48b4354b0ff917a30488d95100fbf7219a3e80"
   integrity sha512-lRQgou1mu19e+Ya0LsTvKrVJ5TYUbqCVPAiImX3UfLTenarvPUl1QFdvu5Z3PYmHT9RCcwIfbjRQBntExyj3Zg==
   dependencies:
     "@babel/runtime" "^7.1.2"
 
 run-parallel@^1.1.9:
   version "1.2.0"
-  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
   integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
   dependencies:
     queue-microtask "^1.2.2"
 
-safe-array-concat@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.2.tgz"
-  integrity sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==
+safe-array-concat@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/safe-array-concat/-/safe-array-concat-1.1.3.tgz#c9e54ec4f603b0bbb8e7e5007a5ee7aecd1538c3"
+  integrity sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==
   dependencies:
-    call-bind "^1.0.7"
-    get-intrinsic "^1.2.4"
-    has-symbols "^1.0.3"
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
+    get-intrinsic "^1.2.6"
+    has-symbols "^1.1.0"
     isarray "^2.0.5"
 
 safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
 safe-buffer@~5.2.0:
   version "5.2.1"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
-safe-regex-test@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.3.tgz"
-  integrity sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==
+safe-push-apply@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/safe-push-apply/-/safe-push-apply-1.0.0.tgz#01850e981c1602d398c85081f360e4e6d03d27f5"
+  integrity sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==
+  dependencies:
+    es-errors "^1.3.0"
+    isarray "^2.0.5"
+
+safe-regex-test@^1.0.3, safe-regex-test@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/safe-regex-test/-/safe-regex-test-1.1.0.tgz#7f87dfb67a3150782eaaf18583ff5d1711ac10c1"
+  integrity sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==
   dependencies:
-    call-bind "^1.0.6"
+    call-bound "^1.0.2"
     es-errors "^1.3.0"
-    is-regex "^1.1.4"
+    is-regex "^1.2.1"
 
 safe-stable-stringify@^1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/safe-stable-stringify/-/safe-stable-stringify-1.1.1.tgz#c8a220ab525cd94e60ebf47ddc404d610dc5d84a"
   integrity sha512-ERq4hUjKDbJfE4+XtZLFPCDi8Vb1JqaxAPTxWFLBx8XcAlf9Bda/ZJdVezs/NAfsMQScyIlUMx+Yeu7P7rx5jw==
 
 "safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
 sax@^1.2.4:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/sax/-/sax-1.4.1.tgz#44cc8988377f126304d3b3fc1010c733b929ef0f"
   integrity sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==
 
 scheduler@^0.23.2:
   version "0.23.2"
-  resolved "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz"
+  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.23.2.tgz#414ba64a3b282892e944cf2108ecc078d115cdc3"
   integrity sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==
   dependencies:
     loose-envify "^1.1.0"
 
 screenfull@^5.1.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/screenfull/-/screenfull-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/screenfull/-/screenfull-5.2.0.tgz#6533d524d30621fc1283b9692146f3f13a93d1ba"
   integrity sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA==
 
 scroll-into-view-if-needed@3.0.10:
   version "3.0.10"
-  resolved "https://registry.npmjs.org/scroll-into-view-if-needed/-/scroll-into-view-if-needed-3.0.10.tgz"
+  resolved "https://registry.yarnpkg.com/scroll-into-view-if-needed/-/scroll-into-view-if-needed-3.0.10.tgz#38fbfe770d490baff0fb2ba34ae3539f6ec44e13"
   integrity sha512-t44QCeDKAPf1mtQH3fYpWz8IM/DyvHLjs8wUvvwMYxk5moOqCzrMSxK6HQVD0QVmVjXFavoFIPRVrMuJPKAvtg==
   dependencies:
     compute-scroll-into-view "^3.0.2"
@@ -13713,7 +14897,7 @@ search-insights@^2.17.2:
 
 section-matter@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/section-matter/-/section-matter-1.0.0.tgz#e9041953506780ec01d59f292a19c7b850b84167"
   integrity sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==
   dependencies:
     extend-shallow "^2.0.1"
@@ -13721,34 +14905,34 @@ section-matter@^1.0.0:
 
 "semver@2 || 3 || 4 || 5":
   version "5.7.2"
-  resolved "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
 
 semver@7.5.4:
   version "7.5.4"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
   dependencies:
     lru-cache "^6.0.0"
 
-semver@7.6.3, semver@^7.5.2, semver@^7.5.4, semver@^7.6.3:
+semver@7.6.3:
   version "7.6.3"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.3.tgz#980f7b5550bc175fb4dc09403085627f9eb33143"
   integrity sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==
 
 semver@^6.3.1:
   version "6.3.1"
-  resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
   integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
 
-semver@^7.3.4:
+semver@^7.1.1, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.5.2, semver@^7.5.3, semver@^7.5.4, semver@^7.7.1, semver@^7.7.2:
   version "7.7.2"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.7.2.tgz#67d99fdcd35cec21e6f8b87a7fd515a33f982b58"
   integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==
 
-set-function-length@^1.2.1:
+set-function-length@^1.2.2:
   version "1.2.2"
-  resolved "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.2.tgz#aac72314198eaed975cf77b2c3b6b880695e5449"
   integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==
   dependencies:
     define-data-property "^1.1.4"
@@ -13758,9 +14942,9 @@ set-function-length@^1.2.1:
     gopd "^1.0.1"
     has-property-descriptors "^1.0.2"
 
-set-function-name@^2.0.1, set-function-name@^2.0.2:
+set-function-name@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/set-function-name/-/set-function-name-2.0.2.tgz#16a705c5a0dc2f5e638ca96d8a8cd4e1c2b90985"
   integrity sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==
   dependencies:
     define-data-property "^1.1.4"
@@ -13770,19 +14954,28 @@ set-function-name@^2.0.1, set-function-name@^2.0.2:
 
 set-harmonic-interval@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/set-harmonic-interval/-/set-harmonic-interval-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/set-harmonic-interval/-/set-harmonic-interval-1.0.1.tgz#e1773705539cdfb80ce1c3d99e7f298bb3995249"
   integrity sha512-AhICkFV84tBP1aWqPwLZqFvAwqEoVA9kxNMniGEUvzOlm4vLmOFLiTT3UZ6bziJTy4bOVpzWGTfSCbmaayGx8g==
 
+set-proto@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/set-proto/-/set-proto-1.0.0.tgz#0760dbcff30b2d7e801fd6e19983e56da337565e"
+  integrity sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==
+  dependencies:
+    dunder-proto "^1.0.1"
+    es-errors "^1.3.0"
+    es-object-atoms "^1.0.0"
+
 shebang-command@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
   integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
   dependencies:
     shebang-regex "^3.0.0"
 
 shebang-regex@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
 shimmer@^1.2.1:
@@ -13792,7 +14985,7 @@ shimmer@^1.2.1:
 
 side-channel-list@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel-list/-/side-channel-list-1.0.0.tgz#10cb5984263115d3b7a0e336591e290a830af8ad"
   integrity sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==
   dependencies:
     es-errors "^1.3.0"
@@ -13800,7 +14993,7 @@ side-channel-list@^1.0.0:
 
 side-channel-map@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel-map/-/side-channel-map-1.0.1.tgz#d6bb6b37902c6fef5174e5f533fab4c732a26f42"
   integrity sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==
   dependencies:
     call-bound "^1.0.2"
@@ -13810,7 +15003,7 @@ side-channel-map@^1.0.1:
 
 side-channel-weakmap@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz#11dda19d5368e40ce9ec2bdc1fb0ecbc0790ecea"
   integrity sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==
   dependencies:
     call-bound "^1.0.2"
@@ -13819,19 +15012,9 @@ side-channel-weakmap@^1.0.2:
     object-inspect "^1.13.3"
     side-channel-map "^1.0.1"
 
-side-channel@^1.0.4, side-channel@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz"
-  integrity sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==
-  dependencies:
-    call-bind "^1.0.7"
-    es-errors "^1.3.0"
-    get-intrinsic "^1.2.4"
-    object-inspect "^1.13.1"
-
 side-channel@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.1.0.tgz#c3fcff9c4da932784873335ec9765fa94ff66bc9"
   integrity sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==
   dependencies:
     es-errors "^1.3.0"
@@ -13842,24 +15025,36 @@ side-channel@^1.1.0:
 
 signal-exit@^3.0.3:
   version "3.0.7"
-  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
   integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
 
 signal-exit@^4.0.1, signal-exit@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04"
   integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==
 
+sigstore@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/sigstore/-/sigstore-3.1.0.tgz#08dc6c0c425263e9fdab85ffdb6477550e2c511d"
+  integrity sha512-ZpzWAFHIFqyFE56dXqgX/DkDRZdz+rRcjoIk/RQU4IX0wiCv1l8S7ZrXDHcCc+uaf+6o7w3h2l3g6GYG5TKN9Q==
+  dependencies:
+    "@sigstore/bundle" "^3.1.0"
+    "@sigstore/core" "^2.0.0"
+    "@sigstore/protobuf-specs" "^0.4.0"
+    "@sigstore/sign" "^3.1.0"
+    "@sigstore/tuf" "^3.1.0"
+    "@sigstore/verify" "^2.1.0"
+
 simple-swizzle@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz"
-  integrity sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==
+  version "0.2.4"
+  resolved "https://registry.yarnpkg.com/simple-swizzle/-/simple-swizzle-0.2.4.tgz#a8d11a45a11600d6a1ecdff6363329e3648c3667"
+  integrity sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw==
   dependencies:
     is-arrayish "^0.3.1"
 
 sirv@^2.0.3:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/sirv/-/sirv-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.4.tgz#5dd9a725c578e34e449f332703eb2a74e46a29b0"
   integrity sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==
   dependencies:
     "@polka/url" "^1.0.0-next.24"
@@ -13868,41 +15063,63 @@ sirv@^2.0.3:
 
 slash@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
 slice-ansi@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-5.0.0.tgz#b73063c57aa96f9cd881654b15294d95d285c42a"
   integrity sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==
   dependencies:
     ansi-styles "^6.0.0"
     is-fullwidth-code-point "^4.0.0"
 
 slice-ansi@^7.1.0:
-  version "7.1.0"
-  resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.0.tgz"
-  integrity sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-7.1.2.tgz#adf7be70aa6d72162d907cd0e6d5c11f507b5403"
+  integrity sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==
   dependencies:
     ansi-styles "^6.2.1"
     is-fullwidth-code-point "^5.0.0"
 
+smart-buffer@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/smart-buffer/-/smart-buffer-4.2.0.tgz#6e1d71fa4f18c05f7d0ff216dd16a481d0e8d9ae"
+  integrity sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==
+
 snake-case@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c"
   integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
   dependencies:
     dot-case "^3.0.4"
     tslib "^2.0.3"
 
+socks-proxy-agent@^8.0.3:
+  version "8.0.5"
+  resolved "https://registry.yarnpkg.com/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz#b9cdb4e7e998509d7659d689ce7697ac21645bee"
+  integrity sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==
+  dependencies:
+    agent-base "^7.1.2"
+    debug "^4.3.4"
+    socks "^2.8.3"
+
+socks@^2.8.3:
+  version "2.8.7"
+  resolved "https://registry.yarnpkg.com/socks/-/socks-2.8.7.tgz#e2fb1d9a603add75050a2067db8c381a0b5669ea"
+  integrity sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==
+  dependencies:
+    ip-address "^10.0.1"
+    smart-buffer "^4.2.0"
+
 source-map-js@^1.0.1, source-map-js@^1.0.2, source-map-js@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46"
   integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
 
 source-map-support@^0.5.21:
   version "0.5.21"
-  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
   integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
   dependencies:
     buffer-from "^1.0.0"
@@ -13910,27 +15127,27 @@ source-map-support@^0.5.21:
 
 source-map@0.5.6:
   version "0.5.6"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.5.6.tgz"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.6.tgz#75ce38f52bf0733c5a7f0c118d81334a2bb5f412"
   integrity sha512-MjZkVp0NHr5+TPihLcadqnlVoGIoWo4IBHptutGh9wI3ttUYvCG26HkSuDi+K6lsZ25syXJXcctwgyVCt//xqA==
 
 source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.0:
   version "0.6.1"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
 source-map@^0.7.0:
-  version "0.7.4"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz"
-  integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==
+  version "0.7.6"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.6.tgz#a3658ab87e5b6429c8a1f3ba0083d4c61ca3ef02"
+  integrity sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==
 
 space-separated-tokens@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz#1ecd9d2350a3844572c3f4a312bceb018348859f"
   integrity sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==
 
 spdx-correct@^3.0.0:
   version "3.2.0"
-  resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.2.0.tgz#4f5ab0668f0059e34f9c00dce331784a12de4e9c"
   integrity sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==
   dependencies:
     spdx-expression-parse "^3.0.0"
@@ -13938,49 +15155,69 @@ spdx-correct@^3.0.0:
 
 spdx-exceptions@^2.1.0:
   version "2.5.0"
-  resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz#5d607d27fc806f66d7b64a766650fa890f04ed66"
   integrity sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==
 
 spdx-expression-parse@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
   integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
   dependencies:
     spdx-exceptions "^2.1.0"
     spdx-license-ids "^3.0.0"
 
+spdx-expression-parse@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-4.0.0.tgz#a23af9f3132115465dac215c099303e4ceac5794"
+  integrity sha512-Clya5JIij/7C6bRR22+tnGXbc4VKlibKSVj2iHvVeX5iMW7s1SIQlqu699JkODJJIhh/pUu8L0/VLh8xflD+LQ==
+  dependencies:
+    spdx-exceptions "^2.1.0"
+    spdx-license-ids "^3.0.0"
+
 spdx-license-ids@^3.0.0:
-  version "3.0.21"
-  resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz"
-  integrity sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==
+  version "3.0.22"
+  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.22.tgz#abf5a08a6f5d7279559b669f47f0a43e8f3464ef"
+  integrity sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==
 
 split2@^3.0.0, split2@^3.2.2:
   version "3.2.2"
-  resolved "https://registry.npmjs.org/split2/-/split2-3.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
   integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
   dependencies:
     readable-stream "^3.0.0"
 
 sprintf-js@~1.0.2:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
   integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
 
+ssri@^12.0.0:
+  version "12.0.0"
+  resolved "https://registry.yarnpkg.com/ssri/-/ssri-12.0.0.tgz#bcb4258417c702472f8191981d3c8a771fee6832"
+  integrity sha512-S7iGNosepx9RadX82oimUkvr0Ct7IjJbEbs4mJcTxst8um95J3sDYU1RBEOvdu6oL1Wek2ODI5i4MAw+dZ6cAQ==
+  dependencies:
+    minipass "^7.0.3"
+
+stable-hash@^0.0.5:
+  version "0.0.5"
+  resolved "https://registry.yarnpkg.com/stable-hash/-/stable-hash-0.0.5.tgz#94e8837aaeac5b4d0f631d2972adef2924b40269"
+  integrity sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==
+
 stack-generator@^2.0.5:
   version "2.0.10"
-  resolved "https://registry.npmjs.org/stack-generator/-/stack-generator-2.0.10.tgz"
+  resolved "https://registry.yarnpkg.com/stack-generator/-/stack-generator-2.0.10.tgz#8ae171e985ed62287d4f1ed55a1633b3fb53bb4d"
   integrity sha512-mwnua/hkqM6pF4k8SnmZ2zfETsRUpWXREfA/goT8SLCV4iOFa4bzOX2nDipWAZFPTjLvQB82f5yaodMVhK0yJQ==
   dependencies:
     stackframe "^1.3.4"
 
 stackframe@^1.3.4:
   version "1.3.4"
-  resolved "https://registry.npmjs.org/stackframe/-/stackframe-1.3.4.tgz"
+  resolved "https://registry.yarnpkg.com/stackframe/-/stackframe-1.3.4.tgz#b881a004c8c149a5e8efef37d51b16e412943310"
   integrity sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==
 
 stacktrace-gps@^3.0.4:
   version "3.1.2"
-  resolved "https://registry.npmjs.org/stacktrace-gps/-/stacktrace-gps-3.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/stacktrace-gps/-/stacktrace-gps-3.1.2.tgz#0c40b24a9b119b20da4525c398795338966a2fb0"
   integrity sha512-GcUgbO4Jsqqg6RxfyTHFiPxdPqF+3LFmQhm7MgCuYQOYuWyqxo5pwRPz5d/u6/WYJdEnWfK4r+jGbyD8TSggXQ==
   dependencies:
     source-map "0.5.6"
@@ -13988,7 +15225,7 @@ stacktrace-gps@^3.0.4:
 
 stacktrace-js@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/stacktrace-js/-/stacktrace-js-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/stacktrace-js/-/stacktrace-js-2.0.2.tgz#4ca93ea9f494752d55709a081d400fdaebee897b"
   integrity sha512-Je5vBeY4S1r/RnLydLl0TBTi3F2qdfWmYsGvtfZgEI+SCprPppaIhQf5nGcal4gI4cGpCV/duLcAzT1np6sQqg==
   dependencies:
     error-stack-parser "^2.0.6"
@@ -14002,33 +15239,34 @@ stacktrace-parser@^0.1.10:
   dependencies:
     type-fest "^0.7.1"
 
-stop-iteration-iterator@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.0.0.tgz"
-  integrity sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==
+stop-iteration-iterator@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz#f481ff70a548f6124d0312c3aa14cbfa7aa542ad"
+  integrity sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==
   dependencies:
-    internal-slot "^1.0.4"
+    es-errors "^1.3.0"
+    internal-slot "^1.1.0"
 
 stream-parser@~0.3.1:
   version "0.3.1"
-  resolved "https://registry.npmjs.org/stream-parser/-/stream-parser-0.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/stream-parser/-/stream-parser-0.3.1.tgz#1618548694420021a1182ff0af1911c129761773"
   integrity sha512-bJ/HgKq41nlKvlhccD5kaCr/P+Hu0wPNKPJOH7en+YrJu/9EgqUF+88w5Jb6KNcjOFMhfX4B2asfeAtIGuHObQ==
   dependencies:
     debug "2"
 
 streamsearch@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-1.1.0.tgz#404dd1e2247ca94af554e841a8ef0eaa238da764"
   integrity sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==
 
-string-argv@~0.3.2:
+string-argv@^0.3.2:
   version "0.3.2"
-  resolved "https://registry.npmjs.org/string-argv/-/string-argv-0.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.3.2.tgz#2b6d0ef24b656274d957d54e0a4bbf6153dc02b6"
   integrity sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==
 
 "string-width-cjs@npm:string-width@^4.2.0":
   version "4.2.3"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
   dependencies:
     emoji-regex "^8.0.0"
@@ -14037,7 +15275,7 @@ string-argv@~0.3.2:
 
 string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
   version "4.2.3"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
   dependencies:
     emoji-regex "^8.0.0"
@@ -14046,7 +15284,7 @@ string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
 
 string-width@^5.0.1, string-width@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
   integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
   dependencies:
     eastasianwidth "^0.2.0"
@@ -14055,69 +15293,75 @@ string-width@^5.0.1, string-width@^5.1.2:
 
 string-width@^7.0.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-7.2.0.tgz#b5bb8e2165ce275d4d43476dd2700ad9091db6dc"
   integrity sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==
   dependencies:
     emoji-regex "^10.3.0"
     get-east-asian-width "^1.0.0"
     strip-ansi "^7.1.0"
 
-string.prototype.includes@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.0.tgz"
-  integrity sha512-E34CkBgyeqNDcrbU76cDjL5JLcVrtSdYq0MEh/B10r17pRP4ciHLwTgnuLV8Ay6cgEMLkcBkFCKyFZ43YldYzg==
+string.prototype.includes@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz#eceef21283640761a81dbe16d6c7171a4edf7d92"
+  integrity sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==
   dependencies:
-    define-properties "^1.1.3"
-    es-abstract "^1.17.5"
+    call-bind "^1.0.7"
+    define-properties "^1.2.1"
+    es-abstract "^1.23.3"
 
-string.prototype.matchall@^4.0.11:
-  version "4.0.11"
-  resolved "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.11.tgz"
-  integrity sha512-NUdh0aDavY2og7IbBPenWqR9exH+E26Sv8e0/eTe1tltDGZL+GtBkDAnnyBtmekfK6/Dq3MkcGtzXFEd1LQrtg==
+string.prototype.matchall@^4.0.12:
+  version "4.0.12"
+  resolved "https://registry.yarnpkg.com/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz#6c88740e49ad4956b1332a911e949583a275d4c0"
+  integrity sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.3"
     define-properties "^1.2.1"
-    es-abstract "^1.23.2"
+    es-abstract "^1.23.6"
     es-errors "^1.3.0"
     es-object-atoms "^1.0.0"
-    get-intrinsic "^1.2.4"
-    gopd "^1.0.1"
-    has-symbols "^1.0.3"
-    internal-slot "^1.0.7"
-    regexp.prototype.flags "^1.5.2"
+    get-intrinsic "^1.2.6"
+    gopd "^1.2.0"
+    has-symbols "^1.1.0"
+    internal-slot "^1.1.0"
+    regexp.prototype.flags "^1.5.3"
     set-function-name "^2.0.2"
-    side-channel "^1.0.6"
+    side-channel "^1.1.0"
 
 string.prototype.repeat@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz#e90872ee0308b29435aa26275f6e1b762daee01a"
   integrity sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==
   dependencies:
     define-properties "^1.1.3"
     es-abstract "^1.17.5"
 
-string.prototype.trim@^1.2.9:
-  version "1.2.9"
-  resolved "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz"
-  integrity sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==
+string.prototype.trim@^1.2.10:
+  version "1.2.10"
+  resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz#40b2dd5ee94c959b4dcfb1d65ce72e90da480c81"
+  integrity sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
+    define-data-property "^1.1.4"
     define-properties "^1.2.1"
-    es-abstract "^1.23.0"
+    es-abstract "^1.23.5"
     es-object-atoms "^1.0.0"
+    has-property-descriptors "^1.0.2"
 
-string.prototype.trimend@^1.0.8:
-  version "1.0.8"
-  resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz"
-  integrity sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==
+string.prototype.trimend@^1.0.9:
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz#62e2731272cd285041b36596054e9f66569b6942"
+  integrity sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
+    call-bound "^1.0.2"
     define-properties "^1.2.1"
     es-object-atoms "^1.0.0"
 
 string.prototype.trimstart@^1.0.8:
   version "1.0.8"
-  resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz#7ee834dda8c7c17eff3118472bb35bfedaa34dde"
   integrity sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==
   dependencies:
     call-bind "^1.0.7"
@@ -14126,26 +15370,26 @@ string.prototype.trimstart@^1.0.8:
 
 string_decoder@^1.1.1:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
   dependencies:
     safe-buffer "~5.2.0"
 
 string_decoder@~0.10.x:
   version "0.10.31"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
   integrity sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==
 
 string_decoder@~1.1.1:
   version "1.1.1"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
   integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
   dependencies:
     safe-buffer "~5.1.0"
 
 stringify-entities@^4.0.0:
   version "4.0.4"
-  resolved "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/stringify-entities/-/stringify-entities-4.0.4.tgz#b3b79ef5f277cc4ac73caeb0236c5ba939b3a4f3"
   integrity sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==
   dependencies:
     character-entities-html4 "^2.0.0"
@@ -14153,7 +15397,7 @@ stringify-entities@^4.0.0:
 
 stringify-object@3.3.0:
   version "3.3.0"
-  resolved "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629"
   integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
   dependencies:
     get-own-enumerable-property-symbols "^3.0.0"
@@ -14162,86 +15406,93 @@ stringify-object@3.3.0:
 
 "strip-ansi-cjs@npm:strip-ansi@^6.0.1":
   version "6.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
   dependencies:
     ansi-regex "^5.0.1"
 
 strip-ansi@^6.0.0, strip-ansi@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
   dependencies:
     ansi-regex "^5.0.1"
 
 strip-ansi@^7.0.1, strip-ansi@^7.1.0:
-  version "7.1.0"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz"
-  integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.2.tgz#132875abde678c7ea8d691533f2e7e22bb744dba"
+  integrity sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==
   dependencies:
     ansi-regex "^6.0.1"
 
 strip-bom-string@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-bom-string/-/strip-bom-string-1.0.0.tgz#e5211e9224369fbb81d633a2f00044dc8cedad92"
   integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==
 
 strip-bom@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
   integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==
 
 strip-final-newline@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
   integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
 
 strip-final-newline@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-3.0.0.tgz#52894c313fbff318835280aed60ff71ebf12b8fd"
   integrity sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==
 
 strip-indent@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
   integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
   dependencies:
     min-indent "^1.0.0"
 
 strip-json-comments@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
-style-to-object@^0.4.0, style-to-object@^0.4.1:
-  version "0.4.4"
-  resolved "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.4.tgz"
-  integrity sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg==
+style-to-js@^1.0.0:
+  version "1.1.17"
+  resolved "https://registry.yarnpkg.com/style-to-js/-/style-to-js-1.1.17.tgz#488b1558a8c1fd05352943f088cc3ce376813d83"
+  integrity sha512-xQcBGDxJb6jjFCTzvQtfiPn6YvvP2O8U1MDIPNfJQlWMYfktPy+iGsHE7cssjs7y84d9fQaK4UF3RIJaAHSoYA==
   dependencies:
-    inline-style-parser "0.1.1"
+    style-to-object "1.0.9"
 
-style-to-object@^1.0.0:
-  version "1.0.8"
-  resolved "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.8.tgz"
-  integrity sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==
+style-to-object@1.0.9:
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-1.0.9.tgz#35c65b713f4a6dba22d3d0c61435f965423653f0"
+  integrity sha512-G4qppLgKu/k6FwRpHiGiKPaPTFcG3g4wNVX/Qsfu+RqQM30E7Tyu/TEgxcL9PNLF5pdRLwQdE3YKKf+KF2Dzlw==
   dependencies:
     inline-style-parser "0.2.4"
 
+style-to-object@^0.4.1:
+  version "0.4.4"
+  resolved "https://registry.yarnpkg.com/style-to-object/-/style-to-object-0.4.4.tgz#266e3dfd56391a7eefb7770423612d043c3f33ec"
+  integrity sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg==
+  dependencies:
+    inline-style-parser "0.1.1"
+
 styled-jsx@5.1.1:
   version "5.1.1"
-  resolved "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/styled-jsx/-/styled-jsx-5.1.1.tgz#839a1c3aaacc4e735fed0781b8619ea5d0009d1f"
   integrity sha512-pW7uC1l4mBZ8ugbiZrcIsiIvVx1UmTfw7UkC3Um2tmfUq9Bhk8IiyEIPl6F8agHgjzku6j0xQEZbfA5uSgSaCw==
   dependencies:
     client-only "0.0.1"
 
 stylis@^4.3.0:
-  version "4.3.2"
-  resolved "https://registry.npmjs.org/stylis/-/stylis-4.3.2.tgz"
-  integrity sha512-bhtUjWd/z6ltJiQwg0dUfxEJ+W+jdqQd8TbWLWyeIJHlnsqmGLRFFd8e5mA0AZi/zx90smXRlN66YMTcaSFifg==
+  version "4.3.6"
+  resolved "https://registry.yarnpkg.com/stylis/-/stylis-4.3.6.tgz#7c7b97191cb4f195f03ecab7d52f7902ed378320"
+  integrity sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==
 
-sucrase@^3.32.0:
+sucrase@^3.35.0:
   version "3.35.0"
-  resolved "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz"
+  resolved "https://registry.yarnpkg.com/sucrase/-/sucrase-3.35.0.tgz#57f17a3d7e19b36d8995f06679d121be914ae263"
   integrity sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==
   dependencies:
     "@jridgewell/gen-mapping" "^0.3.2"
@@ -14254,7 +15505,7 @@ sucrase@^3.32.0:
 
 superagent@3.8.1:
   version "3.8.1"
-  resolved "https://registry.npmjs.org/superagent/-/superagent-3.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/superagent/-/superagent-3.8.1.tgz#2571fd921f3fcdba43ac68c3b35c91951532701f"
   integrity sha512-VMBFLYgFuRdfeNQSMLbxGSLfmXL/xc+OO+BZp41Za/NRDBet/BNbkRJrYzCUu0u4GU0i/ml2dtT8b9qgkw9z6Q==
   dependencies:
     component-emitter "^1.2.0"
@@ -14268,33 +15519,31 @@ superagent@3.8.1:
     qs "^6.5.1"
     readable-stream "^2.0.5"
 
-supports-color@^5.3.0:
-  version "5.5.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz"
-  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
-  dependencies:
-    has-flag "^3.0.0"
-
 supports-color@^7.1.0:
   version "7.2.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
   integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
   dependencies:
     has-flag "^4.0.0"
 
+supports-color@^9.4.0:
+  version "9.4.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-9.4.0.tgz#17bfcf686288f531db3dea3215510621ccb55954"
+  integrity sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==
+
 supports-preserve-symlinks-flag@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
 svg-parser@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/svg-parser/-/svg-parser-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/svg-parser/-/svg-parser-2.0.4.tgz#fdc2e29e13951736140b76cb122c8ee6630eb6b5"
   integrity sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==
 
 svgo@^3.0.2:
   version "3.3.2"
-  resolved "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/svgo/-/svgo-3.3.2.tgz#ad58002652dffbb5986fc9716afe52d869ecbda8"
   integrity sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==
   dependencies:
     "@trysound/sax" "0.2.0"
@@ -14305,75 +15554,69 @@ svgo@^3.0.2:
     csso "^5.0.5"
     picocolors "^1.0.0"
 
-synckit@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.npmjs.org/synckit/-/synckit-0.9.1.tgz"
-  integrity sha512-7gr8p9TQP6RAHusBOSLs46F4564ZrjV8xFmw5zCmgmhGUcw2hxsShhJ6CEiHQMgPDwAQ1fWHPM0ypc4RMAig4A==
+synckit@^0.11.7:
+  version "0.11.11"
+  resolved "https://registry.yarnpkg.com/synckit/-/synckit-0.11.11.tgz#c0b619cf258a97faa209155d9cd1699b5c998cb0"
+  integrity sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==
   dependencies:
-    "@pkgr/core" "^0.1.0"
-    tslib "^2.6.2"
+    "@pkgr/core" "^0.2.9"
 
 tabbable@^6.0.0:
   version "6.2.0"
-  resolved "https://registry.npmjs.org/tabbable/-/tabbable-6.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/tabbable/-/tabbable-6.2.0.tgz#732fb62bc0175cfcec257330be187dcfba1f3b97"
   integrity sha512-Cat63mxsVJlzYvN51JmVXIgNoUokrIaT2zLclCXjRd8boZ0004U4KCs/sToJ75C6sdlByWxpYnb5Boif1VSFew==
 
 tailwind-merge@^1.14.0:
   version "1.14.0"
-  resolved "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-1.14.0.tgz"
+  resolved "https://registry.yarnpkg.com/tailwind-merge/-/tailwind-merge-1.14.0.tgz#e677f55d864edc6794562c63f5001f45093cdb8b"
   integrity sha512-3mFKyCo/MBcgyOTlrY8T7odzZFx+w+qKSMAmdFzRvqBfLlSigU6TZnlFHK0lkMwj9Bj8OYU+9yW9lmGuS0QEnQ==
 
 tailwind-merge@^2.5.2:
   version "2.6.0"
-  resolved "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-2.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/tailwind-merge/-/tailwind-merge-2.6.0.tgz#ac5fb7e227910c038d458f396b7400d93a3142d5"
   integrity sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA==
 
 tailwind-variants@^0.1.20:
   version "0.1.20"
-  resolved "https://registry.npmjs.org/tailwind-variants/-/tailwind-variants-0.1.20.tgz"
+  resolved "https://registry.yarnpkg.com/tailwind-variants/-/tailwind-variants-0.1.20.tgz#8aaed9094be0379a438641a42d588943e44c5fcd"
   integrity sha512-AMh7x313t/V+eTySKB0Dal08RHY7ggYK0MSn/ad8wKWOrDUIzyiWNayRUm2PIJ4VRkvRnfNuyRuKbLV3EN+ewQ==
   dependencies:
     tailwind-merge "^1.14.0"
 
 tailwindcss-animate@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.npmjs.org/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz#318b692c4c42676cc9e67b19b78775742388bef4"
   integrity sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==
 
 tailwindcss@^3.4.3:
-  version "3.4.13"
-  resolved "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.13.tgz"
-  integrity sha512-KqjHOJKogOUt5Bs752ykCeiwvi0fKVkr5oqsFNt/8px/tA8scFPIlkygsf6jXrfCqGHz7VflA6+yytWuM+XhFw==
+  version "3.4.17"
+  resolved "https://registry.yarnpkg.com/tailwindcss/-/tailwindcss-3.4.17.tgz#ae8406c0f96696a631c790768ff319d46d5e5a63"
+  integrity sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==
   dependencies:
     "@alloc/quick-lru" "^5.2.0"
     arg "^5.0.2"
-    chokidar "^3.5.3"
+    chokidar "^3.6.0"
     didyoumean "^1.2.2"
     dlv "^1.1.3"
-    fast-glob "^3.3.0"
+    fast-glob "^3.3.2"
     glob-parent "^6.0.2"
     is-glob "^4.0.3"
-    jiti "^1.21.0"
-    lilconfig "^2.1.0"
-    micromatch "^4.0.5"
+    jiti "^1.21.6"
+    lilconfig "^3.1.3"
+    micromatch "^4.0.8"
     normalize-path "^3.0.0"
     object-hash "^3.0.0"
-    picocolors "^1.0.0"
-    postcss "^8.4.23"
+    picocolors "^1.1.1"
+    postcss "^8.4.47"
     postcss-import "^15.1.0"
     postcss-js "^4.0.1"
-    postcss-load-config "^4.0.1"
-    postcss-nested "^6.0.1"
-    postcss-selector-parser "^6.0.11"
-    resolve "^1.22.2"
-    sucrase "^3.32.0"
-
-tapable@^2.2.0:
-  version "2.2.1"
-  resolved "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz"
-  integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
+    postcss-load-config "^4.0.2"
+    postcss-nested "^6.2.0"
+    postcss-selector-parser "^6.1.2"
+    resolve "^1.22.8"
+    sucrase "^3.35.0"
 
-tar@6.2.1:
+tar@6.2.1, tar@^6.1.11, tar@^6.2.1, tar@^7.4.3:
   version "6.2.1"
   resolved "https://registry.yarnpkg.com/tar/-/tar-6.2.1.tgz#717549c541bc3c2af15751bea94b1dd068d4b03a"
   integrity sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==
@@ -14387,46 +15630,46 @@ tar@6.2.1:
 
 text-extensions@^1.0.0:
   version "1.9.0"
-  resolved "https://registry.npmjs.org/text-extensions/-/text-extensions-1.9.0.tgz"
+  resolved "https://registry.yarnpkg.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26"
   integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==
 
-text-table@^0.2.0:
+text-table@^0.2.0, text-table@~0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
   integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
 
 thenify-all@^1.0.0:
   version "1.6.0"
-  resolved "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/thenify-all/-/thenify-all-1.6.0.tgz#1a1918d402d8fc3f98fbf234db0bcc8cc10e9726"
   integrity sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==
   dependencies:
     thenify ">= 3.1.0 < 4"
 
 "thenify@>= 3.1.0 < 4":
   version "3.3.1"
-  resolved "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/thenify/-/thenify-3.3.1.tgz#8932e686a4066038a016dd9e2ca46add9838a95f"
   integrity sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==
   dependencies:
     any-promise "^1.0.0"
 
-thingies@^1.20.0:
-  version "1.21.0"
-  resolved "https://registry.npmjs.org/thingies/-/thingies-1.21.0.tgz"
-  integrity sha512-hsqsJsFMsV+aD4s3CWKk85ep/3I9XzYV/IXaSouJMYIoDlgyi11cBhsqYe9/geRfB0YIikBQg6raRaM+nIMP9g==
+thingies@^2.5.0:
+  version "2.5.0"
+  resolved "https://registry.yarnpkg.com/thingies/-/thingies-2.5.0.tgz#5f7b882c933b85989f8466b528a6247a6881e04f"
+  integrity sha512-s+2Bwztg6PhWUD7XMfeYm5qliDdSiZm7M7n8KjTkIsm3l/2lgVRc2/Gx/v+ZX8lT4FMA+i8aQvhcWylldc+ZNw==
 
 third-party-capital@1.0.20:
   version "1.0.20"
-  resolved "https://registry.npmjs.org/third-party-capital/-/third-party-capital-1.0.20.tgz"
+  resolved "https://registry.yarnpkg.com/third-party-capital/-/third-party-capital-1.0.20.tgz#e218a929a35bf4d2245da9addb8ab978d2f41685"
   integrity sha512-oB7yIimd8SuGptespDAZnNkzIz+NWaJCu2RMsbs4Wmp9zSDUM8Nhi3s2OOcqYuv3mN4hitXc8DVx+LyUmbUDiA==
 
 throttle-debounce@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/throttle-debounce/-/throttle-debounce-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/throttle-debounce/-/throttle-debounce-3.0.1.tgz#32f94d84dfa894f786c9a1f290e7a645b6a19abb"
   integrity sha512-dTEWWNu6JmeVXY0ZYoPuH5cRIwc0MeGbJwah9KUNYSJwommQpCzTySTpEe8Gs1J23aeWEuAobe4Ag7EHVt/LOg==
 
 through2@^2.0.1:
   version "2.0.5"
-  resolved "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
   integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
   dependencies:
     readable-stream "~2.3.6"
@@ -14434,106 +15677,119 @@ through2@^2.0.1:
 
 through2@^4.0.0:
   version "4.0.2"
-  resolved "https://registry.npmjs.org/through2/-/through2-4.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764"
   integrity sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==
   dependencies:
     readable-stream "3"
 
 "through@>=2.2.7 <3":
   version "2.3.8"
-  resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz"
+  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
 
 tiny-invariant@^1.0.2, tiny-invariant@^1.2.0, tiny-invariant@^1.3.1:
   version "1.3.3"
-  resolved "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.3.3.tgz#46680b7a873a0d5d10005995eb90a70d74d60127"
   integrity sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==
 
+tiny-relative-date@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/tiny-relative-date/-/tiny-relative-date-1.3.0.tgz#fa08aad501ed730f31cc043181d995c39a935e07"
+  integrity sha512-MOQHpzllWxDCHHaDno30hhLfbouoYlOI8YlMNtvKe1zXbjEVhbcEovQxvZrPvtiYW630GQDoMMarCnjfyfHA+A==
+
 tiny-warning@^1.0.0:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/tiny-warning/-/tiny-warning-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/tiny-warning/-/tiny-warning-1.0.3.tgz#94a30db453df4c643d0fd566060d60a875d84754"
   integrity sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==
 
-to-fast-properties@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz"
-  integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==
+tinyglobby@^0.2.12, tinyglobby@^0.2.13:
+  version "0.2.15"
+  resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.15.tgz#e228dd1e638cea993d2fdb4fcd2d4602a79951c2"
+  integrity sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==
+  dependencies:
+    fdir "^6.5.0"
+    picomatch "^4.0.3"
 
 to-regex-range@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
   integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
   dependencies:
     is-number "^7.0.0"
 
 toggle-selection@^1.0.6:
   version "1.0.6"
-  resolved "https://registry.npmjs.org/toggle-selection/-/toggle-selection-1.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/toggle-selection/-/toggle-selection-1.0.6.tgz#6e45b1263f2017fa0acc7d89d78b15b8bf77da32"
   integrity sha512-BiZS+C1OS8g/q2RRbJmy59xpyghNBqrr6k5L/uKBGRsTfxmu3ffiRnd8mlGPUVayg8pvfi5urfnu8TU7DVOkLQ==
 
 toml@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/toml/-/toml-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/toml/-/toml-3.0.0.tgz#342160f1af1904ec9d204d03a5d61222d762c5ee"
   integrity sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==
 
 totalist@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/totalist/-/totalist-3.0.1.tgz#ba3a3d600c915b1a97872348f79c127475f6acf8"
   integrity sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==
 
 tr46@~0.0.3:
   version "0.0.3"
-  resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
   integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
 
-tree-dump@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/tree-dump/-/tree-dump-1.0.2.tgz"
-  integrity sha512-dpev9ABuLWdEubk+cIaI9cHwRNNDjkBBLXTwI4UCUFdQ5xXKqNXoK4FEciw/vxf+NQ7Cb7sGUyeUtORvHIdRXQ==
+tree-dump@^1.0.3:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/tree-dump/-/tree-dump-1.1.0.tgz#ab29129169dc46004414f5a9d4a3c6e89f13e8a4"
+  integrity sha512-rMuvhU4MCDbcbnleZTFezWsaZXRFemSqAM+7jPnzUl1fo9w3YEKOxAeui0fz3OI4EU4hf23iyA7uQRVko+UaBA==
+
+treeverse@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/treeverse/-/treeverse-3.0.0.tgz#dd82de9eb602115c6ebd77a574aae67003cb48c8"
+  integrity sha512-gcANaAnd2QDZFmHFEOF4k7uc1J/6a6z3DJMd/QwEyxLoKGiptJRwid582r7QIsFlFMIZ3SnxfS52S4hm2DHkuQ==
 
 trim-lines@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/trim-lines/-/trim-lines-3.0.1.tgz#d802e332a07df861c48802c04321017b1bd87338"
   integrity sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==
 
 trim-newlines@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144"
   integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==
 
 trough@^1.0.0:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/trough/-/trough-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/trough/-/trough-1.0.5.tgz#b8b639cefad7d0bb2abd37d433ff8293efa5f406"
   integrity sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==
 
 trough@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/trough/-/trough-2.2.0.tgz#94a60bd6bd375c152c1df911a4b11d5b0256f50f"
   integrity sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==
 
 ts-api-utils@^1.0.1:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.3.0.tgz"
-  integrity sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/ts-api-utils/-/ts-api-utils-1.4.3.tgz#bfc2215fe6528fecab2b0fba570a2e8a4263b064"
+  integrity sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==
 
 ts-easing@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.npmjs.org/ts-easing/-/ts-easing-0.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/ts-easing/-/ts-easing-0.2.0.tgz#c8a8a35025105566588d87dbda05dd7fbfa5a4ec"
   integrity sha512-Z86EW+fFFh/IFB1fqQ3/+7Zpf9t2ebOAxNI/V6Wo7r5gqiqtxmgTlQ1qbqQcjLKYeSHPTsEmvlJUDg/EuL0uHQ==
 
 ts-interface-checker@^0.1.9:
   version "0.1.13"
-  resolved "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz"
+  resolved "https://registry.yarnpkg.com/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz#784fd3d679722bc103b1b4b8030bcddb5db2a699"
   integrity sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==
 
 ts-keycode-enum@^1.0.6:
   version "1.0.6"
-  resolved "https://registry.npmjs.org/ts-keycode-enum/-/ts-keycode-enum-1.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/ts-keycode-enum/-/ts-keycode-enum-1.0.6.tgz#aeefd1c2fc7b0557f86a0e696e300905bbb4c1c1"
   integrity sha512-DF8+Cf/FJJnPRxwz8agCoDelQXKZWQOS/gnnwx01nZ106tPJdB3BgJ9QTtLwXgR82D8O+nTjuZzWgf0Rg4vuRA==
 
 ts-node@^10.8.1:
   version "10.9.2"
-  resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.2.tgz#70f021c9e185bccdca820e26dc413805c101c71f"
   integrity sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==
   dependencies:
     "@cspotcode/source-map-support" "^0.8.0"
@@ -14551,13 +15807,13 @@ ts-node@^10.8.1:
     yn "3.1.1"
 
 ts-pattern@^5.0.6:
-  version "5.3.1"
-  resolved "https://registry.npmjs.org/ts-pattern/-/ts-pattern-5.3.1.tgz"
-  integrity sha512-1RUMKa8jYQdNfmnK4jyzBK3/PS/tnjcZ1CW0v1vWDeYe5RBklc/nquw03MEoB66hVBm4BnlCfmOqDVxHyT1DpA==
+  version "5.8.0"
+  resolved "https://registry.yarnpkg.com/ts-pattern/-/ts-pattern-5.8.0.tgz#1bf2dcdc58ae96ac7b64e59c9515d7ce1bf0ff19"
+  integrity sha512-kIjN2qmWiHnhgr5DAkAafF9fwb0T5OhMVSWrm8XEdTFnX6+wfXwYOFjeF86UZ54vduqiR7BfqScFmXSzSaH8oA==
 
 tsconfig-paths@^3.15.0:
   version "3.15.0"
-  resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz"
+  resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz#5299ec605e55b1abb23ec939ef15edaf483070d4"
   integrity sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==
   dependencies:
     "@types/json5" "^0.0.29"
@@ -14565,36 +15821,45 @@ tsconfig-paths@^3.15.0:
     minimist "^1.2.6"
     strip-bom "^3.0.0"
 
-tslib@^2.0.0, tslib@^2.0.3, tslib@^2.1.0, tslib@^2.2.0, tslib@^2.3.0, tslib@^2.3.1, tslib@^2.4.0, tslib@^2.4.1, tslib@^2.6.2:
-  version "2.7.0"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz"
-  integrity sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==
+tslib@^2.0.0, tslib@^2.0.3, tslib@^2.1.0, tslib@^2.2.0, tslib@^2.3.0, tslib@^2.3.1, tslib@^2.4.0, tslib@^2.4.1, tslib@^2.6.2, tslib@^2.8.0:
+  version "2.8.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.8.1.tgz#612efe4ed235d567e8aba5f2a5fab70280ade83f"
+  integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==
+
+tuf-js@^3.0.1:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/tuf-js/-/tuf-js-3.1.0.tgz#61b847fe9aa86a7d5bda655a4647e026aa73a1be"
+  integrity sha512-3T3T04WzowbwV2FDiGXBbr81t64g1MUGGJRgT4x5o97N+8ArdhVCAF9IxFrxuSJmM3E5Asn7nKHkao0ibcZXAg==
+  dependencies:
+    "@tufjs/models" "3.0.1"
+    debug "^4.4.1"
+    make-fetch-happen "^14.0.3"
 
 typanion@^3.12.1, typanion@^3.8.0:
   version "3.14.0"
-  resolved "https://registry.npmjs.org/typanion/-/typanion-3.14.0.tgz"
+  resolved "https://registry.yarnpkg.com/typanion/-/typanion-3.14.0.tgz#a766a91810ce8258033975733e836c43a2929b94"
   integrity sha512-ZW/lVMRabETuYCd9O9ZvMhAh8GslSqaUjxmK/JLPCh6l73CvLBiuXswj/+7LdnWOgYsQ130FqLzFz5aGT4I3Ug==
 
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
-  resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
   integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
   dependencies:
     prelude-ls "^1.2.1"
 
 type-fest@^0.18.0:
   version "0.18.1"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.18.1.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f"
   integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==
 
 type-fest@^0.20.2:
   version "0.20.2"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
   integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
 
 type-fest@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
   integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==
 
 type-fest@^0.7.1:
@@ -14604,122 +15869,118 @@ type-fest@^0.7.1:
 
 type-fest@^0.8.1:
   version "0.8.1"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
   integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
 
 type-fest@^4.10.0:
-  version "4.26.1"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-4.26.1.tgz"
-  integrity sha512-yOGpmOAL7CkKe/91I5O3gPICmJNLJ1G4zFYVAsRHg7M64biSnPtRj0WNQt++bRkjYOqjWXrhnUw1utzmVErAdg==
+  version "4.41.0"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-4.41.0.tgz#6ae1c8e5731273c2bf1f58ad39cbae2c91a46c58"
+  integrity sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==
 
 type-is@^1.6.18:
   version "1.6.18"
-  resolved "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz"
+  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"
   integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
   dependencies:
     media-typer "0.3.0"
     mime-types "~2.1.24"
 
-typed-array-buffer@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz"
-  integrity sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==
+typed-array-buffer@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz#a72395450a4869ec033fd549371b47af3a2ee536"
+  integrity sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==
   dependencies:
-    call-bind "^1.0.7"
+    call-bound "^1.0.3"
     es-errors "^1.3.0"
-    is-typed-array "^1.1.13"
+    is-typed-array "^1.1.14"
 
-typed-array-byte-length@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz"
-  integrity sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==
+typed-array-byte-length@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz#8407a04f7d78684f3d252aa1a143d2b77b4160ce"
+  integrity sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==
   dependencies:
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
     for-each "^0.3.3"
-    gopd "^1.0.1"
-    has-proto "^1.0.3"
-    is-typed-array "^1.1.13"
+    gopd "^1.2.0"
+    has-proto "^1.2.0"
+    is-typed-array "^1.1.14"
 
-typed-array-byte-offset@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.2.tgz"
-  integrity sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==
+typed-array-byte-offset@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz#ae3698b8ec91a8ab945016108aef00d5bff12355"
+  integrity sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==
   dependencies:
     available-typed-arrays "^1.0.7"
-    call-bind "^1.0.7"
+    call-bind "^1.0.8"
     for-each "^0.3.3"
-    gopd "^1.0.1"
-    has-proto "^1.0.3"
-    is-typed-array "^1.1.13"
+    gopd "^1.2.0"
+    has-proto "^1.2.0"
+    is-typed-array "^1.1.15"
+    reflect.getprototypeof "^1.0.9"
 
-typed-array-length@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.6.tgz"
-  integrity sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==
+typed-array-length@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/typed-array-length/-/typed-array-length-1.0.7.tgz#ee4deff984b64be1e118b0de8c9c877d5ce73d3d"
+  integrity sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==
   dependencies:
     call-bind "^1.0.7"
     for-each "^0.3.3"
     gopd "^1.0.1"
-    has-proto "^1.0.3"
     is-typed-array "^1.1.13"
     possible-typed-array-names "^1.0.0"
+    reflect.getprototypeof "^1.0.6"
 
-"typescript@^4.6.4 || ^5.2.2":
-  version "5.8.3"
-  resolved "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz"
-  integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==
-
-typescript@^5.1.3:
-  version "5.6.2"
-  resolved "https://registry.npmjs.org/typescript/-/typescript-5.6.2.tgz"
-  integrity sha512-NW8ByodCSNCwZeghjN3o+JX5OFH0Ojg6sadjEKY4huZ52TqbJTJnDo5+Tw98lSy63NZvi4n+ez5m2u5d4PkZyw==
+"typescript@^4.6.4 || ^5.2.2", typescript@^5.1.3:
+  version "5.9.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.9.2.tgz#d93450cddec5154a2d5cabe3b8102b83316fb2a6"
+  integrity sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==
 
 uglify-js@^3.0.0:
   version "3.19.3"
-  resolved "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz"
+  resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.19.3.tgz#82315e9bbc6f2b25888858acd1fff8441035b77f"
   integrity sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==
 
-unbox-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz"
-  integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
+unbox-primitive@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.1.0.tgz#8d9d2c9edeea8460c7f35033a88867944934d1e2"
+  integrity sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==
   dependencies:
-    call-bind "^1.0.2"
+    call-bound "^1.0.3"
     has-bigints "^1.0.2"
-    has-symbols "^1.0.3"
-    which-boxed-primitive "^1.0.2"
+    has-symbols "^1.1.0"
+    which-boxed-primitive "^1.1.1"
 
-undici-types@~6.19.2:
-  version "6.19.8"
-  resolved "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz"
-  integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==
+undici-types@~7.12.0:
+  version "7.12.0"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-7.12.0.tgz#15c5c7475c2a3ba30659529f5cdb4674b622fafb"
+  integrity sha512-goOacqME2GYyOZZfb5Lgtu+1IDmAlAEu5xnD3+xTzS10hT0vzpf0SPjkXwAw9Jm+4n/mQGDP3LO8CPbYROeBfQ==
 
 unicode-canonical-property-names-ecmascript@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz#cb3173fe47ca743e228216e4a3ddc4c84d628cc2"
   integrity sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==
 
 unicode-match-property-ecmascript@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3"
   integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==
   dependencies:
     unicode-canonical-property-names-ecmascript "^2.0.0"
     unicode-property-aliases-ecmascript "^2.0.0"
 
-unicode-match-property-value-ecmascript@^2.1.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz"
-  integrity sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==
+unicode-match-property-value-ecmascript@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz#65a7adfad8574c219890e219285ce4c64ed67eaa"
+  integrity sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==
 
 unicode-property-aliases-ecmascript@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz"
-  integrity sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz#301d4f8a43d2b75c97adfad87c9dd5350c9475d1"
+  integrity sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==
 
 unified@^11.0.0, unified@^11.0.4:
   version "11.0.5"
-  resolved "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/unified/-/unified-11.0.5.tgz#f66677610a5c0a9ee90cab2b8d4d66037026d9e1"
   integrity sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -14732,7 +15993,7 @@ unified@^11.0.0, unified@^11.0.4:
 
 unified@^9.2.1:
   version "9.2.2"
-  resolved "https://registry.npmjs.org/unified/-/unified-9.2.2.tgz"
+  resolved "https://registry.yarnpkg.com/unified/-/unified-9.2.2.tgz#67649a1abfc3ab85d2969502902775eb03146975"
   integrity sha512-Sg7j110mtefBD+qunSLO1lqOEKdrwBFBrR6Qd8f4uwkhWNlbkaqwHse6e7QvD3AP/MNoJdEDLaf8OxYyoWgorQ==
   dependencies:
     bail "^1.0.0"
@@ -14742,16 +16003,30 @@ unified@^9.2.1:
     trough "^1.0.0"
     vfile "^4.0.0"
 
+unique-filename@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-4.0.0.tgz#a06534d370e7c977a939cd1d11f7f0ab8f1fed13"
+  integrity sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ==
+  dependencies:
+    unique-slug "^5.0.0"
+
+unique-slug@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/unique-slug/-/unique-slug-5.0.0.tgz#ca72af03ad0dbab4dad8aa683f633878b1accda8"
+  integrity sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg==
+  dependencies:
+    imurmurhash "^0.1.4"
+
 unist-builder@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/unist-builder/-/unist-builder-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-builder/-/unist-builder-3.0.1.tgz#258b89dcadd3c973656b2327b347863556907f58"
   integrity sha512-gnpOw7DIpCA0vpr6NqdPvTWnlPTApCTRzr+38E6hCWx3rz/cjo83SsKIlS1Z+L5ttScQ2AwutNnb8+tAvpb6qQ==
   dependencies:
     "@types/unist" "^2.0.0"
 
 unist-util-filter@^5.0.0:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/unist-util-filter/-/unist-util-filter-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-filter/-/unist-util-filter-5.0.1.tgz#f9f3a0bdee007e040964c274dda27bac663d0a39"
   integrity sha512-pHx7D4Zt6+TsfwylH9+lYhBhzyhEnCXs/lbq/Hstxno5z4gVdyc2WEW0asfjGKPyG4pEKrnBv5hdkO6+aRnQJw==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -14760,60 +16035,69 @@ unist-util-filter@^5.0.0:
 
 unist-util-generated@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-generated/-/unist-util-generated-2.0.1.tgz#e37c50af35d3ed185ac6ceacb6ca0afb28a85cae"
   integrity sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==
 
 unist-util-is@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-4.1.0.tgz#976e5f462a7a5de73d94b706bac1b90671b57797"
   integrity sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==
 
 unist-util-is@^5.0.0:
   version "5.2.1"
-  resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-5.2.1.tgz#b74960e145c18dcb6226bc57933597f5486deae9"
   integrity sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==
   dependencies:
     "@types/unist" "^2.0.0"
 
 unist-util-is@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-is/-/unist-util-is-6.0.0.tgz#b775956486aff107a9ded971d996c173374be424"
   integrity sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-position-from-estree@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz#d94da4df596529d1faa3de506202f0c9a23f2200"
   integrity sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-position@^4.0.0:
   version "4.0.4"
-  resolved "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-4.0.4.tgz#93f6d8c7d6b373d9b825844645877c127455f037"
   integrity sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==
   dependencies:
     "@types/unist" "^2.0.0"
 
 unist-util-position@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-position/-/unist-util-position-5.0.0.tgz#678f20ab5ca1207a97d7ea8a388373c9cf896be4"
   integrity sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-remove-position@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz#fea68a25658409c9460408bc6b4991b965b52163"
   integrity sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==
   dependencies:
     "@types/unist" "^3.0.0"
     unist-util-visit "^5.0.0"
 
+unist-util-remove@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/unist-util-remove/-/unist-util-remove-3.1.1.tgz#8bfa181aff916bd32a4ed30b3ed76d0c21c077df"
+  integrity sha512-kfCqZK5YVY5yEa89tvpl7KnBBHu2c6CzMkqHUrlOqaRgGOMp0sMvwWOVrbAtj03KhovQB7i96Gda72v/EFE0vw==
+  dependencies:
+    "@types/unist" "^2.0.0"
+    unist-util-is "^5.0.0"
+    unist-util-visit-parents "^5.0.0"
+
 unist-util-select@^4.0.0, unist-util-select@^4.0.1:
   version "4.0.3"
-  resolved "https://registry.npmjs.org/unist-util-select/-/unist-util-select-4.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-select/-/unist-util-select-4.0.3.tgz#861b403e273d9f677685dd9edefc663dbe1bf517"
   integrity sha512-1074+K9VyR3NyUz3lgNtHKm7ln+jSZXtLJM4E22uVuoFn88a/Go2pX8dusrt/W+KWH1ncn8jcd8uCQuvXb/fXA==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -14823,28 +16107,28 @@ unist-util-select@^4.0.0, unist-util-select@^4.0.1:
 
 unist-util-stringify-position@^2.0.0:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz#cce3bfa1cdf85ba7375d1d5b17bdc4cada9bd9da"
   integrity sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==
   dependencies:
     "@types/unist" "^2.0.2"
 
 unist-util-stringify-position@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz#03ad3348210c2d930772d64b489580c13a7db39d"
   integrity sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==
   dependencies:
     "@types/unist" "^2.0.0"
 
 unist-util-stringify-position@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz#449c6e21a880e0855bf5aabadeb3a740314abac2"
   integrity sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==
   dependencies:
     "@types/unist" "^3.0.0"
 
 unist-util-visit-parents@^3.0.0:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz#65a6ce698f78a6b0f56aa0e88f13801886cdaef6"
   integrity sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -14852,15 +16136,15 @@ unist-util-visit-parents@^3.0.0:
 
 unist-util-visit-parents@^4.0.0:
   version "4.1.1"
-  resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz#e83559a4ad7e6048a46b1bdb22614f2f3f4724f2"
   integrity sha512-1xAFJXAKpnnJl8G7K5KgU7FY55y3GcLIXqkzUj5QF/QVP7biUm0K0O2oqVkYsdjzJKifYeWn9+o6piAK2hGSHw==
   dependencies:
     "@types/unist" "^2.0.0"
     unist-util-is "^5.0.0"
 
-unist-util-visit-parents@^5.1.1:
+unist-util-visit-parents@^5.0.0, unist-util-visit-parents@^5.1.1:
   version "5.1.3"
-  resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz#b4520811b0ca34285633785045df7a8d6776cfeb"
   integrity sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -14868,7 +16152,7 @@ unist-util-visit-parents@^5.1.1:
 
 unist-util-visit-parents@^6.0.0:
   version "6.0.1"
-  resolved "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz#4d5f85755c3b8f0dc69e21eca5d6d82d22162815"
   integrity sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -14876,7 +16160,7 @@ unist-util-visit-parents@^6.0.0:
 
 unist-util-visit@^3.0.0, unist-util-visit@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-3.1.0.tgz#9420d285e1aee938c7d9acbafc8e160186dbaf7b"
   integrity sha512-Szoh+R/Ll68QWAyQyZZpQzZQm2UPbxibDvaY8Xc9SUtYgPsDzx5AWSk++UUt2hJuow8mvwR+rG+LQLw+KsuAKA==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -14885,7 +16169,7 @@ unist-util-visit@^3.0.0, unist-util-visit@^3.1.0:
 
 unist-util-visit@^4.0.0:
   version "4.1.2"
-  resolved "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-4.1.2.tgz#125a42d1eb876283715a3cb5cceaa531828c72e2"
   integrity sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -14894,7 +16178,7 @@ unist-util-visit@^4.0.0:
 
 unist-util-visit@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/unist-util-visit/-/unist-util-visit-5.0.0.tgz#a7de1f31f72ffd3519ea71814cccf5fd6a9217d6"
   integrity sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -14903,12 +16187,12 @@ unist-util-visit@^5.0.0:
 
 universalify@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz#168efc2180964e6386d061e094df61afe239b18d"
   integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==
 
 unload@2.2.0:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/unload/-/unload-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/unload/-/unload-2.2.0.tgz#ccc88fdcad345faa06a92039ec0f80b488880ef7"
   integrity sha512-B60uB5TNBLtN6/LsgAf3udH9saB5p7gqJwcFfbOEZ8BcBHnGwCf6G/TGiEqkRAxX7zAFIUtzdrXQSdL3Q/wqNA==
   dependencies:
     "@babel/runtime" "^7.6.2"
@@ -14924,19 +16208,38 @@ unplugin@1.0.1:
     webpack-sources "^3.2.3"
     webpack-virtual-modules "^0.5.0"
 
+unrs-resolver@^1.6.2:
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/unrs-resolver/-/unrs-resolver-1.11.1.tgz#be9cd8686c99ef53ecb96df2a473c64d304048a9"
+  integrity sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==
+  dependencies:
+    napi-postinstall "^0.3.0"
+  optionalDependencies:
+    "@unrs/resolver-binding-android-arm-eabi" "1.11.1"
+    "@unrs/resolver-binding-android-arm64" "1.11.1"
+    "@unrs/resolver-binding-darwin-arm64" "1.11.1"
+    "@unrs/resolver-binding-darwin-x64" "1.11.1"
+    "@unrs/resolver-binding-freebsd-x64" "1.11.1"
+    "@unrs/resolver-binding-linux-arm-gnueabihf" "1.11.1"
+    "@unrs/resolver-binding-linux-arm-musleabihf" "1.11.1"
+    "@unrs/resolver-binding-linux-arm64-gnu" "1.11.1"
+    "@unrs/resolver-binding-linux-arm64-musl" "1.11.1"
+    "@unrs/resolver-binding-linux-ppc64-gnu" "1.11.1"
+    "@unrs/resolver-binding-linux-riscv64-gnu" "1.11.1"
+    "@unrs/resolver-binding-linux-riscv64-musl" "1.11.1"
+    "@unrs/resolver-binding-linux-s390x-gnu" "1.11.1"
+    "@unrs/resolver-binding-linux-x64-gnu" "1.11.1"
+    "@unrs/resolver-binding-linux-x64-musl" "1.11.1"
+    "@unrs/resolver-binding-wasm32-wasi" "1.11.1"
+    "@unrs/resolver-binding-win32-arm64-msvc" "1.11.1"
+    "@unrs/resolver-binding-win32-ia32-msvc" "1.11.1"
+    "@unrs/resolver-binding-win32-x64-msvc" "1.11.1"
+
 untildify@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/untildify/-/untildify-4.0.0.tgz#2bc947b953652487e4600949fb091e3ae8cd919b"
   integrity sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==
 
-update-browserslist-db@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz"
-  integrity sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==
-  dependencies:
-    escalade "^3.1.2"
-    picocolors "^1.0.1"
-
 update-browserslist-db@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz#348377dd245216f9e7060ff50b15a1b740b75420"
@@ -14947,68 +16250,68 @@ update-browserslist-db@^1.1.3:
 
 uri-js@^4.2.2:
   version "4.4.1"
-  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
   integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
   dependencies:
     punycode "^2.1.0"
 
 urijs@^1.19.11:
   version "1.19.11"
-  resolved "https://registry.npmjs.org/urijs/-/urijs-1.19.11.tgz"
+  resolved "https://registry.yarnpkg.com/urijs/-/urijs-1.19.11.tgz#204b0d6b605ae80bea54bea39280cdb7c9f923cc"
   integrity sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==
 
 use-callback-ref@^1.3.3:
   version "1.3.3"
-  resolved "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz"
+  resolved "https://registry.yarnpkg.com/use-callback-ref/-/use-callback-ref-1.3.3.tgz#98d9fab067075841c5b2c6852090d5d0feabe2bf"
   integrity sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==
   dependencies:
     tslib "^2.0.0"
 
 use-composed-ref@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/use-composed-ref/-/use-composed-ref-1.3.0.tgz"
-  integrity sha512-GLMG0Jc/jiKov/3Ulid1wbv3r54K9HlMW29IWcDFPEqFkSO2nS0MuefWgMJpeHQ9YJeXDL3ZUF+P3jdXlZX/cQ==
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/use-composed-ref/-/use-composed-ref-1.4.0.tgz#09e023bf798d005286ad85cd20674bdf5770653b"
+  integrity sha512-djviaxuOOh7wkj0paeO1Q/4wMZ8Zrnag5H6yBvzN7AKKe8beOaED9SF5/ByLqsku8NP4zQqsvM2u3ew/tJK8/w==
 
 use-isomorphic-layout-effect@^1.1.1:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/use-isomorphic-layout-effect/-/use-isomorphic-layout-effect-1.1.2.tgz"
-  integrity sha512-49L8yCO3iGT/ZF9QttjwLF/ZD9Iwto5LnH5LmEdk/6cFmXddqi2ulF0edxTwjj+7mqvpVVGQWvbXZdn32wRSHA==
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/use-isomorphic-layout-effect/-/use-isomorphic-layout-effect-1.2.1.tgz#2f11a525628f56424521c748feabc2ffcc962fce"
+  integrity sha512-tpZZ+EX0gaghDAiFR37hj5MgY6ZN55kLiPkJsKxBMZ6GZdOSPJXiOzPM984oPYZ5AnehYx5WQp1+ME8I/P/pRA==
 
 use-latest@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/use-latest/-/use-latest-1.2.1.tgz"
-  integrity sha512-xA+AVm/Wlg3e2P/JiItTziwS7FK92LWrDB0p+hgXloIMuVCeJJ8v6f0eeHyPZaJrM+usM1FkFfbNCrJGs8A/zw==
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/use-latest/-/use-latest-1.3.0.tgz#549b9b0d4c1761862072f0899c6f096eb379137a"
+  integrity sha512-mhg3xdm9NaM8q+gLT8KryJPnRFOz1/5XPBhmDEVZK1webPzDjrPk7f/mbpeLqTgB9msytYWANxgALOCJKnLvcQ==
   dependencies:
     use-isomorphic-layout-effect "^1.1.1"
 
 use-resize-observer@^9.0.2:
   version "9.1.0"
-  resolved "https://registry.npmjs.org/use-resize-observer/-/use-resize-observer-9.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/use-resize-observer/-/use-resize-observer-9.1.0.tgz#14735235cf3268569c1ea468f8a90c5789fc5c6c"
   integrity sha512-R25VqO9Wb3asSD4eqtcxk8sJalvIOYBqS8MNZlpDSQ4l4xMQxC/J7Id9HoTqPq8FwULIn0PVW+OAqF2dyYbjow==
   dependencies:
     "@juggle/resize-observer" "^3.3.1"
 
 use-sidecar@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/use-sidecar/-/use-sidecar-1.1.3.tgz#10e7fd897d130b896e2c546c63a5e8233d00efdb"
   integrity sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==
   dependencies:
     detect-node-es "^1.1.0"
     tslib "^2.0.0"
 
-use-sync-external-store@^1.0.0:
+use-sync-external-store@^1.0.0, use-sync-external-store@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.5.0.tgz"
+  resolved "https://registry.yarnpkg.com/use-sync-external-store/-/use-sync-external-store-1.5.0.tgz#55122e2a3edd2a6c106174c27485e0fd59bcfca0"
   integrity sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A==
 
 util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
 util@^0.12.4:
   version "0.12.5"
-  resolved "https://registry.npmjs.org/util/-/util-0.12.5.tgz"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.12.5.tgz#5f17a6059b73db61a875668781a1c2b136bd6fbc"
   integrity sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==
   dependencies:
     inherits "^2.0.3"
@@ -15019,12 +16322,12 @@ util@^0.12.4:
 
 utility-types@^3.10.0:
   version "3.11.0"
-  resolved "https://registry.npmjs.org/utility-types/-/utility-types-3.11.0.tgz"
+  resolved "https://registry.yarnpkg.com/utility-types/-/utility-types-3.11.0.tgz#607c40edb4f258915e901ea7995607fdf319424c"
   integrity sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==
 
 uuid@8.3.2:
   version "8.3.2"
-  resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
   integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
 
 uuid@^9.0.0, uuid@^9.0.1:
@@ -15034,30 +16337,35 @@ uuid@^9.0.0, uuid@^9.0.1:
 
 v8-compile-cache-lib@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
   integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
 
-validate-npm-package-license@^3.0.1:
+validate-npm-package-license@^3.0.1, validate-npm-package-license@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
   dependencies:
     spdx-correct "^3.0.0"
     spdx-expression-parse "^3.0.0"
 
+validate-npm-package-name@^6.0.0, validate-npm-package-name@^6.0.1:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/validate-npm-package-name/-/validate-npm-package-name-6.0.2.tgz#4e8d2c4d939975a73dd1b7a65e8f08d44c85df96"
+  integrity sha512-IUoow1YUtvoBBC06dXs8bR8B9vuA3aJfmQNKMoaPG/OFsPmoQvw8xh+6Ye25Gx9DQhoEom3Pcu9MKHerm/NpUQ==
+
 validate.io-array@^1.0.3:
   version "1.0.6"
-  resolved "https://registry.npmjs.org/validate.io-array/-/validate.io-array-1.0.6.tgz"
+  resolved "https://registry.yarnpkg.com/validate.io-array/-/validate.io-array-1.0.6.tgz#5b5a2cafd8f8b85abb2f886ba153f2d93a27774d"
   integrity sha512-DeOy7CnPEziggrOO5CZhVKJw6S3Yi7e9e65R1Nl/RTN1vTQKnzjfvks0/8kQ40FP/dsjRAOd4hxmJ7uLa6vxkg==
 
 validate.io-function@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/validate.io-function/-/validate.io-function-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/validate.io-function/-/validate.io-function-1.0.2.tgz#343a19802ed3b1968269c780e558e93411c0bad7"
   integrity sha512-LlFybRJEriSuBnUhQyG5bwglhh50EpTL2ul23MPIuR1odjO7XaMLFV8vHGwp7AZciFxtYOeiSCT5st+XSPONiQ==
 
 validate.io-integer-array@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/validate.io-integer-array/-/validate.io-integer-array-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/validate.io-integer-array/-/validate.io-integer-array-1.0.0.tgz#2cabde033293a6bcbe063feafe91eaf46b13a089"
   integrity sha512-mTrMk/1ytQHtCY0oNO3dztafHYyGU88KL+jRxWuzfOmQb+4qqnWmI+gykvGp8usKZOM0H7keJHEbRaFiYA0VrA==
   dependencies:
     validate.io-array "^1.0.3"
@@ -15065,31 +16373,31 @@ validate.io-integer-array@^1.0.0:
 
 validate.io-integer@^1.0.4:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/validate.io-integer/-/validate.io-integer-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/validate.io-integer/-/validate.io-integer-1.0.5.tgz#168496480b95be2247ec443f2233de4f89878068"
   integrity sha512-22izsYSLojN/P6bppBqhgUDjCkr5RY2jd+N2a3DCAUey8ydvrZ/OkGvFPR7qfOpwR2LC5p4Ngzxz36g5Vgr/hQ==
   dependencies:
     validate.io-number "^1.0.3"
 
 validate.io-number@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/validate.io-number/-/validate.io-number-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/validate.io-number/-/validate.io-number-1.0.3.tgz#f63ffeda248bf28a67a8d48e0e3b461a1665baf8"
   integrity sha512-kRAyotcbNaSYoDnXvb4MHg/0a1egJdLwS6oJ38TJY7aw9n93Fl/3blIXdyYvPOp55CNxywooG/3BcrwNrBpcSg==
 
 value-equal@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.npmjs.org/value-equal/-/value-equal-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/value-equal/-/value-equal-1.0.1.tgz#1e0b794c734c5c0cade179c437d356d931a34d6c"
   integrity sha512-NOJ6JZCAWr0zlxZt+xqCHNTEKOsrks2HQd4MqhP1qy4z1SkbEP467eNx6TgDKXMvUOb+OENfJCZwM+16n7fRfw==
 
 vaul@^1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/vaul/-/vaul-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/vaul/-/vaul-1.1.2.tgz#c959f8b9dc2ed4f7d99366caee433fbef91f5ba9"
   integrity sha512-ZFkClGpWyI2WUQjdLJ/BaGuV6AVQiJ3uELGk3OYtP+B6yCO7Cmn9vPFXVJkRaGkOJu3m8bQMgtyzNHixULceQA==
   dependencies:
     "@radix-ui/react-dialog" "^1.1.1"
 
 vfile-location@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/vfile-location/-/vfile-location-4.1.0.tgz#69df82fb9ef0a38d0d02b90dd84620e120050dd0"
   integrity sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -15097,15 +16405,23 @@ vfile-location@^4.0.0:
 
 vfile-location@^5.0.0:
   version "5.0.3"
-  resolved "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/vfile-location/-/vfile-location-5.0.3.tgz#cb9eacd20f2b6426d19451e0eafa3d0a846225c3"
   integrity sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==
   dependencies:
     "@types/unist" "^3.0.0"
     vfile "^6.0.0"
 
+vfile-matter@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/vfile-matter/-/vfile-matter-5.0.1.tgz#3f701840dde13c68d72d5c5ebd9cf233dff84419"
+  integrity sha512-o6roP82AiX0XfkyTHyRCMXgHfltUNlXSEqCIS80f+mbAyiQBE2fxtDVMtseyytGx75sihiJFo/zR6r/4LTs2Cw==
+  dependencies:
+    vfile "^6.0.0"
+    yaml "^2.0.0"
+
 vfile-message@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-2.0.4.tgz#5b43b88171d409eae58477d13f23dd41d52c371a"
   integrity sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -15113,23 +16429,23 @@ vfile-message@^2.0.0:
 
 vfile-message@^3.0.0:
   version "3.1.4"
-  resolved "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-3.1.4.tgz#15a50816ae7d7c2d1fa87090a7f9f96612b59dea"
   integrity sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==
   dependencies:
     "@types/unist" "^2.0.0"
     unist-util-stringify-position "^3.0.0"
 
 vfile-message@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz"
-  integrity sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/vfile-message/-/vfile-message-4.0.3.tgz#87b44dddd7b70f0641c2e3ed0864ba73e2ea8df4"
+  integrity sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==
   dependencies:
     "@types/unist" "^3.0.0"
     unist-util-stringify-position "^4.0.0"
 
 vfile@^4.0.0:
   version "4.2.1"
-  resolved "https://registry.npmjs.org/vfile/-/vfile-4.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-4.2.1.tgz#03f1dce28fc625c625bc6514350fbdb00fa9e624"
   integrity sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -15139,7 +16455,7 @@ vfile@^4.0.0:
 
 vfile@^5.0.0:
   version "5.3.7"
-  resolved "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-5.3.7.tgz#de0677e6683e3380fafc46544cfe603118826ab7"
   integrity sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==
   dependencies:
     "@types/unist" "^2.0.0"
@@ -15149,7 +16465,7 @@ vfile@^5.0.0:
 
 vfile@^6.0.0, vfile@^6.0.1:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/vfile/-/vfile-6.0.3.tgz#3652ab1c496531852bf55a6bac57af981ebc38ab"
   integrity sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==
   dependencies:
     "@types/unist" "^3.0.0"
@@ -15157,7 +16473,7 @@ vfile@^6.0.0, vfile@^6.0.1:
 
 victory-vendor@^36.6.8:
   version "36.9.2"
-  resolved "https://registry.npmjs.org/victory-vendor/-/victory-vendor-36.9.2.tgz"
+  resolved "https://registry.yarnpkg.com/victory-vendor/-/victory-vendor-36.9.2.tgz#668b02a448fa4ea0f788dbf4228b7e64669ff801"
   integrity sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==
   dependencies:
     "@types/d3-array" "^3.0.3"
@@ -15175,29 +16491,34 @@ victory-vendor@^36.6.8:
     d3-time "^3.0.0"
     d3-timer "^3.0.1"
 
+walk-up-path@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/walk-up-path/-/walk-up-path-3.0.1.tgz#c8d78d5375b4966c717eb17ada73dbd41490e886"
+  integrity sha512-9YlCL/ynK3CTlrSRrDxZvUauLzAswPCrsaCgilqFevUYpeEW0/3ScEjaa3kbW/T0ghhkEr7mv+fpjqn1Y1YuTA==
+
 weakmap-polyfill@2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/weakmap-polyfill/-/weakmap-polyfill-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/weakmap-polyfill/-/weakmap-polyfill-2.0.4.tgz#bcc301e4c8eb4eda3e406f08f1a691093e407884"
   integrity sha512-ZzxBf288iALJseijWelmECm/1x7ZwQn3sMYIkDr2VvZp7r6SEKuT8D0O9Wiq6L9Nl5mazrOMcmiZE/2NCenaxw==
 
 web-namespaces@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/web-namespaces/-/web-namespaces-2.0.1.tgz#1010ff7c650eccb2592cebeeaf9a1b253fd40692"
   integrity sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==
 
 web-streams-polyfill@4.0.0-beta.3:
   version "4.0.0-beta.3"
-  resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz"
+  resolved "https://registry.yarnpkg.com/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz#2898486b74f5156095e473efe989dcf185047a38"
   integrity sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==
 
 webidl-conversions@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
   integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==
 
 webpack-bundle-analyzer@4.10.1:
   version "4.10.1"
-  resolved "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.1.tgz"
+  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.10.1.tgz#84b7473b630a7b8c21c741f81d8fe4593208b454"
   integrity sha512-s3P7pgexgT/HTUSYgxJyn28A+99mmLq4HsJepMPzu0R8ImJc52QNqaFYW1Z2z2uIb1/J3eYgaAWVpaC+v/1aAQ==
   dependencies:
     "@discoveryjs/json-ext" "0.5.7"
@@ -15226,49 +16547,50 @@ webpack-virtual-modules@^0.5.0:
 
 whatwg-fetch@^3.4.1:
   version "3.6.20"
-  resolved "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-3.6.20.tgz"
+  resolved "https://registry.yarnpkg.com/whatwg-fetch/-/whatwg-fetch-3.6.20.tgz#580ce6d791facec91d37c72890995a0b48d31c70"
   integrity sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==
 
 whatwg-url@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
   integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==
   dependencies:
     tr46 "~0.0.3"
     webidl-conversions "^3.0.0"
 
-which-boxed-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz"
-  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
+which-boxed-primitive@^1.1.0, which-boxed-primitive@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz#d76ec27df7fa165f18d5808374a5fe23c29b176e"
+  integrity sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==
   dependencies:
-    is-bigint "^1.0.1"
-    is-boolean-object "^1.1.0"
-    is-number-object "^1.0.4"
-    is-string "^1.0.5"
-    is-symbol "^1.0.3"
+    is-bigint "^1.1.0"
+    is-boolean-object "^1.2.1"
+    is-number-object "^1.1.1"
+    is-string "^1.1.1"
+    is-symbol "^1.1.1"
 
-which-builtin-type@^1.1.3:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.1.4.tgz"
-  integrity sha512-bppkmBSsHFmIMSl8BO9TbsyzsvGjVoppt8xUiGzwiu/bhDCGxnpOKCxgqj6GuyHE0mINMDecBFPlOm2hzY084w==
+which-builtin-type@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/which-builtin-type/-/which-builtin-type-1.2.1.tgz#89183da1b4907ab089a6b02029cc5d8d6574270e"
+  integrity sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==
   dependencies:
+    call-bound "^1.0.2"
     function.prototype.name "^1.1.6"
     has-tostringtag "^1.0.2"
     is-async-function "^2.0.0"
-    is-date-object "^1.0.5"
-    is-finalizationregistry "^1.0.2"
+    is-date-object "^1.1.0"
+    is-finalizationregistry "^1.1.0"
     is-generator-function "^1.0.10"
-    is-regex "^1.1.4"
+    is-regex "^1.2.1"
     is-weakref "^1.0.2"
     isarray "^2.0.5"
-    which-boxed-primitive "^1.0.2"
+    which-boxed-primitive "^1.1.0"
     which-collection "^1.0.2"
-    which-typed-array "^1.1.15"
+    which-typed-array "^1.1.16"
 
-which-collection@^1.0.1, which-collection@^1.0.2:
+which-collection@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/which-collection/-/which-collection-1.0.2.tgz#627ef76243920a107e7ce8e96191debe4b16c2a0"
   integrity sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==
   dependencies:
     is-map "^2.0.3"
@@ -15276,15 +16598,17 @@ which-collection@^1.0.1, which-collection@^1.0.2:
     is-weakmap "^2.0.2"
     is-weakset "^2.0.3"
 
-which-typed-array@^1.1.13, which-typed-array@^1.1.14, which-typed-array@^1.1.15, which-typed-array@^1.1.2:
-  version "1.1.15"
-  resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz"
-  integrity sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==
+which-typed-array@^1.1.16, which-typed-array@^1.1.19, which-typed-array@^1.1.2:
+  version "1.1.19"
+  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.19.tgz#df03842e870b6b88e117524a4b364b6fc689f956"
+  integrity sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==
   dependencies:
     available-typed-arrays "^1.0.7"
-    call-bind "^1.0.7"
-    for-each "^0.3.3"
-    gopd "^1.0.1"
+    call-bind "^1.0.8"
+    call-bound "^1.0.4"
+    for-each "^0.3.5"
+    get-proto "^1.0.1"
+    gopd "^1.2.0"
     has-tostringtag "^1.0.2"
 
 which@^2.0.1, which@^2.0.2:
@@ -15294,24 +16618,31 @@ which@^2.0.1, which@^2.0.2:
   dependencies:
     isexe "^2.0.0"
 
+which@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/which/-/which-5.0.0.tgz#d93f2d93f79834d4363c7d0c23e00d07c466c8d6"
+  integrity sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==
+  dependencies:
+    isexe "^3.1.1"
+
 wolfy87-eventemitter@~5.2.8:
   version "5.2.9"
-  resolved "https://registry.npmjs.org/wolfy87-eventemitter/-/wolfy87-eventemitter-5.2.9.tgz"
+  resolved "https://registry.yarnpkg.com/wolfy87-eventemitter/-/wolfy87-eventemitter-5.2.9.tgz#e879f770b30fbb6512a8afbb330c388591099c2a"
   integrity sha512-P+6vtWyuDw+MB01X7UeF8TaHBvbCovf4HPEMF/SV7BdDc1SMTiBy13SRD71lQh4ExFTG1d/WNzDGDCyOKSMblw==
 
 word-exists@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/word-exists/-/word-exists-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/word-exists/-/word-exists-1.0.0.tgz#2d3e0903b085afe7bf4a3d044dabfffaf083fb52"
   integrity sha512-uvBrbg1bjPzist7dMwRLuOn4TZojTOUgocFFbRft+RPGZuFpzuNO32PXHIKOPFKeocItfCPCkw/Nic09fKqOSA==
 
 word-wrap@^1.2.5:
   version "1.2.5"
-  resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz"
+  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.5.tgz#d2c45c6dd4fbce621a66f136cbe328afd0410b34"
   integrity sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==
 
 "wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
   version "7.0.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
   dependencies:
     ansi-styles "^4.0.0"
@@ -15320,7 +16651,7 @@ word-wrap@^1.2.5:
 
 wrap-ansi@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
   dependencies:
     ansi-styles "^4.0.0"
@@ -15329,7 +16660,7 @@ wrap-ansi@^7.0.0:
 
 wrap-ansi@^8.1.0:
   version "8.1.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
   integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
   dependencies:
     ansi-styles "^6.1.0"
@@ -15337,9 +16668,9 @@ wrap-ansi@^8.1.0:
     strip-ansi "^7.0.1"
 
 wrap-ansi@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz"
-  integrity sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==
+  version "9.0.2"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-9.0.2.tgz#956832dea9494306e6d209eb871643bb873d7c98"
+  integrity sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==
   dependencies:
     ansi-styles "^6.2.1"
     string-width "^7.0.0"
@@ -15347,25 +16678,33 @@ wrap-ansi@^9.0.0:
 
 wrappy@1:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
 
+write-file-atomic@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-6.0.0.tgz#e9c89c8191b3ef0606bc79fb92681aa1aa16fa93"
+  integrity sha512-GmqrO8WJ1NuzJ2DrziEI2o57jKAVIQNf8a18W3nCYU3H7PNWqCCVTeH6/NQE93CIllIgQS98rrmVkYgTX9fFJQ==
+  dependencies:
+    imurmurhash "^0.1.4"
+    signal-exit "^4.0.1"
+
 ws@^7.3.1:
   version "7.5.10"
-  resolved "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.10.tgz#58b5c20dc281633f6c19113f39b349bd8bd558d9"
   integrity sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==
 
 xml-formatter@^3.6.3:
-  version "3.6.3"
-  resolved "https://registry.npmjs.org/xml-formatter/-/xml-formatter-3.6.3.tgz"
-  integrity sha512-++x1TlRO1FRlQ82AZ4WnoCSufaI/PT/sycn4K8nRl4gnrNC1uYY2VV/67aALZ2m0Q4Q/BLj/L69K360Itw9NNg==
+  version "3.6.7"
+  resolved "https://registry.yarnpkg.com/xml-formatter/-/xml-formatter-3.6.7.tgz#75d140e6dbe19b3e956ef20ef55f421c52ef8cc0"
+  integrity sha512-IsfFYJQuoDqtUlKhm4EzeoBOb+fQwzQVeyxxAQ0sThn/nFnQmyLPTplqq4yRhaOENH/tAyujD2TBfIYzUKB6hg==
   dependencies:
-    xml-parser-xo "^4.1.2"
+    xml-parser-xo "^4.1.5"
 
-xml-parser-xo@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.npmjs.org/xml-parser-xo/-/xml-parser-xo-4.1.2.tgz"
-  integrity sha512-Z/DRB0ZAKj5vAQg++XsfQQKfT73Vfj5n5lKIVXobBDQEva6NHWUTxOA6OohJmEcpoy8AEqBmSGkXXAnFwt5qAA==
+xml-parser-xo@^4.1.5:
+  version "4.1.5"
+  resolved "https://registry.yarnpkg.com/xml-parser-xo/-/xml-parser-xo-4.1.5.tgz#c3326af56219a406f1e20741a2826655fcb3b607"
+  integrity sha512-TxyRxk9sTOUg3glxSIY6f0nfuqRll2OEF8TspLgh5mZkLuBgheCn3zClcDSGJ58TvNmiwyCCuat4UajPud/5Og==
 
 xtend@^4.0.0, xtend@~4.0.1:
   version "4.0.2"
@@ -15374,42 +16713,42 @@ xtend@^4.0.0, xtend@~4.0.1:
 
 y18n@^5.0.5:
   version "5.0.8"
-  resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
   integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
 
 yallist@^3.0.2:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
   integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
 
 yallist@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
 yaml@^1.10.2:
   version "1.10.2"
-  resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz"
+  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b"
   integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
 
-yaml@^2.0.0, yaml@^2.3.1, yaml@^2.3.4, yaml@~2.5.0:
-  version "2.5.1"
-  resolved "https://registry.npmjs.org/yaml/-/yaml-2.5.1.tgz"
-  integrity sha512-bLQOjaX/ADgQ20isPJRvF0iRUHIxVhYvr53Of7wGcWlO2jvtUlH5m87DsmulFVxRpNLOnI4tB6p/oh8D7kpn9Q==
+yaml@^2.0.0, yaml@^2.3.1, yaml@^2.3.4, yaml@^2.7.0:
+  version "2.8.1"
+  resolved "https://registry.yarnpkg.com/yaml/-/yaml-2.8.1.tgz#1870aa02b631f7e8328b93f8bc574fac5d6c4d79"
+  integrity sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==
 
 yargs-parser@^20.2.2, yargs-parser@^20.2.3:
   version "20.2.9"
-  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
   integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
 
 yargs-parser@^21.1.1:
   version "21.1.1"
-  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
   integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
 
 yargs@^16.1.0:
   version "16.2.0"
-  resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
   integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
   dependencies:
     cliui "^7.0.2"
@@ -15422,7 +16761,7 @@ yargs@^16.1.0:
 
 yargs@^17.0.0, yargs@^17.7.2:
   version "17.7.2"
-  resolved "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269"
   integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==
   dependencies:
     cliui "^8.0.1"
@@ -15435,30 +16774,30 @@ yargs@^17.0.0, yargs@^17.7.2:
 
 yn@3.1.1:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
   integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
 
 yocto-queue@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
 
 zod@^3.22.4:
-  version "3.23.8"
-  resolved "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz"
-  integrity sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==
+  version "3.25.76"
+  resolved "https://registry.yarnpkg.com/zod/-/zod-3.25.76.tgz#26841c3f6fd22a6a2760e7ccb719179768471e34"
+  integrity sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==
 
 zustand@^3.5.2:
   version "3.7.2"
-  resolved "https://registry.npmjs.org/zustand/-/zustand-3.7.2.tgz"
+  resolved "https://registry.yarnpkg.com/zustand/-/zustand-3.7.2.tgz#7b44c4f4a5bfd7a8296a3957b13e1c346f42514d"
   integrity sha512-PIJDIZKtokhof+9+60cpockVOq05sJzHCriyvaLBmEJixseQ1a5Kdov6fWZfWOu5SK9c+FhH1jU0tntLxRJYMA==
 
 zwitch@^1.0.0:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/zwitch/-/zwitch-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-1.0.5.tgz#d11d7381ffed16b742f6af7b3f223d5cd9fe9920"
   integrity sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw==
 
 zwitch@^2.0.0, zwitch@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/zwitch/-/zwitch-2.0.4.tgz#c827d4b0acb76fc3e685a4c6ec2902d51070e9d7"
   integrity sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==